def ComputeL1NormOfError(method, j_var, k_var):
E = 0.
E_r = 0.
main_path = os.getcwd()
with open(
main_path + '/coors_' + str(method) + str(j_var) + str(k_var) +
'.txt', 'r') as f_coors:
ch_pp.include_history_force = 1
sim = ch.AnalyticSimulator(ch_pp)
i = 0
for line in f_coors:
i += 1
coor = line.split()
coor = [float(comp) for comp in coor]
exact_coor = [0.] * 3
sim.CalculatePosition(exact_coor, coor[0])
x = exact_coor[0] * ch_pp.R
y = exact_coor[1] * ch_pp.R
r = Radius(coor[1:3])
exact_r = Radius([x, y])
delta_coor = [coor[1] - x, coor[2] - y]
#E = max(E, Radius(delta_coor) / exact_r)
#E_r = max(E_r, (r - exact_r) / exact_r)
E += Radius(delta_coor) / exact_r
E_r += (r - exact_r) / exact_r
return E / i, E_r / i
def SetCustomBetaParameters(self, custom_parameters): # These are input parameters that have not yet been transferred to the interface
super(CandelierBenchmarkAnalysis, self).SetCustomBetaParameters(custom_parameters)
candelier_pp.include_history_force = bool(self.project_parameters["basset_force_type"].GetInt())
candelier_pp.include_lift = PT.RecursiveFindParametersWithCondition(custom_parameters["properties"],
'vorticity_induced_lift_parameters',
condition=lambda value: not (value['name']=='default'))
candelier.sim = candelier.AnalyticSimulator(candelier_pp)
self.project_parameters["fluid_already_calculated"].SetBool(True)
self.project_parameters.AddEmptyValue("load_derivatives").SetBool(False)
def __init__(self, model, varying_parameters=Parameters("{}")):
super(CandelierBenchmarkAnalysis, self).__init__(model, varying_parameters)
self._GetSolver().is_rotating_frame = self.project_parameters["frame_of_reference"]["frame_type"].GetInt()
self._GetDEMAnalysis().mdpas_folder_path = os.path.join(self._GetDEMAnalysis().main_path, 'candelier_tests')
candelier_pp.include_history_force = self.vars_man.do_include_history_force
candelier_pp.include_lift = PT.RecursiveFindParametersWithCondition(self.project_parameters["properties"],
'vorticity_induced_lift_parameters',
condition=lambda value: not (value['name']=='default'))
candelier.sim = candelier.AnalyticSimulator(candelier_pp)
self.project_parameters["custom_fluid"]["fluid_already_calculated"].SetBool(True)
self.project_parameters.AddEmptyValue("load_derivatives").SetBool(False)
def __init__(self, project_parameters, path):
self.sim = candelier.AnalyticSimulator(ch_pp)
self.sim.CalculateNonDimensionalVars()
self.path = path + '/candelier_results.h5py'
self.reading_index = 0
self.times = []
self.errors = []
self.do_include_history_force = (PT.RecursiveFindParametersWithCondition(
project_parameters["properties"], 'history_force_parameters',
condition=lambda value: value['name'].GetString() != 'default'))
ch_pp.include_history_force = self.do_include_history_force
self.dt = project_parameters["time_stepping"]["time_step"].GetDouble()
if self.do_include_history_force: #TODO: extend to multiple properties
for prop in project_parameters["properties"].values():
self.history_force_parameters = prop["hydrodynamic_law_parameters"]["history_force_parameters"]
break
self.N_q = self.history_force_parameters["time_steps_per_quadrature_step"].GetInt()
self.quadrature_order = self.history_force_parameters["quadrature_order"].GetInt()
if not self.history_force_parameters["mae_parameters"]['do_use_mae'].GetBool():
self.method = 'Daitche'
else:
self.method = 'Hinsberg'
self.m = self.history_force_parameters["mae_parameters"]["m"].GetInt()
self.t_w = self.history_force_parameters["mae_parameters"]["window_time_interval"].GetDouble()
self.result_code = self.method + '_dt=' + str(self.dt) + '_Nq=' + str(self.N_q) + '_quadrature_order=' + str(self.quadrature_order)
if self.method == 'Hinsberg':
self.result_code += '_tw=' + str(self.t_w) + '_m=' + str(self.m)
with h5py.File(self.path) as f:
result = f.require_group(self.result_code)
result.attrs['method'] = self.method
result.attrs['dt'] = self.dt
result.attrs['N_q'] = self.N_q
result.attrs['quadrature_order'] = self.quadrature_order
if self.method == 'Hinsberg':
result.attrs['t_w'] = self.t_w
result.attrs['m'] = self.m
def __init__(self, parameters, path):
self.sim = candelier.AnalyticSimulator(ch_pp)
self.sim.CalculateNonDimensionalVars()
self.path = path + '/candelier_results.h5py'
self.dt = project_parameters["MaxTimeStep"].GetDouble()
self.N_q = project_parameters["time_steps_per_quadrature_step"].GetInt(
)
self.quadrature_order = project_parameters["quadrature_order"].GetInt()
self.reading_index = 0
self.times = []
self.errors = []
ch_pp.include_history_force = bool(
project_parameters["basset_force_type"].GetInt())
if project_parameters["basset_force_type"].GetInt() == 2:
self.method = 'Daitche'
else:
self.method = 'Hinsberg'
self.m = project_parameters["number_of_exponentials"].GetInt()
self.t_w = project_parameters["time_window"].GetDouble()
self.result_code = self.method + '_dt=' + str(self.dt) + '_Nq=' + str(
self.N_q) + '_quadrature_order=' + str(self.quadrature_order)
if self.method == 'Hinsberg':
self.result_code += '_tw=' + str(self.t_w) + '_m=' + str(self.m)
with h5py.File(self.path) as f:
result = f.require_group(self.result_code)
result.attrs['method'] = self.method
result.attrs['dt'] = self.dt
result.attrs['N_q'] = self.N_q
result.attrs['quadrature_order'] = self.quadrature_order
if self.method == 'Hinsberg':
result.attrs['t_w'] = self.t_w
result.attrs['m'] = self.m
import matplotlib.pyplot as plt
import math
import candelier.candelier_parameters as ch_pp
import candelier as ch
import DEM_explicit_solver_var as DEM_parameters
def Radius(a):
a_2 = [x**2 for x in a]
return math.sqrt(sum(a_2))
sim = ch.AnalyticSimulator(ch_pp)
coors = [None] * 3
sim.CalculatePosition(coors, 100.0)
x_final = coors[0] * ch_pp.R
y_final = coors[1] * ch_pp.R
r_final = Radius([x_final, y_final])
ch_pp.include_history_force = 0
sim = ch.AnalyticSimulator(ch_pp)
sim.CalculatePosition(coors, 100.0)
x_final_NH = coors[0] * ch_pp.R
y_final_NH = coors[1] * ch_pp.R
r_final_NH = Radius([x_final_NH, y_final_NH])
E_NH = Radius([abs(x_final_NH - x_final), abs(y_final - y_final_NH)]) / r_final
E_RNH = abs(r_final_NH - r_final) / r_final
final_positions = []
with open("final_positions_Dt=0.0025", 'r') as f:
for line in f:
position = line.split()
position = [float(position[0]), float(position[1])]
