def test_trilinos_levelset_convection(self): current_model = KratosMultiphysics.Model() self.model_part = current_model.CreateModelPart("Main",2) self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISTANCE) self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY) self.model_part.AddNodalSolutionStepVariable(KratosMultiphysics.PARTITION_INDEX) # Import the model part, perform the partitioning and create communicators import_settings = KratosMultiphysics.Parameters(self.parameters) DistributedModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility(self.model_part, import_settings) DistributedModelPartImporter.ImportModelPart() DistributedModelPartImporter.CreateCommunicators() # Recall to set the buffer size self.model_part.SetBufferSize(2) # Set the initial distance field and the convection velocity for node in self.model_part.Nodes: node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, 0, BaseDistance(node.X,node.Y,node.Z)) node.SetSolutionStepValue(KratosMultiphysics.VELOCITY, 0, ConvectionVelocity(node.X,node.Y,node.Z)) # Fix the left side values for node in self.model_part.Nodes: if node.X < 0.001: node.Fix(KratosMultiphysics.DISTANCE) # Set the Trilinos linear solver and Epetra communicator trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""") ) epetra_comm = TrilinosApplication.CreateEpetraCommunicator(KratosMultiphysics.DataCommunicator.GetDefault()) # Fake time advance self.model_part.CloneTimeStep(40.0) # Convect the distance field TrilinosApplication.TrilinosLevelSetConvectionProcess2D( epetra_comm, KratosMultiphysics.DISTANCE, self.model_part, trilinos_linear_solver).Execute() # Check the obtained values max_distance = -1.0 min_distance = +1.0 for node in self.model_part.Nodes: d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE) max_distance = max(max_distance, d) min_distance = min(min_distance, d) comm = self.model_part.GetCommunicator().GetDataCommunicator() min_distance = comm.MinAll(min_distance) max_distance = comm.MaxAll(max_distance) self.assertAlmostEqual(max_distance, 0.7333041045431626) self.assertAlmostEqual(min_distance,-0.06371359024393104)
def test_resize(self): comm = KratosTrilinos.CreateEpetraCommunicator( KratosMultiphysics.DataCommunicator.GetDefault()) space = KratosTrilinos.TrilinosSparseSpace() pb = space.CreateEmptyVectorPointer(comm) space.ResizeVector(pb, 2) n = space.Size(pb.GetReference()) self.assertEqual(n, 2)
def test_trilinos_levelset_convection(self): # Set the initial distance field and the convection velocity for node in self.model_part.Nodes: node.SetSolutionStepValue(KratosMultiphysics.DISTANCE, 0, BaseDistance(node.X, node.Y, node.Z)) node.SetSolutionStepValue( KratosMultiphysics.VELOCITY, 0, ConvectionVelocity(node.X, node.Y, node.Z)) # Fix the left side values for node in self.model_part.Nodes: if node.X < 0.001: node.Fix(KratosMultiphysics.DISTANCE) # Set the Trilinos linear solver and Epetra communicator trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""")) epetra_comm = TrilinosApplication.CreateEpetraCommunicator( KratosMultiphysics.DataCommunicator.GetDefault()) # Fake time advance self.model_part.CloneTimeStep(40.0) # Convect the distance field levelset_convection_settings = KratosMultiphysics.Parameters("""{ "max_CFL" : 1.0, "max_substeps" : 0, "eulerian_error_compensation" : false, "element_type" : "levelset_convection_supg" }""") TrilinosApplication.TrilinosLevelSetConvectionProcess2D( epetra_comm, self.model_part, trilinos_linear_solver, levelset_convection_settings).Execute() # Check the obtained values max_distance = -1.0 min_distance = +1.0 for node in self.model_part.Nodes: d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE) max_distance = max(max_distance, d) min_distance = min(min_distance, d) comm = self.model_part.GetCommunicator().GetDataCommunicator() min_distance = comm.MinAll(min_distance) max_distance = comm.MaxAll(max_distance) self.assertAlmostEqual(max_distance, 0.7333041045431626) self.assertAlmostEqual(min_distance, -0.06371359024393104)
def testTrilinosRedistance(self): # Initialize the DISTANCE values for node in self.model_part.Nodes: node.SetSolutionStepValue( KratosMultiphysics.DISTANCE, 0, self._ExpectedDistance(node.X, node.Y, node.Z)) # Fake time advance self.model_part.CloneTimeStep(1.0) # Set the utility and compute the variational distance values trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""")) epetra_comm = TrilinosApplication.CreateEpetraCommunicator( KratosMultiphysics.DataCommunicator.GetDefault()) max_iterations = 2 TrilinosApplication.TrilinosVariationalDistanceCalculationProcess3D( epetra_comm, self.model_part, trilinos_linear_solver, max_iterations, (KratosMultiphysics.VariationalDistanceCalculationProcess3D. CALCULATE_EXACT_DISTANCES_TO_PLANE).AsFalse()).Execute() # Check the obtained values max_distance = -1.0 min_distance = +1.0 for node in self.model_part.Nodes: d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE) max_distance = max(max_distance, d) min_distance = min(min_distance, d) comm = self.model_part.GetCommunicator().GetDataCommunicator() min_distance = comm.MinAll(min_distance) max_distance = comm.MaxAll(max_distance) self.assertAlmostEqual(max_distance, 0.44556526310761013) # Serial max_distance self.assertAlmostEqual(min_distance, -0.504972246827639) # Serial min_distance
def _GetEpetraCommunicator(self): if not hasattr(self, '_epetra_communicator'): self._epetra_communicator = KratosTrilinos.CreateEpetraCommunicator(self.main_model_part.GetCommunicator().GetDataCommunicator()) return self._epetra_communicator
def test_trilinos_levelset_convection_BFECC(self): # Set the initial distance field and the convection velocity for node in self.model_part.Nodes: node.SetSolutionStepValue( KratosMultiphysics.DISTANCE, BaseJumpedDistance(node.X, node.Y, node.Z)) node.SetSolutionStepValue( KratosMultiphysics.VELOCITY, ConvectionVelocity(node.X, node.Y, node.Z)) # Fix the left side values for node in self.model_part.Nodes: if node.X < 0.001: node.Fix(KratosMultiphysics.DISTANCE) # Set the Trilinos linear solver and Epetra communicator trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""")) epetra_comm = TrilinosApplication.CreateEpetraCommunicator( KratosMultiphysics.DataCommunicator.GetDefault()) # Fake time advance self.model_part.CloneTimeStep(30.0) kratos_comm = KratosMultiphysics.DataCommunicator.GetDefault() KratosMultiphysics.FindGlobalNodalNeighboursProcess( kratos_comm, self.model_part).Execute() KratosMultiphysics.ComputeNonHistoricalNodalGradientProcess( self.model_part, KratosMultiphysics.DISTANCE, KratosMultiphysics.DISTANCE_GRADIENT, KratosMultiphysics.NODAL_AREA).Execute() levelset_convection_settings = KratosMultiphysics.Parameters("""{ "levelset_variable_name" : "DISTANCE", "levelset_convection_variable_name" : "VELOCITY", "levelset_gradient_variable_name" : "DISTANCE_GRADIENT", "max_CFL" : 1.0, "max_substeps" : 0, "eulerian_error_compensation" : true, "cross_wind_stabilization_factor" : 0.7 }""") TrilinosApplication.TrilinosLevelSetConvectionProcess2D( epetra_comm, self.model_part, trilinos_linear_solver, levelset_convection_settings).Execute() max_distance = -1.0 min_distance = +1.0 for node in self.model_part.Nodes: d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE) max_distance = max(max_distance, d) min_distance = min(min_distance, d) min_distance = kratos_comm.MinAll(min_distance) max_distance = kratos_comm.MaxAll(max_distance) # gid_output = GiDOutputProcess(model_part, # "levelset_test_2D", # KratosMultiphysics.Parameters(""" # { # "result_file_configuration" : { # "gidpost_flags": { # "GiDPostMode": "GiD_PostBinary", # "WriteDeformedMeshFlag": "WriteUndeformed", # "WriteConditionsFlag": "WriteConditions", # "MultiFileFlag": "SingleFile" # }, # "nodal_results" : ["DISTANCE","VELOCITY"] # } # } # """) # ) # gid_output.ExecuteInitialize() # gid_output.ExecuteBeforeSolutionLoop() # gid_output.ExecuteInitializeSolutionStep() # gid_output.PrintOutput() # gid_output.ExecuteFinalizeSolutionStep() # gid_output.ExecuteFinalize() self.assertAlmostEqual(max_distance, 1.0617777301844604) self.assertAlmostEqual(min_distance, -0.061745786561321375)
def testTrilinosRedistance(self): # Set the model part current_model = KratosMultiphysics.Model() self.model_part = current_model.CreateModelPart("Main") self.model_part.AddNodalSolutionStepVariable( KratosMultiphysics.DISTANCE) self.model_part.AddNodalSolutionStepVariable( KratosMultiphysics.FLAG_VARIABLE) self.model_part.AddNodalSolutionStepVariable( KratosMultiphysics.PARTITION_INDEX) # Import the model part, perform the partitioning and create communicators import_settings = KratosMultiphysics.Parameters(self.parameters) ModelPartImporter = distributed_import_model_part_utility.DistributedImportModelPartUtility( self.model_part, import_settings) ModelPartImporter.ImportModelPart() ModelPartImporter.CreateCommunicators() # Recall to set the buffer size self.model_part.SetBufferSize(2) # Initialize the DISTANCE values for node in self.model_part.Nodes: node.SetSolutionStepValue( KratosMultiphysics.DISTANCE, 0, self._ExpectedDistance(node.X, node.Y, node.Z)) # Fake time advance self.model_part.CloneTimeStep(1.0) # Set the utility and compute the variational distance values trilinos_linear_solver = trilinos_linear_solver_factory.ConstructSolver( KratosMultiphysics.Parameters("""{"solver_type" : "amesos" }""")) epetra_comm = TrilinosApplication.CreateEpetraCommunicator( KratosMultiphysics.DataCommunicator.GetDefault()) max_iterations = 2 TrilinosApplication.TrilinosVariationalDistanceCalculationProcess3D( epetra_comm, self.model_part, trilinos_linear_solver, max_iterations, (KratosMultiphysics.VariationalDistanceCalculationProcess3D. CALCULATE_EXACT_DISTANCES_TO_PLANE).AsFalse()).Execute() # Check the obtained values max_distance = -1.0 min_distance = +1.0 for node in self.model_part.Nodes: d = node.GetSolutionStepValue(KratosMultiphysics.DISTANCE) max_distance = max(max_distance, d) min_distance = min(min_distance, d) comm = self.model_part.GetCommunicator().GetDataCommunicator() min_distance = comm.MinAll(min_distance) max_distance = comm.MaxAll(max_distance) self.assertAlmostEqual(max_distance, 0.44556526310761013) # Serial max_distance self.assertAlmostEqual(min_distance, -0.504972246827639) # Serial min_distance
def get_communicator(self): if not hasattr(self, '_communicator'): self._communicator = TrilinosApplication.CreateEpetraCommunicator( self.mesh_model_part.GetCommunicator().GetDataCommunicator()) return self._communicator
def _create_epetra_communicator(self): return TrilinosApplication.CreateEpetraCommunicator( self.main_model_part.GetCommunicator().GetDataCommunicator())