def test_solver_calculix(self):
fcc_print(
"\n--------------- Start of FEM tests solver framework solver CalculiX ------"
)
# set up the CalculiX static analysis example
from femexamples import boxanalysis as box
box.setup_static(self.active_doc, "calculix")
solver_obj = self.active_doc.SolverCalculiX
base_name = "cube_static"
analysis_dir = testtools.get_unit_test_tmp_dir(self.temp_dir,
solver_obj.Name)
# save the file
save_fc_file = join(analysis_dir,
solver_obj.Name + "_" + base_name + ".FCStd")
fcc_print("Save FreeCAD file to {}...".format(save_fc_file))
self.active_doc.saveAs(save_fc_file)
# write input file
fcc_print(
"Checking FEM input file writing for CalculiX solver framework solver ..."
)
machine_ccx = solver_obj.Proxy.createMachine(solver_obj, analysis_dir)
machine_ccx.target = femsolver.run.PREPARE
machine_ccx.start()
machine_ccx.join() # wait for the machine to finish.
infile_given = join(testtools.get_fem_test_home_dir(), "ccx",
(base_name + ".inp"))
inpfile_totest = join(analysis_dir, (self.mesh_name + ".inp"))
fcc_print("Comparing {} to {}".format(infile_given, inpfile_totest))
ret = testtools.compare_inp_files(infile_given, inpfile_totest)
self.assertFalse(
ret, "ccxtools write_inp_file test failed.\n{}".format(ret))
fcc_print(
"--------------- End of FEM tests solver framework solver CalculiX --------"
)
def test_1_static_analysis(self):
fcc_print(
"\n--------------- Start of FEM ccxtools static analysis test ---------------"
)
# set up the static analysis example
from femexamples import boxanalysis as box
box.setup_static(self.active_doc, "ccxtools")
analysis = self.active_doc.Analysis
solver_object = self.active_doc.CalculiXccxTools
fcc_print("Analysis {}".format(type(analysis)))
fcc_print("Analysis {}".format(analysis.TypeId))
static_analysis_dir = testtools.get_unit_test_tmp_dir(
self.temp_dir, "FEM_ccx_static")
fea = ccxtools.FemToolsCcx(analysis, solver_object, test_mode=True)
fea.update_objects()
fcc_print("fea Analysis {}".format(type(fea.analysis)))
fcc_print("fea Analysis {}".format(fea.analysis.TypeId))
fcc_print(
"Setting up working directory {}".format(static_analysis_dir))
fea.setup_working_dir(static_analysis_dir)
self.assertTrue(
True if fea.working_dir == static_analysis_dir else False,
"Setting working directory {} failed".format(static_analysis_dir))
fcc_print("Checking FEM inp file prerequisites for static analysis...")
error = fea.check_prerequisites()
self.assertFalse(
error,
"ccxtools check_prerequisites returned error message: {}".format(
error))
static_base_name = "cube_static"
inpfile_given = join(self.test_file_dir, (static_base_name + ".inp"))
inpfile_totest = join(static_analysis_dir, (self.mesh_name + ".inp"))
fcc_print("Checking FEM inp file write...")
fcc_print("Writing {} for static analysis".format(inpfile_totest))
error = fea.write_inp_file()
self.assertFalse(error, "Writing failed")
fcc_print("Comparing {} to {}".format(inpfile_given, inpfile_totest))
ret = testtools.compare_inp_files(inpfile_given, inpfile_totest)
self.assertFalse(
ret, "ccxtools write_inp_file test failed.\n{}".format(ret))
fcc_print(
"Setting up working directory to {} in order to read simulated calculations"
.format(self.test_file_dir))
fea.setup_working_dir(self.test_file_dir)
fcc_print(fea.working_dir)
fcc_print(self.test_file_dir)
self.assertTrue(
True if fea.working_dir == self.test_file_dir else False,
"Setting working directory {} failed".format(self.test_file_dir))
fcc_print("Setting base name to read test {}.frd file...".format(
"cube_static"))
fea.set_base_name(static_base_name)
self.assertTrue(
True if fea.base_name == static_base_name else False,
"Setting base name to {} failed".format(static_base_name))
fcc_print("Setting inp file name to read test {}.frd file...".format(
"cube_static"))
fea.set_inp_file_name()
self.assertTrue(
True if fea.inp_file_name == inpfile_given else False,
"Setting inp file name to {} failed".format(inpfile_given))
fcc_print("Checking FEM frd file read from static analysis...")
fea.load_results()
self.assertTrue(
fea.results_present,
"Cannot read results from {}.frd frd file".format(fea.base_name))
fcc_print("Reading stats from result object for static analysis...")
static_expected_values = join(self.test_file_dir,
"cube_static_expected_values")
ret = testtools.compare_stats(fea, static_expected_values,
"CCX_Results")
self.assertFalse(ret, "Invalid results read from .frd file")
static_save_fc_file = static_analysis_dir + static_base_name + ".FCStd"
fcc_print("Save FreeCAD file for static analysis to {}...".format(
static_save_fc_file))
self.active_doc.saveAs(static_save_fc_file)
fcc_print(
"--------------- End of FEM ccxtools static analysis test -------------------"
)
def test_solver_elmer(
self
):
fcc_print("\n--------------- Start of FEM tests solver framework solver Elmer ---------")
# set up the Elmer static analysis example
from femexamples import boxanalysis as box
box.setup_static(self.document, "elmer")
analysis_obj = self.document.Analysis
solver_obj = self.document.SolverElmer
material_obj = self.document.MechanicalMaterial
mesh_obj = self.document.Mesh
box_object = self.document.Box
base_name = "cube_static"
analysis_dir = testtools.get_unit_test_tmp_dir(self.temp_dir, solver_obj.Name)
# TODO move to elmer solver of femexample code
ObjectsFem.makeEquationElasticity(self.document, solver_obj)
# set ThermalExpansionCoefficient
# FIXME elmer elasticity needs the dictionary key "ThermalExpansionCoefficient"
# even on simple elasticity analysis, otherwise it fails
mat = material_obj.Material
mat["ThermalExpansionCoefficient"] = "0 um/m/K"
material_obj.Material = mat
# elmer needs a GMHS mesh object
# FIXME error message on Python solver run
mesh_gmsh = ObjectsFem.makeMeshGmsh(self.document)
mesh_gmsh.CharacteristicLengthMin = "9 mm"
mesh_gmsh.FemMesh = mesh_obj.FemMesh
mesh_gmsh.Part = box_object
analysis_obj.addObject(mesh_gmsh)
self.document.removeObject(mesh_obj.Name) # remove original mesh object
# save the file
save_fc_file = join(analysis_dir, solver_obj.Name + "_" + base_name + ".FCStd")
fcc_print("Save FreeCAD file to {}...".format(save_fc_file))
self.document.saveAs(save_fc_file)
# write input files
fcc_print("Checking FEM input file writing for Elmer solver framework solver ...")
machine_elmer = solver_obj.Proxy.createMachine(
solver_obj,
analysis_dir,
True
)
machine_elmer.target = femsolver.run.PREPARE
machine_elmer.start()
machine_elmer.join() # wait for the machine to finish.
# compare startinfo, case and gmsh input files
test_file_dir_elmer = join(testtools.get_fem_test_home_dir(), "elmer")
fcc_print(test_file_dir_elmer)
fcc_print("Test writing STARTINFO file")
startinfo_given = join(test_file_dir_elmer, "ELMERSOLVER_STARTINFO")
startinfo_totest = join(analysis_dir, "ELMERSOLVER_STARTINFO")
fcc_print("Comparing {} to {}".format(startinfo_given, startinfo_totest))
ret = testtools.compare_files(startinfo_given, startinfo_totest)
self.assertFalse(ret, "STARTINFO write file test failed.\n{}".format(ret))
fcc_print("Test writing case file")
casefile_given = join(test_file_dir_elmer, "case.sif")
casefile_totest = join(analysis_dir, "case.sif")
fcc_print("Comparing {} to {}".format(casefile_given, casefile_totest))
ret = testtools.compare_files(casefile_given, casefile_totest)
self.assertFalse(ret, "case write file test failed.\n{}".format(ret))
fcc_print("Test writing GMSH geo file")
gmshgeofile_given = join(test_file_dir_elmer, "group_mesh.geo")
gmshgeofile_totest = join(analysis_dir, "group_mesh.geo")
fcc_print("Comparing {} to {}".format(gmshgeofile_given, gmshgeofile_totest))
ret = testtools.compare_files(gmshgeofile_given, gmshgeofile_totest)
self.assertFalse(ret, "GMSH geo write file test failed.\n{}".format(ret))
fcc_print("--------------- End of FEM tests solver framework solver Elmer -----------")
