materialsField = iron.Field() equationsSet.MaterialsCreateStart(materialsFieldUserNumber, materialsField) equationsSet.MaterialsCreateFinish() # Set the materials values # Set Am materialsField.ComponentValuesInitialise(iron.FieldVariableTypes.U,iron.FieldParameterSetTypes.VALUES,1,Am) # Set Cm materialsField.ComponentValuesInitialise(iron.FieldVariableTypes.U,iron.FieldParameterSetTypes.VALUES,2,Cm) # Set conductivity materialsField.ComponentValuesInitialise(iron.FieldVariableTypes.U,iron.FieldParameterSetTypes.VALUES,3,conductivity) #DOC-END equations set fields #DOC-START create cellml environment # Create the CellML environment cellML = iron.CellML() cellML.CreateStart(cellMLUserNumber, region) # Import a Nobel 98 cell model from a file noble98Model = cellML.ModelImport(modelFile) #DOC-END create cellml environment #DOC-START flag variables # Now we have imported the model we are able to specify which variables from the model we want to set from openCMISS cellML.VariableSetAsKnown(noble98Model, "fast_sodium_current/g_Na") cellML.VariableSetAsKnown(noble98Model, "membrane/IStim") # and variables to get from the CellML cellML.VariableSetAsWanted(noble98Model, "membrane/i_K1") cellML.VariableSetAsWanted(noble98Model, "membrane/i_to") cellML.VariableSetAsWanted(noble98Model, "membrane/i_K") cellML.VariableSetAsWanted(noble98Model, "membrane/i_K_ATP") cellML.VariableSetAsWanted(noble98Model, "membrane/i_Ca_L_K")
def simulate(fibreAngleIn, materialParameters):
'''
Main function to run a finite elasticity simulation using OpenCMISS with a unit cube and the Guccione material law (in CellML).
fibreAngle is a scalar angle in degrees
materialParameters is a list of the four Guccione material parameters.
'''
# Set problem parameters - Unit cube
height = 1.0
width = 1.0
length = 1.0
# if len(sys.argv) != 2:
# usage(sys.argv[0])
# exit(-1)
fa = fibreAngleIn
print("fa = " + str(fa))
# Fibre angles in radians:
fibreAngle = fa * pi / 180.0
# (transversly isotropic, so assume 0 cross-fibre angle?)
sheetAngle = 90.0 * pi / 180.0
fibreAngles = [fibreAngle, 0.0, sheetAngle]
# Guccione constitutive relation:
constitutiveRelation = iron.EquationsSetSubtypes.CONSTITUTIVE_LAW_IN_CELLML_EVALUATE
constitutiveParameters = [0.88, 18.5, 3.58, 3.26]
constitutiveParameters = materialParameters
initialHydrostaticPressure = 0.0
UsePressureBasis = False
NumberOfGaussXi = 2
coordinateSystemUserNumber = 1
regionUserNumber = 1
basisUserNumber = 1
pressureBasisUserNumber = 2
generatedMeshUserNumber = 1
meshUserNumber = 1
decompositionUserNumber = 1
geometricFieldUserNumber = 1
fibreFieldUserNumber = 2
materialFieldUserNumber = 3
dependentFieldUserNumber = 4
equationsSetFieldUserNumber = 5
deformedFieldUserNumber = 6
equationsSetUserNumber = 1
problemUserNumber = 1
CellMLUserNumber = 1
CellMLModelsFieldUserNumber = 7
CellMLParametersFieldUserNumber = 8
CellMLIntermediateFieldUserNumber = 9
# Set all diganostic levels on for testing
#iron.DiagnosticsSetOn(iron.DiagnosticTypes.ALL,[1,2,3,4,5],"Diagnostics",["DOMAIN_MAPPINGS_LOCAL_FROM_GLOBAL_CALCULATE"])
numberGlobalXElements = 1
numberGlobalYElements = 1
numberGlobalZElements = 1
totalNumberOfNodes = 8
totalNumberOfElements = 1
InterpolationType = 1
if (UsePressureBasis):
numberOfMeshComponents = 2
else:
numberOfMeshComponents = 1
if (numberGlobalZElements == 0):
numberOfXi = 2
else:
numberOfXi = 3
# 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 manually generated mesh in the region
mesh = iron.Mesh()
mesh.CreateStart(meshUserNumber, region, numberOfXi)
mesh.NumberOfComponentsSet(numberOfMeshComponents)
mesh.NumberOfElementsSet(totalNumberOfElements)
#Define nodes for the mesh
nodes = iron.Nodes()
nodes.CreateStart(region, totalNumberOfNodes)
nodes.CreateFinish()
elements = iron.MeshElements()
meshComponentNumber = 1
elements.CreateStart(mesh, meshComponentNumber, basis)
elements.NodesSet(1, [1, 2, 3, 4, 5, 6, 7, 8])
elements.CreateFinish()
mesh.CreateFinish()
# 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 manually
geometricField.ParameterSetUpdateStart(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES)
# node 1
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 1, 1, 0.0)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 1, 2, 0.0)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 1, 3, 0.0)
# node 2
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 2, 1, height)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 2, 2, 0.0)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 2, 3, 0.0)
# node 3
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 3, 1, 0.0)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 3, 2, width)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 3, 3, 0.0)
# node 4
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 4, 1, height)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 4, 2, width)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 4, 3, 0.0)
# node 5
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 5, 1, 0.0)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 5, 2, 0.0)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 5, 3, length)
# node 6
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 6, 1, height)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 6, 2, 0.0)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 6, 3, length)
# node 7
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 7, 1, 0.0)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 7, 2, width)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 7, 3, length)
# node 8
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 8, 1, height)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 8, 2, width)
geometricField.ParameterSetUpdateNodeDP(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, 1, 8, 3, length)
geometricField.ParameterSetUpdateFinish(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES)
# 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()
iron.Field.ComponentValuesInitialiseDP(fibreField,
iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
1, fibreAngle)
iron.Field.ComponentValuesInitialiseDP(fibreField,
iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
2, 0.0)
iron.Field.ComponentValuesInitialiseDP(fibreField,
iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES,
3, sheetAngle)
# # Create the material field
# materialField = iron.Field()
# materialField.CreateStart(materialFieldUserNumber,region)
# materialField.TypeSet(iron.FieldTypes.MATERIAL)
# materialField.MeshDecompositionSet(decomposition)
# materialField.GeometricFieldSet(geometricField)
# materialField.NumberOfVariablesSet(1)
# materialField.NumberOfComponentsSet(iron.FieldVariableTypes.U,len(constitutiveParameters))
# materialField.VariableLabelSet(iron.FieldVariableTypes.U,"Material")
# materialField.ComponentMeshComponentSet(iron.FieldVariableTypes.U,1,1)
# materialField.ComponentMeshComponentSet(iron.FieldVariableTypes.U,2,1)
# if InterpolationType == 4:
# materialField.fieldScalingType = iron.FieldScalingTypes.ARITHMETIC_MEAN
# materialField.CreateFinish()
# Set constant material parameters:
# for (component, value) in enumerate(constitutiveParameters, 1):
# materialField.ComponentValuesInitialise(
# iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES,
# component, value)
# Create the dependent field
dependentField = iron.Field()
dependentField.CreateStart(dependentFieldUserNumber, region)
dependentField.VariableLabelSet(iron.FieldVariableTypes.U, "Dependent")
dependentField.TypeSet(iron.FieldTypes.GEOMETRIC_GENERAL)
dependentField.MeshDecompositionSet(decomposition)
dependentField.GeometricFieldSet(geometricField)
dependentField.DependentTypeSet(iron.FieldDependentTypes.DEPENDENT)
dependentField.NumberOfVariablesSet(4)
dependentField.VariableTypesSet([
iron.FieldVariableTypes.U, iron.FieldVariableTypes.DELUDELN,
iron.FieldVariableTypes.U1, iron.FieldVariableTypes.U2
])
dependentField.NumberOfComponentsSet(iron.FieldVariableTypes.U, 4)
dependentField.NumberOfComponentsSet(iron.FieldVariableTypes.DELUDELN, 4)
dependentField.NumberOfComponentsSet(iron.FieldVariableTypes.U1, 6)
dependentField.NumberOfComponentsSet(iron.FieldVariableTypes.U2, 6)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 1, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 2, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U, 3, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.DELUDELN,
1, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.DELUDELN,
2, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.DELUDELN,
3, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U1, 1, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U1, 2, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U1, 3, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U1, 4, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U1, 5, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U1, 6, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U2, 1, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U2, 2, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U2, 3, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U2, 4, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U2, 5, 1)
dependentField.ComponentMeshComponentSet(iron.FieldVariableTypes.U2, 6, 1)
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
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U1, 1,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U1, 2,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U1, 3,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U1, 4,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U1, 5,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U1, 6,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U2, 1,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U2, 2,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U2, 3,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U2, 4,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U2, 5,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.ComponentInterpolationSet(
iron.FieldVariableTypes.U2, 6,
iron.FieldInterpolationTypes.GAUSS_POINT_BASED)
dependentField.VariableLabelSet(iron.FieldVariableTypes.U1, "strain")
dependentField.VariableLabelSet(iron.FieldVariableTypes.U2, "stress")
dependentField.CreateFinish()
# 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, -8.0)
# Create a deformed geometry field, as cmgui 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()
# Create the equations_set
equationsSetField = iron.Field()
equationsSet = iron.EquationsSet()
equationsSetSpecification = [
iron.EquationsSetClasses.ELASTICITY,
iron.EquationsSetTypes.FINITE_ELASTICITY, constitutiveRelation
]
equationsSet.CreateStart(equationsSetUserNumber, region, fibreField,
equationsSetSpecification,
equationsSetFieldUserNumber, equationsSetField)
equationsSet.CreateFinish()
# Create the CellML environment
CellML = iron.CellML()
CellML.CreateStart(CellMLUserNumber, region)
# here we get the current path of this script so that we can specify the CellML model document relative to
# this script, rather than the execution folder.
from os.path import dirname, join
script_path = dirname(__file__)
cellmlFile = join(script_path, "guccione.cellml")
# guccioneCellMLParameters = [0.88, 0.0, 18.5, 3.58, 3.26] # default values in CellML model
guccioneCellMLParameters = [1.0, 0.0, 5.0, 10.0, 5.0]
guccioneCellMLParameters = [
materialParameters[0], 0.0, materialParameters[1],
materialParameters[2], materialParameters[3]
]
# the names of the variables in the CellML model for the parameters in the same order as the values above
guccioneCellMLParameterIds = [
"interface/c1", "interface/c2", "interface/c3", "interface/c4",
"interface/c5"
]
# Import a Guccione material law from a file
GuccioneModel = CellML.ModelImport(cellmlFile)
# Now we have imported the model we are able to specify which variables from the model we want to set from openCMISS
CellML.VariableSetAsKnown(GuccioneModel, "equations/E11")
CellML.VariableSetAsKnown(GuccioneModel, "equations/E12")
CellML.VariableSetAsKnown(GuccioneModel, "equations/E13")
CellML.VariableSetAsKnown(GuccioneModel, "equations/E22")
CellML.VariableSetAsKnown(GuccioneModel, "equations/E23")
CellML.VariableSetAsKnown(GuccioneModel, "equations/E33")
for component, parameter in enumerate(guccioneCellMLParameterIds):
CellML.VariableSetAsKnown(GuccioneModel, parameter)
# and variables to get from the CellML
CellML.VariableSetAsWanted(GuccioneModel, "equations/Tdev11")
CellML.VariableSetAsWanted(GuccioneModel, "equations/Tdev12")
CellML.VariableSetAsWanted(GuccioneModel, "equations/Tdev13")
CellML.VariableSetAsWanted(GuccioneModel, "equations/Tdev22")
CellML.VariableSetAsWanted(GuccioneModel, "equations/Tdev23")
CellML.VariableSetAsWanted(GuccioneModel, "equations/Tdev33")
CellML.CreateFinish()
# Start the creation of CellML <--> OpenCMISS field maps
CellML.FieldMapsCreateStart()
#Now we can set up the field variable component <--> CellML model variable mappings.
#Map the strain components
CellML.CreateFieldToCellMLMap(dependentField, iron.FieldVariableTypes.U1,
1, iron.FieldParameterSetTypes.VALUES,
GuccioneModel, "equations/E11",
iron.FieldParameterSetTypes.VALUES)
CellML.CreateFieldToCellMLMap(dependentField, iron.FieldVariableTypes.U1,
2, iron.FieldParameterSetTypes.VALUES,
GuccioneModel, "equations/E12",
iron.FieldParameterSetTypes.VALUES)
CellML.CreateFieldToCellMLMap(dependentField, iron.FieldVariableTypes.U1,
3, iron.FieldParameterSetTypes.VALUES,
GuccioneModel, "equations/E13",
iron.FieldParameterSetTypes.VALUES)
CellML.CreateFieldToCellMLMap(dependentField, iron.FieldVariableTypes.U1,
4, iron.FieldParameterSetTypes.VALUES,
GuccioneModel, "equations/E22",
iron.FieldParameterSetTypes.VALUES)
CellML.CreateFieldToCellMLMap(dependentField, iron.FieldVariableTypes.U1,
5, iron.FieldParameterSetTypes.VALUES,
GuccioneModel, "equations/E23",
iron.FieldParameterSetTypes.VALUES)
CellML.CreateFieldToCellMLMap(dependentField, iron.FieldVariableTypes.U1,
6, iron.FieldParameterSetTypes.VALUES,
GuccioneModel, "equations/E33",
iron.FieldParameterSetTypes.VALUES)
#DOC-END map strain components
#DOC-START map stress components
#Map the stress components
CellML.CreateCellMLToFieldMap(GuccioneModel, "equations/Tdev11",
iron.FieldParameterSetTypes.VALUES,
dependentField, iron.FieldVariableTypes.U2,
1, iron.FieldParameterSetTypes.VALUES)
CellML.CreateCellMLToFieldMap(GuccioneModel, "equations/Tdev12",
iron.FieldParameterSetTypes.VALUES,
dependentField, iron.FieldVariableTypes.U2,
2, iron.FieldParameterSetTypes.VALUES)
CellML.CreateCellMLToFieldMap(GuccioneModel, "equations/Tdev13",
iron.FieldParameterSetTypes.VALUES,
dependentField, iron.FieldVariableTypes.U2,
3, iron.FieldParameterSetTypes.VALUES)
CellML.CreateCellMLToFieldMap(GuccioneModel, "equations/Tdev22",
iron.FieldParameterSetTypes.VALUES,
dependentField, iron.FieldVariableTypes.U2,
4, iron.FieldParameterSetTypes.VALUES)
CellML.CreateCellMLToFieldMap(GuccioneModel, "equations/Tdev23",
iron.FieldParameterSetTypes.VALUES,
dependentField, iron.FieldVariableTypes.U2,
5, iron.FieldParameterSetTypes.VALUES)
CellML.CreateCellMLToFieldMap(GuccioneModel, "equations/Tdev33",
iron.FieldParameterSetTypes.VALUES,
dependentField, iron.FieldVariableTypes.U2,
6, iron.FieldParameterSetTypes.VALUES)
#Finish the creation of CellML <--> OpenCMISS field maps
CellML.FieldMapsCreateFinish()
#Create the CellML models field
CellMLModelsField = iron.Field()
CellML.ModelsFieldCreateStart(CellMLModelsFieldUserNumber,
CellMLModelsField)
CellML.ModelsFieldCreateFinish()
xidiv = 1.0 / (NumberOfGaussXi + 1)
for elem in [1]:
#Gauss point number counter
ctr = 0
#Assign model for each quadraturePoint:
for xi in range(0, NumberOfGaussXi):
xi1 = (1.0 + xi) * xidiv
for xj in range(0, NumberOfGaussXi):
xi2 = (1.0 + xj) * xidiv
for xk in range(0, NumberOfGaussXi):
xi3 = (1.0 + xk) * xidiv
ctr = ctr + 1
CellMLModelsField.ParameterSetUpdateGaussPoint(
iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES, ctr, 1, 1,
GuccioneModel)
#Create the CellML parameters field --- the strain field
CellMLParametersField = iron.Field()
CellML.ParametersFieldCreateStart(CellMLParametersFieldUserNumber,
CellMLParametersField)
CellML.ParametersFieldCreateFinish()
# Create the CellML intermediate field --- the stress field
CellMLIntermediateField = iron.Field()
CellML.IntermediateFieldCreateStart(CellMLIntermediateFieldUserNumber,
CellMLIntermediateField)
CellML.IntermediateFieldCreateFinish()
for valueIndex, parameter in enumerate(guccioneCellMLParameterIds, 0):
component = CellML.FieldComponentGet(GuccioneModel,
iron.CellMLFieldTypes.PARAMETERS,
parameter)
print("Setting parameter: " + parameter + "; to value: " +
str(guccioneCellMLParameters[valueIndex]) +
"; field component: " + str(component))
iron.Field.ComponentValuesInitialiseDP(
CellMLParametersField, iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES, component,
guccioneCellMLParameters[valueIndex])
#equationsSet.MaterialsCreateStart(materialFieldUserNumber,materialField)
#equationsSet.MaterialsCreateFinish()
equationsSet.DependentCreateStart(dependentFieldUserNumber, dependentField)
equationsSet.DependentCreateFinish()
# Create equations
equations = iron.Equations()
equationsSet.EquationsCreateStart(equations)
equations.sparsityType = iron.EquationsSparsityTypes.SPARSE
equations.outputType = iron.EquationsOutputTypes.NONE
equationsSet.EquationsCreateFinish()
def defineProblemSolver():
# Define the problem
problem = iron.Problem()
problemSpecification = [
iron.ProblemClasses.ELASTICITY,
iron.ProblemTypes.FINITE_ELASTICITY,
iron.ProblemSubtypes.FINITE_ELASTICITY_CELLML
]
problem.CreateStart(problemUserNumber, problemSpecification)
problem.CreateFinish()
# Create control loops
problem.ControlLoopCreateStart()
problem.ControlLoopCreateFinish()
# Create problem solver
nonLinearSolver = iron.Solver()
linearSolver = iron.Solver()
problem.SolversCreateStart()
problem.SolverGet([iron.ControlLoopIdentifiers.NODE], 1,
nonLinearSolver)
nonLinearSolver.outputType = iron.SolverOutputTypes.PROGRESS
nonLinearSolver.NewtonJacobianCalculationTypeSet(
iron.JacobianCalculationTypes.FD)
nonLinearSolver.NewtonLinearSolverGet(linearSolver)
linearSolver.linearType = iron.LinearSolverTypes.DIRECT
#linearSolver.libraryType = iron.SolverLibraries.LAPACK
problem.SolversCreateFinish()
#Create the problem solver CellML equations
CellMLSolver = iron.Solver()
problem.CellMLEquationsCreateStart()
nonLinearSolver.NewtonCellMLSolverGet(CellMLSolver)
CellMLEquations = iron.CellMLEquations()
CellMLSolver.CellMLEquationsGet(CellMLEquations)
CellMLEquations.CellMLAdd(CellML)
problem.CellMLEquationsCreateFinish()
# 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()
return [problem, solverEquations]
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()
# loop over load steps
numberOfLoadSteps = 70
displacementIncrement = 0.01 # 1%
displacementIncrementDimension = displacementIncrement * width # length units
resultRecord = {}
resultRecord["strain"] = [0.0]
resultRecord["stress"] = [0.0]
for counter in range(1, numberOfLoadSteps + 1):
# define the problem, solver, control loops, etc.
[problem, solverEquations] = defineProblemSolver()
# define the boundary conditions
defineBoundaryConditions(solverEquations,
displacementIncrementDimension)
# execute the experiment
problem.Solve()
# clean up
problem.Finalise()
solverEquations.Finalise()
# export the results
filename = "results-{:03d}".format(counter)
# 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)
# Export results
fields = iron.Fields()
fields.CreateRegion(region)
fields.NodesExport(filename, "FORTRAN")
fields.ElementsExport(filename, "FORTRAN")
fields.Finalise()
versionNumber = 1
derivativeNumber = 1
nodeNumber = 8
componentNumber = 1 # x-dirn
reactionForceX = dependentField.ParameterSetGetNode(
iron.FieldVariableTypes.DELUDELN,
iron.FieldParameterSetTypes.VALUES, versionNumber,
derivativeNumber, nodeNumber, componentNumber)
print("Reaction force (x) at counter: " + str(counter) + ": " +
str(reactionForceX))
resultRecord["strain"].append(counter * displacementIncrement)
resultRecord["stress"].append(reactionForceX)
coordinateSystem.Destroy()
region.Destroy()
basis.Destroy()
return resultRecord
iron.FieldParameterSetTypes.VALUES)
RyRDensityField.ParameterSetUpdateFinish(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES)
RyRTimelagField.ParameterSetUpdateStart(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES)
RyRTimelagField.ParameterSetUpdateFinish(iron.FieldVariableTypes.U,
iron.FieldParameterSetTypes.VALUES)
del ryrData
gc.collect()
# C e l l M L
# -----------
if computationalNodeNumber == 0:
print('Setting up CellML model and variable mapping...')
cellmlModelIndex = 1
cellml = iron.CellML()
cellml.CreateStart(userNumber.getInc(), region)
cellml.ModelImport(cellmlFile)
known = ["CRU/iCa", "CRU/ryrDensity", "CRU/timelag"]
for var in known:
cellml.VariableSetAsKnown(cellmlModelIndex, var)
wanted = [
"CRU/Jryr", "FluoBuffer/Jfluo", "TnCBuffer/Jtnc", "ATPBuffer/JATP",
"CaMBuffer/JCaM"
]
for var in wanted:
cellml.VariableSetAsWanted(cellmlModelIndex, var)
cellml.CreateFinish()