def load_behaviour(self): self.is_finite_strain = mgis_bv.isStandardFiniteStrainBehaviour(self.path, self.name) if self.is_finite_strain: # finite strain options bopts = mgis_bv.FiniteStrainBehaviourOptions() bopts.stress_measure = mgis_bv.FiniteStrainBehaviourOptionsStressMeasure.PK1 bopts.tangent_operator = mgis_bv.FiniteStrainBehaviourOptionsTangentOperator.DPK1_DF self.behaviour = mgis_bv.load(bopts, self.path, self.name, self.hypothesis) else: self.behaviour = mgis_bv.load(self.path, self.name, self.hypothesis)
def __init__( self, nq: int, library_path: str, library_name: str, hypothesis: Hypothesis, stabilization_parameter: float, lagrange_parameter: float, field: Field, parameters: Dict[str, float] = None, integration_type: IntegrationType = IntegrationType. IntegrationWithConsistentTangentOperator, storage_mode: MaterialStateManagerStorageMode = MaterialStateManagerStorageMode. ExternalStorage, temperature: float = 293.15, ): """ Args: nq: library_path: library_name: hypothesis: stabilization_parameter: field: parameters: integration_type: storage_mode: temperature: """ self.nq = nq self.behaviour_name = library_name if field.grad_type in [GradType.DISPLACEMENT_SMALL_STRAIN]: if field.flux_type == FluxType.STRESS_CAUCHY: self.behaviour = mgis_bv.load(library_path, library_name, hypothesis) elif field.grad_type == GradType.DISPLACEMENT_TRANSFORMATION_GRADIENT: if field.flux_type == FluxType.STRESS_PK1: opt = mgis_bv.FiniteStrainBehaviourOptions() opt.stress_measure = mgis_bv.FiniteStrainBehaviourOptionsStressMeasure.PK1 opt.tangent_operator = mgis_bv.FiniteStrainBehaviourOptionsTangentOperator.DPK1_DF self.behaviour = mgis_bv.load(opt, library_path, library_name, hypothesis) self.mat_data = mgis_bv.MaterialDataManager(self.behaviour, self.nq) self.stabilization_parameter = stabilization_parameter self.lagrange_parameter = lagrange_parameter if not parameters is None: for key, val in parameters.items(): mgis_bv.setParameter(self.behaviour, key, val) self.integration_type = integration_type self.storage_mode = storage_mode self.temperature = temperature
def test_pass(self): stress_options = mgis_bv.FiniteStrainBehaviourOptionsStressMeasure to_options = mgis_bv.FiniteStrainBehaviourOptionsTangentOperator # path to the test library lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] version = os.environ['MGIS_TEST_TFEL_VERSION'] h = mgis_bv.Hypothesis.Tridimensional o = mgis_bv.FiniteStrainBehaviourOptions() o.stress_measure = stress_options.PK1 o.tangent_operator = to_options.DPK1_DF b = mgis_bv.load(o, lib, 'FiniteStrainSingleCrystal', h) self.assertTrue(b.tfel_version == version, "invalid TFEL version") self.assertTrue(len(b.gradients) == 1, 'invalid number of gradients') self.assertTrue(b.gradients[0].name == 'DeformationGradient', 'invalid gradient name') self.assertTrue(b.gradients[0].getType() == 'Tensor', 'invalid gradient type') self.assertTrue(b.gradients[0].type == mgis_bv.VariableType.TENSOR, 'invalid gradient type') self.assertTrue(b.gradients[0].type == mgis_bv.VariableType.Tensor, 'invalid gradient type') self.assertTrue( len(b.thermodynamic_forces) == 1, 'invalid number of thermodynamic_forces') pk1 = b.thermodynamic_forces[0] self.assertTrue(pk1.name == 'FirstPiolaKirchhoffStress', 'invalid thermodynamic force name') self.assertTrue(pk1.getType() == 'Tensor', 'invalid thermodynamic force type') self.assertTrue(pk1.type == mgis_bv.VariableType.TENSOR, 'invalid thermodynamic force type')
def test_pass(self): yg = 150e9 nu = 0.3 eps = 1.e-14 # path to the test library lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] version = os.environ['MGIS_TEST_TFEL_VERSION'] h = mgis_bv.Hypothesis.Tridimensional b = mgis_bv.load(lib, 'ParameterTest', h) self.assertTrue(b.behaviour == "ParameterTest", "invalid behaviour name") self.assertTrue(b.hypothesis == h, "invalid hypothesis") self.assertTrue(b.source == "ParameterTest.mfront", "invalid source") self.assertTrue(b.tfel_version == version, "invalid TFEL version") self.assertTrue(len(b.params) == 4, "invalid number of parameters") self.assertTrue(b.params[0] == "YoungModulus", "invalid first parameter") self.assertTrue(b.params[1] == "PoissonRatio", "invalid second parameter") self.assertTrue(b.params[2] == "minimal_time_step_scaling_factor", "invalid third parameter") self.assertTrue(b.params[3] == "maximal_time_step_scaling_factor", "invalid fourth parameter") self.assertTrue( abs(mgis_bv.getParameterDefaultValue(b, "YoungModulus") - yg) < eps * yg, "invalid 'YoungModulus' default value") self.assertTrue( abs(b.getParameterDefaultValue("YoungModulus") - yg) < eps * yg, "invalid 'YoungModulus' default value") self.assertTrue( abs(b.getParameterDefaultValue("PoissonRatio") - nu) < eps * nu, "invalid 'PoissonRatio' default value")
def test_pass(self): # path to the test library lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] # reference values pref = [ 0, 1.3523277308229e-11, 1.0955374667213e-07, 5.5890770166084e-06, 3.2392193670428e-05, 6.645865307584e-05, 9.9676622883138e-05, 0.00013302758358953, 0.00016635821069889, 0.00019969195920296, 0.00023302522883648, 0.00026635857194317, 0.000299691903777, 0.0003330252373404, 0.00036635857063843, 0.00039969190397718, 0.00043302523730968, 0.00046635857064314, 0.00049969190397646, 0.00053302523730979, 0.00056635857064313 ] # comparison criterion eps = 1.e-12 b = mgis_bv.load(lib, 'Norton', mgis_bv.Hypothesis.Tridimensional) d = mgis_bv.BehaviourData(b) o = mgis_bv.getVariableOffset(b.isvs, 'EquivalentViscoplasticStrain', b.hypothesis) # strain increment per time step de = 5.e-5 # time step d.dt = 180 # setting the temperature mgis_bv.setExternalStateVariable(d.s1, 'Temperature', 293.15) # copy d.s1 in d.s0 mgis_bv.update(d) d.s1.gradients[0] = de # equivalent plastic strain p = [d.s0.internal_state_variables[o]] # integrate the behaviour for i in range(0, 20): mgis_bv.integrate(d, b) mgis_bv.update(d) d.s1.gradients[0] += de p.append(d.s1.internal_state_variables[o]) # check-in results for i in range(0, 20): self.assertTrue(abs(p[i] - pref[i]) < eps) pass
def __get_behaviour(self, h): lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] return mgis_bv.load(lib, 'PostProcessingTest', h)
def test_pass(self): btype = mgis_bv.BehaviourType bkinematic = mgis_bv.BehaviourKinematic # path to the test library lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] version = os.environ['MGIS_TEST_TFEL_VERSION'] h = mgis_bv.Hypothesis.Tridimensional b = mgis_bv.load(lib, 'Gurson', h) self.assertTrue(b.behaviour == "Gurson", "invalid behaviour name") self.assertTrue(b.hypothesis == h, "invalid hypothesis") self.assertTrue(b.source == "Gurson.mfront", "invalid source") self.assertTrue(b.tfel_version == version, "invalid TFEL version") self.assertTrue( len(b.mps) == 0, "invalid number of material properties") self.assertTrue(b.getBehaviourType() == "StandardStrainBasedBehaviour", "invalid behaviour type") self.assertTrue(b.btype == btype.StandardStrainBasedBehaviour, "invalid behaviour type") self.assertTrue(b.btype == btype.STANDARDSTRAINBASEDBEHAVIOUR, "invalid behaviour type") self.assertTrue(b.getKinematic() == "SmallStrainKinematic", "invalid kinematic value") self.assertTrue(b.kinematic == bkinematic.SmallStrainKinematic, "invalid kinematic value") self.assertTrue(b.kinematic == bkinematic.SMALLSTRAINKINEMATIC, "invalid kinematic value") self.assertTrue(b.symmetry == mgis_bv.BehaviourSymmetry.Isotropic, "invalid behaviour symmetry") self.assertTrue(len(b.gradients) == 1, "invalid number of gradients") F = b.gradients[0] self.assertTrue(F.name == "Strain", "invalid gradient name") self.assertTrue(F.type == mgis_bv.VariableType.Stensor, "invalid gradient type") self.assertTrue(F.type == mgis_bv.VariableType.STENSOR, "invalid gradient type") self.assertTrue( len(b.thermodynamic_forces) == 1, "invalid number of thermodynamic_forces") pk1 = b.thermodynamic_forces[0] self.assertTrue(pk1.name == "Stress", "invalid flux name") self.assertTrue(pk1.type == mgis_bv.VariableType.Stensor, "invalid flux type") self.assertTrue(pk1.type == mgis_bv.VariableType.STENSOR, "invalid flux type") self.assertTrue( len(b.isvs) == 4, "invalid number of internal state variables") self.assertTrue( len(b.internal_state_variables) == 4, "invalid number of internal state variables") self.assertTrue(b.isvs[0].name == "ElasticStrain", "invalid name for the first internal state variable") self.assertTrue(b.isvs[0].type == mgis_bv.VariableType.STENSOR, "invalid type for the first internal state variable") self.assertTrue(b.isvs[1].name == "EquivalentPlasticStrain", "invalid name for the second internal state variable") self.assertTrue(b.isvs[1].type == mgis_bv.VariableType.SCALAR, "invalid type for the second internal state variable") self.assertTrue(b.isvs[1].type == mgis_bv.VariableType.Scalar, "invalid type for the second internal state variable") self.assertTrue(b.isvs[1].getType() == 'Scalar', "invalid type for the second internal state variable") self.assertTrue(b.isvs[2].name == "MatrixEquivalentPlasticStrain", "invalid name for the third internal state variable") self.assertTrue(b.isvs[2].type == mgis_bv.VariableType.SCALAR, "invalid type for the third internal state variable") self.assertTrue(b.isvs[3].name == "Porosity", "invalid name for the third internal state variable") self.assertTrue(b.isvs[3].type == mgis_bv.VariableType.SCALAR, "invalid type for the fourth internal state variable") # external state variables self.assertTrue( len(b.esvs) == 1, "invalid number of external state variables") self.assertTrue( len(b.external_state_variables) == 1, "invalid number of external state variables") self.assertTrue(b.esvs[0].name == "Temperature", "invalid name for the first external state variable") self.assertTrue(b.esvs[0].type == mgis_bv.VariableType.SCALAR, "invalid type for the first external state variable") # parameters params = b.parameters self.assertTrue(len(params) == 15, "invalid number of parameters") self.assertTrue('epsilon' in params, "'epsilon is not a parameter") self.assertTrue( len(b.iparams) == 0, "invalid number of integer parameters") self.assertTrue( len(b.integer_parameters) == 0, "invalid number of integer parameters") self.assertTrue( len(b.unsigned_short_parameters) == 1, "invalid number of unsigned short parameters") self.assertTrue(b.usparams[0] == 'iterMax', "invalid name for the first unsigned short parameter")
def __get_behaviour(self, h): lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] return mgis_bv.load(lib, 'InitializeFunctionTest', h)
def test_pass(self): print(dir(mgis)) # path to the test library lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] # reference values pref = [ 0, 1.3523277308229e-11, 1.0955374667213e-07, 5.5890770166084e-06, 3.2392193670428e-05, 6.645865307584e-05, 9.9676622883138e-05, 0.00013302758358953, 0.00016635821069889, 0.00019969195920296, 0.00023302522883648, 0.00026635857194317, 0.000299691903777, 0.0003330252373404, 0.00036635857063843, 0.00039969190397718, 0.00043302523730968, 0.00046635857064314, 0.00049969190397646, 0.00053302523730979, 0.00056635857064313 ] # modelling hypothesis h = mgis_bv.Hypothesis.Tridimensional # loading the behaviour b = mgis_bv.load(lib, 'Norton', h) # number of integration points nig = 100 # material data manager m = mgis_bv.MaterialDataManager(b, nig) # index of the equivalent viscplastic strain in the array of # state variable o = mgis_bv.getVariableOffset(b.isvs, 'EquivalentViscoplasticStrain', h) # strain increment per time step de = 5.e-5 # time step increment dt = 180 # setting the temperature mgis_bv.setExternalStateVariable(m.s1, 'Temperature', 293.15) # copy d.s1 in d.s0 mgis_bv.update(m) # index of the first integration point ni = 0 # index of the last integration point ne = nig - 1 # values of the equivalent plastic strain # for the first integration point pi = [m.s0.internal_state_variables[ni][o]] # values of the equivalent plastic strain # for the last integration point pe = [m.s0.internal_state_variables[ne][o]] # setting the gradient at the end of the first time step for i in range(0, nig): m.s1.gradients[i][0] = de # creating a thread pool for parallel integration p = mgis.ThreadPool(2) # integration for i in range(0, 20): it = mgis_bv.IntegrationType.IntegrationWithoutTangentOperator mgis_bv.integrate(p, m, it, dt) mgis_bv.update(m) for j in range(0, nig): m.s1.gradients[j][0] += de pi.append(m.s0.internal_state_variables[ni][o]) pe.append(m.s0.internal_state_variables[ne][o]) # checks # comparison criterion eps = 1.e-12 for i in range(0, 21): self.assertTrue(abs(pi[i] - pref[i]) < eps) self.assertTrue(abs(pe[i] - pref[i]) < eps) pass
# integration points. Various overloads of this function exist. We will # use a version taking as argument a ``MaterialStateManager``, the time # increment and a range of integration points. # # In the present case, we compute a plane strain von Mises plasticity with isotropic # linear hardening. The material behaviour is implemented in the :download:`IsotropicLinearHardeningPlasticity.mfront` file # which must first be compiled to generate the appropriate librairies as follows:: # > mfront --obuild --interface=generic IsotropicLinearHardeningPlasticity.mfront # # We can then setup the ``MaterialDataManager``:: # Defining the modelling hypothesis h = mgis_bv.Hypothesis.TRIDIMENSIONAL # Loading the behaviour b = mgis_bv.load('src/libBehaviour.so','CosseratIsotropicLinearHardeningPlasticity',h) # Setting the material data manager m = mgis_bv.MaterialDataManager(b, ngauss) # elastic parameters for Cosserat strain E = 107e3 llambda = 80e3 # In [MPa] mu = 70e3 mu_c = 100e3 # elastic parameters for Cosserat wryness alpha = 0. # In [MPa] beta = 30e3 gamma = 30e3 # yield strength sig0 = 800. Et = E/100. # hardening slope
from minieigen import VectorX, MatrixX from SPFEMexp import SPFEM import mgis.behaviour as mgis_bv import numpy intType = mgis_bv.IntegrationType.IntegrationWithConsistentTangentOperator behaviour = mgis_bv.load('src/libBehaviour.so', 'Elasticity', mgis_bv.Hypothesis.PlaneStrain) class Elasticity(object): def __init__(self, pts, mater=None, sigma=None, gravity=[0., 0.], charlen=1.): """ :var pts: type numpy ndarray, shape = (npts, 2), points coordinates :var mater: type structure, material properties :var sigma: type numpy ndarray, initial stress, shape = (4,) or (npts, 4) :var gravity: type vector, size = 2, gravity constant :var charlen: type double, characteristic spacing :var limlen: type double, minimum spacing """ self.__npts = len(pts) # no. of nodes self.__pts = pts self.__spfem = SPFEM( ) # SPFEM module with C++ backend and Python binding through compiled shared library self.__materData = mgis_bv.MaterialDataManager( behaviour, self.__npts) # material data container
def __get_behaviour(self, h): lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] return mgis_bv.load(lib, 'TensorialExternalStateVariableTest', h)
def test_pass(self): btype = mgis_bv.BehaviourType bkinematic = mgis_bv.BehaviourKinematic bsyme = mgis_bv.BehaviourSymmetry stress_options = mgis_bv.FiniteStrainBehaviourOptionsStressMeasure to_options = mgis_bv.FiniteStrainBehaviourOptionsTangentOperator # path to the test library lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] version = os.environ['MGIS_TEST_TFEL_VERSION'] h = mgis_bv.Hypothesis.Tridimensional o = mgis_bv.FiniteStrainBehaviourOptions() o.stress_measure = stress_options.PK1 o.tangent_operator = to_options.DPK1_DF b = mgis_bv.load(o, lib, 'FiniteStrainSingleCrystal', h) self.assertTrue(b.behaviour == 'FiniteStrainSingleCrystal', 'invalid behaviour name') self.assertTrue(b.hypothesis == h, 'invalid hypothesis') self.assertTrue(b.source == 'FiniteStrainSingleCrystal.mfront', 'invalid source') self.assertTrue(b.tfel_version == version, 'invalid TFEL version') self.assertTrue( b.getBehaviourType() == 'StandardFiniteStrainBehaviour', 'invalid behaviour type') self.assertTrue(b.btype == btype.STANDARDFINITESTRAINBEHAVIOUR, 'invalid behaviour type') self.assertTrue(b.btype == btype.StandardFiniteStrainBehaviour, 'invalid behaviour type') self.assertTrue(b.getKinematic() == 'F_CAUCHY', 'invalid kinematic value') self.assertTrue( b.kinematic == bkinematic.FINITESTRAINKINEMATIC_F_CAUCHY, 'invalid kinematic value') self.assertTrue( b.kinematic == bkinematic.FiniteStrainKinematic_F_Cauchy, 'invalid kinematic value') self.assertTrue(b.getSymmetry() == 'Orthotropic', 'invalid behaviour symmetry') self.assertTrue(b.symmetry == bsyme.ORTHOTROPIC, 'invalid behaviour symmetry') self.assertTrue(b.symmetry == bsyme.Orthotropic, 'invalid behaviour symmetry') self.assertTrue(len(b.gradients) == 1, 'invalid number of gradients') F = b.gradients[0] self.assertTrue(F.name == 'DeformationGradient', 'invalid gradient name') self.assertTrue(F.getType() == 'Tensor', 'invalid gradient type') self.assertTrue(F.type == mgis_bv.VariableType.TENSOR, 'invalid gradient type') self.assertTrue(F.type == mgis_bv.VariableType.Tensor, 'invalid gradient type') self.assertTrue( len(b.thermodynamic_forces) == 1, 'invalid number of thermodynamic_forces') pk1 = b.thermodynamic_forces[0] self.assertTrue(pk1.name == 'FirstPiolaKirchhoffStress', 'invalid flux name') self.assertTrue(pk1.getType() == 'Tensor', 'invalid flux type') self.assertTrue(pk1.type == mgis_bv.VariableType.TENSOR, 'invalid flux type') self.assertTrue(pk1.type == mgis_bv.VariableType.Tensor, 'invalid flux type') self.assertTrue( len(b.mps) == 16, 'invalid number of material properties') def check_mp_name(mp, n): self.assertTrue( mp.name == n, "invalid material property name, " "expected '" + n + "'") for mp in b.mps: self.assertTrue(mp.getType() == 'Scalar', "invalid material property type '" + mp.name + "'") self.assertTrue(mp.type == mgis_bv.VariableType.SCALAR, "invalid material property type '" + mp.name + "'") self.assertTrue(mp.type == mgis_bv.VariableType.Scalar, "invalid material property type '" + mp.name + "'") check_mp_name(b.mps[0], 'YoungModulus1') check_mp_name(b.mps[1], 'YoungModulus2') check_mp_name(b.mps[2], 'YoungModulus3') check_mp_name(b.mps[3], 'PoissonRatio12') check_mp_name(b.mps[4], 'PoissonRatio23') check_mp_name(b.mps[5], 'PoissonRatio13') check_mp_name(b.mps[6], 'ShearModulus12') check_mp_name(b.mps[7], 'ShearModulus23') check_mp_name(b.mps[8], 'ShearModulus13') check_mp_name(b.mps[9], 'm') check_mp_name(b.mps[10], 'K') check_mp_name(b.mps[11], 'C') check_mp_name(b.mps[12], 'R0') check_mp_name(b.mps[13], 'Q') check_mp_name(b.mps[14], 'b') check_mp_name(b.mps[15], 'd1') self.assertTrue( len(b.isvs) == 37, 'invalid number of internal state variables') def check_iv_name(iv, n, i): vn = n + '[' + str(i) + ']' self.assertTrue( iv.name == vn, "invalid internal state variable name, " "expected '" + vn + "'") self.assertTrue( iv.getType() == 'Scalar', 'invalid type for internal ' + 'state variable \'' + vn + '\'') self.assertTrue( iv.type == mgis_bv.VariableType.SCALAR, 'invalid type for internal ' + 'state variable \'' + vn + '\'') self.assertTrue( iv.type == mgis_bv.VariableType.Scalar, 'invalid type for internal ' + 'state variable \'' + vn + '\'') for i in range(0, 12): check_iv_name(b.isvs[i], 'g', i) check_iv_name(b.isvs[13 + i], 'p', i) check_iv_name(b.isvs[25 + i], 'a', i) self.assertTrue(b.isvs[12].name == 'Fe', "invalid name for internal state variable 'Fe'") self.assertTrue(b.isvs[12].getType() == "Tensor", "invalid type for internal state variable 'Fe'") self.assertTrue(b.isvs[12].type == mgis_bv.VariableType.TENSOR, "invalid type for internal state variable 'Fe'") self.assertTrue(b.isvs[12].type == mgis_bv.VariableType.Tensor, "invalid type for internal state variable 'Fe'") self.assertTrue( len(b.esvs) == 1, 'invalid number of external state variables') self.assertTrue(b.esvs[0].name == 'Temperature', 'invalid name for the first external state variable') self.assertTrue(b.esvs[0].getType() == 'Scalar', 'invalid type for the first external state variable') self.assertTrue(b.esvs[0].type == mgis_bv.VariableType.SCALAR, 'invalid type for the first external state variable') self.assertTrue(b.esvs[0].type == mgis_bv.VariableType.Scalar, 'invalid type for the first external state variable')
def test_pass(self): eps = 1.e-14 yg_min = 100.e9 yg_max = 200.e9 nu_min = -1 nu_max = 0.5 iv_pmin = 0. iv_pmax = 0.8 iv_min = 0.2 iv_max = 0.5 ev_pmin = 0. ev_pmax = 500. ev_min = 200. ev_max = 400. # path to the test library lib = os.environ['MGIS_TEST_BEHAVIOURS_LIBRARY'] version = os.environ['MGIS_TEST_TFEL_VERSION'] h = mgis_bv.Hypothesis.Tridimensional b = mgis_bv.load(lib, 'BoundsCheckTest', h) self.assertTrue(b.behaviour == "BoundsCheckTest", "invalid behaviour name") self.assertTrue(b.hypothesis == h, "invalid hypothesis") self.assertTrue(b.source == "BoundsCheckTest.mfront", "invalid source") self.assertTrue(b.tfel_version == version, "invalid TFEL version") # test on material properties self.assertTrue(mgis_bv.hasBounds(b, "YoungModulus"), "'YoungModulus' shall have bounds") self.assertTrue(mgis_bv.hasLowerBound(b, "YoungModulus"), "'YoungModulus' shall have a lower bound") bound = mgis_bv.getLowerBound(b, "YoungModulus") self.assertTrue( abs(bound - yg_min) < eps * yg_min, "invalid value for the 'YoungModulus' lower bound") bound = mgis_bv.getUpperBound(b, "YoungModulus") self.assertTrue( abs(bound - yg_max) < eps * yg_max, "invalid value for the 'YoungModulus' upper bound") self.assertTrue(mgis_bv.hasUpperBound(b, "YoungModulus"), "'YoungModulus' shall have an upper bound") self.assertTrue(mgis_bv.hasPhysicalBounds(b, "YoungModulus"), "'YoungModulus' shall have physical bounds") self.assertTrue(mgis_bv.hasLowerPhysicalBound(b, "YoungModulus"), "'YoungModulus' shall have a lower physical bound") bound = mgis_bv.getLowerPhysicalBound(b, "YoungModulus") self.assertTrue( abs(bound) < eps * yg_max, "invalid value for the 'YoungModulus' " "physical lower bound") self.assertTrue( not mgis_bv.hasUpperPhysicalBound(b, "YoungModulus"), "'YoungModulus' shall not have an " "upper physical bound") self.assertTrue(not mgis_bv.hasBounds(b, "PoissonRatio"), "'PoissonRatio' shall not have bounds") self.assertTrue(not mgis_bv.hasLowerBound(b, "PoissonRatio"), "'PoissonRatio' shall not have a lower bound") self.assertTrue(not mgis_bv.hasUpperBound(b, "PoissonRatio"), "'PoissonRatio' shall not have an upper bound") self.assertTrue(mgis_bv.hasPhysicalBounds(b, "PoissonRatio"), "'PoissonRatio' shall have physical bounds") self.assertTrue(mgis_bv.hasLowerPhysicalBound(b, "PoissonRatio"), "'PoissonRatio' shall have a lower physical bound") bound = mgis_bv.getLowerPhysicalBound(b, "PoissonRatio") self.assertTrue( abs(bound - nu_min) < eps, "invalid value for the 'PoissonRatio' physical " "lower bound") self.assertTrue(mgis_bv.hasUpperPhysicalBound(b, "PoissonRatio"), "'PoissonRatio' shall have an upper physical bound") bound = mgis_bv.getUpperPhysicalBound(b, "PoissonRatio") self.assertTrue( abs(bound - nu_max) < eps * nu_max, "invalid value for the 'PoissonRatio' " "physical upper bound") # internal state variables self.assertTrue(mgis_bv.hasBounds(b, "StateVariable"), "'StateVariable' shall have bounds") self.assertTrue(mgis_bv.hasLowerBound(b, "StateVariable"), "'StateVariable' shall have a lower bound") bound = mgis_bv.getLowerBound(b, "StateVariable") self.assertTrue( abs(bound - iv_min) < eps * iv_min, "invalid value for the 'StateVariable' lower bound") bound = mgis_bv.getUpperBound(b, "StateVariable") self.assertTrue( abs(bound - iv_max) < eps * iv_max, "invalid value for the 'StateVariable' upper bound") self.assertTrue(mgis_bv.hasUpperBound(b, "StateVariable"), "'StateVariable' shall have an upper bound") self.assertTrue(mgis_bv.hasPhysicalBounds(b, "StateVariable"), "'StateVariable' shall have physical bounds") self.assertTrue(mgis_bv.hasLowerPhysicalBound(b, "StateVariable"), "'StateVariable' shall have a lower physical bound") bound = mgis_bv.getLowerPhysicalBound(b, "StateVariable") self.assertTrue( abs(bound - iv_pmin) < eps, "invalid value for the 'StateVariable' " "physical lower bound") self.assertTrue( mgis_bv.hasUpperPhysicalBound(b, "StateVariable"), "'StateVariable' shall not have an " "upper physical bound") bound = mgis_bv.getUpperPhysicalBound(b, "StateVariable") self.assertTrue( abs(bound - iv_pmax) < eps * iv_pmax, "invalid value for the 'StateVariable' " "physical upper bound") # external state variable ev = "ExternalStateVariable" self.assertTrue(mgis_bv.hasBounds(b, ev), "'ExternalStateVariable' shall have bounds") self.assertTrue(mgis_bv.hasLowerBound(b, ev), "'ExternalStateVariable' shall have a lower bound") bound = mgis_bv.getLowerBound(b, ev) self.assertTrue( abs(bound - ev_min) < eps * ev_min, "invalid value for the 'ExternalStateVariable' " "lower bound") bound = mgis_bv.getUpperBound(b, ev) self.assertTrue( abs(bound - ev_max) < eps * ev_max, "invalid value for the 'ExternalStateVariable' " "upper bound") self.assertTrue(mgis_bv.hasUpperBound(b, ev), "'ExternalStateVariable' shall have an upper bound") self.assertTrue(mgis_bv.hasPhysicalBounds(b, ev), "'ExternalStateVariable' shall have physical bounds") self.assertTrue( mgis_bv.hasLowerPhysicalBound(b, ev), "'ExternalStateVariable' shall have a " "lower physical bound") bound = mgis_bv.getLowerPhysicalBound(b, ev) self.assertTrue( abs(bound - ev_pmin) < eps, "invalid value for the 'ExternalStateVariable' " "physical lower bound") self.assertTrue( mgis_bv.hasUpperPhysicalBound(b, ev), "'ExternalStateVariable' shall not have an " "upper physical bound") bound = mgis_bv.getUpperPhysicalBound(b, ev) self.assertTrue( abs(bound - ev_pmax) < eps * ev_pmax, "invalid value for the 'ExternalStateVariable' " "physical upper bound")
from minieigen import * #Eigen for Python, publically available from SPFEMexp import SPFEM #import compiled SPFEMexp library import mgis #MFrontGenericInterfaceSupport import mgis.behaviour as mgis_bv import numpy import optimesh #mesh optimization from scipy.interpolate import LinearNDInterpolator pool = mgis.ThreadPool(20) #thread pool for parallel stress integration IT = mgis_bv.IntegrationType.IntegrationWithConsistentTangentOperator behaviour = mgis_bv.load('src/libBehaviour.so','MisesVocePlasticity',mgis_bv.Hypothesis.PlaneStrain) #plane strain assumption class spfem_mfront(object): def __init__(self,pts,mater,sigma=None,gravity=[0.,0.],charlen=1.): """ pts: type numpy ndarray, shape = (npts, 2), points coordinates mater: type structure, material properties sigma: type numpy ndarray, initial stress, shape = (4,) or (npts, 4) gravity: type vector, size = 2, gravity constant charlen: type double, characteristic spacing """ self.__npts = len(pts) self.__pts = pts self.__spfem = SPFEM() #SPFEM module with C++ backend and Python binding through compiled shared library compliance = 1. / mater['young'] * numpy.array([[1.,-mater['poisson'],-mater['poisson'],0.], \ [-mater['poisson'],1.,-mater['poisson'],0.], \ [-mater['poisson'],-mater['poisson'],1.,0.], \ [0.,0.,0.,numpy.sqrt(2)*(1+mater['poisson'])]]) if sigma is None: sigma = numpy.zeros(4) epsilon = numpy.dot(compliance, sigma.T).T