def setup_problem(self): """ Setup the fitting problem. """ # Create fitting problem self.problem.CreateStart(self.problem_user_num, self.problem_specification) self.problem.CreateFinish() self.problem.ControlLoopCreateStart() self.problem.ControlLoopCreateFinish() self.solver = iron.Solver() self.problem.SolversCreateStart() self.problem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1, self.solver) # self.solver.OutputTypeSet(iron.SolverOutputTypes.NONE) self.solver.OutputTypeSet(iron.SolverOutputTypes.PROGRESS) # self.solver.LinearTypeSet(iron.LinearSolverTypes.DIRECT) # self.solver.LibraryTypeSet(iron.SolverLibraries.UMFPACK) # UMFPACK/SUPERLU self.solver.LinearTypeSet(iron.LinearSolverTypes.ITERATIVE) self.solver.LinearIterativeMaximumIterationsSet(5000) self.solver.LinearIterativeAbsoluteToleranceSet(1.0E-10) self.solver.LinearIterativeRelativeToleranceSet(1.0E-05) self.problem.SolversCreateFinish() self.solver = iron.Solver() self.solver_equations = iron.SolverEquations() self.problem.SolverEquationsCreateStart() self.problem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1, self.solver) self.solver.SolverEquationsGet(self.solver_equations) self.solver_equations.SparsityTypeSet( iron.SolverEquationsSparsityTypes.SPARSE) _ = self.solver_equations.EquationsSetAdd(self.equations_set) self.problem.SolverEquationsCreateFinish() self.boundary_conditions = iron.BoundaryConditions() self.solver_equations.BoundaryConditionsCreateStart( self.boundary_conditions) # Mapping constraints if self.dependent_field_mappings: version = 1 for mapped_node_idx in range( self.num_mapped_dependent_field_nodes): for component in range(1, self.num_data_components + 1): self.boundary_conditions.ConstrainNodeDofsEqual( self.dependent_field, iron.FieldVariableTypes.U, version, iron.GlobalDerivativeConstants.NO_GLOBAL_DERIV, component, self.mapped_dependent_field_node_nums[ mapped_node_idx, :], 1.0) self.solver_equations.BoundaryConditionsCreateFinish()
linearSolver.linearType = iron.LinearSolverTypes.DIRECT # linearSolver.LinearIterativeMaximumIterationsSet(1000) problem.SolversCreateFinish() # Create solver equations and add equations set to solver equations solver = iron.Solver() solverEquations = iron.SolverEquations() problem.SolverEquationsCreateStart() problem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1, solver) solver.SolverEquationsGet(solverEquations) solverEquations.sparsityType = iron.SolverEquationsSparsityTypes.SPARSE equationsSetIndex = solverEquations.EquationsSetAdd(equationsSet) problem.SolverEquationsCreateFinish() # Create boundary conditions boundaryConditions = iron.BoundaryConditions() solverEquations.BoundaryConditionsCreateStart(boundaryConditions) # Set maximum concentration (1) for nodes at the inlet for inlet_node in inlet_node_array: boundaryConditions.SetNode(dependentField, iron.FieldVariableTypes.U, 1, 1, int(inlet_node), 1, iron.BoundaryConditionsTypes.FIXED, 1.0) # Set minimum concentration (0) for nodes at the outlet for outlet_node in outlet_node_array: boundaryConditions.SetNode(dependentField, iron.FieldVariableTypes.U, 1, 1, int(outlet_node), 1, iron.BoundaryConditionsTypes.FIXED, 0.0) solverEquations.BoundaryConditionsCreateFinish()
def reset_problem(simulation): """ Resets the FE model's solvers so there is no data from the previous solve used in the next one. :param simulation: The simulation which needs its solver reset. """ problemUserNumber = 12 numberOfLoadIncrements = 1 NumberOfGaussXi = 4 simulation.problem.Destroy() simulation.problem = iron.Problem() simulation.problemSpecification = [iron.ProblemClasses.ELASTICITY, iron.ProblemTypes.FINITE_ELASTICITY, iron.ProblemSubtypes.NONE] simulation.problem.CreateStart(problemUserNumber, simulation.problemSpecification) simulation.problem.CreateFinish() # Create the problem control loop simulation.problem.ControlLoopCreateStart() simulation.controlLoop = iron.ControlLoop() simulation.problem.ControlLoopGet([iron.ControlLoopIdentifiers.NODE],simulation.controlLoop) simulation.controlLoop.MaximumIterationsSet(numberOfLoadIncrements) simulation.problem.ControlLoopCreateFinish() simulation.nonLinearSolver = iron.Solver() simulation.linearSolver = iron.Solver() simulation.problem.SolversCreateStart() simulation.problem.SolverGet([iron.ControlLoopIdentifiers.NODE],1,simulation.nonLinearSolver) if simulation.diagnostics == 4 or simulation.diagnostics == 'Matrix': simulation.nonLinearSolver.outputType = iron.SolverOutputTypes.MATRIX elif simulation.diagnostics == 3 or simulation.diagnostics == 'Solver': simulation.nonLinearSolver.outputType = iron.SolverOutputTypes.SOLVER elif simulation.diagnostics == 2 or simulation.diagnostics == 'Timing': simulation.nonLinearSolver.outputType = iron.SolverOutputTypes.TIMING elif simulation.diagnostics == 1 or simulation.diagnostics == 'Progress': simulation.nonLinearSolver.outputType = iron.SolverOutputTypes.PROGRESS else: simulation.nonLinearSolver.outputType = iron.SolverOutputTypes.NONE simulation.nonLinearSolver.NewtonJacobianCalculationTypeSet(iron.JacobianCalculationTypes.FD) simulation.nonLinearSolver.NewtonAbsoluteToleranceSet(1e-9) simulation.nonLinearSolver.NewtonSolutionToleranceSet(1e-9) simulation.nonLinearSolver.NewtonRelativeToleranceSet(1e-9) simulation.nonLinearSolver.NewtonMaximumIterationsSet(int(1e6)) simulation.nonLinearSolver.NewtonMaximumFunctionEvaluationsSet(int(1e6)) simulation.nonLinearSolver.NewtonLinearSolverGet(simulation.linearSolver) simulation.linearSolver.linearType = iron.LinearSolverTypes.DIRECT #linearSolver.libraryType = iron.SolverLibraries.LAPACK simulation.problem.SolversCreateFinish() simulation.solver = iron.Solver() simulation.solverEquations = iron.SolverEquations() simulation.problem.SolverEquationsCreateStart() simulation.problem.SolverGet([iron.ControlLoopIdentifiers.NODE],1,simulation.solver) simulation.solver.SolverEquationsGet(simulation.solverEquations) simulation.solverEquations.sparsityType = iron.SolverEquationsSparsityTypes.SPARSE equationsSetIndex = simulation.solverEquations.EquationsSetAdd(simulation.equationsSet) simulation.problem.SolverEquationsCreateFinish() simulation.boundaryConditions = iron.BoundaryConditions() simulation.solverEquations.BoundaryConditionsCreateStart(simulation.boundaryConditions) numberOfNodes = (NumberOfGaussXi + (NumberOfGaussXi-1)*(simulation.cantilever_elements[0]-1))\ * (NumberOfGaussXi + (NumberOfGaussXi-1)*(simulation.cantilever_elements[1]-1))\ * (NumberOfGaussXi + (NumberOfGaussXi-1)*(simulation.cantilever_elements[2]-1)) for nodeNum in range(1, numberOfNodes+1, (NumberOfGaussXi + (NumberOfGaussXi-1)*(simulation.cantilever_elements[0]-1))): simulation.boundaryConditions.AddNode(simulation.dependentField, iron.FieldVariableTypes.U, 1, 1, nodeNum, 1, iron.BoundaryConditionsTypes.FIXED, 0.0) simulation.boundaryConditions.AddNode(simulation.dependentField, iron.FieldVariableTypes.U, 1, 1, nodeNum, 2, iron.BoundaryConditionsTypes.FIXED, 0.0) simulation.boundaryConditions.AddNode(simulation.dependentField, iron.FieldVariableTypes.U, 1, 1, nodeNum, 3, iron.BoundaryConditionsTypes.FIXED, 0.0) simulation.solverEquations.BoundaryConditionsCreateFinish()
def solve_model(exportname, model=1, debug=False): # Setting debug=False will prevent output of solver progress/results to the screen. if debug: print("Solving model {0}".format(model)) # Get the number of computational nodes and this computational node number numberOfComputationalNodes = iron.ComputationalNumberOfNodesGet() # computationalNodeNumber = iron.ComputationalNodeNumberGet() # Create a 3D rectangular cartesian coordinate system coordinateSystem = iron.CoordinateSystem() coordinateSystem.CreateStart(coordinateSystemUserNumber) coordinateSystem.DimensionSet(3) coordinateSystem.CreateFinish() # Create a region and assign the coordinate system to the region region = iron.Region() region.CreateStart(regionUserNumber, iron.WorldRegion) region.LabelSet("Region") region.coordinateSystem = coordinateSystem region.CreateFinish() # Define basis basis = iron.Basis() basis.CreateStart(basisUserNumber) if InterpolationType in (1, 2, 3, 4): basis.type = iron.BasisTypes.LAGRANGE_HERMITE_TP elif InterpolationType in (7, 8, 9): basis.type = iron.BasisTypes.SIMPLEX basis.numberOfXi = numberOfXi basis.interpolationXi = ( [iron.BasisInterpolationSpecifications.LINEAR_LAGRANGE] * numberOfXi) if (NumberOfGaussXi > 0): basis.quadratureNumberOfGaussXi = [NumberOfGaussXi] * numberOfXi basis.CreateFinish() if (UsePressureBasis): # Define pressure basis pressureBasis = iron.Basis() pressureBasis.CreateStart(pressureBasisUserNumber) if InterpolationType in (1, 2, 3, 4): pressureBasis.type = iron.BasisTypes.LAGRANGE_HERMITE_TP elif InterpolationType in (7, 8, 9): pressureBasis.type = iron.BasisTypes.SIMPLEX pressureBasis.numberOfXi = numberOfXi pressureBasis.interpolationXi = ( [iron.BasisInterpolationSpecifications.LINEAR_LAGRANGE] * numberOfXi) if (NumberOfGaussXi > 0): pressureBasis.quadratureNumberOfGaussXi = [NumberOfGaussXi ] * numberOfXi pressureBasis.CreateFinish() # Start the creation of a generated mesh in the region generatedMesh = iron.GeneratedMesh() generatedMesh.CreateStart(generatedMeshUserNumber, region) generatedMesh.type = iron.GeneratedMeshTypes.REGULAR if (UsePressureBasis): generatedMesh.basis = [basis, pressureBasis] else: generatedMesh.basis = [basis] generatedMesh.extent = [width, length, height] generatedMesh.numberOfElements = ([ numberGlobalXElements, numberGlobalYElements, numberGlobalZElements ]) # Finish the creation of a generated mesh in the region mesh = iron.Mesh() generatedMesh.CreateFinish(meshUserNumber, mesh) # Create a decomposition for the mesh decomposition = iron.Decomposition() decomposition.CreateStart(decompositionUserNumber, mesh) decomposition.type = iron.DecompositionTypes.CALCULATED decomposition.numberOfDomains = numberOfComputationalNodes decomposition.CreateFinish() # Create a field for the geometry geometricField = iron.Field() geometricField.CreateStart(geometricFieldUserNumber, region) geometricField.MeshDecompositionSet(decomposition) geometricField.TypeSet(iron.FieldTypes.GEOMETRIC) geometricField.VariableLabelSet(iron.FieldVariableTypes.U, "Geometry") geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 1, 1) geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 2, 1) geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 3, 1) if InterpolationType == 4: geometricField.fieldScalingType = iron.FieldScalingTypes.ARITHMETIC_MEAN geometricField.CreateFinish() # Update the geometric field parameters from generated mesh generatedMesh.GeometricParametersCalculate(geometricField) # Create a fibre field and attach it to the geometric field fibreField = iron.Field() fibreField.CreateStart(fibreFieldUserNumber, region) fibreField.TypeSet(iron.FieldTypes.FIBRE) fibreField.MeshDecompositionSet(decomposition) fibreField.GeometricFieldSet(geometricField) fibreField.VariableLabelSet(iron.FieldVariableTypes.U, "Fibre") if InterpolationType == 4: fibreField.fieldScalingType = iron.FieldScalingTypes.ARITHMETIC_MEAN fibreField.CreateFinish() # Create a deformed geometry field, as Cmgui/Zinc doesn't like displaying # deformed fibres from the dependent field because it isn't a geometric field. deformedField = iron.Field() deformedField.CreateStart(deformedFieldUserNumber, region) deformedField.MeshDecompositionSet(decomposition) deformedField.TypeSet(iron.FieldTypes.GEOMETRIC) deformedField.VariableLabelSet(iron.FieldVariableTypes.U, "DeformedGeometry") for component in [1, 2, 3]: deformedField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, component, 1) if InterpolationType == 4: deformedField.ScalingTypeSet(iron.FieldScalingTypes.ARITHMETIC_MEAN) deformedField.CreateFinish() pressureField = iron.Field() pressureField.CreateStart(pressureFieldUserNumber, region) pressureField.MeshDecompositionSet(decomposition) pressureField.VariableLabelSet(iron.FieldVariableTypes.U, "Pressure") pressureField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 1, 1) pressureField.ComponentInterpolationSet( iron.FieldVariableTypes.U, 1, iron.FieldInterpolationTypes.ELEMENT_BASED) pressureField.NumberOfComponentsSet(iron.FieldVariableTypes.U, 1) pressureField.CreateFinish() # Create the equations_set equationsSetField = iron.Field() equationsSet = iron.EquationsSet() problemSpecification = [ iron.ProblemClasses.ELASTICITY, iron.ProblemTypes.FINITE_ELASTICITY, iron.EquationsSetSubtypes.MOONEY_RIVLIN ] equationsSet.CreateStart(equationsSetUserNumber, region, fibreField, problemSpecification, equationsSetFieldUserNumber, equationsSetField) equationsSet.CreateFinish() # Create the dependent field dependentField = iron.Field() equationsSet.DependentCreateStart(dependentFieldUserNumber, dependentField) dependentField.VariableLabelSet(iron.FieldVariableTypes.U, "Dependent") dependentField.ComponentInterpolationSet( iron.FieldVariableTypes.U, 4, iron.FieldInterpolationTypes.ELEMENT_BASED) dependentField.ComponentInterpolationSet( iron.FieldVariableTypes.DELUDELN, 4, iron.FieldInterpolationTypes.ELEMENT_BASED) if (UsePressureBasis): # Set the pressure to be nodally based and use the second mesh component if InterpolationType == 4: dependentField.ComponentInterpolationSet( iron.FieldVariableTypes.U, 4, iron.FieldInterpolationTypes.NODE_BASED) dependentField.ComponentInterpolationSet( iron.FieldVariableTypes.DELUDELN, 4, iron.FieldInterpolationTypes.NODE_BASED) dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 4, 2) dependentField.ComponentMeshComponentSet( iron.FieldVariableTypes.DELUDELN, 4, 2) if InterpolationType == 4: dependentField.fieldScalingType = iron.FieldScalingTypes.ARITHMETIC_MEAN equationsSet.DependentCreateFinish() # Create the material field materialField = iron.Field() equationsSet.MaterialsCreateStart(materialFieldUserNumber, materialField) materialField.VariableLabelSet(iron.FieldVariableTypes.U, "Material") equationsSet.MaterialsCreateFinish() # Set Mooney-Rivlin constants c10 and c01 respectively. materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1, 1.0) materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 2, 0.2) # Create equations equations = iron.Equations() equationsSet.EquationsCreateStart(equations) equations.sparsityType = iron.EquationsSparsityTypes.SPARSE equations.outputType = iron.EquationsOutputTypes.NONE equationsSet.EquationsCreateFinish() # Initialise dependent field from undeformed geometry and displacement bcs and set hydrostatic pressure iron.Field.ParametersToFieldParametersComponentCopy( geometricField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1, dependentField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1) iron.Field.ParametersToFieldParametersComponentCopy( geometricField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 2, dependentField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 2) iron.Field.ParametersToFieldParametersComponentCopy( geometricField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 3, dependentField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 3) iron.Field.ComponentValuesInitialiseDP(dependentField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 4, 0.0) # Define the problem problem = iron.Problem() problemSpecification = [ iron.ProblemClasses.ELASTICITY, iron.ProblemTypes.FINITE_ELASTICITY, iron.ProblemSubtypes.NONE ] problem.CreateStart(problemUserNumber, problemSpecification) problem.CreateFinish() # Create the problem control loop problem.ControlLoopCreateStart() controlLoop = iron.ControlLoop() problem.ControlLoopGet([iron.ControlLoopIdentifiers.NODE], controlLoop) controlLoop.MaximumIterationsSet(numberOfLoadIncrements) problem.ControlLoopCreateFinish() # Create problem solver nonLinearSolver = iron.Solver() linearSolver = iron.Solver() problem.SolversCreateStart() problem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1, nonLinearSolver) if debug: nonLinearSolver.outputType = iron.SolverOutputTypes.PROGRESS else: nonLinearSolver.outputType = iron.SolverOutputTypes.NONE nonLinearSolver.NewtonJacobianCalculationTypeSet( iron.JacobianCalculationTypes.EQUATIONS) nonLinearSolver.NewtonLinearSolverGet(linearSolver) linearSolver.linearType = iron.LinearSolverTypes.DIRECT #linearSolver.libraryType = iron.SolverLibraries.LAPACK problem.SolversCreateFinish() # Create solver equations and add equations set to solver equations solver = iron.Solver() solverEquations = iron.SolverEquations() problem.SolverEquationsCreateStart() problem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1, solver) solver.SolverEquationsGet(solverEquations) solverEquations.sparsityType = iron.SolverEquationsSparsityTypes.SPARSE _ = solverEquations.EquationsSetAdd(equationsSet) problem.SolverEquationsCreateFinish() # Prescribe boundary conditions (absolute nodal parameters) boundaryConditions = iron.BoundaryConditions() solverEquations.BoundaryConditionsCreateStart(boundaryConditions) if model == 1: boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) p = -2. * -0.1056E+01 elif model == 2: boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, Y, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, Y, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, Y, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, Y, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) p = -2. * -0.6656E+00 elif model == 3: boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) p = -2. * -0.1450E+01 elif model == 4: boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Z, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, Z, iron.BoundaryConditionsTypes.FIXED, 0.5) p = -2. * -0.1056E+01 elif model == 5: boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, X, iron.BoundaryConditionsTypes.FIXED, 0.5) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, X, iron.BoundaryConditionsTypes.FIXED, 0.75) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, X, iron.BoundaryConditionsTypes.FIXED, 0.75) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) p = -2. * -0.1000E+01 solverEquations.BoundaryConditionsCreateFinish() # Solve the problem problem.Solve() # Copy deformed geometry into deformed field for component in [1, 2, 3]: dependentField.ParametersToFieldParametersComponentCopy( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, component, deformedField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, component) # Copy pressure into pressure field dependentField.ParametersToFieldParametersComponentCopy( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 4, pressureField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1) # Export results fields = iron.Fields() fields.CreateRegion(region) fields.NodesExport(exportname, "FORTRAN") fields.ElementsExport(exportname, "FORTRAN") fields.Finalise() results = {} elementNumber = 1 xiPosition = [0.5, 0.5, 0.5] F = equationsSet.TensorInterpolateXi( iron.EquationsSetTensorEvaluateTypes.DEFORMATION_GRADIENT, elementNumber, xiPosition, (3, 3)) results['Deformation Gradient Tensor'] = F if debug: print("Deformation Gradient Tensor") print(F) C = equationsSet.TensorInterpolateXi( iron.EquationsSetTensorEvaluateTypes.R_CAUCHY_GREEN_DEFORMATION, elementNumber, xiPosition, (3, 3)) results['Right Cauchy-Green Deformation Tensor'] = C if debug: print("Right Cauchy-Green Deformation Tensor") print(C) E = equationsSet.TensorInterpolateXi( iron.EquationsSetTensorEvaluateTypes.GREEN_LAGRANGE_STRAIN, elementNumber, xiPosition, (3, 3)) results['Green-Lagrange Strain Tensor'] = E if debug: print("Green-Lagrange Strain Tensor") print(E) I1 = numpy.trace(C) I2 = 0.5 * (numpy.trace(C)**2. - numpy.tensordot(C, C)) I3 = numpy.linalg.det(C) results['Invariants'] = [I1, I2, I3] if debug: print("Invariants") print("I1={0}, I2={1}, I3={2}".format(I1, I2, I3)) TC = equationsSet.TensorInterpolateXi( iron.EquationsSetTensorEvaluateTypes.CAUCHY_STRESS, elementNumber, xiPosition, (3, 3)) results['Cauchy Stress Tensor'] = TC if debug: print("Cauchy Stress Tensor") print(TC) # Output of Second Piola-Kirchhoff Stress Tensor not implemented. It is # instead, calculated from TG=J*F^(-1)*TC*F^(-T), where T indicates the # transpose fo the matrix. #TG = equationsSet.TensorInterpolateXi( # iron.EquationsSetTensorEvaluateTypes.SECOND_PK_STRESS, # elementNumber, xiPosition,(3,3)) #J=1. #Assumes J=1 TG = numpy.dot(numpy.linalg.inv(F), numpy.dot(TC, numpy.linalg.inv(numpy.matrix.transpose(F)))) results['Second Piola-Kirchhoff Stress Tensor'] = TG if debug: print("Second Piola-Kirchhoff Stress Tensor") print(TG) # Note that the hydrostatic pressure value is different from the value quoted # in the original lab instructions. This is because the stress has been # evaluated using modified invariants (isochoric invariants) #p = dependentField.ParameterSetGetElement( # iron.FieldVariableTypes.U, # iron.FieldParameterSetTypes.VALUES,elementNumber,4) results['Hydrostatic pressure'] = p if debug: print("Hydrostatic pressure") print(p) problem.Destroy() coordinateSystem.Destroy() region.Destroy() basis.Destroy() return results
def solve_model(exportname, model=1, debug=False): # Setting debug=False will prevent output of solver progress/results to the screen. if debug: print("Solving model {0}".format(model)) # Get the number of computational nodes and this computational node number numberOfComputationalNodes = iron.ComputationalNumberOfNodesGet() # computationalNodeNumber = iron.ComputationalNodeNumberGet() # Create a 3D rectangular cartesian coordinate system coordinateSystem = iron.CoordinateSystem() coordinateSystem.CreateStart(coordinateSystemUserNumber) coordinateSystem.DimensionSet(3) coordinateSystem.CreateFinish() # Create a region and assign the coordinate system to the region region = iron.Region() region.CreateStart(regionUserNumber, iron.WorldRegion) region.LabelSet("Region") region.coordinateSystem = coordinateSystem region.CreateFinish() # Define basis basis = iron.Basis() basis.CreateStart(basisUserNumber) if InterpolationType in (1, 2, 3, 4): basis.type = iron.BasisTypes.LAGRANGE_HERMITE_TP elif InterpolationType in (7, 8, 9): basis.type = iron.BasisTypes.SIMPLEX basis.numberOfXi = numberOfXi basis.interpolationXi = ( [iron.BasisInterpolationSpecifications.LINEAR_LAGRANGE] * numberOfXi) if (NumberOfGaussXi > 0): basis.quadratureNumberOfGaussXi = [NumberOfGaussXi] * numberOfXi basis.CreateFinish() if (UsePressureBasis): # Define pressure basis pressureBasis = iron.Basis() pressureBasis.CreateStart(pressureBasisUserNumber) if InterpolationType in (1, 2, 3, 4): pressureBasis.type = iron.BasisTypes.LAGRANGE_HERMITE_TP elif InterpolationType in (7, 8, 9): pressureBasis.type = iron.BasisTypes.SIMPLEX pressureBasis.numberOfXi = numberOfXi pressureBasis.interpolationXi = ( [iron.BasisInterpolationSpecifications.LINEAR_LAGRANGE] * numberOfXi) if (NumberOfGaussXi > 0): pressureBasis.quadratureNumberOfGaussXi = [NumberOfGaussXi ] * numberOfXi pressureBasis.CreateFinish() # Start the creation of a generated mesh in the region generatedMesh = iron.GeneratedMesh() generatedMesh.CreateStart(generatedMeshUserNumber, region) generatedMesh.type = iron.GeneratedMeshTypes.REGULAR if (UsePressureBasis): generatedMesh.basis = [basis, pressureBasis] else: generatedMesh.basis = [basis] generatedMesh.extent = [width, length, height] generatedMesh.numberOfElements = ([ numberGlobalXElements, numberGlobalYElements, numberGlobalZElements ]) # Finish the creation of a generated mesh in the region mesh = iron.Mesh() generatedMesh.CreateFinish(meshUserNumber, mesh) # Create a decomposition for the mesh decomposition = iron.Decomposition() decomposition.CreateStart(decompositionUserNumber, mesh) decomposition.type = iron.DecompositionTypes.CALCULATED decomposition.numberOfDomains = numberOfComputationalNodes decomposition.CreateFinish() # Create a field for the geometry geometricField = iron.Field() geometricField.CreateStart(geometricFieldUserNumber, region) geometricField.MeshDecompositionSet(decomposition) geometricField.TypeSet(iron.FieldTypes.GEOMETRIC) geometricField.VariableLabelSet(iron.FieldVariableTypes.U, "Geometry") geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 1, 1) geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 2, 1) geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 3, 1) if InterpolationType == 4: geometricField.fieldScalingType = iron.FieldScalingTypes.ARITHMETIC_MEAN geometricField.CreateFinish() # Update the geometric field parameters from generated mesh generatedMesh.GeometricParametersCalculate(geometricField) # Create a fibre field and attach it to the geometric field fibreField = iron.Field() fibreField.CreateStart(fibreFieldUserNumber, region) fibreField.TypeSet(iron.FieldTypes.FIBRE) fibreField.MeshDecompositionSet(decomposition) fibreField.GeometricFieldSet(geometricField) fibreField.VariableLabelSet(iron.FieldVariableTypes.U, "Fibre") if InterpolationType == 4: fibreField.fieldScalingType = iron.FieldScalingTypes.ARITHMETIC_MEAN fibreField.CreateFinish() # Create a deformed geometry field, as Cmgui/Zinc doesn't like displaying # deformed fibres from the dependent field because it isn't a geometric field. deformedField = iron.Field() deformedField.CreateStart(deformedFieldUserNumber, region) deformedField.MeshDecompositionSet(decomposition) deformedField.TypeSet(iron.FieldTypes.GEOMETRIC) deformedField.VariableLabelSet(iron.FieldVariableTypes.U, "DeformedGeometry") for component in [1, 2, 3]: deformedField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, component, 1) if InterpolationType == 4: deformedField.ScalingTypeSet(iron.FieldScalingTypes.ARITHMETIC_MEAN) deformedField.CreateFinish() pressureField = iron.Field() pressureField.CreateStart(pressureFieldUserNumber, region) pressureField.MeshDecompositionSet(decomposition) pressureField.VariableLabelSet(iron.FieldVariableTypes.U, "Pressure") pressureField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 1, 1) pressureField.ComponentInterpolationSet( iron.FieldVariableTypes.U, 1, iron.FieldInterpolationTypes.ELEMENT_BASED) pressureField.NumberOfComponentsSet(iron.FieldVariableTypes.U, 1) pressureField.CreateFinish() # Create the equations_set equationsSetField = iron.Field() equationsSet = iron.EquationsSet() problemSpecification = [ iron.ProblemClasses.ELASTICITY, iron.ProblemTypes.FINITE_ELASTICITY, iron.EquationsSetSubtypes.ORTHOTROPIC_MATERIAL_COSTA ] equationsSet.CreateStart(equationsSetUserNumber, region, fibreField, problemSpecification, equationsSetFieldUserNumber, equationsSetField) equationsSet.CreateFinish() # Create the dependent field dependentField = iron.Field() equationsSet.DependentCreateStart(dependentFieldUserNumber, dependentField) dependentField.VariableLabelSet(iron.FieldVariableTypes.U, "Dependent") dependentField.ComponentInterpolationSet( iron.FieldVariableTypes.U, 4, iron.FieldInterpolationTypes.ELEMENT_BASED) dependentField.ComponentInterpolationSet( iron.FieldVariableTypes.DELUDELN, 4, iron.FieldInterpolationTypes.ELEMENT_BASED) if (UsePressureBasis): # Set the pressure to be nodally based and use the second mesh component if InterpolationType == 4: dependentField.ComponentInterpolationSet( iron.FieldVariableTypes.U, 4, iron.FieldInterpolationTypes.NODE_BASED) dependentField.ComponentInterpolationSet( iron.FieldVariableTypes.DELUDELN, 4, iron.FieldInterpolationTypes.NODE_BASED) dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 4, 2) dependentField.ComponentMeshComponentSet( iron.FieldVariableTypes.DELUDELN, 4, 2) if InterpolationType == 4: dependentField.fieldScalingType = iron.FieldScalingTypes.ARITHMETIC_MEAN equationsSet.DependentCreateFinish() # Create the material field materialField = iron.Field() equationsSet.MaterialsCreateStart(materialFieldUserNumber, materialField) materialField.VariableLabelSet(iron.FieldVariableTypes.U, "Material") equationsSet.MaterialsCreateFinish() # Set Costa constitutive relation parameters. # Q=[c_ff 2c_fs 2c_fn c_ss 2c_ns c_nn]' * [E_ff E_fs E_fn E_ss E_sn E_nn].^2; if model in [1, 3, 4]: c_1 = 0.0475 c_ff = 15.25 c_fs = 6.05 c_fn = c_fs c_ss = c_ff c_sn = c_fs c_nn = c_ff elif model in [2, 5, 6]: c_1 = 0.0475 c_ff = 15.25 c_fs = 6.95 c_fn = 6.05 c_ss = 6.8 c_sn = 4.93 c_nn = 8.9 materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1, c_1) materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 2, c_ff) materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 3, c_fs) materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 4, c_fn) materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 5, c_ss) materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 6, c_sn) materialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 7, c_nn) if model in [1, 2]: angle = numpy.deg2rad(0.) elif model == 3: angle = numpy.deg2rad(30.) elif model in [4, 5]: angle = numpy.deg2rad(45.) elif model == 6: angle = numpy.deg2rad(90.) fibreField.ComponentValuesInitialiseDP(iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1, angle) # Create equations equations = iron.Equations() equationsSet.EquationsCreateStart(equations) equations.sparsityType = iron.EquationsSparsityTypes.SPARSE equations.outputType = iron.EquationsOutputTypes.NONE equationsSet.EquationsCreateFinish() # Initialise dependent field from undeformed geometry and displacement bcs and set hydrostatic pressure iron.Field.ParametersToFieldParametersComponentCopy( geometricField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1, dependentField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1) iron.Field.ParametersToFieldParametersComponentCopy( geometricField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 2, dependentField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 2) iron.Field.ParametersToFieldParametersComponentCopy( geometricField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 3, dependentField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 3) iron.Field.ComponentValuesInitialiseDP(dependentField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 4, 0.0) # Define the problem problem = iron.Problem() problemSpecification = [ iron.ProblemClasses.ELASTICITY, iron.ProblemTypes.FINITE_ELASTICITY, iron.ProblemSubtypes.NONE ] problem.CreateStart(problemUserNumber, problemSpecification) problem.CreateFinish() # Create the problem control loop problem.ControlLoopCreateStart() controlLoop = iron.ControlLoop() problem.ControlLoopGet([iron.ControlLoopIdentifiers.NODE], controlLoop) controlLoop.MaximumIterationsSet(numberOfLoadIncrements) problem.ControlLoopCreateFinish() # Create problem solver nonLinearSolver = iron.Solver() linearSolver = iron.Solver() problem.SolversCreateStart() problem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1, nonLinearSolver) if debug: nonLinearSolver.outputType = iron.SolverOutputTypes.PROGRESS else: nonLinearSolver.outputType = iron.SolverOutputTypes.NONE nonLinearSolver.NewtonJacobianCalculationTypeSet( iron.JacobianCalculationTypes.EQUATIONS) nonLinearSolver.NewtonLinearSolverGet(linearSolver) linearSolver.linearType = iron.LinearSolverTypes.DIRECT #linearSolver.libraryType = iron.SolverLibraries.LAPACK problem.SolversCreateFinish() # Create solver equations and add equations set to solver equations solver = iron.Solver() solverEquations = iron.SolverEquations() problem.SolverEquationsCreateStart() problem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1, solver) solver.SolverEquationsGet(solverEquations) solverEquations.sparsityType = iron.SolverEquationsSparsityTypes.SPARSE _ = solverEquations.EquationsSetAdd(equationsSet) problem.SolverEquationsCreateFinish() # Prescribe boundary conditions (absolute nodal parameters) boundaryConditions = iron.BoundaryConditions() solverEquations.BoundaryConditionsCreateStart(boundaryConditions) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, X, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, X, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, Y, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, Y, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, Y, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, Y, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, Y, iron.BoundaryConditionsTypes.FIXED, 0.25) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, Z, iron.BoundaryConditionsTypes.FIXED, 0.0) solverEquations.BoundaryConditionsCreateFinish() # Solve the problem problem.Solve() # Copy deformed geometry into deformed field for component in [1, 2, 3]: dependentField.ParametersToFieldParametersComponentCopy( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, component, deformedField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, component) # Copy pressure into pressure field dependentField.ParametersToFieldParametersComponentCopy( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 4, pressureField, iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1) # Export results fields = iron.Fields() fields.CreateRegion(region) fields.NodesExport(exportname, "FORTRAN") fields.ElementsExport(exportname, "FORTRAN") fields.Finalise() Q = numpy.array([[numpy.cos(angle), -numpy.sin(angle), 0.], [numpy.sin(angle), numpy.cos(angle), 0.], [0., 0., 1.]]) results = {} elementNumber = 1 xiPosition = [0.5, 0.5, 0.5] # Note that there seems to be a bug with F in OpenCMISS when fibre angles are specified in x1-x2 plane #F = equationsSet.TensorInterpolateXi( # iron.EquationsSetTensorEvaluateTypes.DEFORMATION_GRADIENT, # elementNumber, xiPosition,(3,3)) Ffib = numpy.array([[0.1250E+01, 0., 0.], [0., 0.1250E+01, 0.], [0., 0., 0.6400E+00]]) Fref = Ffib results["Deformation gradient tensor (fibre coordinate system)"] = Ffib results["Deformation gradient tensor (reference coordinate system)"] = Fref if debug: print("Deformation gradient tensor (fibre coordinate system)") print(Ffib) print("Deformation gradient tensor (reference coordinate system)") print(Fref) Cfib = equationsSet.TensorInterpolateXi( iron.EquationsSetTensorEvaluateTypes.R_CAUCHY_GREEN_DEFORMATION, elementNumber, xiPosition, (3, 3)) Cref = Cfib results[ "Right Cauchy-Green deformation tensor (fibre coordinate system)"] = Cfib results[ "Right Cauchy-Green deformation tensor (reference coordinate system)"] = Cref if debug: print( "Right Cauchy-Green deformation tensor (fibre coordinate system)") print(Cfib) print( "Right Cauchy-Green deformation tensor (reference coordinate system)" ) print(Cref) Efib = equationsSet.TensorInterpolateXi( iron.EquationsSetTensorEvaluateTypes.GREEN_LAGRANGE_STRAIN, elementNumber, xiPosition, (3, 3)) results["Green-Lagrange strain tensor (fibre coordinate system)"] = Efib if debug: print("Green-Lagrange strain tensor (fibre coordinate system)") print(Efib) Eref = numpy.dot(Q, numpy.dot(Efib, numpy.matrix.transpose(Q))) results[ "Green-Lagrange strain tensor (reference coordinate system)"] = Eref if debug: print("Green-Lagrange strain tensor (reference coordinate system)") print(Eref) I1 = numpy.trace(Cfib) I2 = 0.5 * (numpy.trace(Cfib)**2. - numpy.tensordot(Cfib, Cfib)) I3 = numpy.linalg.det(Cfib) results["Invariants of Cfib (fibre coordinate system)"] = [I1, I2, I3] if debug: print("Invariants of Cfib (fibre coordinate system)") print("I1={0}, I2={1}, I3={2}".format(I1, I2, I3)) I1 = numpy.trace(Cref) I2 = 0.5 * (numpy.trace(Cref)**2. - numpy.tensordot(Cref, Cref)) I3 = numpy.linalg.det(Cref) results["Invariants of Cref (reference coordinate system)"] = [I1, I2, I3] if debug: print("Invariants of Cref (reference coordinate system)") print("I1={0}, I2={1}, I3={2}".format(I1, I2, I3)) TCref = equationsSet.TensorInterpolateXi( iron.EquationsSetTensorEvaluateTypes.CAUCHY_STRESS, elementNumber, xiPosition, (3, 3)) results["Cauchy stress tensor (reference coordinate system)"] = TCref if debug: print("Cauchy stress tensor (reference coordinate system)") print(TCref) # Output of Second Piola-Kirchhoff Stress Tensor not implemented. It is # instead, calculated from TG=J*F^(-1)*TC*F^(-T), where T indicates the # transpose fo the matrix. #TG = equationsSet.TensorInterpolateXi( # iron.EquationsSetTensorEvaluateTypes.SECOND_PK_STRESS, # elementNumber, xiPosition,(3,3)) #J=1. #Assumes J=1 TGref = numpy.dot( numpy.linalg.inv(Fref), numpy.dot(TCref, numpy.linalg.inv(numpy.matrix.transpose(Fref)))) results[ "Second Piola-Kirchhoff stress tensor (reference coordinate system)"] = TGref if debug: print( "Second Piola-Kirchhoff stress tensor (reference coordinate system)" ) print(TGref) TGfib = numpy.dot(numpy.matrix.transpose(Q), numpy.dot(TGref, Q)) results[ "Second Piola-Kirchhoff stress tensor (fibre coordinate system)"] = TGfib if debug: print("Second Piola-Kirchhoff stress tensor (fibre coordinate system)") print(TGfib) # Note that the hydrostatic pressure value is different from the value quoted # in the original lab instructions. This is because the stress has been # evaluated using modified invariants (isochoric invariants) p = -dependentField.ParameterSetGetElement( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, elementNumber, 4) results["Hydrostatic pressure"] = p if debug: print("Hydrostatic pressure") print(p) problem.Destroy() coordinateSystem.Destroy() region.Destroy() basis.Destroy() return results
def defineBoundaryConditions(solverEquations, increment): # Prescribe boundary conditions (absolute nodal parameters) boundaryConditions = iron.BoundaryConditions() solverEquations.BoundaryConditionsCreateStart(boundaryConditions) #Set x=0 nodes to no x displacment in x. Set x=width nodes to 10% x displacement boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, 1, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, 1, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, 1, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 7, 1, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, 1, iron.BoundaryConditionsTypes.FIXED, increment) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, 1, iron.BoundaryConditionsTypes.FIXED, increment) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, 1, iron.BoundaryConditionsTypes.FIXED, increment) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 8, 1, iron.BoundaryConditionsTypes.FIXED, increment) # Set y=0 nodes to no y displacement boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, 2, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, 2, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 5, 2, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 6, 2, iron.BoundaryConditionsTypes.FIXED, 0.0) # Set z=0 nodes to no y displacement boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 1, 3, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 2, 3, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 3, 3, iron.BoundaryConditionsTypes.FIXED, 0.0) boundaryConditions.AddNode(dependentField, iron.FieldVariableTypes.U, 1, 1, 4, 3, iron.BoundaryConditionsTypes.FIXED, 0.0) solverEquations.BoundaryConditionsCreateFinish()
elasticityNonLinearSolver.NewtonRelativeToleranceSet(1e-14) elasticityNonLinearSolver.NewtonLinearSolverGet(elasticityLinearSolver) #elasticityLinearSolver.linearType = iron.LinearSolverTypes.DIRECT elasticityProblem.SolversCreateFinish() # Create elasticity solver equations and add elasticity equations set to solver equations elasticitySolverEquations = iron.SolverEquations() elasticityProblem.SolverEquationsCreateStart() elasticityNonLinearSolver.SolverEquationsGet(elasticitySolverEquations) elasticitySolverEquations.sparsityType = iron.SolverEquationsSparsityTypes.SPARSE elasticityEquationsSetIndex = elasticitySolverEquations.EquationsSetAdd( elasticityEquationsSet) elasticityProblem.SolverEquationsCreateFinish() # Prescribe boundary conditions (absolute nodal parameters) elasticityBoundaryConditions = iron.BoundaryConditions() elasticitySolverEquations.BoundaryConditionsCreateStart( elasticityBoundaryConditions) for widthNodeIdx in range(1, numberOfXNodes + 1): for heightNodeIdx in range(1, numberOfYNodes + 1): # Set left hand build in nodes ot no displacement nodeIdx = widthNodeIdx + (heightNodeIdx - 1) * numberOfXNodes elasticityBoundaryConditions.AddNode( elasticityDependentField, iron.FieldVariableTypes.U, 1, 1, nodeIdx, 1, iron.BoundaryConditionsTypes.FIXED, 0.0) elasticityBoundaryConditions.AddNode( elasticityDependentField, iron.FieldVariableTypes.U, 1, 1, nodeIdx, 2, iron.BoundaryConditionsTypes.FIXED, 0.0) elasticityBoundaryConditions.AddNode( elasticityDependentField, iron.FieldVariableTypes.U, 1, 1, nodeIdx,
def setupProblem(self, showProgress=False): # Number of Gauss points used numberOfGaussXi = 3 numberOfCircumfrentialElements = self.circumferentialElements numberOfLengthElements = self.axialElements numberOfLengthNodes = self.axialElements + 1 numberOfCircumfrentialNodes = numberOfCircumfrentialElements numberOfWallNodes = self.wallElements + 1 numberOfWallElements = self.wallElements coordinateSystemUserNumber = 1 regionUserNumber = 1 tricubicHermiteBasisUserNumber = 1 meshUserNumber = 1 decompositionUserNumber = 1 geometricFieldUserNumber = 1 tau = 0.1 kappa = 0.05 lambdaFieldUserNumber = 12 fittingEquationsSetUserNumber = 13 fittingEquationsSetFieldUserNumber = 14 fittingDependentFieldUserNumber = 15 fittingIndependentFieldUserNumber = 16 fittingMaterialsFieldUserNumber = 17 fittingProblemUserNumber = 18 # Get the number of computational nodes and this computational node number numberOfComputationalNodes = iron.ComputationalNumberOfNodesGet() # Create a 3D rectangular cartesian coordinate system coordinateSystem = iron.CoordinateSystem() coordinateSystem.CreateStart(coordinateSystemUserNumber) # Set the number of dimensions to 3 coordinateSystem.DimensionSet(3) # Finish the creation of the coordinate system coordinateSystem.CreateFinish() # Create a region and assign the coordinate system to the region region = iron.Region() region.CreateStart(regionUserNumber, iron.WorldRegion) region.LabelSet("HeartTubeRegion") # Set the regions coordinate system to the 3D RC coordinate system that we have created region.coordinateSystem = coordinateSystem # Finish the creation of the region region.CreateFinish() self.region = region # Define basis # Start the creation of a tricubic Hermite basis function tricubicHermiteBasis = iron.Basis() tricubicHermiteBasis.CreateStart(tricubicHermiteBasisUserNumber) tricubicHermiteBasis.type = iron.BasisTypes.LAGRANGE_HERMITE_TP tricubicHermiteBasis.numberOfXi = 3 tricubicHermiteBasis.interpolationXi = [ iron.BasisInterpolationSpecifications.CUBIC_HERMITE ] * 3 tricubicHermiteBasis.quadratureNumberOfGaussXi = [numberOfGaussXi] * 3 tricubicHermiteBasis.CreateFinish() # Start the creation of a manually generated mesh in the region numberOfNodes = numberOfCircumfrentialElements * ( numberOfLengthElements + 1) * (numberOfWallElements + 1) numberOfElements = numberOfCircumfrentialElements * numberOfLengthElements * numberOfWallElements # Define nodes for the mesh nodes = iron.Nodes() nodes.CreateStart(region, numberOfNodes) nodes.CreateFinish() mesh = iron.Mesh() # Create the mesh. The mesh will have two components - 1. tricubic Hermite elements; 2. trilinear Lagrange elements mesh.CreateStart(meshUserNumber, region, 3) mesh.NumberOfComponentsSet(1) mesh.NumberOfElementsSet(numberOfElements) tricubicHermiteElements = iron.MeshElements() tricubicHermiteElements.CreateStart(mesh, 1, tricubicHermiteBasis) elementNumber = 0 for wallElementIdx in range(1, numberOfWallElements + 1): for lengthElementIdx in range(1, numberOfLengthElements + 1): for circumfrentialElementIdx in range( 1, numberOfCircumfrentialElements + 1): elementNumber = elementNumber + 1 localNode1 = circumfrentialElementIdx + (lengthElementIdx-1)*numberOfCircumfrentialNodes + \ (wallElementIdx-1)*numberOfCircumfrentialNodes*numberOfLengthNodes if circumfrentialElementIdx == numberOfCircumfrentialElements: localNode2 = 1 + (lengthElementIdx-1)*numberOfCircumfrentialNodes + \ (wallElementIdx-1)*numberOfCircumfrentialNodes*numberOfLengthNodes else: localNode2 = localNode1 + 1 localNode3 = localNode1 + numberOfCircumfrentialNodes localNode4 = localNode2 + numberOfCircumfrentialNodes localNode5 = localNode1 + numberOfCircumfrentialNodes * numberOfLengthNodes localNode6 = localNode2 + numberOfCircumfrentialNodes * numberOfLengthNodes localNode7 = localNode3 + numberOfCircumfrentialNodes * numberOfLengthNodes localNode8 = localNode4 + numberOfCircumfrentialNodes * numberOfLengthNodes localNodes = [ localNode1, localNode2, localNode3, localNode4, localNode5, localNode6, localNode7, localNode8 ] tricubicHermiteElements.NodesSet(elementNumber, localNodes) tricubicHermiteElements.CreateFinish() # Finish the mesh creation mesh.CreateFinish() # Create a decomposition for the mesh decomposition = iron.Decomposition() decomposition.CreateStart(decompositionUserNumber, mesh) # Set the decomposition to be a general decomposition with the specified number of domains decomposition.type = iron.DecompositionTypes.CALCULATED decomposition.numberOfDomains = numberOfComputationalNodes # Finish the decomposition decomposition.CreateFinish() # Create a field for the geometry geometricField = iron.Field() geometricField.CreateStart(geometricFieldUserNumber, region) # Set the decomposition to use geometricField.MeshDecompositionSet(decomposition) geometricField.TypeSet(iron.FieldTypes.GEOMETRIC) # Set the field label geometricField.VariableLabelSet(iron.FieldVariableTypes.U, "Geometry") # Set the domain to be used by the field components to be tricubic Hermite geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 1, 1) geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 2, 1) geometricField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 3, 1) # Set the scaling type geometricField.ScalingTypeSet(iron.FieldScalingTypes.UNIT) # Finish creating the field geometricField.CreateFinish() self.setupGeometry(geometricField) # Update the geometric field geometricField.ParameterSetUpdateStart( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES) geometricField.ParameterSetUpdateFinish( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES) lambdaField = iron.Field() lambdaField.CreateStart(lambdaFieldUserNumber, region) lambdaField.TypeSet(iron.FieldTypes.GENERAL) # Set the decomposition lambdaField.MeshDecompositionSet(decomposition) # Set the geometric field lambdaField.GeometricFieldSet(geometricField) lambdaField.ScalingTypeSet(iron.FieldScalingTypes.NONE) # Set the field variables lambdaField.NumberOfVariablesSet(1) lambdaField.VariableTypesSet([iron.FieldVariableTypes.U]) # Set the variable label lambdaField.VariableLabelSet(iron.FieldVariableTypes.U, "NodeLambda") # Set the components to be tricubic-hermite lambdaField.NumberOfComponentsSet(iron.FieldVariableTypes.U, 9) for comp in range(1, 10): lambdaField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, comp, 1) # Set the interpolation types lambdaField.ComponentInterpolationSet( iron.FieldVariableTypes.U, comp, iron.FieldInterpolationTypes.NODE_BASED) lambdaField.ScalingTypeSet(iron.FieldScalingTypes.UNIT) lambdaField.CreateFinish() # Initialise the lambda field for comp in range(1, 10): lambdaField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, comp, 0.0) # Create Gauss point fitting equations set fittingEquationsSetSpecification = [ iron.EquationsSetClasses.FITTING, iron.EquationsSetTypes.GAUSS_FITTING_EQUATION, iron.EquationsSetSubtypes.GAUSS_POINT_FITTING, iron.EquationsSetFittingSmoothingTypes.SOBOLEV_VALUE ] fittingEquationsSetField = iron.Field() fittingEquationsSet = iron.EquationsSet() fittingEquationsSet.CreateStart(fittingEquationsSetUserNumber, region, geometricField, fittingEquationsSetSpecification, fittingEquationsSetFieldUserNumber, fittingEquationsSetField) fittingEquationsSet.CreateFinish() # Create the fitting dependent field fittingDependentField = iron.Field() fittingEquationsSet.DependentCreateStart( fittingDependentFieldUserNumber, fittingDependentField) fittingDependentField.VariableLabelSet(iron.FieldVariableTypes.U, "FittingU") fittingDependentField.VariableLabelSet( iron.FieldVariableTypes.DELUDELN, "FittingDelUdelN") # Set the number of components to 9 fittingDependentField.NumberOfComponentsSet(iron.FieldVariableTypes.U, 9) fittingDependentField.NumberOfComponentsSet( iron.FieldVariableTypes.DELUDELN, 9) # Set the field variables to be tricubic hermite for comp in range(1, 10): fittingDependentField.ComponentMeshComponentSet( iron.FieldVariableTypes.U, comp, 1) fittingDependentField.ComponentMeshComponentSet( iron.FieldVariableTypes.DELUDELN, comp, 1) # Finish creating the fitting dependent field fittingEquationsSet.DependentCreateFinish() # Create the fitting independent field fittingIndependentField = iron.Field() fittingEquationsSet.IndependentCreateStart( fittingIndependentFieldUserNumber, fittingIndependentField) fittingIndependentField.VariableLabelSet(iron.FieldVariableTypes.U, "GaussLambda") fittingIndependentField.VariableLabelSet(iron.FieldVariableTypes.V, "LambdaWeight") # Set the number of components to 9 fittingIndependentField.NumberOfComponentsSet( iron.FieldVariableTypes.U, 9) fittingIndependentField.NumberOfComponentsSet( iron.FieldVariableTypes.V, 9) # Finish creating the fitting independent field fittingEquationsSet.IndependentCreateFinish() # Initialise data point vector field to 0.0 for comp in range(1, 10): fittingIndependentField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, comp, 0.0) # Initialise data point weight field to 1.0 fittingIndependentField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.V, iron.FieldParameterSetTypes.VALUES, comp, 1.0) # Create material field (Sobolev parameters) fittingMaterialField = iron.Field() fittingEquationsSet.MaterialsCreateStart( fittingMaterialsFieldUserNumber, fittingMaterialField) fittingMaterialField.VariableLabelSet(iron.FieldVariableTypes.U, "SmoothingParameters") fittingEquationsSet.MaterialsCreateFinish() # Set kappa and tau - Sobolev smoothing parameters fittingMaterialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 1, tau) fittingMaterialField.ComponentValuesInitialiseDP( iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES, 2, kappa) # Create the fitting equations fittingEquations = iron.Equations() fittingEquationsSet.EquationsCreateStart(fittingEquations) # Set the fitting equations sparsity type fittingEquations.sparsityType = iron.EquationsSparsityTypes.SPARSE # Set the fitting equations output type to none fittingEquations.outputType = iron.EquationsOutputTypes.NONE # Finish creating the fitting equations fittingEquationsSet.EquationsCreateFinish() # Create fitting problem fittingProblemSpecification = [ iron.ProblemClasses.FITTING, iron.ProblemTypes.DATA_FITTING, iron.ProblemSubtypes.STATIC_FITTING ] fittingProblem = iron.Problem() fittingProblem.CreateStart(fittingProblemUserNumber, fittingProblemSpecification) fittingProblem.CreateFinish() # Create control loops fittingProblem.ControlLoopCreateStart() fittingProblem.ControlLoopCreateFinish() # Create problem solver fittingSolver = iron.Solver() fittingProblem.SolversCreateStart() fittingProblem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1, fittingSolver) fittingSolver.outputType = iron.SolverOutputTypes.NONE fittingProblem.SolversCreateFinish() # Create fitting solver equations and add fitting equations set to solver equations fittingSolverEquations = iron.SolverEquations() fittingProblem.SolverEquationsCreateStart() # Get the solver equations fittingSolver.SolverEquationsGet(fittingSolverEquations) fittingSolverEquations.sparsityType = iron.SolverEquationsSparsityTypes.SPARSE fittingEquationsSetIndex = fittingSolverEquations.EquationsSetAdd( fittingEquationsSet) fittingProblem.SolverEquationsCreateFinish() # Prescribe boundary conditions for the fitting problem fittingBoundaryConditions = iron.BoundaryConditions() fittingSolverEquations.BoundaryConditionsCreateStart( fittingBoundaryConditions) fittingBoundaryConditions.AddNode( fittingDependentField, iron.FieldVariableTypes.U, 1, iron.GlobalDerivativeConstants.NO_GLOBAL_DERIV, 1, 8, iron.BoundaryConditionsTypes.FIXED, 0.0) fittingSolverEquations.BoundaryConditionsCreateFinish() self.fittingIndependentField = fittingIndependentField self.fittingDependentField = fittingDependentField self.lambdaField = lambdaField self.fittingProblem = fittingProblem