diff --git a/src/Mod/Fem/femtest/testccxtools.py b/src/Mod/Fem/femtest/testccxtools.py index f6ff8b8bbf..a695ca58ea 100644 --- a/src/Mod/Fem/femtest/testccxtools.py +++ b/src/Mod/Fem/femtest/testccxtools.py @@ -37,7 +37,10 @@ from os.path import join class TestCcxTools(unittest.TestCase): fcc_print('import TestCcxTools') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): # init, is executed before every test self.doc_name = "TestCcxTools" try: @@ -49,17 +52,34 @@ class TestCcxTools(unittest.TestCase): self.active_doc = FreeCAD.ActiveDocument self.mesh_name = 'Mesh' self.temp_dir = testtools.get_fem_test_tmp_dir() - self.test_file_dir = join(testtools.get_fem_test_home_dir(), 'ccx') + self.test_file_dir = join( + testtools.get_fem_test_home_dir(), + 'ccx' + ) - def test_1_static_analysis(self): + # ******************************************************************************************** + def test_1_static_analysis( + self + ): fcc_print('--------------- Start of FEM tests ---------------') + box = self.active_doc.addObject("Part::Box", "Box") + fcc_print('Checking FEM new analysis...') - analysis = ObjectsFem.makeAnalysis(self.active_doc, 'Analysis') - self.assertTrue(analysis, "FemTest of new analysis failed") + analysis = ObjectsFem.makeAnalysis( + self.active_doc, + 'Analysis' + ) + self.assertTrue( + analysis, + "FemTest of new analysis failed" + ) fcc_print('Checking FEM new solver...') - solver_object = ObjectsFem.makeSolverCalculixCcxTools(self.active_doc, 'CalculiX') + solver_object = ObjectsFem.makeSolverCalculixCcxTools( + self.active_doc, + 'CalculiX' + ) solver_object.AnalysisType = 'static' solver_object.GeometricalNonlinearity = 'linear' solver_object.ThermoMechSteadyState = False @@ -68,43 +88,70 @@ class TestCcxTools(unittest.TestCase): solver_object.EigenmodesCount = 10 solver_object.EigenmodeHighLimit = 1000000.0 solver_object.EigenmodeLowLimit = 0.0 - self.assertTrue(solver_object, "FemTest of new solver failed") + self.assertTrue( + solver_object, + "FemTest of new solver failed" + ) analysis.addObject(solver_object) fcc_print('Checking FEM new material...') - material_object = ObjectsFem.makeMaterialSolid(self.active_doc, 'MechanicalMaterial') + material_object = ObjectsFem.makeMaterialSolid( + self.active_doc, + 'MechanicalMaterial' + ) mat = material_object.Material mat['Name'] = "Steel-Generic" mat['YoungsModulus'] = "200000 MPa" mat['PoissonRatio'] = "0.30" mat['Density'] = "7900 kg/m^3" material_object.Material = mat - self.assertTrue(material_object, "FemTest of new material failed") + self.assertTrue( + material_object, + "FemTest of new material failed" + ) analysis.addObject(material_object) fcc_print('Checking FEM new fixed constraint...') - fixed_constraint = self.active_doc.addObject("Fem::ConstraintFixed", "FemConstraintFixed") + fixed_constraint = self.active_doc.addObject( + "Fem::ConstraintFixed", + "FemConstraintFixed" + ) fixed_constraint.References = [(box, "Face1")] - self.assertTrue(fixed_constraint, "FemTest of new fixed constraint failed") + self.assertTrue( + fixed_constraint, + "FemTest of new fixed constraint failed" + ) analysis.addObject(fixed_constraint) fcc_print('Checking FEM new force constraint...') - force_constraint = self.active_doc.addObject("Fem::ConstraintForce", "FemConstraintForce") + force_constraint = self.active_doc.addObject( + "Fem::ConstraintForce", + "FemConstraintForce" + ) force_constraint.References = [(box, "Face6")] force_constraint.Force = 40000.0 force_constraint.Direction = (box, ["Edge5"]) self.active_doc.recompute() force_constraint.Reversed = True self.active_doc.recompute() - self.assertTrue(force_constraint, "FemTest of new force constraint failed") + self.assertTrue( + force_constraint, + "FemTest of new force constraint failed" + ) analysis.addObject(force_constraint) fcc_print('Checking FEM new pressure constraint...') - pressure_constraint = self.active_doc.addObject("Fem::ConstraintPressure", "FemConstraintPressure") + pressure_constraint = self.active_doc.addObject( + "Fem::ConstraintPressure", + "FemConstraintPressure" + ) pressure_constraint.References = [(box, "Face2")] pressure_constraint.Pressure = 1000.0 pressure_constraint.Reversed = False - self.assertTrue(pressure_constraint, "FemTest of new pressure constraint failed") + self.assertTrue( + pressure_constraint, + "FemTest of new pressure constraint failed" + ) analysis.addObject(pressure_constraint) fcc_print('Checking FEM new mesh...') @@ -112,28 +159,48 @@ class TestCcxTools(unittest.TestCase): from .testfiles.ccx.cube_mesh import create_elements_cube mesh = Fem.FemMesh() ret = create_nodes_cube(mesh) - self.assertTrue(ret, "Import of mesh nodes failed") + self.assertTrue( + ret, + "Import of mesh nodes failed" + ) ret = create_elements_cube(mesh) - self.assertTrue(ret, "Import of mesh volumes failed") - mesh_object = self.active_doc.addObject('Fem::FemMeshObject', self.mesh_name) + self.assertTrue( + ret, + "Import of mesh volumes failed" + ) + mesh_object = self.active_doc.addObject( + 'Fem::FemMeshObject', + self.mesh_name + ) mesh_object.FemMesh = mesh - self.assertTrue(mesh, "FemTest of new mesh failed") + self.assertTrue( + mesh, + "FemTest of new mesh failed" + ) analysis.addObject(mesh_object) self.active_doc.recompute() - static_analysis_dir = testtools.get_unit_test_tmp_dir(self.temp_dir, 'FEM_ccx_static') + 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('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)) + 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)) + 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')) @@ -141,47 +208,75 @@ class TestCcxTools(unittest.TestCase): 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") + 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)) + 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)) + 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)) + 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)) + 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)) + 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)) + 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, 'CalculiX_static_results') - self.assertFalse(ret, "Invalid results read from .frd file") + ret = testtools.compare_stats( + fea, static_expected_values, + 'CalculiX_static_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 tests static and analysis ---------------') - def test_2_static_multiple_material(self): + # ******************************************************************************************** + def test_2_static_multiple_material( + self + ): fcc_print('--------------- Start of FEM ccxtools multiple material test ---------------') - # create a CompSolid of two Boxes extract the CompSolid (we are able to remesh if needed) + # create a CompSolid of two Boxes extract the CompSolid + # we are able to remesh if needed boxlow = self.active_doc.addObject("Part::Box", "BoxLower") boxupp = self.active_doc.addObject("Part::Box", "BoxUpper") boxupp.Placement.Base = (0, 0, 10) @@ -212,8 +307,14 @@ class TestCcxTools(unittest.TestCase): FreeCADGui.ActiveDocument.activeView().viewAxonometric() FreeCADGui.SendMsgToActiveView("ViewFit") - analysis = ObjectsFem.makeAnalysis(self.active_doc, 'Analysis') - solver_object = ObjectsFem.makeSolverCalculixCcxTools(self.active_doc, 'CalculiXccxTools') + analysis = ObjectsFem.makeAnalysis( + self.active_doc, + 'Analysis' + ) + solver_object = ObjectsFem.makeSolverCalculixCcxTools( + self.active_doc, + 'CalculiXccxTools' + ) solver_object.AnalysisType = 'static' solver_object.GeometricalNonlinearity = 'linear' solver_object.ThermoMechSteadyState = False @@ -221,7 +322,10 @@ class TestCcxTools(unittest.TestCase): solver_object.IterationsControlParameterTimeUse = False analysis.addObject(solver_object) - material_object_low = ObjectsFem.makeMaterialSolid(self.active_doc, 'MechanicalMaterialLow') + material_object_low = ObjectsFem.makeMaterialSolid( + self.active_doc, + 'MechanicalMaterialLow' + ) mat = material_object_low.Material mat['Name'] = "Aluminium-Generic" mat['YoungsModulus'] = "70000 MPa" @@ -231,7 +335,10 @@ class TestCcxTools(unittest.TestCase): material_object_low.References = [(boxlow, 'Solid1')] analysis.addObject(material_object_low) - material_object_upp = ObjectsFem.makeMaterialSolid(self.active_doc, 'MechanicalMaterialUpp') + material_object_upp = ObjectsFem.makeMaterialSolid( + self.active_doc, + 'MechanicalMaterialUpp' + ) mat = material_object_upp.Material mat['Name'] = "Steel-Generic" mat['YoungsModulus'] = "200000 MPa" @@ -241,12 +348,18 @@ class TestCcxTools(unittest.TestCase): material_object_upp.References = [(boxupp, 'Solid1')] analysis.addObject(material_object_upp) - fixed_constraint = self.active_doc.addObject("Fem::ConstraintFixed", "ConstraintFixed") + fixed_constraint = self.active_doc.addObject( + "Fem::ConstraintFixed", + "ConstraintFixed" + ) # fixed_constraint.References = [(cf, "Face3")] fixed_constraint.References = [(boxlow, "Face5")] analysis.addObject(fixed_constraint) - pressure_constraint = self.active_doc.addObject("Fem::ConstraintPressure", "ConstraintPressure") + pressure_constraint = self.active_doc.addObject( + "Fem::ConstraintPressure", + "ConstraintPressure" + ) # pressure_constraint.References = [(cf, "Face9")] pressure_constraint.References = [(boxupp, "Face6")] pressure_constraint.Pressure = 1000.0 @@ -262,14 +375,20 @@ class TestCcxTools(unittest.TestCase): analysis.addObject(mesh_object) self.active_doc.recompute() - static_multiplemat_dir = testtools.get_unit_test_tmp_dir(self.temp_dir, 'FEM_ccx_multimat/') + static_multiplemat_dir = testtools.get_unit_test_tmp_dir( + self.temp_dir, + 'FEM_ccx_multimat/' + ) fea = ccxtools.FemToolsCcx(analysis, solver_object, test_mode=True) fea.update_objects() fea.setup_working_dir(static_multiplemat_dir) fcc_print('Checking FEM inp file prerequisites for ccxtools multimat analysis...') error = fea.check_prerequisites() - self.assertFalse(error, "ccxtools check_prerequisites returned error message: {}".format(error)) + self.assertFalse( + error, + "ccxtools check_prerequisites returned error message: {}".format(error) + ) static_base_name = 'multimat' inpfile_given = join(self.test_file_dir, (static_base_name + '.inp')) @@ -277,26 +396,46 @@ class TestCcxTools(unittest.TestCase): fcc_print('Checking FEM inp file write...') fcc_print('Writing {} for static multiple material'.format(inpfile_totest)) error = fea.write_inp_file() - self.assertFalse(error, "Writing failed") + 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)) + self.assertFalse( + ret, + "ccxtools write_inp_file test failed.\n{}".format(ret) + ) static_save_fc_file = static_multiplemat_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 multiple material test ---------------') - def test_3_freq_analysis(self): + # ******************************************************************************************** + def test_3_freq_analysis( + self + ): fcc_print('--------------- Start of FEM tests ---------------') + self.active_doc.addObject("Part::Box", "Box") + fcc_print('Checking FEM new analysis...') - analysis = ObjectsFem.makeAnalysis(self.active_doc, 'Analysis') - self.assertTrue(analysis, "FemTest of new analysis failed") + analysis = ObjectsFem.makeAnalysis( + self.active_doc, + 'Analysis' + ) + self.assertTrue( + analysis, + "FemTest of new analysis failed" + ) fcc_print('Checking FEM new solver...') - solver_object = ObjectsFem.makeSolverCalculixCcxTools(self.active_doc, 'CalculiX') + solver_object = ObjectsFem.makeSolverCalculixCcxTools( + self.active_doc, + 'CalculiX' + ) solver_object.AnalysisType = 'frequency' solver_object.GeometricalNonlinearity = 'linear' solver_object.ThermoMechSteadyState = False @@ -305,18 +444,27 @@ class TestCcxTools(unittest.TestCase): solver_object.EigenmodesCount = 10 solver_object.EigenmodeHighLimit = 1000000.0 solver_object.EigenmodeLowLimit = 0.01 - self.assertTrue(solver_object, "FemTest of new solver failed") + self.assertTrue( + solver_object, + "FemTest of new solver failed" + ) analysis.addObject(solver_object) fcc_print('Checking FEM new material...') - material_object = ObjectsFem.makeMaterialSolid(self.active_doc, 'MechanicalMaterial') + material_object = ObjectsFem.makeMaterialSolid( + self.active_doc, + 'MechanicalMaterial' + ) mat = material_object.Material mat['Name'] = "Steel-Generic" mat['YoungsModulus'] = "200000 MPa" mat['PoissonRatio'] = "0.30" mat['Density'] = "7900 kg/m^3" material_object.Material = mat - self.assertTrue(material_object, "FemTest of new material failed") + self.assertTrue( + material_object, + "FemTest of new material failed" + ) analysis.addObject(material_object) fcc_print('Checking FEM new mesh...') @@ -327,25 +475,36 @@ class TestCcxTools(unittest.TestCase): self.assertTrue(ret, "Import of mesh nodes failed") ret = create_elements_cube(mesh) self.assertTrue(ret, "Import of mesh volumes failed") - mesh_object = self.active_doc.addObject('Fem::FemMeshObject', self.mesh_name) + mesh_object = self.active_doc.addObject( + 'Fem::FemMeshObject', + self.mesh_name + ) mesh_object.FemMesh = mesh self.assertTrue(mesh, "FemTest of new mesh failed") analysis.addObject(mesh_object) self.active_doc.recompute() - frequency_analysis_dir = testtools.get_unit_test_tmp_dir(self.temp_dir, 'FEM_ccx_frequency') + frequency_analysis_dir = testtools.get_unit_test_tmp_dir( + self.temp_dir, + 'FEM_ccx_frequency' + ) fea = ccxtools.FemToolsCcx(analysis, solver_object, test_mode=True) fea.update_objects() fcc_print('Setting up working directory {}'.format(frequency_analysis_dir)) fea.setup_working_dir(frequency_analysis_dir) - self.assertTrue(True if fea.working_dir == frequency_analysis_dir else False, - "Setting working directory {} failed".format(frequency_analysis_dir)) + self.assertTrue( + True if fea.working_dir == frequency_analysis_dir else False, + "Setting working directory {} failed".format(frequency_analysis_dir) + ) fcc_print('Checking FEM inp file prerequisites for frequency analysis...') error = fea.check_prerequisites() - self.assertFalse(error, "ccxtools check_prerequisites returned error message: {}".format(error)) + self.assertFalse( + error, + "ccxtools check_prerequisites returned error message: {}".format(error) + ) frequency_base_name = 'cube_frequency' inpfile_given = join(self.test_file_dir, (frequency_base_name + '.inp')) @@ -353,64 +512,113 @@ class TestCcxTools(unittest.TestCase): fcc_print('Checking FEM inp file write...') fcc_print('Writing {} for frequency analysis'.format(inpfile_totest)) error = fea.write_inp_file() - self.assertFalse(error, "Writing failed") + 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)) + 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)) + 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) - self.assertTrue(True if fea.working_dir == self.test_file_dir else False, - "Setting working directory {} failed".format(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(frequency_base_name)) fea.set_base_name(frequency_base_name) - self.assertTrue(True if fea.base_name == frequency_base_name else False, - "Setting base name to {} failed".format(frequency_base_name)) + self.assertTrue( + True if fea.base_name == frequency_base_name else False, + "Setting base name to {} failed".format(frequency_base_name) + ) fcc_print('Setting inp file name to read test {}.frd file...'.format('cube_frequency')) 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)) + 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 frequency analysis...') fea.load_results() - self.assertTrue(fea.results_present, "Cannot read results from {}.frd frd file".format(fea.base_name)) + self.assertTrue( + fea.results_present, + "Cannot read results from {}.frd frd file".format(fea.base_name) + ) fcc_print('Reading stats from result object for frequency analysis...') frequency_expected_values = join(self.test_file_dir, "cube_frequency_expected_values") - ret = testtools.compare_stats(fea, frequency_expected_values, 'CalculiX_frequency_mode_1_results') - self.assertFalse(ret, "Invalid results read from .frd file") + ret = testtools.compare_stats( + fea, + frequency_expected_values, + 'CalculiX_frequency_mode_1_results' + ) + self.assertFalse( + ret, + "Invalid results read from .frd file" + ) frequency_save_fc_file = frequency_analysis_dir + frequency_base_name + '.FCStd' - fcc_print('Save FreeCAD file for frequency analysis to {}...'.format(frequency_save_fc_file)) + fcc_print( + 'Save FreeCAD file for frequency analysis to {}...' + .format(frequency_save_fc_file) + ) self.active_doc.saveAs(frequency_save_fc_file) fcc_print('--------------- End of FEM tests frequency analysis ---------------') - def test_4_thermomech_analysis(self): + # ******************************************************************************************** + def test_4_thermomech_analysis( + self + ): + fcc_print('--------------- Start of FEM tests ---------------') + box = self.active_doc.addObject("Part::Box", "Box") box.Height = 25.4 box.Width = 25.4 box.Length = 203.2 + fcc_print('Checking FEM new analysis...') - analysis = ObjectsFem.makeAnalysis(self.active_doc, 'Analysis') - self.assertTrue(analysis, "FemTest of new analysis failed") + analysis = ObjectsFem.makeAnalysis( + self.active_doc, + 'Analysis' + ) + self.assertTrue( + analysis, + "FemTest of new analysis failed" + ) fcc_print('Checking FEM new solver...') - solver_object = ObjectsFem.makeSolverCalculixCcxTools(self.active_doc, 'CalculiX') + solver_object = ObjectsFem.makeSolverCalculixCcxTools( + self.active_doc, + 'CalculiX' + ) solver_object.AnalysisType = 'thermomech' solver_object.GeometricalNonlinearity = 'linear' solver_object.ThermoMechSteadyState = True solver_object.MatrixSolverType = 'default' solver_object.IterationsThermoMechMaximum = 2000 solver_object.IterationsControlParameterTimeUse = True - self.assertTrue(solver_object, "FemTest of new solver failed") + self.assertTrue( + solver_object, + "FemTest of new solver failed" + ) analysis.addObject(solver_object) fcc_print('Checking FEM new material...') - material_object = ObjectsFem.makeMaterialSolid(self.active_doc, 'MechanicalMaterial') + material_object = ObjectsFem.makeMaterialSolid( + self.active_doc, + 'MechanicalMaterial' + ) mat = material_object.Material mat['Name'] = "Steel-Generic" mat['YoungsModulus'] = "200000 MPa" @@ -420,34 +628,66 @@ class TestCcxTools(unittest.TestCase): mat['ThermalExpansionCoefficient'] = "12 um/m/K" mat['SpecificHeat'] = "500 J/kg/K" # SvdW: Change to Ansys model values material_object.Material = mat - self.assertTrue(material_object, "FemTest of new material failed") + self.assertTrue( + material_object, + "FemTest of new material failed" + ) analysis.addObject(material_object) fcc_print('Checking FEM new fixed constraint...') - fixed_constraint = self.active_doc.addObject("Fem::ConstraintFixed", "FemConstraintFixed") + fixed_constraint = self.active_doc.addObject( + "Fem::ConstraintFixed", + "FemConstraintFixed" + ) fixed_constraint.References = [(box, "Face1")] - self.assertTrue(fixed_constraint, "FemTest of new fixed constraint failed") + self.assertTrue( + fixed_constraint, + "FemTest of new fixed constraint failed" + ) analysis.addObject(fixed_constraint) fcc_print('Checking FEM new initial temperature constraint...') - initialtemperature_constraint = self.active_doc.addObject("Fem::ConstraintInitialTemperature", "FemConstraintInitialTemperature") + initialtemperature_constraint = self.active_doc.addObject( + "Fem::ConstraintInitialTemperature", + "FemConstraintInitialTemperature" + ) initialtemperature_constraint.initialTemperature = 300.0 - self.assertTrue(initialtemperature_constraint, "FemTest of new initial temperature constraint failed") + self.assertTrue( + initialtemperature_constraint, + "FemTest of new initial temperature constraint failed" + ) analysis.addObject(initialtemperature_constraint) fcc_print('Checking FEM new temperature constraint...') - temperature_constraint = self.active_doc.addObject("Fem::ConstraintTemperature", "FemConstraintTemperature") + temperature_constraint = self.active_doc.addObject( + "Fem::ConstraintTemperature", + "FemConstraintTemperature" + ) temperature_constraint.References = [(box, "Face1")] temperature_constraint.Temperature = 310.93 - self.assertTrue(temperature_constraint, "FemTest of new temperature constraint failed") + self.assertTrue( + temperature_constraint, + "FemTest of new temperature constraint failed" + ) analysis.addObject(temperature_constraint) fcc_print('Checking FEM new heatflux constraint...') - heatflux_constraint = self.active_doc.addObject("Fem::ConstraintHeatflux", "FemConstraintHeatflux") - heatflux_constraint.References = [(box, "Face3"), (box, "Face4"), (box, "Face5"), (box, "Face6")] + heatflux_constraint = self.active_doc.addObject( + "Fem::ConstraintHeatflux", + "FemConstraintHeatflux" + ) + heatflux_constraint.References = [ + (box, "Face3"), + (box, "Face4"), + (box, "Face5"), + (box, "Face6") + ] heatflux_constraint.AmbientTemp = 255.3722 heatflux_constraint.FilmCoef = 5.678 - self.assertTrue(heatflux_constraint, "FemTest of new heatflux constraint failed") + self.assertTrue( + heatflux_constraint, + "FemTest of new heatflux constraint failed" + ) analysis.addObject(heatflux_constraint) fcc_print('Checking FEM new mesh...') @@ -455,28 +695,48 @@ class TestCcxTools(unittest.TestCase): from .testfiles.ccx.spine_mesh import create_elements_spine mesh = Fem.FemMesh() ret = create_nodes_spine(mesh) - self.assertTrue(ret, "Import of mesh nodes failed") + self.assertTrue( + ret, + "Import of mesh nodes failed" + ) ret = create_elements_spine(mesh) - self.assertTrue(ret, "Import of mesh volumes failed") - mesh_object = self.active_doc.addObject('Fem::FemMeshObject', self.mesh_name) + self.assertTrue( + ret, + "Import of mesh volumes failed" + ) + mesh_object = self.active_doc.addObject( + 'Fem::FemMeshObject', + self.mesh_name + ) mesh_object.FemMesh = mesh - self.assertTrue(mesh, "FemTest of new mesh failed") + self.assertTrue( + mesh, + "FemTest of new mesh failed" + ) analysis.addObject(mesh_object) self.active_doc.recompute() - thermomech_analysis_dir = testtools.get_unit_test_tmp_dir(self.temp_dir, 'FEM_ccx_thermomech') + thermomech_analysis_dir = testtools.get_unit_test_tmp_dir( + self.temp_dir, + 'FEM_ccx_thermomech' + ) fea = ccxtools.FemToolsCcx(analysis, test_mode=True) fea.update_objects() fcc_print('Setting up working directory {}'.format(thermomech_analysis_dir)) fea.setup_working_dir(thermomech_analysis_dir) - self.assertTrue(True if fea.working_dir == thermomech_analysis_dir else False, - "Setting working directory {} failed".format(thermomech_analysis_dir)) + self.assertTrue( + True if fea.working_dir == thermomech_analysis_dir else False, + "Setting working directory {} failed".format(thermomech_analysis_dir) + ) fcc_print('Checking FEM inp file prerequisites for thermo-mechanical analysis...') error = fea.check_prerequisites() - self.assertFalse(error, "ccxtools check_prerequisites returned error message: {}".format(error)) + self.assertFalse( + error, + "ccxtools check_prerequisites returned error message: {}".format(error) + ) thermomech_base_name = 'spine_thermomech' inpfile_given = join(self.test_file_dir, (thermomech_base_name + '.inp')) @@ -484,45 +744,79 @@ class TestCcxTools(unittest.TestCase): fcc_print('Checking FEM inp file write...') fcc_print('Writing {} for thermomech analysis'.format(inpfile_totest)) error = fea.write_inp_file() - self.assertFalse(error, "Writing failed") + 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)) + 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)) + 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) - self.assertTrue(True if fea.working_dir == self.test_file_dir else False, - "Setting working directory {} failed".format(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('spine_thermomech')) fea.set_base_name(thermomech_base_name) - self.assertTrue(True if fea.base_name == thermomech_base_name else False, - "Setting base name to {} failed".format(thermomech_base_name)) + self.assertTrue( + True if fea.base_name == thermomech_base_name else False, + "Setting base name to {} failed".format(thermomech_base_name) + ) fcc_print('Setting inp file name to read test {}.frd file...'.format('spine_thermomech')) 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)) + 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 thermomech analysis...') fea.load_results() - self.assertTrue(fea.results_present, "Cannot read results from {}.frd frd file".format(fea.base_name)) + self.assertTrue( + fea.results_present, + "Cannot read results from {}.frd frd file".format(fea.base_name) + ) fcc_print('Reading stats from result object for thermomech analysis...') - thermomech_expected_values = join(self.test_file_dir, "spine_thermomech_expected_values") - ret = testtools.compare_stats(fea, thermomech_expected_values, 'CalculiX_thermomech_results') - self.assertFalse(ret, "Invalid results read from .frd file") + thermomech_expected_values = join( + self.test_file_dir, + "spine_thermomech_expected_values" + ) + ret = testtools.compare_stats( + fea, + thermomech_expected_values, + 'CalculiX_thermomech_results' + ) + self.assertFalse( + ret, + "Invalid results read from .frd file" + ) thermomech_save_fc_file = thermomech_analysis_dir + thermomech_base_name + '.FCStd' - fcc_print('Save FreeCAD file for thermomech analysis to {}...'.format(thermomech_save_fc_file)) + fcc_print( + 'Save FreeCAD file for thermomech analysis to {}...' + .format(thermomech_save_fc_file) + ) self.active_doc.saveAs(thermomech_save_fc_file) fcc_print('--------------- End of FEM tests thermomech analysis ---------------') - def test_5_Flow1D_thermomech_analysis(self): + # ******************************************************************************************** + def test_5_Flow1D_thermomech_analysis( + self + ): fcc_print('--------------- Start of 1D Flow FEM tests ---------------') - import Draft + p1 = FreeCAD.Vector(0, 0, 50) p2 = FreeCAD.Vector(0, 0, -50) p3 = FreeCAD.Vector(0, 0, -4300) @@ -550,25 +844,48 @@ class TestCcxTools(unittest.TestCase): p25 = FreeCAD.Vector(14495.425, 0, -13796.425) p26 = FreeCAD.Vector(15046.97, 0, -11147.97) p27 = FreeCAD.Vector(15046.97, 0, -7897.97) - points = [p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27] - line = Draft.makeWire(points, closed=False, face=False, support=None) + points = [ + p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, + p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, + p21, p22, p23, p24, p25, p26, p27 + ] + from Draft import makeWire + line = makeWire( + points, + closed=False, + face=False, + support=None + ) + fcc_print('Checking FEM new analysis...') - analysis = ObjectsFem.makeAnalysis(self.active_doc, 'Analysis') + analysis = ObjectsFem.makeAnalysis( + self.active_doc, + 'Analysis' + ) self.assertTrue(analysis, "FemTest of new analysis failed") fcc_print('Checking FEM new solver...') - solver_object = ObjectsFem.makeSolverCalculixCcxTools(self.active_doc, 'CalculiX') + solver_object = ObjectsFem.makeSolverCalculixCcxTools( + self.active_doc, + 'CalculiX' + ) solver_object.AnalysisType = 'thermomech' solver_object.GeometricalNonlinearity = 'linear' solver_object.ThermoMechSteadyState = True solver_object.MatrixSolverType = 'default' solver_object.IterationsThermoMechMaximum = 2000 solver_object.IterationsControlParameterTimeUse = False - self.assertTrue(solver_object, "FemTest of new solver failed") + self.assertTrue( + solver_object, + "FemTest of new solver failed" + ) analysis.addObject(solver_object) fcc_print('Checking FEM new material...') - material_object = ObjectsFem.makeMaterialFluid(self.active_doc, 'FluidMaterial') + material_object = ObjectsFem.makeMaterialFluid( + self.active_doc, + 'FluidMaterial' + ) mat = material_object.Material mat['Name'] = "Water" mat['Density'] = "998 kg/m^3" @@ -577,41 +894,64 @@ class TestCcxTools(unittest.TestCase): mat['VolumetricThermalExpansionCoefficient'] = "2.07e-4 m/m/K" mat['ThermalConductivity'] = "0.591 W/m/K" material_object.Material = mat - self.assertTrue(material_object, "FemTest of new material failed") + self.assertTrue( + material_object, + "FemTest of new material failed" + ) analysis.addObject(material_object) fcc_print('Checking FEM Flow1D inlet constraint...') - Flow1d_inlet = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_inlet = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_inlet.SectionType = 'Liquid' Flow1d_inlet.LiquidSectionType = 'PIPE INLET' Flow1d_inlet.InletPressure = 0.1 Flow1d_inlet.References = [(line, "Edge1")] - self.assertTrue(Flow1d_inlet, "FemTest of new Flow1D inlet constraint failed") + self.assertTrue( + Flow1d_inlet, + "FemTest of new Flow1D inlet constraint failed" + ) analysis.addObject(Flow1d_inlet) fcc_print('Checking FEM new Flow1D entrance constraint...') - Flow1d_entrance = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_entrance = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_entrance.SectionType = 'Liquid' Flow1d_entrance.LiquidSectionType = 'PIPE ENTRANCE' Flow1d_entrance.EntrancePipeArea = 31416.00 Flow1d_entrance.EntranceArea = 25133.00 Flow1d_entrance.References = [(line, "Edge2")] - self.assertTrue(Flow1d_entrance, "FemTest of new Flow1D entrance constraint failed") + self.assertTrue( + Flow1d_entrance, "FemTest of new Flow1D entrance constraint failed" + ) analysis.addObject(Flow1d_entrance) fcc_print('Checking FEM new Flow1D manning constraint...') - Flow1d_manning = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_manning = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_manning.SectionType = 'Liquid' Flow1d_manning.LiquidSectionType = 'PIPE MANNING' Flow1d_manning.ManningArea = 31416 Flow1d_manning.ManningRadius = 50 Flow1d_manning.ManningCoefficient = 0.002 Flow1d_manning.References = [(line, "Edge3"), (line, "Edge5")] - self.assertTrue(Flow1d_manning, "FemTest of new Flow1D manning constraint failed") + self.assertTrue( + Flow1d_manning, + "FemTest of new Flow1D manning constraint failed" + ) analysis.addObject(Flow1d_manning) fcc_print('Checking FEM new Flow1D bend constraint...') - Flow1d_bend = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_bend = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_bend.SectionType = 'Liquid' Flow1d_bend.LiquidSectionType = 'PIPE BEND' Flow1d_bend.BendPipeArea = 31416 @@ -619,86 +959,137 @@ class TestCcxTools(unittest.TestCase): Flow1d_bend.BendAngle = 45 Flow1d_bend.BendLossCoefficient = 0.4 Flow1d_bend.References = [(line, "Edge4")] - self.assertTrue(Flow1d_bend, "FemTest of new Flow1D bend constraint failed") + self.assertTrue( + Flow1d_bend, + "FemTest of new Flow1D bend constraint failed" + ) analysis.addObject(Flow1d_bend) fcc_print('Checking FEM new Flow1D enlargement constraint...') - Flow1d_enlargement = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_enlargement = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_enlargement.SectionType = 'Liquid' Flow1d_enlargement.LiquidSectionType = 'PIPE ENLARGEMENT' Flow1d_enlargement.EnlargeArea1 = 31416.00 Flow1d_enlargement.EnlargeArea2 = 70686.00 Flow1d_enlargement.References = [(line, "Edge6")] - self.assertTrue(Flow1d_enlargement, "FemTest of new Flow1D enlargement constraint failed") + self.assertTrue( + Flow1d_enlargement, + "FemTest of new Flow1D enlargement constraint failed" + ) analysis.addObject(Flow1d_enlargement) fcc_print('Checking FEM new Flow1D manning constraint...') - Flow1d_manning1 = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_manning1 = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_manning1.SectionType = 'Liquid' Flow1d_manning1.LiquidSectionType = 'PIPE MANNING' Flow1d_manning1.ManningArea = 70686.00 Flow1d_manning1.ManningRadius = 75 Flow1d_manning1.ManningCoefficient = 0.002 Flow1d_manning1.References = [(line, "Edge7")] - self.assertTrue(Flow1d_manning1, "FemTest of new Flow1D manning constraint failed") + self.assertTrue( + Flow1d_manning1, + "FemTest of new Flow1D manning constraint failed" + ) analysis.addObject(Flow1d_manning1) fcc_print('Checking FEM new Flow1D contraction constraint...') - Flow1d_contraction = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_contraction = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_contraction.SectionType = 'Liquid' Flow1d_contraction.LiquidSectionType = 'PIPE CONTRACTION' Flow1d_contraction.ContractArea1 = 70686 Flow1d_contraction.ContractArea2 = 17671 Flow1d_contraction.References = [(line, "Edge8")] - self.assertTrue(Flow1d_contraction, "FemTest of new Flow1D contraction constraint failed") + self.assertTrue( + Flow1d_contraction, + "FemTest of new Flow1D contraction constraint failed" + ) analysis.addObject(Flow1d_contraction) fcc_print('Checking FEM new Flow1D manning constraint...') - Flow1d_manning2 = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_manning2 = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_manning2.SectionType = 'Liquid' Flow1d_manning2.LiquidSectionType = 'PIPE MANNING' Flow1d_manning2.ManningArea = 17671.00 Flow1d_manning2.ManningRadius = 37.5 Flow1d_manning2.ManningCoefficient = 0.002 Flow1d_manning2.References = [(line, "Edge11"), (line, "Edge9")] - self.assertTrue(Flow1d_manning2, "FemTest of new Flow1D manning constraint failed") + self.assertTrue( + Flow1d_manning2, + "FemTest of new Flow1D manning constraint failed" + ) analysis.addObject(Flow1d_manning2) fcc_print('Checking FEM new Flow1D gate valve constraint...') - Flow1d_gate_valve = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_gate_valve = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_gate_valve.SectionType = 'Liquid' Flow1d_gate_valve.LiquidSectionType = 'PIPE GATE VALVE' Flow1d_gate_valve.GateValvePipeArea = 17671 Flow1d_gate_valve.GateValveClosingCoeff = 0.5 Flow1d_gate_valve.References = [(line, "Edge10")] - self.assertTrue(Flow1d_gate_valve, "FemTest of new Flow1D gate valve constraint failed") + self.assertTrue( + Flow1d_gate_valve, + "FemTest of new Flow1D gate valve constraint failed" + ) analysis.addObject(Flow1d_gate_valve) fcc_print('Checking FEM new Flow1D enlargement constraint...') - Flow1d_enlargement1 = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_enlargement1 = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_enlargement1.SectionType = 'Liquid' Flow1d_enlargement1.LiquidSectionType = 'PIPE ENLARGEMENT' Flow1d_enlargement1.EnlargeArea1 = 17671 Flow1d_enlargement1.EnlargeArea2 = 1e12 Flow1d_enlargement1.References = [(line, "Edge12")] - self.assertTrue(Flow1d_enlargement1, "FemTest of new Flow1D enlargement constraint failed") + self.assertTrue( + Flow1d_enlargement1, + "FemTest of new Flow1D enlargement constraint failed" + ) analysis.addObject(Flow1d_enlargement1) fcc_print('Checking FEM Flow1D outlet constraint...') - Flow1d_outlet = ObjectsFem.makeElementFluid1D(self.active_doc, "ElementFluid1D") + Flow1d_outlet = ObjectsFem.makeElementFluid1D( + self.active_doc, + "ElementFluid1D" + ) Flow1d_outlet.SectionType = 'Liquid' Flow1d_outlet.LiquidSectionType = 'PIPE OUTLET' Flow1d_outlet.OutletPressure = 0.1 Flow1d_outlet.References = [(line, "Edge13")] - self.assertTrue(Flow1d_outlet, "FemTest of new Flow1D inlet constraint failed") + self.assertTrue( + Flow1d_outlet, + "FemTest of new Flow1D inlet constraint failed" + ) analysis.addObject(Flow1d_outlet) fcc_print('Checking FEM self weight constraint...') - Flow1d_self_weight = ObjectsFem.makeConstraintSelfWeight(self.active_doc, "ConstraintSelfWeight") + Flow1d_self_weight = ObjectsFem.makeConstraintSelfWeight( + self.active_doc, + "ConstraintSelfWeight" + ) Flow1d_self_weight.Gravity_x = 0.0 Flow1d_self_weight.Gravity_y = 0.0 Flow1d_self_weight.Gravity_z = -1.0 - self.assertTrue(Flow1d_outlet, "FemTest of new Flow1D self weight constraint failed") + self.assertTrue( + Flow1d_outlet, + "FemTest of new Flow1D self weight constraint failed" + ) analysis.addObject(Flow1d_self_weight) fcc_print('Checking FEM new mesh...') @@ -709,25 +1100,36 @@ class TestCcxTools(unittest.TestCase): self.assertTrue(ret, "Import of mesh nodes failed") ret = create_elements_Flow1D(mesh) self.assertTrue(ret, "Import of mesh volumes failed") - mesh_object = self.active_doc.addObject('Fem::FemMeshObject', self.mesh_name) + mesh_object = self.active_doc.addObject( + 'Fem::FemMeshObject', + self.mesh_name + ) mesh_object.FemMesh = mesh self.assertTrue(mesh, "FemTest of new mesh failed") analysis.addObject(mesh_object) self.active_doc.recompute() - Flow1D_thermomech_analysis_dir = testtools.get_unit_test_tmp_dir(self.temp_dir, 'FEM_ccx_Flow1D_thermomech') + Flow1D_thermomech_analysis_dir = testtools.get_unit_test_tmp_dir( + self.temp_dir, + 'FEM_ccx_Flow1D_thermomech' + ) fea = ccxtools.FemToolsCcx(analysis, test_mode=True) fea.update_objects() fcc_print('Setting up working directory {}'.format(Flow1D_thermomech_analysis_dir)) fea.setup_working_dir(Flow1D_thermomech_analysis_dir) - self.assertTrue(True if fea.working_dir == Flow1D_thermomech_analysis_dir else False, - "Setting working directory {} failed".format(Flow1D_thermomech_analysis_dir)) + self.assertTrue( + True if fea.working_dir == Flow1D_thermomech_analysis_dir else False, + "Setting working directory {} failed".format(Flow1D_thermomech_analysis_dir) + ) fcc_print('Checking FEM inp file prerequisites for thermo-mechanical analysis...') error = fea.check_prerequisites() - self.assertFalse(error, "ccxtools check_prerequisites returned error message: {}".format(error)) + self.assertFalse( + error, + "ccxtools check_prerequisites returned error message: {}".format(error) + ) Flow1D_thermomech_base_name = 'Flow1D_thermomech' inpfile_given = join(self.test_file_dir, (Flow1D_thermomech_base_name + '.inp')) @@ -735,49 +1137,100 @@ class TestCcxTools(unittest.TestCase): fcc_print('Checking FEM inp file write...') fcc_print('Writing {} for thermomech analysis'.format(inpfile_totest)) error = fea.write_inp_file() - self.assertFalse(error, "Writing failed") + 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)) + 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)) + 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) - self.assertTrue(True if fea.working_dir == self.test_file_dir else False, - "Setting working directory {} failed".format(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('Flow1D_thermomech')) fea.set_base_name(Flow1D_thermomech_base_name) - self.assertTrue(True if fea.base_name == Flow1D_thermomech_base_name else False, - "Setting base name to {} failed".format(Flow1D_thermomech_base_name)) + self.assertTrue( + True if fea.base_name == Flow1D_thermomech_base_name else False, + "Setting base name to {} failed".format(Flow1D_thermomech_base_name) + ) fcc_print('Setting inp file name to read test {}.frd file...'.format('Flow1D_thermomech')) 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)) + 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 Flow1D thermomech analysis...') fea.load_results() - self.assertTrue(fea.results_present, "Cannot read results from {}.frd frd file".format(fea.base_name)) + self.assertTrue( + fea.results_present, + "Cannot read results from {}.frd frd file".format(fea.base_name) + ) fcc_print('Reading stats from result object for Flow1D thermomech analysis...') - Flow1D_thermomech_expected_values = join(self.test_file_dir, "Flow1D_thermomech_expected_values") - stat_types = ["U1", "U2", "U3", "Uabs", "Sabs", "MaxPrin", "MidPrin", "MinPrin", "MaxShear", "Peeq", "Temp", "MFlow", "NPress"] - ret = testtools.compare_stats(fea, Flow1D_thermomech_expected_values, stat_types, 'CalculiX_thermomech_time_1_0_results') - self.assertFalse(ret, "Invalid results read from .frd file") + Flow1D_thermomech_expected_values = join( + self.test_file_dir, + "Flow1D_thermomech_expected_values" + ) + stat_types = [ + "U1", + "U2", + "U3", + "Uabs", + "Sabs", + "MaxPrin", + "MidPrin", + "MinPrin", + "MaxShear", + "Peeq", + "Temp", + "MFlow", + "NPress" + ] + ret = testtools.compare_stats( + fea, Flow1D_thermomech_expected_values, + stat_types, + 'CalculiX_thermomech_time_1_0_results') + self.assertFalse( + ret, + "Invalid results read from .frd file" + ) - Flow1D_thermomech_save_fc_file = Flow1D_thermomech_analysis_dir + Flow1D_thermomech_base_name + '.FCStd' - fcc_print('Save FreeCAD file for thermomech analysis to {}...'.format(Flow1D_thermomech_save_fc_file)) + Flow1D_thermomech_save_fc_file = join( + Flow1D_thermomech_analysis_dir, + (Flow1D_thermomech_base_name + '.FCStd') + ) + fcc_print( + 'Save FreeCAD file for thermomech analysis to {}...' + .format(Flow1D_thermomech_save_fc_file) + ) self.active_doc.saveAs(Flow1D_thermomech_save_fc_file) fcc_print('--------------- End of FEM tests FLow 1D thermomech analysis ---------------') - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): # clearance, is executed after every test FreeCAD.closeDocument(self.doc_name) pass +# ************************************************************************************************ def create_test_results(): import shutil @@ -786,7 +1239,12 @@ def create_test_results(): import femresult.resulttools as resulttools from femtools import ccxtools - stat_types = ["U1", "U2", "U3", "Uabs", "Sabs", "MaxPrin", "MidPrin", "MinPrin", "MaxShear", "Peeq", "Temp", "MFlow", "NPress"] + stat_types = [ + "U1", "U2", "U3", "Uabs", + "Sabs", + "MaxPrin", "MidPrin", "MinPrin", "MaxShear", + "Peeq", "Temp", "MFlow", "NPress" + ] temp_dir = testtools.get_fem_test_tmp_dir() static_analysis_dir = temp_dir + 'FEM_ccx_static/' frequency_analysis_dir = temp_dir + 'FEM_ccx_frequency/' @@ -811,9 +1269,18 @@ def create_test_results(): fea.load_results() stats_static = [] for s in stat_types: - statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject('CalculiX_static_results'), s) - stats_static.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2])) - static_expected_values_file = static_analysis_dir + 'cube_static_expected_values' + statval = resulttools.get_stats( + FreeCAD.ActiveDocument.getObject('CalculiX_static_results'), + s + ) + stats_static.append( + "{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n" + .format(s, statval[0], statval[1], statval[2]) + ) + static_expected_values_file = join( + static_analysis_dir, + 'cube_static_expected_values' + ) f = open(static_expected_values_file, 'w') for s in stats_static: f.write(s) @@ -838,9 +1305,18 @@ def create_test_results(): fea.load_results() stats_frequency = [] for s in stat_types: - statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject('CalculiX_frequency_mode_1_results'), s) - stats_frequency.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2])) - frequency_expected_values_file = frequency_analysis_dir + 'cube_frequency_expected_values' + statval = resulttools.get_stats( + FreeCAD.ActiveDocument.getObject('CalculiX_frequency_mode_1_results'), + s + ) + stats_frequency.append( + "{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n" + .format(s, statval[0], statval[1], statval[2]) + ) + frequency_expected_values_file = join( + frequency_analysis_dir, + 'cube_frequency_expected_values' + ) f = open(frequency_expected_values_file, 'w') for s in stats_frequency: f.write(s) @@ -860,9 +1336,18 @@ def create_test_results(): fea.load_results() stats_thermomech = [] for s in stat_types: - statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject('CalculiX_thermomech_results'), s) - stats_thermomech.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2])) - thermomech_expected_values_file = thermomech_analysis_dir + 'spine_thermomech_expected_values' + statval = resulttools.get_stats( + FreeCAD.ActiveDocument.getObject('CalculiX_thermomech_results'), + s + ) + stats_thermomech.append( + "{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n" + .format(s, statval[0], statval[1], statval[2]) + ) + thermomech_expected_values_file = join( + thermomech_analysis_dir, + 'spine_thermomech_expected_values' + ) f = open(thermomech_expected_values_file, 'w') for s in stats_thermomech: f.write(s) @@ -885,17 +1370,32 @@ def create_test_results(): fea.load_results() stats_flow1D = [] for s in stat_types: - statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject('CalculiX_thermomech_time_1_0_results'), s) - stats_flow1D.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2])) - Flow1D_thermomech_expected_values_file = Flow1D_thermomech_analysis_dir + 'Flow1D_thermomech_expected_values' + statval = resulttools.get_stats( + FreeCAD.ActiveDocument.getObject('CalculiX_thermomech_time_1_0_results'), + s + ) + stats_flow1D.append( + "{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n" + .format(s, statval[0], statval[1], statval[2]) + ) + Flow1D_thermomech_expected_values_file = join( + Flow1D_thermomech_analysis_dir, + 'Flow1D_thermomech_expected_values' + ) f = open(Flow1D_thermomech_expected_values_file, 'w') for s in stats_flow1D: f.write(s) f.close() frd_result_file = os.path.splitext(fea.inp_file_name)[0] + '.frd' dat_result_file = os.path.splitext(fea.inp_file_name)[0] + '.dat' - frd_Flow1D_thermomech_test_result_file = Flow1D_thermomech_analysis_dir + 'Flow1D_thermomech.frd' - dat_Flow1D_thermomech_test_result_file = Flow1D_thermomech_analysis_dir + 'Flow1D_thermomech.dat' + frd_Flow1D_thermomech_test_result_file = join( + Flow1D_thermomech_analysis_dir, + 'Flow1D_thermomech.frd' + ) + dat_Flow1D_thermomech_test_result_file = join( + Flow1D_thermomech_analysis_dir, + 'Flow1D_thermomech.dat' + ) shutil.copyfile(frd_result_file, frd_Flow1D_thermomech_test_result_file) shutil.copyfile(dat_result_file, dat_Flow1D_thermomech_test_result_file) print('Flow1D thermomech results copied to the appropriate FEM test dirs in: ' + temp_dir) @@ -914,5 +1414,6 @@ start FreeCAD and run FEM unit test if FEM unit test is fine --> commit new FEM unit test results TODO compare the inp file of the helper with the inp file of FEM unit tests -TODO the better way: move the result creation inside the TestFem and add some preference to deactivate this because it needs ccx +TODO the better way: move the result creation inside the TestFem +and add some preference to deactivate this because it needs ccx ''' diff --git a/src/Mod/Fem/femtest/testcommon.py b/src/Mod/Fem/femtest/testcommon.py index f73d42ccce..ab99160aa1 100644 --- a/src/Mod/Fem/femtest/testcommon.py +++ b/src/Mod/Fem/femtest/testcommon.py @@ -35,7 +35,10 @@ from os.path import join class TestFemCommon(unittest.TestCase): fcc_print('import TestFemCommon') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): # init, is executed before every test self.doc_name = "TestsFemCommon" try: @@ -46,23 +49,34 @@ class TestFemCommon(unittest.TestCase): FreeCAD.setActiveDocument(self.doc_name) self.active_doc = FreeCAD.ActiveDocument - def test_adding_refshaps(self): + # ******************************************************************************************** + def test_adding_refshaps( + self + ): doc = self.active_doc slab = doc.addObject("Part::Plane", "Face") slab.Length = 500.00 slab.Width = 500.00 cf = ObjectsFem.makeConstraintFixed(doc) ref_eles = [] - # FreeCAD list property seam not to support append, thus we need some workaround, which is on many elements even much faster + # FreeCAD list property seam not to support append, + # thus we need some workaround + # which is on many elements even much faster for i, face in enumerate(slab.Shape.Edges): ref_eles.append("Edge%d" % (i + 1)) cf.References = [(slab, ref_eles)] doc.recompute() expected_reflist = [(slab, ('Edge1', 'Edge2', 'Edge3', 'Edge4'))] - assert_err_message = 'Adding reference shapes did not result in expected list ' + str(cf.References) + ' != ' + str(expected_reflist) + assert_err_message = ( + 'Adding reference shapes did not result in expected list {} != {}' + .format(cf.References, expected_reflist) + ) self.assertEqual(cf.References, expected_reflist, assert_err_message) - def test_pyimport_all_FEM_modules(self): + # ******************************************************************************************** + def test_pyimport_all_FEM_modules( + self + ): # we're going to try to import all python modules from FreeCAD Fem pymodules = [] @@ -76,7 +90,8 @@ class TestFemCommon(unittest.TestCase): pymodules += testtools.collect_python_modules('femtest') pymodules += testtools.collect_python_modules('femtools') pymodules += testtools.collect_python_modules('femsolver') - # TODO test with join on windows, the use of os.path.join in following code seams to make problems on windws os + # TODO test with join on windows, the use of os.path.join + # in following code seams to make problems on windws os pymodules += testtools.collect_python_modules('femsolver/elmer') pymodules += testtools.collect_python_modules('femsolver/elmer/equations') pymodules += testtools.collect_python_modules('femsolver/z88') @@ -94,10 +109,14 @@ class TestFemCommon(unittest.TestCase): except: im = False if not im: - __import__('{0}'.format(mod)) # to get an error message what was going wrong + # to get an error message what was going wrong + __import__('{0}'.format(mod)) self.assertTrue(im, 'Problem importing {0}'.format(mod)) - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): # clearance, is executed after every test FreeCAD.closeDocument(self.doc_name) pass diff --git a/src/Mod/Fem/femtest/testmaterial.py b/src/Mod/Fem/femtest/testmaterial.py index 3c37dede96..113c736e60 100644 --- a/src/Mod/Fem/femtest/testmaterial.py +++ b/src/Mod/Fem/femtest/testmaterial.py @@ -33,7 +33,10 @@ from os.path import join class TestMaterialUnits(unittest.TestCase): fcc_print('import TestMaterialUnits') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): # init, is executed before every test self.doc_name = "TestMaterialUnits" try: @@ -44,7 +47,10 @@ class TestMaterialUnits(unittest.TestCase): FreeCAD.setActiveDocument(self.doc_name) self.active_doc = FreeCAD.ActiveDocument - def test_known_quantity_units(self): + # ******************************************************************************************** + def test_known_quantity_units( + self + ): from materialtools.cardutils import get_known_material_quantity_parameter as knownquant known_quantity_parameter = knownquant() from materialtools.cardutils import check_parm_unit as checkparamunit @@ -52,17 +58,27 @@ class TestMaterialUnits(unittest.TestCase): fcc_print('{}'.format(param)) self.assertTrue( checkparamunit(param), - 'Unit of quantity material parameter {} is not known by FreeCAD unit system.' + 'Unit of quantity material parameter {} ' + 'is not known by FreeCAD unit system.' .format(param) ) - def test_material_card_quantities(self): - # test the value and unit of known quantity parameter from solid build in material cards + # ******************************************************************************************** + def test_material_card_quantities( + self + ): + # test the value and unit of known quantity parameter + # from solid build in material cards # keep in mind only if FreeCAD is installed all materials are copied # TODO Fluid materials (are they installed?) # get build in materials - builtin_solid_mat_dir = join(FreeCAD.getResourceDir(), "Mod", "Material", "StandardMaterial") + builtin_solid_mat_dir = join( + FreeCAD.getResourceDir(), + "Mod", + "Material", + "StandardMaterial" + ) fcc_print('{}'.format(builtin_solid_mat_dir)) from materialtools.cardutils import add_cards_from_a_dir as addmats materials, cards, icons = addmats({}, {}, {}, builtin_solid_mat_dir, '') @@ -84,7 +100,10 @@ class TestMaterialUnits(unittest.TestCase): .format(value, param) ) - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): # clearance, is executed after every test FreeCAD.closeDocument(self.doc_name) pass diff --git a/src/Mod/Fem/femtest/testmesh.py b/src/Mod/Fem/femtest/testmesh.py index a5ebdab363..cab985c9a0 100644 --- a/src/Mod/Fem/femtest/testmesh.py +++ b/src/Mod/Fem/femtest/testmesh.py @@ -35,7 +35,10 @@ from os.path import join class TestMeshCommon(unittest.TestCase): fcc_print('import TestMeshCommon') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): # init, is executed before every test self.doc_name = "TestMeshCommon" try: @@ -46,7 +49,10 @@ class TestMeshCommon(unittest.TestCase): FreeCAD.setActiveDocument(self.doc_name) self.active_doc = FreeCAD.ActiveDocument - def test_mesh_seg2_python(self): + # ******************************************************************************************** + def test_mesh_seg2_python( + self + ): seg2 = Fem.FemMesh() seg2.addNode(0, 0, 0, 1) seg2.addNode(2, 0, 0, 2) @@ -54,14 +60,40 @@ class TestMeshCommon(unittest.TestCase): seg2.addEdge([1, 2]) seg2.addEdge([2, 3], 2) - node_data = [seg2.NodeCount, seg2.Nodes] - edge_data = [seg2.EdgeCount, seg2.Edges[0], seg2.getElementNodes(seg2.Edges[0]), seg2.Edges[1], seg2.getElementNodes(seg2.Edges[1])] - expected_nodes = [3, {1: FreeCAD.Vector(0.0, 0.0, 0.0), 2: FreeCAD.Vector(2.0, 0.0, 0.0), 3: FreeCAD.Vector(4.0, 0.0, 0.0)}] + node_data = [ + seg2.NodeCount, + seg2.Nodes + ] + edge_data = [ + seg2.EdgeCount, + seg2.Edges[0], + seg2.getElementNodes(seg2.Edges[0]), + seg2.Edges[1], + seg2.getElementNodes(seg2.Edges[1]) + ] + expected_nodes = [ + 3, + { + 1: FreeCAD.Vector(0.0, 0.0, 0.0), + 2: FreeCAD.Vector(2.0, 0.0, 0.0), + 3: FreeCAD.Vector(4.0, 0.0, 0.0) + } + ] expected_edges = [2, 1, (1, 2), 2, (2, 3)] - self.assertEqual(node_data, expected_nodes, "Nodes of Python created seg2 element are unexpected") - self.assertEqual(edge_data, expected_edges, "Edges of Python created seg2 element are unexpected") + self.assertEqual( + node_data, + expected_nodes, + "Nodes of Python created seg2 element are unexpected" + ) + self.assertEqual( + edge_data, expected_edges, + "Edges of Python created seg2 element are unexpected" + ) - def test_mesh_seg3_python(self): + # ******************************************************************************************** + def test_mesh_seg3_python( + self + ): seg3 = Fem.FemMesh() seg3.addNode(0, 0, 0, 1) seg3.addNode(1, 0, 0, 2) @@ -72,7 +104,13 @@ class TestMeshCommon(unittest.TestCase): seg3.addEdge([3, 5, 4], 2) node_data = [seg3.NodeCount, seg3.Nodes] - edge_data = [seg3.EdgeCount, seg3.Edges[0], seg3.getElementNodes(seg3.Edges[0]), seg3.Edges[1], seg3.getElementNodes(seg3.Edges[1])] + edge_data = [ + seg3.EdgeCount, + seg3.Edges[0], + seg3.getElementNodes(seg3.Edges[0]), + seg3.Edges[1], + seg3.getElementNodes(seg3.Edges[1]) + ] expected_nodes = [ 5, { 1: FreeCAD.Vector(0.0, 0.0, 0.0), @@ -83,10 +121,21 @@ class TestMeshCommon(unittest.TestCase): } ] expected_edges = [2, 1, (1, 3, 2), 2, (3, 5, 4)] - self.assertEqual(node_data, expected_nodes, "Nodes of Python created seg3 element are unexpected") - self.assertEqual(edge_data, expected_edges, "Edges of Python created seg3 element are unexpected") + self.assertEqual( + node_data, + expected_nodes, + "Nodes of Python created seg3 element are unexpected" + ) + self.assertEqual( + edge_data, + expected_edges, + "Edges of Python created seg3 element are unexpected" + ) - def test_unv_save_load(self): + # ******************************************************************************************** + def test_unv_save_load( + self + ): tetra10 = Fem.FemMesh() tetra10.addNode(6, 12, 18, 1) tetra10.addNode(0, 0, 18, 2) @@ -106,16 +155,28 @@ class TestMeshCommon(unittest.TestCase): tetra10.write(unv_file) newmesh = Fem.read(unv_file) expected = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) - self.assertEqual(newmesh.getElementNodes(1), expected, "Nodes order of quadratic volume element is unexpected") + self.assertEqual( + newmesh.getElementNodes(1), + expected, + "Nodes order of quadratic volume element is unexpected" + ) - def test_writeAbaqus_precision(self): + # ******************************************************************************************** + def test_writeAbaqus_precision( + self + ): # https://forum.freecadweb.org/viewtopic.php?f=18&t=22759#p176669 # ccx reads only F20.0 (i. e. Fortran floating point field 20 chars wide) # thus precision is set to 13 in writeAbaqus seg2 = Fem.FemMesh() seg2.addNode(0, 0, 0, 1) - # 1234567890123456789012 1234567890123456789012 123456789012345678901234567 - seg2.addNode(-5000000000000000000.1, -1.123456789123456e-14, -0.1234567890123456789e-101, 2) + seg2.addNode( + # 3456789012345678901234567 + -5000000000000000000.1, + -1.123456789123456e-14, + -0.1234567890123456789e-101, + 2 + ) seg2.addEdge([1, 2]) inp_file = testtools.get_fem_test_tmp_dir() + '/seg2_mesh.inp' @@ -133,18 +194,30 @@ class TestMeshCommon(unittest.TestCase): expected_win = '2, -5e+018, -1.123456789123e-014, -1.234567890123e-102' expected_lin = '2, -5e+18, -1.123456789123e-14, -1.234567890123e-102' expected = [expected_lin, expected_win] - self.assertTrue(True if read_node_line in expected else False, - "Problem in test_writeAbaqus_precision, \n{0}\n{1}".format(read_node_line, expected)) + self.assertTrue( + True if read_node_line in expected else False, + "Problem in test_writeAbaqus_precision, \n{0}\n{1}".format( + read_node_line, + expected + ) + ) - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): FreeCAD.closeDocument(self.doc_name) pass +# ************************************************************************************************ class TestMeshEleTetra10(unittest.TestCase): fcc_print('import TestMeshEleTetra10') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): self.doc_name = "TestMeshEleTetra10" try: FreeCAD.setActiveDocument(self.doc_name) @@ -155,8 +228,15 @@ class TestMeshEleTetra10(unittest.TestCase): self.active_doc = FreeCAD.ActiveDocument self.elem = 'tetra10' - self.base_testfile = join(testtools.get_fem_test_home_dir(), 'mesh', (self.elem + '_mesh.')) - self.base_outfile = join(testtools.get_fem_test_tmp_dir(), (self.elem + '_mesh.')) + self.base_testfile = join( + testtools.get_fem_test_home_dir(), + 'mesh', + (self.elem + '_mesh.') + ) + self.base_outfile = join( + testtools.get_fem_test_tmp_dir(), + (self.elem + '_mesh.') + ) # 10 node tetrahedron --> tetra10 femmesh = Fem.FemMesh() femmesh.addNode(6, 12, 18, 1) @@ -198,7 +278,10 @@ class TestMeshEleTetra10(unittest.TestCase): fcc_print('\n') ''' - def test_tetra10_create(self): + # ******************************************************************************************** + def test_tetra10_create( + self + ): # tetra10 element: creating by Python node_data = { 'count': self.femmesh.NodeCount, @@ -207,10 +290,21 @@ class TestMeshEleTetra10(unittest.TestCase): elem_data = { 'volcount': self.femmesh.VolumeCount, 'tetcount': self.femmesh.TetraCount, - 'volumes': [self.femmesh.Volumes[0], self.femmesh.getElementNodes(self.femmesh.Volumes[0])] + 'volumes': [ + self.femmesh.Volumes[0], + self.femmesh.getElementNodes(self.femmesh.Volumes[0]) + ] } - self.assertEqual(node_data, self.expected_nodes, "Nodes of Python created " + self.elem + "mesh element are unexpected") - self.assertEqual(elem_data, self.expected_elem, "Elements of Python created " + self.elem + "mesh element are unexpected") + self.assertEqual( + node_data, + self.expected_nodes, + "Nodes of Python created " + self.elem + "mesh element are unexpected" + ) + self.assertEqual( + elem_data, + self.expected_elem, + "Elements of Python created " + self.elem + "mesh element are unexpected" + ) ''' obj = doc.addObject("Fem::FemMeshObject" , elem) obj.FemMesh = femmesh @@ -218,7 +312,10 @@ class TestMeshEleTetra10(unittest.TestCase): obj.ViewObject.DisplayMode = "Faces, Wireframe & Nodes" ''' - def test_tetra10_inp(self): + # ******************************************************************************************** + def test_tetra10_inp( + self + ): # tetra10 element: reading from and writing to inp mesh file format filetyp = 'inp' outfile = self.base_outfile + filetyp @@ -229,41 +326,79 @@ class TestMeshEleTetra10(unittest.TestCase): femmesh_outfile = Fem.read(outfile) # read the mesh from written mesh femmesh_testfile = Fem.read(testfile) # read the mesh from test mesh # reading the test mesh - # fcc_print([femmesh_testfile.Volumes[0], femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0])]) + # ''' + fcc_print([ + femmesh_testfile.Volumes[0], + femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0]) + ]) + # ''' self.assertEqual( femmesh_testfile.Nodes, self.expected_nodes['nodes'], - "Test reading " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_testfile.Volumes[0], femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0])], + [ + femmesh_testfile.Volumes[0], + femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], self.expected_elem['volumes'], - "Test reading " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) # reading the written mesh self.assertEqual( femmesh_outfile.Nodes, self.expected_nodes['nodes'], - "Test reading " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_outfile.Volumes[0], femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0])], + [ + femmesh_outfile.Volumes[0], + femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], self.expected_elem['volumes'], - "Test reading " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) # both self.assertEqual( femmesh_outfile.Nodes, femmesh_testfile.Nodes, - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_outfile.Volumes[0], femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0])], - [femmesh_testfile.Volumes[0], femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0])], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + [ + femmesh_outfile.Volumes[0], + femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], + [ + femmesh_testfile.Volumes[0], + femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) - def test_tetra10_unv(self): + # ******************************************************************************************** + def test_tetra10_unv( + self + ): # tetra10 element: reading from and writing to unv mesh file format filetyp = 'unv' outfile = self.base_outfile + filetyp @@ -277,37 +412,64 @@ class TestMeshEleTetra10(unittest.TestCase): self.assertEqual( femmesh_testfile.Nodes, self.expected_nodes['nodes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_testfile.Volumes[0], femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0])], + [ + femmesh_testfile.Volumes[0], + femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], self.expected_elem['volumes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) # reading the written mesh self.assertEqual( femmesh_outfile.Nodes, self.expected_nodes['nodes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_outfile.Volumes[0], femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0])], + [ + femmesh_outfile.Volumes[0], + femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], self.expected_elem['volumes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) # both self.assertEqual( femmesh_outfile.Nodes, femmesh_testfile.Nodes, - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( femmesh_outfile.Volumes, femmesh_testfile.Volumes, - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) - def test_tetra10_vkt(self): + # ******************************************************************************************** + def test_tetra10_vkt( + self + ): # tetra10 element: reading from and writing to unv mesh file format filetyp = 'vtk' outfile = self.base_outfile + filetyp @@ -322,39 +484,66 @@ class TestMeshEleTetra10(unittest.TestCase): self.assertEqual( femmesh_testfile.Nodes, self.expected_nodes['nodes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_testfile.Volumes[0], femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0])], + [ + femmesh_testfile.Volumes[0], + femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], self.expected_elem['volumes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) # reading the written mesh self.assertEqual( femmesh_outfile.Nodes, self.expected_nodes['nodes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_outfile.Volumes[0], femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0])], + [ + femmesh_outfile.Volumes[0], + femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], self.expected_elem['volumes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) # both self.assertEqual( femmesh_outfile.Nodes, femmesh_testfile.Nodes, - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( femmesh_outfile.Volumes, femmesh_testfile.Volumes, - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) else: fcc_print('FEM_VTK post processing is disabled.') - def test_tetra10_z88(self): + # ******************************************************************************************** + def test_tetra10_z88( + self + ): # tetra10 element: reading from and writing to z88 mesh file format filetyp = 'z88' outfile = self.base_outfile + filetyp @@ -368,37 +557,64 @@ class TestMeshEleTetra10(unittest.TestCase): self.assertEqual( femmesh_testfile.Nodes, self.expected_nodes['nodes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_testfile.Volumes[0], femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0])], + [ + femmesh_testfile.Volumes[0], + femmesh_testfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], self.expected_elem['volumes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) # reading the written mesh self.assertEqual( femmesh_outfile.Nodes, self.expected_nodes['nodes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( - [femmesh_outfile.Volumes[0], femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0])], + [ + femmesh_outfile.Volumes[0], + femmesh_outfile.getElementNodes(femmesh_outfile.Volumes[0]) + ], self.expected_elem['volumes'], - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) # both self.assertEqual( femmesh_outfile.Nodes, femmesh_testfile.Nodes, - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Nodes are different.\n" + "Test reading {} mesh to {} file failed. Nodes are different.\n".format( + self.elem, + filetyp + ) ) self.assertEqual( femmesh_outfile.Volumes, femmesh_testfile.Volumes, - "Test writing " + self.elem + " mesh to " + filetyp + " file failed. Volumes are different.\n" + "Test reading {} mesh to {} file failed. Volumes are different.\n".format( + self.elem, + filetyp + ) ) - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): # clearance, is executed after every test FreeCAD.closeDocument(self.doc_name) pass diff --git a/src/Mod/Fem/femtest/testobject.py b/src/Mod/Fem/femtest/testobject.py index 8ed27013dd..1f4a5a85a1 100644 --- a/src/Mod/Fem/femtest/testobject.py +++ b/src/Mod/Fem/femtest/testobject.py @@ -33,7 +33,10 @@ from .utilstest import fcc_print class TestObjectCreate(unittest.TestCase): fcc_print('import TestObjectCreate') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): # init, is executed before every test self.doc_name = "TestObjectCreate" try: @@ -44,7 +47,10 @@ class TestObjectCreate(unittest.TestCase): FreeCAD.setActiveDocument(self.doc_name) self.active_doc = FreeCAD.ActiveDocument - def test_femobjects_make(self): + # ******************************************************************************************** + def test_femobjects_make( + self + ): doc = self.active_doc analysis = ObjectsFem.makeAnalysis(doc) @@ -114,17 +120,28 @@ class TestObjectCreate(unittest.TestCase): fem_vtk_post = True else: fem_vtk_post = False - self.assertEqual(len(analysis.Group), testtools.get_defmake_count(fem_vtk_post) - 1) # because of the analysis itself count -1 + # because of the analysis itself count -1 + self.assertEqual( + len(analysis.Group), + testtools.get_defmake_count(fem_vtk_post) - 1 + ) - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): FreeCAD.closeDocument(self.doc_name) pass +# ************************************************************************************************ class TestObjectType(unittest.TestCase): fcc_print('import TestObjectType') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): self.doc_name = "TestObjectType" try: FreeCAD.setActiveDocument(self.doc_name) @@ -134,114 +151,379 @@ class TestObjectType(unittest.TestCase): FreeCAD.setActiveDocument(self.doc_name) self.active_doc = FreeCAD.ActiveDocument - def test_femobjects_type(self): + # ******************************************************************************************** + def test_femobjects_type( + self + ): doc = self.active_doc from femtools.femutils import type_of_obj - self.assertEqual('Fem::FemAnalysis', type_of_obj(ObjectsFem.makeAnalysis(doc))) - self.assertEqual('Fem::ConstraintBearing', type_of_obj(ObjectsFem.makeConstraintBearing(doc))) - self.assertEqual('Fem::ConstraintBodyHeatSource', type_of_obj(ObjectsFem.makeConstraintBodyHeatSource(doc))) - self.assertEqual('Fem::ConstraintContact', type_of_obj(ObjectsFem.makeConstraintContact(doc))) - self.assertEqual('Fem::ConstraintDisplacement', type_of_obj(ObjectsFem.makeConstraintDisplacement(doc))) - self.assertEqual('Fem::ConstraintElectrostaticPotential', type_of_obj(ObjectsFem.makeConstraintElectrostaticPotential(doc))) - self.assertEqual('Fem::ConstraintFixed', type_of_obj(ObjectsFem.makeConstraintFixed(doc))) - self.assertEqual('Fem::ConstraintFlowVelocity', type_of_obj(ObjectsFem.makeConstraintFlowVelocity(doc))) - self.assertEqual('Fem::ConstraintFluidBoundary', type_of_obj(ObjectsFem.makeConstraintFluidBoundary(doc))) - self.assertEqual('Fem::ConstraintForce', type_of_obj(ObjectsFem.makeConstraintForce(doc))) - self.assertEqual('Fem::ConstraintGear', type_of_obj(ObjectsFem.makeConstraintGear(doc))) - self.assertEqual('Fem::ConstraintHeatflux', type_of_obj(ObjectsFem.makeConstraintHeatflux(doc))) - self.assertEqual('Fem::ConstraintInitialFlowVelocity', type_of_obj(ObjectsFem.makeConstraintInitialFlowVelocity(doc))) - self.assertEqual('Fem::ConstraintInitialTemperature', type_of_obj(ObjectsFem.makeConstraintInitialTemperature(doc))) - self.assertEqual('Fem::ConstraintPlaneRotation', type_of_obj(ObjectsFem.makeConstraintPlaneRotation(doc))) - self.assertEqual('Fem::ConstraintPressure', type_of_obj(ObjectsFem.makeConstraintPressure(doc))) - self.assertEqual('Fem::ConstraintPulley', type_of_obj(ObjectsFem.makeConstraintPulley(doc))) - self.assertEqual('Fem::ConstraintSelfWeight', type_of_obj(ObjectsFem.makeConstraintSelfWeight(doc))) - self.assertEqual('Fem::ConstraintTemperature', type_of_obj(ObjectsFem.makeConstraintTemperature(doc))) - self.assertEqual('Fem::ConstraintTransform', type_of_obj(ObjectsFem.makeConstraintTransform(doc))) - self.assertEqual('Fem::FemElementFluid1D', type_of_obj(ObjectsFem.makeElementFluid1D(doc))) - self.assertEqual('Fem::FemElementGeometry1D', type_of_obj(ObjectsFem.makeElementGeometry1D(doc))) - self.assertEqual('Fem::FemElementGeometry2D', type_of_obj(ObjectsFem.makeElementGeometry2D(doc))) - self.assertEqual('Fem::FemElementRotation1D', type_of_obj(ObjectsFem.makeElementRotation1D(doc))) + self.assertEqual( + 'Fem::FemAnalysis', + type_of_obj(ObjectsFem.makeAnalysis(doc)) + ) + self.assertEqual( + 'Fem::ConstraintBearing', + type_of_obj(ObjectsFem.makeConstraintBearing(doc)) + ) + self.assertEqual( + 'Fem::ConstraintBodyHeatSource', + type_of_obj(ObjectsFem.makeConstraintBodyHeatSource(doc)) + ) + self.assertEqual( + 'Fem::ConstraintContact', + type_of_obj(ObjectsFem.makeConstraintContact(doc)) + ) + self.assertEqual( + 'Fem::ConstraintDisplacement', + type_of_obj(ObjectsFem.makeConstraintDisplacement(doc)) + ) + self.assertEqual( + 'Fem::ConstraintElectrostaticPotential', + type_of_obj(ObjectsFem.makeConstraintElectrostaticPotential(doc)) + ) + self.assertEqual( + 'Fem::ConstraintFixed', + type_of_obj(ObjectsFem.makeConstraintFixed(doc)) + ) + self.assertEqual( + 'Fem::ConstraintFlowVelocity', + type_of_obj(ObjectsFem.makeConstraintFlowVelocity(doc)) + ) + self.assertEqual( + 'Fem::ConstraintFluidBoundary', + type_of_obj(ObjectsFem.makeConstraintFluidBoundary(doc)) + ) + self.assertEqual( + 'Fem::ConstraintForce', + type_of_obj(ObjectsFem.makeConstraintForce(doc)) + ) + self.assertEqual( + 'Fem::ConstraintGear', + type_of_obj(ObjectsFem.makeConstraintGear(doc)) + ) + self.assertEqual( + 'Fem::ConstraintHeatflux', + type_of_obj(ObjectsFem.makeConstraintHeatflux(doc)) + ) + self.assertEqual( + 'Fem::ConstraintInitialFlowVelocity', + type_of_obj(ObjectsFem.makeConstraintInitialFlowVelocity(doc)) + ) + self.assertEqual( + 'Fem::ConstraintInitialTemperature', + type_of_obj(ObjectsFem.makeConstraintInitialTemperature(doc)) + ) + self.assertEqual( + 'Fem::ConstraintPlaneRotation', + type_of_obj(ObjectsFem.makeConstraintPlaneRotation(doc)) + ) + self.assertEqual( + 'Fem::ConstraintPressure', + type_of_obj(ObjectsFem.makeConstraintPressure(doc)) + ) + self.assertEqual( + 'Fem::ConstraintPulley', + type_of_obj(ObjectsFem.makeConstraintPulley(doc)) + ) + self.assertEqual( + 'Fem::ConstraintSelfWeight', + type_of_obj(ObjectsFem.makeConstraintSelfWeight(doc)) + ) + self.assertEqual( + 'Fem::ConstraintTemperature', + type_of_obj(ObjectsFem.makeConstraintTemperature(doc)) + ) + self.assertEqual( + 'Fem::ConstraintTransform', + type_of_obj(ObjectsFem.makeConstraintTransform(doc)) + ) + self.assertEqual( + 'Fem::FemElementFluid1D', + type_of_obj(ObjectsFem.makeElementFluid1D(doc)) + ) + self.assertEqual( + 'Fem::FemElementGeometry1D', + type_of_obj(ObjectsFem.makeElementGeometry1D(doc)) + ) + self.assertEqual( + 'Fem::FemElementGeometry2D', + type_of_obj(ObjectsFem.makeElementGeometry2D(doc)) + ) + self.assertEqual( + 'Fem::FemElementRotation1D', + type_of_obj(ObjectsFem.makeElementRotation1D(doc)) + ) materialsolid = ObjectsFem.makeMaterialSolid(doc) - self.assertEqual('Fem::Material', type_of_obj(ObjectsFem.makeMaterialFluid(doc))) - self.assertEqual('Fem::Material', type_of_obj(materialsolid)) - self.assertEqual('Fem::MaterialMechanicalNonlinear', type_of_obj(ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid))) + self.assertEqual( + 'Fem::Material', + type_of_obj(ObjectsFem.makeMaterialFluid(doc)) + ) + self.assertEqual( + 'Fem::Material', + type_of_obj(materialsolid)) + self.assertEqual( + 'Fem::MaterialMechanicalNonlinear', + type_of_obj(ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid)) + ) mesh = ObjectsFem.makeMeshGmsh(doc) - self.assertEqual('Fem::FemMeshGmsh', type_of_obj(mesh)) - self.assertEqual('Fem::FemMeshBoundaryLayer', type_of_obj(ObjectsFem.makeMeshBoundaryLayer(doc, mesh))) - self.assertEqual('Fem::FemMeshGroup', type_of_obj(ObjectsFem.makeMeshGroup(doc, mesh))) - self.assertEqual('Fem::FemMeshRegion', type_of_obj(ObjectsFem.makeMeshRegion(doc, mesh))) - self.assertEqual('Fem::FemMeshShapeNetgenObject', type_of_obj(ObjectsFem.makeMeshNetgen(doc))) - self.assertEqual('Fem::FemMeshResult', type_of_obj(ObjectsFem.makeMeshResult(doc))) - self.assertEqual('Fem::FemResultMechanical', type_of_obj(ObjectsFem.makeResultMechanical(doc))) + self.assertEqual( + 'Fem::FemMeshGmsh', + type_of_obj(mesh)) + self.assertEqual( + 'Fem::FemMeshBoundaryLayer', + type_of_obj(ObjectsFem.makeMeshBoundaryLayer(doc, mesh)) + ) + self.assertEqual( + 'Fem::FemMeshGroup', + type_of_obj(ObjectsFem.makeMeshGroup(doc, mesh)) + ) + self.assertEqual( + 'Fem::FemMeshRegion', + type_of_obj(ObjectsFem.makeMeshRegion(doc, mesh)) + ) + self.assertEqual( + 'Fem::FemMeshShapeNetgenObject', + type_of_obj(ObjectsFem.makeMeshNetgen(doc)) + ) + self.assertEqual( + 'Fem::FemMeshResult', + type_of_obj(ObjectsFem.makeMeshResult(doc)) + ) + self.assertEqual( + 'Fem::FemResultMechanical', + type_of_obj(ObjectsFem.makeResultMechanical(doc)) + ) solverelmer = ObjectsFem.makeSolverElmer(doc) - self.assertEqual('Fem::FemSolverCalculixCcxTools', type_of_obj(ObjectsFem.makeSolverCalculixCcxTools(doc))) - self.assertEqual('Fem::FemSolverObjectCalculix', type_of_obj(ObjectsFem.makeSolverCalculix(doc))) - self.assertEqual('Fem::FemSolverObjectElmer', type_of_obj(solverelmer)) - self.assertEqual('Fem::FemSolverObjectZ88', type_of_obj(ObjectsFem.makeSolverZ88(doc))) - self.assertEqual('Fem::FemEquationElmerElasticity', type_of_obj(ObjectsFem.makeEquationElasticity(doc, solverelmer))) - self.assertEqual('Fem::FemEquationElmerElectrostatic', type_of_obj(ObjectsFem.makeEquationElectrostatic(doc, solverelmer))) - self.assertEqual('Fem::FemEquationElmerFlow', type_of_obj(ObjectsFem.makeEquationFlow(doc, solverelmer))) - self.assertEqual('Fem::FemEquationElmerFluxsolver', type_of_obj(ObjectsFem.makeEquationFluxsolver(doc, solverelmer))) - self.assertEqual('Fem::FemEquationElmerHeat', type_of_obj(ObjectsFem.makeEquationHeat(doc, solverelmer))) + self.assertEqual( + 'Fem::FemSolverCalculixCcxTools', + type_of_obj(ObjectsFem.makeSolverCalculixCcxTools(doc)) + ) + self.assertEqual( + 'Fem::FemSolverObjectCalculix', + type_of_obj(ObjectsFem.makeSolverCalculix(doc)) + ) + self.assertEqual( + 'Fem::FemSolverObjectElmer', + type_of_obj(solverelmer)) + self.assertEqual( + 'Fem::FemSolverObjectZ88', + type_of_obj(ObjectsFem.makeSolverZ88(doc)) + ) + self.assertEqual( + 'Fem::FemEquationElmerElasticity', + type_of_obj(ObjectsFem.makeEquationElasticity(doc, solverelmer)) + ) + self.assertEqual( + 'Fem::FemEquationElmerElectrostatic', + type_of_obj(ObjectsFem.makeEquationElectrostatic(doc, solverelmer)) + ) + self.assertEqual( + 'Fem::FemEquationElmerFlow', + type_of_obj(ObjectsFem.makeEquationFlow(doc, solverelmer)) + ) + self.assertEqual( + 'Fem::FemEquationElmerFluxsolver', + type_of_obj(ObjectsFem.makeEquationFluxsolver(doc, solverelmer)) + ) + self.assertEqual( + 'Fem::FemEquationElmerHeat', + type_of_obj(ObjectsFem.makeEquationHeat(doc, solverelmer)) + ) # is = 43 (just copy in empty file to test) # TODO: vtk post objs # TODO: use different type for fluid and solid material - def test_femobjects_isoftype(self): + # ******************************************************************************************** + def test_femobjects_isoftype( + self + ): doc = self.active_doc from femtools.femutils import is_of_type - self.assertTrue(is_of_type(ObjectsFem.makeAnalysis(doc), 'Fem::FemAnalysis')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintBearing(doc), 'Fem::ConstraintBearing')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintBodyHeatSource(doc), 'Fem::ConstraintBodyHeatSource')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintContact(doc), 'Fem::ConstraintContact')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintDisplacement(doc), 'Fem::ConstraintDisplacement')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintElectrostaticPotential(doc), 'Fem::ConstraintElectrostaticPotential')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintFixed(doc), 'Fem::ConstraintFixed')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintFlowVelocity(doc), 'Fem::ConstraintFlowVelocity')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintFluidBoundary(doc), 'Fem::ConstraintFluidBoundary')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintForce(doc), 'Fem::ConstraintForce')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintGear(doc), 'Fem::ConstraintGear')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintHeatflux(doc), 'Fem::ConstraintHeatflux')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintInitialFlowVelocity(doc), 'Fem::ConstraintInitialFlowVelocity')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintInitialTemperature(doc), 'Fem::ConstraintInitialTemperature')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintPlaneRotation(doc), 'Fem::ConstraintPlaneRotation')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintPressure(doc), 'Fem::ConstraintPressure')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintPulley(doc), 'Fem::ConstraintPulley')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintSelfWeight(doc), 'Fem::ConstraintSelfWeight')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintTemperature(doc), 'Fem::ConstraintTemperature')) - self.assertTrue(is_of_type(ObjectsFem.makeConstraintTransform(doc), 'Fem::ConstraintTransform')) - self.assertTrue(is_of_type(ObjectsFem.makeElementFluid1D(doc), 'Fem::FemElementFluid1D')) - self.assertTrue(is_of_type(ObjectsFem.makeElementGeometry1D(doc), 'Fem::FemElementGeometry1D')) - self.assertTrue(is_of_type(ObjectsFem.makeElementGeometry2D(doc), 'Fem::FemElementGeometry2D')) - self.assertTrue(is_of_type(ObjectsFem.makeElementRotation1D(doc), 'Fem::FemElementRotation1D')) + self.assertTrue(is_of_type( + ObjectsFem.makeAnalysis(doc), + 'Fem::FemAnalysis' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintBearing(doc), + 'Fem::ConstraintBearing' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintBodyHeatSource(doc), + 'Fem::ConstraintBodyHeatSource' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintContact(doc), + 'Fem::ConstraintContact' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintDisplacement(doc), + 'Fem::ConstraintDisplacement' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintElectrostaticPotential(doc), + 'Fem::ConstraintElectrostaticPotential' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintFixed(doc), + 'Fem::ConstraintFixed' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintFlowVelocity(doc), + 'Fem::ConstraintFlowVelocity' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintFluidBoundary(doc), + 'Fem::ConstraintFluidBoundary' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintForce(doc), + 'Fem::ConstraintForce' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintGear(doc), + 'Fem::ConstraintGear' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintHeatflux(doc), + 'Fem::ConstraintHeatflux' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintInitialFlowVelocity(doc), + 'Fem::ConstraintInitialFlowVelocity' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintInitialTemperature(doc), + 'Fem::ConstraintInitialTemperature' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintPlaneRotation(doc), + 'Fem::ConstraintPlaneRotation' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintPressure(doc), + 'Fem::ConstraintPressure' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintPulley(doc), + 'Fem::ConstraintPulley' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintSelfWeight(doc), + 'Fem::ConstraintSelfWeight' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintTemperature(doc), + 'Fem::ConstraintTemperature' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeConstraintTransform(doc), + 'Fem::ConstraintTransform' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeElementFluid1D(doc), + 'Fem::FemElementFluid1D' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeElementGeometry1D(doc), + 'Fem::FemElementGeometry1D' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeElementGeometry2D(doc), + 'Fem::FemElementGeometry2D' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeElementRotation1D(doc), + 'Fem::FemElementRotation1D' + )) materialsolid = ObjectsFem.makeMaterialSolid(doc) - self.assertTrue(is_of_type(ObjectsFem.makeMaterialFluid(doc), 'Fem::Material')) - self.assertTrue(is_of_type(materialsolid, 'Fem::Material')) - self.assertTrue(is_of_type(ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid), 'Fem::MaterialMechanicalNonlinear')) + self.assertTrue(is_of_type( + ObjectsFem.makeMaterialFluid(doc), + 'Fem::Material' + )) + self.assertTrue(is_of_type( + materialsolid, + 'Fem::Material' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid), + 'Fem::MaterialMechanicalNonlinear' + )) mesh = ObjectsFem.makeMeshGmsh(doc) - self.assertTrue(is_of_type(mesh, 'Fem::FemMeshGmsh')) - self.assertTrue(is_of_type(ObjectsFem.makeMeshBoundaryLayer(doc, mesh), 'Fem::FemMeshBoundaryLayer')) - self.assertTrue(is_of_type(ObjectsFem.makeMeshGroup(doc, mesh), 'Fem::FemMeshGroup')) - self.assertTrue(is_of_type(ObjectsFem.makeMeshRegion(doc, mesh), 'Fem::FemMeshRegion')) - self.assertTrue(is_of_type(ObjectsFem.makeMeshNetgen(doc), 'Fem::FemMeshShapeNetgenObject')) - self.assertTrue(is_of_type(ObjectsFem.makeMeshResult(doc), 'Fem::FemMeshResult')) - self.assertTrue(is_of_type(ObjectsFem.makeResultMechanical(doc), 'Fem::FemResultMechanical')) + self.assertTrue(is_of_type( + mesh, + 'Fem::FemMeshGmsh' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeMeshBoundaryLayer(doc, mesh), + 'Fem::FemMeshBoundaryLayer' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeMeshGroup(doc, mesh), + 'Fem::FemMeshGroup' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeMeshRegion(doc, mesh), + 'Fem::FemMeshRegion' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeMeshNetgen(doc), + 'Fem::FemMeshShapeNetgenObject' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeMeshResult(doc), + 'Fem::FemMeshResult' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeResultMechanical(doc), + 'Fem::FemResultMechanical' + )) solverelmer = ObjectsFem.makeSolverElmer(doc) - self.assertTrue(is_of_type(ObjectsFem.makeSolverCalculixCcxTools(doc), 'Fem::FemSolverCalculixCcxTools')) - self.assertTrue(is_of_type(ObjectsFem.makeSolverCalculix(doc), 'Fem::FemSolverObjectCalculix')) - self.assertTrue(is_of_type(solverelmer, 'Fem::FemSolverObjectElmer')) - self.assertTrue(is_of_type(ObjectsFem.makeSolverZ88(doc), 'Fem::FemSolverObjectZ88')) - self.assertTrue(is_of_type(ObjectsFem.makeEquationElasticity(doc, solverelmer), 'Fem::FemEquationElmerElasticity')) - self.assertTrue(is_of_type(ObjectsFem.makeEquationElectrostatic(doc, solverelmer), 'Fem::FemEquationElmerElectrostatic')) - self.assertTrue(is_of_type(ObjectsFem.makeEquationFlow(doc, solverelmer), 'Fem::FemEquationElmerFlow')) - self.assertTrue(is_of_type(ObjectsFem.makeEquationFluxsolver(doc, solverelmer), 'Fem::FemEquationElmerFluxsolver')) - self.assertTrue(is_of_type(ObjectsFem.makeEquationHeat(doc, solverelmer), 'Fem::FemEquationElmerHeat')) + self.assertTrue(is_of_type( + ObjectsFem.makeSolverCalculixCcxTools(doc), + 'Fem::FemSolverCalculixCcxTools' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeSolverCalculix(doc), + 'Fem::FemSolverObjectCalculix' + )) + self.assertTrue(is_of_type( + solverelmer, + 'Fem::FemSolverObjectElmer' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeSolverZ88(doc), + 'Fem::FemSolverObjectZ88' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeEquationElasticity(doc, solverelmer), + 'Fem::FemEquationElmerElasticity' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeEquationElectrostatic(doc, solverelmer), + 'Fem::FemEquationElmerElectrostatic' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeEquationFlow(doc, solverelmer), + 'Fem::FemEquationElmerFlow' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeEquationFluxsolver(doc, solverelmer), + 'Fem::FemEquationElmerFluxsolver' + )) + self.assertTrue(is_of_type( + ObjectsFem.makeEquationHeat(doc, solverelmer), + 'Fem::FemEquationElmerHeat' + )) # is = 43 (just copy in empty file to test) - def test_femobjects_derivedfromfem(self): - # try to add all possible True types from inheritance chain see https://forum.freecadweb.org/viewtopic.php?f=10&t=32625 + # ******************************************************************************************** + def test_femobjects_derivedfromfem( + self + ): + # try to add all possible True types from inheritance chain see + # https://forum.freecadweb.org/viewtopic.php?f=10&t=32625 doc = self.active_doc from femtools.femutils import is_derived_from @@ -250,232 +532,788 @@ class TestObjectType(unittest.TestCase): mesh = ObjectsFem.makeMeshGmsh(doc) solverelmer = ObjectsFem.makeSolverElmer(doc) - self.assertTrue(is_derived_from(ObjectsFem.makeAnalysis(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeAnalysis(doc), 'Fem::FemAnalysis')) + self.assertTrue(is_derived_from( + ObjectsFem.makeAnalysis(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeAnalysis(doc), + 'Fem::FemAnalysis' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintBearing(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintBearing(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintBearing(doc), 'Fem::ConstraintBearing')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintBearing(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintBearing(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintBearing(doc), + 'Fem::ConstraintBearing' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintBodyHeatSource(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintBodyHeatSource(doc), 'Fem::ConstraintPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintBodyHeatSource(doc), 'Fem::ConstraintBodyHeatSource')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintBodyHeatSource(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintBodyHeatSource(doc), + 'Fem::ConstraintPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintBodyHeatSource(doc), + 'Fem::ConstraintBodyHeatSource' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintContact(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintContact(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintContact(doc), 'Fem::ConstraintContact')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintContact(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintContact(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintContact(doc), + 'Fem::ConstraintContact' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintDisplacement(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintDisplacement(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintDisplacement(doc), 'Fem::ConstraintDisplacement')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintDisplacement(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintDisplacement(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintDisplacement(doc), + 'Fem::ConstraintDisplacement' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintElectrostaticPotential(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintElectrostaticPotential(doc), 'Fem::ConstraintPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintElectrostaticPotential(doc), 'Fem::ConstraintElectrostaticPotential')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintElectrostaticPotential(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintElectrostaticPotential(doc), + 'Fem::ConstraintPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintElectrostaticPotential(doc), + 'Fem::ConstraintElectrostaticPotential' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFixed(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFixed(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFixed(doc), 'Fem::ConstraintFixed')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFixed(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFixed(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFixed(doc), + 'Fem::ConstraintFixed' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFlowVelocity(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFlowVelocity(doc), 'Fem::ConstraintPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFlowVelocity(doc), 'Fem::ConstraintFlowVelocity')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFlowVelocity(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFlowVelocity(doc), + 'Fem::ConstraintPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFlowVelocity(doc), + 'Fem::ConstraintFlowVelocity' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFluidBoundary(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFluidBoundary(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintFluidBoundary(doc), 'Fem::ConstraintFluidBoundary')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFluidBoundary(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFluidBoundary(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintFluidBoundary(doc), + 'Fem::ConstraintFluidBoundary' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintForce(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintForce(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintForce(doc), 'Fem::ConstraintForce')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintForce(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintForce(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintForce(doc), + 'Fem::ConstraintForce' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintGear(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintGear(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintGear(doc), 'Fem::ConstraintGear')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintGear(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintGear(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintGear(doc), + 'Fem::ConstraintGear' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintHeatflux(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintHeatflux(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintHeatflux(doc), 'Fem::ConstraintHeatflux')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintHeatflux(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintHeatflux(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintHeatflux(doc), + 'Fem::ConstraintHeatflux' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintInitialFlowVelocity(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintInitialFlowVelocity(doc), 'Fem::ConstraintPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintInitialFlowVelocity(doc), 'Fem::ConstraintInitialFlowVelocity')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintInitialFlowVelocity(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintInitialFlowVelocity(doc), + 'Fem::ConstraintPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintInitialFlowVelocity(doc), + 'Fem::ConstraintInitialFlowVelocity' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintInitialTemperature(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintInitialTemperature(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintInitialTemperature(doc), 'Fem::ConstraintInitialTemperature')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintInitialTemperature(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintInitialTemperature(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintInitialTemperature(doc), + 'Fem::ConstraintInitialTemperature' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPlaneRotation(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPlaneRotation(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPlaneRotation(doc), 'Fem::ConstraintPlaneRotation')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPlaneRotation(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPlaneRotation(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPlaneRotation(doc), + 'Fem::ConstraintPlaneRotation' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPressure(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPressure(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPressure(doc), 'Fem::ConstraintPressure')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPressure(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPressure(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPressure(doc), + 'Fem::ConstraintPressure' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPulley(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPulley(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintPulley(doc), 'Fem::ConstraintPulley')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPulley(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPulley(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintPulley(doc), + 'Fem::ConstraintPulley' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintSelfWeight(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintSelfWeight(doc), 'Fem::ConstraintPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintSelfWeight(doc), 'Fem::ConstraintSelfWeight')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintSelfWeight(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintSelfWeight(doc), + 'Fem::ConstraintPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintSelfWeight(doc), + 'Fem::ConstraintSelfWeight' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintTemperature(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintTemperature(doc), 'Fem::Constraint')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintTemperature(doc), 'Fem::ConstraintTemperature')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintTemperature(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintTemperature(doc), + 'Fem::Constraint' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintTemperature(doc), + 'Fem::ConstraintTemperature' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintTransform(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeConstraintTransform(doc), 'Fem::ConstraintTransform')) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintTransform(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeConstraintTransform(doc), + 'Fem::ConstraintTransform' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeElementFluid1D(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeElementFluid1D(doc), 'Fem::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeElementFluid1D(doc), 'Fem::FemElementFluid1D')) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementFluid1D(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementFluid1D(doc), + 'Fem::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementFluid1D(doc), + 'Fem::FemElementFluid1D' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeElementGeometry1D(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeElementGeometry1D(doc), 'Fem::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeElementGeometry1D(doc), 'Fem::FemElementGeometry1D')) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementGeometry1D(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementGeometry1D(doc), + 'Fem::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementGeometry1D(doc), + 'Fem::FemElementGeometry1D' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeElementGeometry2D(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeElementGeometry2D(doc), 'Fem::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeElementGeometry2D(doc), 'Fem::FemElementGeometry2D')) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementGeometry2D(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementGeometry2D(doc), + 'Fem::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementGeometry2D(doc), + 'Fem::FemElementGeometry2D' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeElementRotation1D(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeElementRotation1D(doc), 'Fem::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeElementRotation1D(doc), 'Fem::FemElementRotation1D')) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementRotation1D(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementRotation1D(doc), + 'Fem::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeElementRotation1D(doc), + 'Fem::FemElementRotation1D' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeMaterialFluid(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeMaterialFluid(doc), 'App::MaterialObjectPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeMaterialFluid(doc), 'Fem::Material')) + self.assertTrue(is_derived_from( + ObjectsFem.makeMaterialFluid(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMaterialFluid(doc), + 'App::MaterialObjectPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMaterialFluid(doc), + 'Fem::Material' + )) - self.assertTrue(is_derived_from(materialsolid, 'App::DocumentObject')) - self.assertTrue(is_derived_from(materialsolid, 'App::MaterialObjectPython')) - self.assertTrue(is_derived_from(materialsolid, 'Fem::Material')) + self.assertTrue(is_derived_from( + materialsolid, 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + materialsolid, 'App::MaterialObjectPython' + )) + self.assertTrue(is_derived_from( + materialsolid, 'Fem::Material' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid), 'Fem::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid), 'Fem::MaterialMechanicalNonlinear')) + self.assertTrue(is_derived_from( + ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid), + 'Fem::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid), + 'Fem::MaterialMechanicalNonlinear' + )) - self.assertTrue(is_derived_from(mesh, 'App::DocumentObject')) - self.assertTrue(is_derived_from(mesh, 'Fem::FemMeshObjectPython')) - self.assertTrue(is_derived_from(mesh, 'Fem::FemMeshGmsh')) + self.assertTrue(is_derived_from( + mesh, 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + mesh, 'Fem::FemMeshObjectPython' + )) + self.assertTrue(is_derived_from( + mesh, 'Fem::FemMeshGmsh' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshBoundaryLayer(doc, mesh), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshBoundaryLayer(doc, mesh), + 'Fem::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshBoundaryLayer(doc, mesh), + 'Fem::FemMeshBoundaryLayer' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshBoundaryLayer(doc, mesh), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshBoundaryLayer(doc, mesh), 'Fem::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshBoundaryLayer(doc, mesh), 'Fem::FemMeshBoundaryLayer')) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshGroup(doc, mesh), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshGroup(doc, mesh), + 'Fem::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshGroup(doc, mesh), + 'Fem::FemMeshGroup' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshGroup(doc, mesh), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshGroup(doc, mesh), 'Fem::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshGroup(doc, mesh), 'Fem::FemMeshGroup')) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshRegion(doc, mesh), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshRegion(doc, mesh), + 'Fem::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshRegion(doc, mesh), + 'Fem::FemMeshRegion' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshRegion(doc, mesh), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshRegion(doc, mesh), 'Fem::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshRegion(doc, mesh), 'Fem::FemMeshRegion')) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshNetgen(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshNetgen(doc), + 'Fem::FemMeshShapeNetgenObject' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshNetgen(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshNetgen(doc), 'Fem::FemMeshShapeNetgenObject')) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshResult(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshResult(doc), + 'Fem::FemMeshObjectPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeMeshResult(doc), + 'Fem::FemMeshResult' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshResult(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshResult(doc), 'Fem::FemMeshObjectPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeMeshResult(doc), 'Fem::FemMeshResult')) + self.assertTrue(is_derived_from( + ObjectsFem.makeResultMechanical(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeResultMechanical(doc), + 'Fem::FemResultObjectPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeResultMechanical(doc), + 'Fem::FemResultMechanical' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeResultMechanical(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeResultMechanical(doc), 'Fem::FemResultObjectPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeResultMechanical(doc), 'Fem::FemResultMechanical')) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverCalculixCcxTools(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverCalculixCcxTools(doc), + 'Fem::FemSolverObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverCalculixCcxTools(doc), + 'Fem::FemSolverObjectPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverCalculixCcxTools(doc), + 'Fem::FemSolverCalculixCcxTools' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverCalculixCcxTools(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverCalculixCcxTools(doc), 'Fem::FemSolverObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverCalculixCcxTools(doc), 'Fem::FemSolverObjectPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverCalculixCcxTools(doc), 'Fem::FemSolverCalculixCcxTools')) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverCalculix(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverCalculix(doc), + 'Fem::FemSolverObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverCalculix(doc), + 'Fem::FemSolverObjectPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverCalculix(doc), + 'Fem::FemSolverObjectCalculix' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverCalculix(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverCalculix(doc), 'Fem::FemSolverObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverCalculix(doc), 'Fem::FemSolverObjectPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverCalculix(doc), 'Fem::FemSolverObjectCalculix')) + self.assertTrue(is_derived_from( + solverelmer, 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + solverelmer, 'Fem::FemSolverObject' + )) + self.assertTrue(is_derived_from( + solverelmer, 'Fem::FemSolverObjectPython' + )) + self.assertTrue(is_derived_from( + solverelmer, 'Fem::FemSolverObjectElmer' + )) - self.assertTrue(is_derived_from(solverelmer, 'App::DocumentObject')) - self.assertTrue(is_derived_from(solverelmer, 'Fem::FemSolverObject')) - self.assertTrue(is_derived_from(solverelmer, 'Fem::FemSolverObjectPython')) - self.assertTrue(is_derived_from(solverelmer, 'Fem::FemSolverObjectElmer')) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverZ88(doc), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverZ88(doc), + 'Fem::FemSolverObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverZ88(doc), + 'Fem::FemSolverObjectPython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeSolverZ88(doc), + 'Fem::FemSolverObjectZ88' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverZ88(doc), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverZ88(doc), 'Fem::FemSolverObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverZ88(doc), 'Fem::FemSolverObjectPython')) - self.assertTrue(is_derived_from(ObjectsFem.makeSolverZ88(doc), 'Fem::FemSolverObjectZ88')) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationElasticity(doc, solverelmer), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationElasticity(doc, solverelmer), + 'App::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationElasticity(doc, solverelmer), + 'Fem::FemEquationElmerElasticity' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationElasticity(doc, solverelmer), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationElasticity(doc, solverelmer), 'App::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationElasticity(doc, solverelmer), 'Fem::FemEquationElmerElasticity')) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationElectrostatic(doc, solverelmer), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationElectrostatic(doc, solverelmer), + 'App::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationElectrostatic(doc, solverelmer), + 'Fem::FemEquationElmerElectrostatic' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationElectrostatic(doc, solverelmer), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationElectrostatic(doc, solverelmer), 'App::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationElectrostatic(doc, solverelmer), 'Fem::FemEquationElmerElectrostatic')) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationFlow(doc, solverelmer), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationFlow(doc, solverelmer), + 'App::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationFlow(doc, solverelmer), + 'Fem::FemEquationElmerFlow' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationFlow(doc, solverelmer), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationFlow(doc, solverelmer), 'App::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationFlow(doc, solverelmer), 'Fem::FemEquationElmerFlow')) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationFluxsolver(doc, solverelmer), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationFluxsolver(doc, solverelmer), + 'App::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationFluxsolver(doc, solverelmer), + 'Fem::FemEquationElmerFluxsolver' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationFluxsolver(doc, solverelmer), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationFluxsolver(doc, solverelmer), 'App::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationFluxsolver(doc, solverelmer), 'Fem::FemEquationElmerFluxsolver')) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationHeat(doc, solverelmer), + 'App::DocumentObject' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationHeat(doc, solverelmer), + 'App::FeaturePython' + )) + self.assertTrue(is_derived_from( + ObjectsFem.makeEquationHeat(doc, solverelmer), + 'Fem::FemEquationElmerHeat' + )) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationHeat(doc, solverelmer), 'App::DocumentObject')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationHeat(doc, solverelmer), 'App::FeaturePython')) - self.assertTrue(is_derived_from(ObjectsFem.makeEquationHeat(doc, solverelmer), 'Fem::FemEquationElmerHeat')) - - def test_femobjects_derivedfromstd(self): + # ******************************************************************************************** + def test_femobjects_derivedfromstd( + self + ): # only the last True type is used doc = self.active_doc - self.assertTrue(ObjectsFem.makeAnalysis(doc).isDerivedFrom('Fem::FemAnalysis')) - self.assertTrue(ObjectsFem.makeConstraintBearing(doc).isDerivedFrom('Fem::ConstraintBearing')) - self.assertTrue(ObjectsFem.makeConstraintBodyHeatSource(doc).isDerivedFrom('Fem::ConstraintPython')) - self.assertTrue(ObjectsFem.makeConstraintContact(doc).isDerivedFrom('Fem::ConstraintContact')) - self.assertTrue(ObjectsFem.makeConstraintDisplacement(doc).isDerivedFrom('Fem::ConstraintDisplacement')) - self.assertTrue(ObjectsFem.makeConstraintElectrostaticPotential(doc).isDerivedFrom('Fem::ConstraintPython')) - self.assertTrue(ObjectsFem.makeConstraintFixed(doc).isDerivedFrom('Fem::ConstraintFixed')) - self.assertTrue(ObjectsFem.makeConstraintFlowVelocity(doc).isDerivedFrom('Fem::ConstraintPython')) - self.assertTrue(ObjectsFem.makeConstraintFluidBoundary(doc).isDerivedFrom('Fem::ConstraintFluidBoundary')) - self.assertTrue(ObjectsFem.makeConstraintForce(doc).isDerivedFrom('Fem::ConstraintForce')) - self.assertTrue(ObjectsFem.makeConstraintGear(doc).isDerivedFrom('Fem::ConstraintGear')) - self.assertTrue(ObjectsFem.makeConstraintHeatflux(doc).isDerivedFrom('Fem::ConstraintHeatflux')) - self.assertTrue(ObjectsFem.makeConstraintInitialFlowVelocity(doc).isDerivedFrom('Fem::ConstraintPython')) - self.assertTrue(ObjectsFem.makeConstraintInitialTemperature(doc).isDerivedFrom('Fem::ConstraintInitialTemperature')) - self.assertTrue(ObjectsFem.makeConstraintPlaneRotation(doc).isDerivedFrom('Fem::ConstraintPlaneRotation')) - self.assertTrue(ObjectsFem.makeConstraintPressure(doc).isDerivedFrom('Fem::ConstraintPressure')) - self.assertTrue(ObjectsFem.makeConstraintPulley(doc).isDerivedFrom('Fem::ConstraintPulley')) - self.assertTrue(ObjectsFem.makeConstraintSelfWeight(doc).isDerivedFrom('Fem::ConstraintPython')) - self.assertTrue(ObjectsFem.makeConstraintTemperature(doc).isDerivedFrom('Fem::ConstraintTemperature')) - self.assertTrue(ObjectsFem.makeConstraintTransform(doc).isDerivedFrom('Fem::ConstraintTransform')) - self.assertTrue(ObjectsFem.makeElementFluid1D(doc).isDerivedFrom('Fem::FeaturePython')) - self.assertTrue(ObjectsFem.makeElementGeometry1D(doc).isDerivedFrom('Fem::FeaturePython')) - self.assertTrue(ObjectsFem.makeElementGeometry2D(doc).isDerivedFrom('Fem::FeaturePython')) - self.assertTrue(ObjectsFem.makeElementRotation1D(doc).isDerivedFrom('Fem::FeaturePython')) + self.assertTrue( + ObjectsFem.makeAnalysis( + doc + ).isDerivedFrom('Fem::FemAnalysis') + ) + self.assertTrue( + ObjectsFem.makeConstraintBearing( + doc + ).isDerivedFrom('Fem::ConstraintBearing') + ) + self.assertTrue( + ObjectsFem.makeConstraintBodyHeatSource( + doc).isDerivedFrom('Fem::ConstraintPython') + ) + self.assertTrue( + ObjectsFem.makeConstraintContact( + doc + ).isDerivedFrom('Fem::ConstraintContact') + ) + self.assertTrue( + ObjectsFem.makeConstraintDisplacement( + doc + ).isDerivedFrom('Fem::ConstraintDisplacement') + ) + self.assertTrue( + ObjectsFem.makeConstraintElectrostaticPotential( + doc + ).isDerivedFrom('Fem::ConstraintPython') + ) + self.assertTrue( + ObjectsFem.makeConstraintFixed( + doc).isDerivedFrom('Fem::ConstraintFixed') + ) + self.assertTrue( + ObjectsFem.makeConstraintFlowVelocity( + doc).isDerivedFrom('Fem::ConstraintPython') + ) + self.assertTrue( + ObjectsFem.makeConstraintFluidBoundary( + doc + ).isDerivedFrom('Fem::ConstraintFluidBoundary') + ) + self.assertTrue( + ObjectsFem.makeConstraintForce( + doc + ).isDerivedFrom('Fem::ConstraintForce') + ) + self.assertTrue( + ObjectsFem.makeConstraintGear( + doc + ).isDerivedFrom('Fem::ConstraintGear') + ) + self.assertTrue( + ObjectsFem.makeConstraintHeatflux( + doc + ).isDerivedFrom('Fem::ConstraintHeatflux') + ) + self.assertTrue( + ObjectsFem.makeConstraintInitialFlowVelocity( + doc + ).isDerivedFrom('Fem::ConstraintPython') + ) + self.assertTrue( + ObjectsFem.makeConstraintInitialTemperature( + doc + ).isDerivedFrom('Fem::ConstraintInitialTemperature') + ) + self.assertTrue( + ObjectsFem.makeConstraintPlaneRotation( + doc + ).isDerivedFrom('Fem::ConstraintPlaneRotation') + ) + self.assertTrue( + ObjectsFem.makeConstraintPressure( + doc + ).isDerivedFrom('Fem::ConstraintPressure') + ) + self.assertTrue( + ObjectsFem.makeConstraintPulley( + doc + ).isDerivedFrom('Fem::ConstraintPulley') + ) + self.assertTrue( + ObjectsFem.makeConstraintSelfWeight( + doc + ).isDerivedFrom('Fem::ConstraintPython') + ) + self.assertTrue( + ObjectsFem.makeConstraintTemperature( + doc + ).isDerivedFrom('Fem::ConstraintTemperature') + ) + self.assertTrue( + ObjectsFem.makeConstraintTransform( + doc).isDerivedFrom('Fem::ConstraintTransform') + ) + self.assertTrue( + ObjectsFem.makeElementFluid1D( + doc + ).isDerivedFrom('Fem::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeElementGeometry1D( + doc + ).isDerivedFrom('Fem::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeElementGeometry2D( + doc + ).isDerivedFrom('Fem::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeElementRotation1D( + doc + ).isDerivedFrom('Fem::FeaturePython') + ) materialsolid = ObjectsFem.makeMaterialSolid(doc) - self.assertTrue(ObjectsFem.makeMaterialFluid(doc).isDerivedFrom('App::MaterialObjectPython')) - self.assertTrue(materialsolid.isDerivedFrom('App::MaterialObjectPython')) - self.assertTrue(ObjectsFem.makeMaterialMechanicalNonlinear(doc, materialsolid).isDerivedFrom('Fem::FeaturePython')) + self.assertTrue( + ObjectsFem.makeMaterialFluid( + doc + ).isDerivedFrom('App::MaterialObjectPython') + ) + self.assertTrue( + materialsolid.isDerivedFrom('App::MaterialObjectPython') + ) + self.assertTrue( + ObjectsFem.makeMaterialMechanicalNonlinear( + doc, + materialsolid + ).isDerivedFrom('Fem::FeaturePython') + ) mesh = ObjectsFem.makeMeshGmsh(doc) - self.assertTrue(mesh.isDerivedFrom('Fem::FemMeshObjectPython')) - self.assertTrue(ObjectsFem.makeMeshBoundaryLayer(doc, mesh).isDerivedFrom('Fem::FeaturePython')) - self.assertTrue(ObjectsFem.makeMeshGroup(doc, mesh).isDerivedFrom('Fem::FeaturePython')) - self.assertTrue(ObjectsFem.makeMeshRegion(doc, mesh).isDerivedFrom('Fem::FeaturePython')) - self.assertTrue(ObjectsFem.makeMeshNetgen(doc).isDerivedFrom('Fem::FemMeshShapeNetgenObject')) - self.assertTrue(ObjectsFem.makeMeshResult(doc).isDerivedFrom('Fem::FemMeshObjectPython')) - self.assertTrue(ObjectsFem.makeResultMechanical(doc).isDerivedFrom('Fem::FemResultObjectPython')) + self.assertTrue( + mesh.isDerivedFrom('Fem::FemMeshObjectPython') + ) + self.assertTrue( + ObjectsFem.makeMeshBoundaryLayer( + doc, + mesh + ).isDerivedFrom('Fem::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeMeshGroup( + doc, + mesh + ).isDerivedFrom('Fem::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeMeshRegion( + doc, + mesh + ).isDerivedFrom('Fem::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeMeshNetgen( + doc + ).isDerivedFrom('Fem::FemMeshShapeNetgenObject') + ) + self.assertTrue( + ObjectsFem.makeMeshResult( + doc + ).isDerivedFrom('Fem::FemMeshObjectPython') + ) + self.assertTrue( + ObjectsFem.makeResultMechanical( + doc + ).isDerivedFrom('Fem::FemResultObjectPython') + ) solverelmer = ObjectsFem.makeSolverElmer(doc) - self.assertTrue(ObjectsFem.makeSolverCalculixCcxTools(doc).isDerivedFrom('Fem::FemSolverObjectPython')) - self.assertTrue(ObjectsFem.makeSolverCalculix(doc).isDerivedFrom('Fem::FemSolverObjectPython')) - self.assertTrue(solverelmer.isDerivedFrom('Fem::FemSolverObjectPython')) - self.assertTrue(ObjectsFem.makeSolverZ88(doc).isDerivedFrom('Fem::FemSolverObjectPython')) - self.assertTrue(ObjectsFem.makeEquationElasticity(doc, solverelmer).isDerivedFrom('App::FeaturePython')) - self.assertTrue(ObjectsFem.makeEquationElectrostatic(doc, solverelmer).isDerivedFrom('App::FeaturePython')) - self.assertTrue(ObjectsFem.makeEquationFlow(doc, solverelmer).isDerivedFrom('App::FeaturePython')) - self.assertTrue(ObjectsFem.makeEquationFluxsolver(doc, solverelmer).isDerivedFrom('App::FeaturePython')) - self.assertTrue(ObjectsFem.makeEquationHeat(doc, solverelmer).isDerivedFrom('App::FeaturePython')) + self.assertTrue( + ObjectsFem.makeSolverCalculixCcxTools( + doc + ).isDerivedFrom('Fem::FemSolverObjectPython') + ) + self.assertTrue( + ObjectsFem.makeSolverCalculix( + doc + ).isDerivedFrom('Fem::FemSolverObjectPython') + ) + self.assertTrue( + solverelmer.isDerivedFrom('Fem::FemSolverObjectPython') + ) + self.assertTrue( + ObjectsFem.makeSolverZ88( + doc + ).isDerivedFrom('Fem::FemSolverObjectPython') + ) + self.assertTrue( + ObjectsFem.makeEquationElasticity( + doc, + solverelmer + ).isDerivedFrom('App::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeEquationElectrostatic( + doc, + solverelmer + ).isDerivedFrom('App::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeEquationFlow( + doc, + solverelmer + ).isDerivedFrom('App::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeEquationFluxsolver( + doc, + solverelmer + ).isDerivedFrom('App::FeaturePython') + ) + self.assertTrue( + ObjectsFem.makeEquationHeat( + doc, + solverelmer + ).isDerivedFrom('App::FeaturePython') + ) # is = 43 (just copy in empty file to test) - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): # clearance, is executed after every test FreeCAD.closeDocument(self.doc_name) pass diff --git a/src/Mod/Fem/femtest/testresult.py b/src/Mod/Fem/femtest/testresult.py index 3b9425bd50..2d75557422 100644 --- a/src/Mod/Fem/femtest/testresult.py +++ b/src/Mod/Fem/femtest/testresult.py @@ -34,7 +34,10 @@ from os.path import join class TestResult(unittest.TestCase): fcc_print('import TestResult') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): # init, is executed before every test self.doc_name = "TestResult" try: @@ -45,9 +48,16 @@ class TestResult(unittest.TestCase): FreeCAD.setActiveDocument(self.doc_name) self.active_doc = FreeCAD.ActiveDocument - def test_read_frd_massflow_networkpressure(self): + # ******************************************************************************************** + def test_read_frd_massflow_networkpressure( + self + ): # read data from frd file - frd_file = join(testtools.get_fem_test_home_dir(), 'ccx', 'Flow1D_thermomech.frd') + frd_file = join( + testtools.get_fem_test_home_dir(), + 'ccx', + 'Flow1D_thermomech.frd' + ) from feminout.importCcxFrdResults import read_frd_result as read_frd frd_content = read_frd(frd_file) @@ -119,8 +129,14 @@ class TestResult(unittest.TestCase): 12: (12, 26, 13) } ''' - efc['Tria3Elem'] = efc['Tria6Elem'] = efc['Quad4Elem'] = efc['Quad8Elem'] = {} # faces - efc['Tetra4Elem'] = efc['Tetra10Elem'] = efc['Hexa8Elem'] = efc['Hexa20Elem'] = efc['Penta6Elem'] = efc['Penta15Elem'] = {} # volumes + # faces + efc['Tria3Elem'] = efc['Tria6Elem'] = {} + efc['Quad4Elem'] = efc['Quad8Elem'] = {} + # volumes + efc['Tetra4Elem'] = efc['Tetra10Elem'] = {} + efc['Hexa8Elem'] = efc['Hexa20Elem'] = {} + efc['Penta6Elem'] = efc['Penta15Elem'] = {} + efc['Results'] = [ {'time': 0.00390625}, {'time': 0.0078125}, @@ -217,21 +233,61 @@ class TestResult(unittest.TestCase): print(expected_npressure) # tests - self.assertEqual(frd_content_len, expected_frd_content_len, "Length's of read frd data values are unexpected") - self.assertEqual(frd_content['Nodes'], expected_frd_content['Nodes'], "Values of read node data are unexpected") - self.assertEqual(frd_content['Seg2Elem'], expected_frd_content['Seg2Elem'], "Values of read Seg2 data are unexpected") - self.assertEqual(frd_content['Seg3Elem'], expected_frd_content['Seg3Elem'], "Values of read Seg3 data are unexpected") - self.assertEqual(res_len, expected_res_len, "Length's of read result data values are unexpected") - self.assertEqual(read_mflow, expected_mflow, "Values of read mflow result data are unexpected") - self.assertEqual(read_npressure, expected_npressure, "Values of read npressure result data are unexpected") + self.assertEqual( + frd_content_len, + expected_frd_content_len, + "Length's of read frd data values are unexpected" + ) + self.assertEqual( + frd_content['Nodes'], + expected_frd_content['Nodes'], + "Values of read node data are unexpected" + ) + self.assertEqual( + frd_content['Seg2Elem'], + expected_frd_content['Seg2Elem'], + "Values of read Seg2 data are unexpected" + ) + self.assertEqual( + frd_content['Seg3Elem'], + expected_frd_content['Seg3Elem'], + "Values of read Seg3 data are unexpected" + ) + self.assertEqual( + res_len, + expected_res_len, + "Length's of read result data values are unexpected" + ) + self.assertEqual( + read_mflow, + expected_mflow, + "Values of read mflow result data are unexpected" + ) + self.assertEqual( + read_npressure, + expected_npressure, + "Values of read npressure result data are unexpected" + ) - def get_stress_values(self): + # ******************************************************************************************** + def get_stress_values( + self + ): # node 5 von calculix cantilver 3D example - # doc = FreeCAD.open(FreeCAD.ConfigGet("AppHomePath") + 'data/examples/FemCalculixCantilever3D.FCStd') + # doc = FreeCAD.open( + # FreeCAD.ConfigGet("AppHomePath") + 'data/examples/FemCalculixCantilever3D.FCStd' + # ) # doc.Box_Mesh.FemMesh.Nodes[5] # Vector (0.0, 1000.0, 0.0) # res = doc.CalculiX_static_results - # stress = (res.NodeStressXX[4], res.NodeStressYY[4], res.NodeStressZZ[4], res.NodeStressXY[4], res.NodeStressXZ[4],res.NodeStressYZ[4]) + # stress = ( + # res.NodeStressXX[4], + # res.NodeStressYY[4], + # res.NodeStressZZ[4], + # res.NodeStressXY[4], + # res.NodeStressXZ[4], + # res.NodeStressYZ[4] + # ) stress = ( -4.52840E+02, # Sxx -1.94075E+02, # Syy @@ -242,30 +298,60 @@ class TestResult(unittest.TestCase): ) return stress - def test_stress_von_mises(self): + # ******************************************************************************************** + def test_stress_von_mises( + self + ): expected_mises = 283.2082 from femresult.resulttools import calculate_von_mises as vm mises = vm(self.get_stress_values()) # fcc_print(round(mises, 4)) - self.assertEqual(round(mises, 4), expected_mises, "Calculated von Mises stress is not the expected value.") + self.assertEqual( + round(mises, 4), + expected_mises, + "Calculated von Mises stress is not the expected value." + ) - def test_stress_principal(self): + # ******************************************************************************************** + def test_stress_principal( + self + ): expected_principal = (-178.0076, -194.0749, -468.9075, 145.4499) from femresult.resulttools import calculate_principal_stress as pr prin = pr(self.get_stress_values()) - rounded_prin = (round(prin[0], 4), round(prin[1], 4), round(prin[2], 4), round(prin[3], 4)) + rounded_prin = ( + round(prin[0], 4), + round(prin[1], 4), + round(prin[2], 4), + round(prin[3], 4) + ) # fcc_print(rounded_prin) - self.assertEqual(rounded_prin, expected_principal, "Calculated principal stresses are not the expected values.") + self.assertEqual( + rounded_prin, + expected_principal, + "Calculated principal stresses are not the expected values." + ) - def test_disp_abs(self): + # ******************************************************************************************** + def test_disp_abs( + self + ): expected_dispabs = 87.302986 - disp_xyz = [FreeCAD.Vector(8.12900E+00, 3.38889E-02, -8.69237E+01)] # x, y, z in node 4 of CalculiX cantilver face load + # x, y, z in node 4 of CalculiX cantilver face load + disp_xyz = [FreeCAD.Vector(8.12900E+00, 3.38889E-02, -8.69237E+01)] from femresult.resulttools import calculate_disp_abs as dp disp_abs = round(dp(disp_xyz)[0], 6) # fcc_print(disp_abs) - self.assertEqual(disp_abs, expected_dispabs, "Calculated displacement abs are not the expected values.") + self.assertEqual( + disp_abs, + expected_dispabs, + "Calculated displacement abs are not the expected values." + ) - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): # clearance, is executed after every test FreeCAD.closeDocument(self.doc_name) pass diff --git a/src/Mod/Fem/femtest/testsolverframework.py b/src/Mod/Fem/femtest/testsolverframework.py index e055f19f10..46923410e9 100644 --- a/src/Mod/Fem/femtest/testsolverframework.py +++ b/src/Mod/Fem/femtest/testsolverframework.py @@ -36,7 +36,10 @@ from os.path import join class TestSolverFrameWork(unittest.TestCase): fcc_print('import TestSolverFrameWork') - def setUp(self): + # ******************************************************************************************** + def setUp( + self + ): # init, is executed before every test self.doc_name = "TestSolverFrameWork" try: @@ -50,15 +53,24 @@ class TestSolverFrameWork(unittest.TestCase): self.temp_dir = testtools.get_fem_test_tmp_dir() self.test_file_dir = join(testtools.get_fem_test_home_dir(), 'ccx') - def test_solver_framework(self): + # ******************************************************************************************** + def test_solver_framework( + self + ): fcc_print('\n--------------- Start of FEM tests solver frame work ---------------') box = self.active_doc.addObject("Part::Box", "Box") fcc_print('Checking FEM new analysis...') - analysis = ObjectsFem.makeAnalysis(self.active_doc, 'Analysis') + analysis = ObjectsFem.makeAnalysis( + self.active_doc, + 'Analysis' + ) self.assertTrue(analysis, "FemTest of new analysis failed") fcc_print('Checking FEM new material...') - material_object = ObjectsFem.makeMaterialSolid(self.active_doc, 'MechanicalMaterial') + material_object = ObjectsFem.makeMaterialSolid( + self.active_doc, + 'MechanicalMaterial' + ) mat = material_object.Material mat['Name'] = "Steel-Generic" mat['YoungsModulus'] = "200000 MPa" @@ -69,13 +81,19 @@ class TestSolverFrameWork(unittest.TestCase): analysis.addObject(material_object) fcc_print('Checking FEM new fixed constraint...') - fixed_constraint = self.active_doc.addObject("Fem::ConstraintFixed", "FemConstraintFixed") + fixed_constraint = self.active_doc.addObject( + "Fem::ConstraintFixed", + "FemConstraintFixed" + ) fixed_constraint.References = [(box, "Face1")] self.assertTrue(fixed_constraint, "FemTest of new fixed constraint failed") analysis.addObject(fixed_constraint) fcc_print('Checking FEM new force constraint...') - force_constraint = self.active_doc.addObject("Fem::ConstraintForce", "FemConstraintForce") + force_constraint = self.active_doc.addObject( + "Fem::ConstraintForce", + "FemConstraintForce" + ) force_constraint.References = [(box, "Face6")] force_constraint.Force = 40000.0 force_constraint.Direction = (box, ["Edge5"]) @@ -86,7 +104,10 @@ class TestSolverFrameWork(unittest.TestCase): analysis.addObject(force_constraint) fcc_print('Checking FEM new pressure constraint...') - pressure_constraint = self.active_doc.addObject("Fem::ConstraintPressure", "FemConstraintPressure") + pressure_constraint = self.active_doc.addObject( + "Fem::ConstraintPressure", + "FemConstraintPressure" + ) pressure_constraint.References = [(box, "Face2")] pressure_constraint.Pressure = 1000.0 pressure_constraint.Reversed = False @@ -101,7 +122,10 @@ class TestSolverFrameWork(unittest.TestCase): self.assertTrue(ret, "Import of mesh nodes failed") ret = create_elements_cube(mesh) self.assertTrue(ret, "Import of mesh volumes failed") - mesh_object = self.active_doc.addObject('Fem::FemMeshObject', self.mesh_name) + mesh_object = self.active_doc.addObject( + 'Fem::FemMeshObject', + self.mesh_name + ) mesh_object.FemMesh = mesh self.assertTrue(mesh, "FemTest of new mesh failed") analysis.addObject(mesh_object) @@ -111,7 +135,10 @@ class TestSolverFrameWork(unittest.TestCase): # solver frame work ccx solver # calculix solver object fcc_print('\nChecking FEM CalculiX solver for solver frame work...') - solver_ccx_object = ObjectsFem.makeSolverCalculix(self.active_doc, 'SolverCalculiX') + solver_ccx_object = ObjectsFem.makeSolverCalculix( + self.active_doc, + 'SolverCalculiX' + ) solver_ccx_object.AnalysisType = 'static' solver_ccx_object.GeometricalNonlinearity = 'linear' solver_ccx_object.ThermoMechSteadyState = False @@ -124,17 +151,27 @@ class TestSolverFrameWork(unittest.TestCase): analysis.addObject(solver_ccx_object) static_base_name = 'cube_static' - solverframework_analysis_dir = testtools.get_unit_test_tmp_dir(testtools.get_fem_test_tmp_dir(), 'FEM_solverframework') + solverframework_analysis_dir = testtools.get_unit_test_tmp_dir( + testtools.get_fem_test_tmp_dir(), + 'FEM_solverframework' + ) # write input file fcc_print('Checking FEM ccx solver for solver frame work......') fcc_print('machine_ccx') - machine_ccx = solver_ccx_object.Proxy.createMachine(solver_ccx_object, solverframework_analysis_dir) + machine_ccx = solver_ccx_object.Proxy.createMachine( + solver_ccx_object, + solverframework_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', (static_base_name + '.inp')) + infile_given = join( + testtools.get_fem_test_home_dir(), + 'ccx', + (static_base_name + '.inp') + ) inpfile_totest = join(solverframework_analysis_dir, (self.mesh_name + '.inp')) fcc_print('Comparing {} to {}'.format(infile_given, inpfile_totest)) ret = testtools.compare_inp_files(infile_given, inpfile_totest) @@ -142,20 +179,30 @@ class TestSolverFrameWork(unittest.TestCase): # use solver frame work elmer solver # elmer solver object - solver_elmer_object = ObjectsFem.makeSolverElmer(self.active_doc, 'SolverElmer') + solver_elmer_object = ObjectsFem.makeSolverElmer( + self.active_doc, + 'SolverElmer' + ) self.assertTrue(solver_elmer_object, "FemTest of elmer solver failed") analysis.addObject(solver_elmer_object) - solver_elmer_eqobj = ObjectsFem.makeEquationElasticity(self.active_doc, solver_elmer_object) + solver_elmer_eqobj = ObjectsFem.makeEquationElasticity( + self.active_doc, + solver_elmer_object + ) self.assertTrue(solver_elmer_eqobj, "FemTest of elmer elasticity equation failed") - # set ThermalExpansionCoefficient, current elmer seems to need it even on simple elasticity analysis + # set ThermalExpansionCoefficient + # current elmer seems to need it even on simple elasticity analysis mat = material_object.Material - mat['ThermalExpansionCoefficient'] = "0 um/m/K" # FIXME elmer elasticity needs the dictionary key, otherwise it fails + # FIXME elmer elasticity needs the dictionary key, otherwise it fails + mat['ThermalExpansionCoefficient'] = "0 um/m/K" material_object.Material = mat mesh_gmsh = ObjectsFem.makeMeshGmsh(self.active_doc) mesh_gmsh.CharacteristicLengthMin = "9 mm" - mesh_gmsh.FemMesh = mesh_object.FemMesh # elmer needs a GMHS mesh object, FIXME error message on Python solver run + # elmer needs a GMHS mesh object + # FIXME error message on Python solver run + mesh_gmsh.FemMesh = mesh_object.FemMesh mesh_gmsh.Part = box analysis.addObject(mesh_gmsh) self.active_doc.removeObject(mesh_object.Name) @@ -163,7 +210,11 @@ class TestSolverFrameWork(unittest.TestCase): # solver frame work Elmer solver # write input files fcc_print('\nChecking FEM Elmer solver for solver frame work...') - machine_elmer = solver_elmer_object.Proxy.createMachine(solver_elmer_object, solverframework_analysis_dir, True) + machine_elmer = solver_elmer_object.Proxy.createMachine( + solver_elmer_object, + solverframework_analysis_dir, + True + ) machine_elmer.target = femsolver.run.PREPARE machine_elmer.start() machine_elmer.join() # wait for the machine to finish. @@ -197,7 +248,10 @@ class TestSolverFrameWork(unittest.TestCase): self.active_doc.saveAs(save_fc_file) fcc_print('--------------- End of FEM tests solver frame work ---------------') - def tearDown(self): + # ******************************************************************************************** + def tearDown( + self + ): # clearance, is executed after every test FreeCAD.closeDocument(self.doc_name) pass diff --git a/src/Mod/Fem/femtest/utilstest.py b/src/Mod/Fem/femtest/utilstest.py index 5e7670d1ab..b0d4f88f5e 100644 --- a/src/Mod/Fem/femtest/utilstest.py +++ b/src/Mod/Fem/femtest/utilstest.py @@ -34,29 +34,38 @@ import FreeCAD from os.path import join -def get_fem_test_home_dir(): +def get_fem_test_home_dir( +): return join(FreeCAD.getHomePath(), 'Mod', 'Fem', 'femtest', 'testfiles') -def get_fem_test_tmp_dir(): +def get_fem_test_tmp_dir( +): temp_dir = join(tempfile.gettempdir(), 'FEM_unittests') if not os.path.exists(temp_dir): os.makedirs(temp_dir) return(temp_dir) -def get_unit_test_tmp_dir(temp_dir, unittestdir): +def get_unit_test_tmp_dir( + temp_dir, + unittestdir +): testdir = join(temp_dir, unittestdir) if not os.path.exists(testdir): os.makedirs(testdir) return testdir -def fcc_print(message): +def fcc_print( + message +): FreeCAD.Console.PrintMessage('{} \n'.format(message)) -def get_defmake_count(fem_vtk_post=True): +def get_defmake_count( + fem_vtk_post=True +): ''' count the def make in module ObjectsFem could also be done in bash with @@ -67,7 +76,9 @@ def get_defmake_count(fem_vtk_post=True): lines_modefile = modfile.readlines() modfile.close() lines_defmake = [l for l in lines_modefile if l.startswith('def make')] - if not fem_vtk_post: # FEM VTK post processing is disabled, we are not able to create VTK post objects + if not fem_vtk_post: + # FEM VTK post processing is disabled + # we are not able to create VTK post objects new_lines = [] for l in lines_defmake: if "PostVtk" not in l: @@ -76,7 +87,9 @@ def get_defmake_count(fem_vtk_post=True): return len(lines_defmake) -def get_fem_test_defs(inout='out'): +def get_fem_test_defs( + inout='out' +): test_path = join(FreeCAD.getHomePath(), 'Mod', 'Fem', 'femtest') collected_test_modules = [] collected_test_methods = [] @@ -97,12 +110,17 @@ def get_fem_test_defs(inout='out'): if ln.startswith('def test'): ln = ln.lstrip('def ') ln = ln.split('(')[0] - collected_test_methods.append('femtest.{}.{}.{}'.format(module_name, class_name, ln)) + collected_test_methods.append( + 'femtest.{}.{}.{}'.format(module_name, class_name, ln) + ) tfile.close() print('') for m in collected_test_methods: run_outside_fc = './bin/FreeCADCmd --run-test "{}"'.format(m) - run_inside_fc = 'unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromName("{}"))'.format(m) + run_inside_fc = ( + 'unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromName("{}"))' + .format(m) + ) if inout == 'in': print('\nimport unittest') print(run_inside_fc) @@ -110,12 +128,17 @@ def get_fem_test_defs(inout='out'): print(run_outside_fc) -def compare_inp_files(file_name1, file_name2): +def compare_inp_files( + file_name1, + file_name2 +): file1 = open(file_name1, 'r') f1 = file1.readlines() file1.close() - # l.startswith('17671.0,1') is a temporary workaround for python3 problem with 1DFlow input - # TODO as soon as the 1DFlow result reading is fixed, this should be triggered in the 1DFlow unit test + # l.startswith('17671.0,1') is a temporary workaround + # for python3 problem with 1DFlow input + # TODO as soon as the 1DFlow result reading is fixed + # this should be triggered in the 1DFlow unit test lf1 = [l for l in f1 if not (l.startswith('** written ') or l.startswith('** file ') or l.startswith('17671.0,1'))] lf1 = force_unix_line_ends(lf1) file2 = open(file_name2, 'r') @@ -130,11 +153,17 @@ def compare_inp_files(file_name1, file_name2): for l in diff: result += l if result: - result = "Comparing {} to {} failed!\n".format(file_name1, file_name2) + result + result = ( + "Comparing {} to {} failed!\n" + .format(file_name1, file_name2) + result + ) return result -def compare_files(file_name1, file_name2): +def compare_files( + file_name1, + file_name2 +): file1 = open(file_name1, 'r') f1 = file1.readlines() file1.close() @@ -157,9 +186,28 @@ def compare_files(file_name1, file_name2): return result -def compare_stats(fea, stat_file=None, loc_stat_types=None, res_obj_name=None): +def compare_stats( + fea, + stat_file=None, + loc_stat_types=None, + res_obj_name=None +): import femresult.resulttools as resulttools - stat_types = ["U1", "U2", "U3", "Uabs", "Sabs", "MaxPrin", "MidPrin", "MinPrin", "MaxShear", "Peeq", "Temp", "MFlow", "NPress"] + stat_types = [ + "U1", + "U2", + "U3", + "Uabs", + "Sabs", + "MaxPrin", + "MidPrin", + "MinPrin", + "MaxShear", + "Peeq", + "Temp", + "MFlow", + "NPress" + ] if not loc_stat_types: loc_stat_types = stat_types if stat_file: @@ -174,11 +222,17 @@ def compare_stats(fea, stat_file=None, loc_stat_types=None, res_obj_name=None): stats = [] for s in loc_stat_types: if res_obj_name: - statval = resulttools.get_stats(FreeCAD.ActiveDocument.getObject(res_obj_name), s) + statval = resulttools.get_stats( + FreeCAD.ActiveDocument.getObject(res_obj_name), + s + ) else: print('No result object name given') return False - stats.append("{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n".format(s, statval[0], statval[1], statval[2])) + stats.append( + "{0}: ({1:.14g}, {2:.14g}, {3:.14g})\n" + .format(s, statval[0], statval[1], statval[2]) + ) if sf_content != stats: fcc_print("Expected stats from {}".format(stat_file)) fcc_print(sf_content) @@ -188,7 +242,9 @@ def compare_stats(fea, stat_file=None, loc_stat_types=None, res_obj_name=None): return False -def force_unix_line_ends(line_list): +def force_unix_line_ends( + line_list +): new_line_list = [] for ln in line_list: if ln.endswith("\r\n"): @@ -197,7 +253,9 @@ def force_unix_line_ends(line_list): return new_line_list -def collect_python_modules(femsubdir=None): +def collect_python_modules( + femsubdir=None +): if not femsubdir: pydir = join(FreeCAD.ConfigGet("AppHomePath"), 'Mod', 'Fem') else: @@ -207,14 +265,19 @@ def collect_python_modules(femsubdir=None): for pyfile in sorted(os.listdir(pydir)): if pyfile.endswith(".py") and not pyfile.startswith('Init'): if not femsubdir: - collected_modules.append(os.path.splitext(os.path.basename(pyfile))[0]) + collected_modules.append( + os.path.splitext(os.path.basename(pyfile))[0] + ) else: - collected_modules.append(femsubdir.replace('/', '.') + '.' + os.path.splitext(os.path.basename(pyfile))[0]) + collected_modules.append( + femsubdir.replace('/', '.') + '.' + os.path.splitext(os.path.basename(pyfile))[0] + ) return collected_modules -# open all files -def all_test_files(): +def all_test_files( +): + # open all files cube_frequency() cube_static() Flow1D_thermomech() @@ -222,32 +285,63 @@ def all_test_files(): spine_thermomech() -# run the specific test case of the file, open the file in FreeCAD GUI and return the doc identifier -def cube_frequency(): +# run the specific test case of the file +# open the file in FreeCAD GUI and return the doc identifier +def cube_frequency( +): testname = "femtest.testccxtools.TestCcxTools.test_3_freq_analysis" unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromName(testname)) - return FreeCAD.open(join(get_fem_test_tmp_dir(), 'FEM_ccx_frequency', 'cube_frequency.FCStd')) + doc = FreeCAD.open(join( + get_fem_test_tmp_dir(), + 'FEM_ccx_frequency', + 'cube_frequency.FCStd') + ) + return doc -def cube_static(): +def cube_static( +): testname = "femtest.testccxtools.TestCcxTools.test_1_static_analysis" unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromName(testname)) - return FreeCAD.open(join(get_fem_test_tmp_dir(), 'FEM_ccx_static', 'cube_static.FCStd')) + doc = FreeCAD.open( + join(get_fem_test_tmp_dir(), + 'FEM_ccx_static', + 'cube_static.FCStd') + ) + return doc -def Flow1D_thermomech(): +def Flow1D_thermomech( +): testname = "femtest.testccxtools.TestCcxTools.test_5_Flow1D_thermomech_analysis" unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromName(testname)) - return FreeCAD.open(join(get_fem_test_tmp_dir(), 'FEM_ccx_Flow1D_thermomech', 'Flow1D_thermomech.FCStd')) + doc = FreeCAD.open(join( + get_fem_test_tmp_dir(), + 'FEM_ccx_Flow1D_thermomech', + 'Flow1D_thermomech.FCStd') + ) + return doc -def multimat(): +def multimat( +): testname = "femtest.testccxtools.TestCcxTools.test_2_static_multiple_material" unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromName(testname)) - return FreeCAD.open(join(get_fem_test_tmp_dir(), 'FEM_ccx_multimat', 'multimat.FCStd')) + doc = FreeCAD.open(join( + get_fem_test_tmp_dir(), + 'FEM_ccx_multimat', + 'multimat.FCStd') + ) + return doc -def spine_thermomech(): +def spine_thermomech( +): testname = "femtest.testccxtools.TestCcxTools.test_4_thermomech_analysis" unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromName(testname)) - return FreeCAD.open(join(get_fem_test_tmp_dir(), 'FEM_ccx_thermomech', 'spine_thermomech.FCStd')) + doc = FreeCAD.open(join( + get_fem_test_tmp_dir(), + 'FEM_ccx_thermomech', + 'spine_thermomech.FCStd') + ) + return doc