Python typical_materials.defElasticMaterial函数代码示例

 def createMaterials(self,preprocessor,name):
     #elastic materials (los incializamos aquí para luego aplicar el módulo elástico que corresponda a cada nudo)
     self.xSpringName= name + '_xSpring'
     self.xSpring=typical_materials.defElasticMaterial(preprocessor,self.xSpringName,0.1)
     self.ySpringName= name + '_ySpring'
     self.ySpring=typical_materials.defElasticMaterial(preprocessor,self.ySpringName,0.1)
     self.zSpringName= name + '_zSpring'
     self.zSpring=typical_materials.defElasticMaterial(preprocessor,self.zSpringName,1)

    def defineMaterials(self,preprocessor):
        '''Define the materials to modelize the pot (Teflon).

        Args:
            :preprocessor: (:obj:'Preprocessor') preprocessor to use.
            :matKX: (str) name for the uniaxial material in direction X.
            :matKY: (str) name for the uniaxial material in direction Y.
        '''
        self.materialHandler= preprocessor.getMaterialHandler
        # Material names.
        nameRoot= 'pot'+str(self.id)
        self.matXName= nameRoot+'X'
        self.matYName= nameRoot+'Y'
        self.materials.extend([self.matXName, self.matYName])
        # Material objects.
        self.matKX= typical_materials.defElasticMaterial(preprocessor, self.matXName, self.getHorizontalStiffness())
        self.matKY= typical_materials.defElasticMaterial(preprocessor, self.matYName, self.getHorizontalStiffness())

 def createSpringMaterials(self):
     '''create the spring materials in X, Y, Z directions. If there is
     no spring in any of these directions, its corresponding material is
     equal to None 
     '''
     if self.Kx != 0:
         typical_materials.defElasticMaterial(self.modelSpace.preprocessor,self.name + '_xSpring',self.Kx)
         self.springMat[0]=self.name + '_xSpring'
     if self.Ky != 0:
         typical_materials.defElasticMaterial(self.modelSpace.preprocessor,self.name + '_ySpring',self.Ky)
         self.springMat[1]=self.name + '_ySpring'
     if self.Kz != 0:
         typical_materials.defElasticMaterial(self.modelSpace.preprocessor,self.name + '_zSpring',self.Kz)
         self.springMat[2]=self.name + '_zSpring'

# Model definition
feProblem= xc.FEProblem()
preprocessor=  feProblem.getPreprocessor
nodes= preprocessor.getNodeHandler
# Problem type
modelSpace= predefined_spaces.SolidMechanics2D(nodes)

nodes.defaultTag= 1 #First node number.
nod= nodes.newNodeXY(0,0)
nod= nodes.newNodeXY(0.0,l-a-b)
nod= nodes.newNodeXY(0.0,l-a)
nod= nodes.newNodeXY(0.0,l)

# Materials definition
elast= typical_materials.defElasticMaterial(preprocessor, "elast",E)
    
''' We define nodes at the points where loads will be applied.
    We will not compute stresses so we can use an arbitrary
    cross section of unit area.'''
    
# Elements definition
elements= preprocessor.getElementHandler
elements.defaultMaterial= "elast"
elements.dimElem= 2 # Dimension of element space
#  sintaxis: truss[<tag>] 
elements.defaultTag= 1 #Tag for the next element.
truss= elements.newElement("Truss",xc.ID([1,2]))
truss.area= 1
truss= elements.newElement("Truss",xc.ID([2,3]))
truss.area= 1

__author__= "Luis C. Pérez Tato (LCPT) and Ana Ortega (AO_O)"
__copyright__= "Copyright 2015, LCPT and AO_O"
__license__= "GPL"
__version__= "3.0"
__email__= "[email protected]"

Ec= 20e9
sideLength= 1.0


feProblem= xc.FEProblem()
preprocessor=  feProblem.getPreprocessor


concrete= typical_materials.defElasticMaterial(preprocessor, 'concrete',Ec)
sectionGeometryTest= preprocessor.getMaterialHandler.newSectionGeometry("sectionGeometryTest")
regions= sectionGeometryTest.getRegions
concrete= regions.newQuadRegion('concrete')
concrete.pMin= geom.Pos2d(0.0,0.0)
concrete.pMax= geom.Pos2d(1.0,1.0)

pt= EHE_limit_state_checking.computeEffectiveHollowSectionParameters(sectionGeometryTest,0.5,0.03)


ratio1= (pt.A()-1)
ratio2= (pt.u()-4)/4
ratio3= (pt.he()-0.25)/0.25
ratio4= (pt.Ae()-(0.75**2))/(0.75**2)
ratio5= (pt.ue()-3)/3

import os
pth= os.path.dirname(__file__)
if(not pth):
  pth= "."
#print "pth= ", pth
execfile(pth+"/fiber_section_test_macros.py")

fy= 2600 # yield strength [kp/cm2].
E= 1e6   # elastic moculus [kp/cm2].

feProblem= xc.FEProblem()
feProblem.logFileName= "/tmp/erase.log" # Ignore warning messages
preprocessor=  feProblem.getPreprocessor
# Materials definition
elast= typical_materials.defElasticMaterial(preprocessor, "elast",E)
respT= typical_materials.defElasticMaterial(preprocessor, "respT",1e6) # Torsion response.
respVy= typical_materials.defElasticMaterial(preprocessor, "respVy",1e6) # Shear response in y direction.
respVz= typical_materials.defElasticMaterial(preprocessor, "respVz",1e6) # Shear response in y direction.

# Section geometry
#creation
geomRectang= preprocessor.getMaterialHandler.newSectionGeometry("geomRectang")
reg= scc1x1.getRegion(geomRectang,"elast")
sa= preprocessor.getMaterialHandler.newMaterial("fiberSectionShear3d","sa")
fiberSectionRepr= sa.getFiberSectionRepr()
fiberSectionRepr.setGeomNamed("geomRectang")
sa.setupFibers()
extractFiberSectionProperties(sa,scc1x1)
sa.setRespVyByName("respVy")
sa.setRespVzByName("respVz")

from solution import predefined_solutions
from model import predefined_spaces
from materials import typical_materials

# Problem type
# Model definition
feProblem= xc.FEProblem()
preprocessor=  feProblem.getPreprocessor
nodes= preprocessor.getNodeHandler
modelSpace= predefined_spaces.StructuralMechanics3D(nodes)
nodes.defaultTag= 1 #First node number.
nod= nodes.newNodeXYZ(1,1,1)

    
# Define materials
kx= typical_materials.defElasticMaterial(preprocessor, "kx",KX)
ky= typical_materials.defElasticMaterial(preprocessor, "ky",KY)


fixedNode, newElement= modelSpace.setBearingOnXYRigZ(nod.tag,["kx","ky"])

# Constraints
constraints= preprocessor.getBoundaryCondHandler

#
spc= constraints.newSPConstraint(nod.tag,3,0.0) # nod1 Rx= 0,Ry= 0 and Rz= 0
spc= constraints.newSPConstraint(nod.tag,4,0.0)
spc= constraints.newSPConstraint(nod.tag,5,0.0)


# Loads definition

 def getRespVz(self,preprocessor):
   '''Material for modeling z shear response of section'''
   return typical_materials.defElasticMaterial(preprocessor,self.respVzName(),5/6.0*self.b*self.h*self.concrType.Gcm())

 def getRespT(self,preprocessor,JTorsion):
   '''Material for modeling torsional response of section'''
   return typical_materials.defElasticMaterial(preprocessor,self.respTName(),self.concrType.Gcm()*JTorsion) # Torsional response of the section.

from materials import typical_materials
import math

# Problem type
feProblem= xc.FEProblem()
preprocessor=  feProblem.getPreprocessor
nodes= preprocessor.getNodeHandler
modelSpace= predefined_spaces.StructuralMechanics2D(nodes)

# Model definition
nodes.defaultTag= 1 #First node number.
nod= nodes.newNodeXY(1,1)
nod= nodes.newNodeXY(1,1)

# Materials definition
k= typical_materials.defElasticMaterial(preprocessor, "k",K)


''' We define nodes at the points where loads will be applied.
    We will not compute stresses so we can use an arbitrary
    cross section of unit area.'''
    
# Elements definition
elements= preprocessor.getElementHandler
elements.defaultMaterial= "k"
elements.dimElem= 3 # Dimension of element space
elements.deraultTag= 1
zl1= elements.newElement("ZeroLength",xc.ID([1,2]))
zl1.setupVectors(xc.Vector([1,1,0]),xc.Vector([-1,1,0]))
zl1.clearMaterials()
zl1.setMaterial(0,"k")

F= 10000
E= 5200
I= 342990
beta= 3*math.pi/L
k= pow(beta,4)*4*E*I
h= pow(12*I,1/3)
A= h # Suponemos width unidad

# Problem type
feProblem= xc.FEProblem()
preprocessor=  feProblem.getPreprocessor
nodes= preprocessor.getNodeHandler
modelSpace= predefined_spaces.StructuralMechanics2D(nodes)

# Define materials
kY= typical_materials.defElasticMaterial(preprocessor, "kY",k*L/numDiv)
nodes.newSeedNode()
# Geometric transformations
lin= modelSpace.newLinearCrdTransf("lin")

# Define materials
scc= typical_materials.defElasticSection2d(preprocessor, "scc",A,E,I)



seedElemHandler= preprocessor.getElementHandler.seedElemHandler
seedElemHandler.defaultTransformation= "lin"
seedElemHandler.defaultMaterial= "scc"
seedElemHandler.defaultTag= 1 #Tag for next element.
beam2d= seedElemHandler.newElement("ElasticBeam2d",xc.ID([0,0]))
beam2d.h= h

import xc_base
import geom
import xc
from model import predefined_spaces
from materials import typical_materials
import math

Es= 2.1e11
n= 15.0
Ec= Es/n
areaFi16= 2.01e-4

feProblem= xc.FEProblem()
preprocessor=  feProblem.getPreprocessor

steel= typical_materials.defElasticMaterial(preprocessor, "steel",Es)

sectionGeometryTest= preprocessor.getMaterialHandler.newSectionGeometry("sectionGeometryTest")
reinforcement= sectionGeometryTest.getReinfLayers
reinforcementA= reinforcement.newStraightReinfLayer("steel")
reinforcementA.numReinfBars= 2
reinforcementA.barDiam= 16e-3
reinforcementA.barArea= areaFi16
reinforcementA.p1= geom.Pos2d(0.05,0.95) # bottom layer.
reinforcementA.p2= geom.Pos2d(0.05,0.05)
reinforcementB= reinforcement.newStraightReinfLayer("steel")
reinforcementB.numReinfBars= 2
reinforcementB.barDiam= 16e-3
reinforcementB.barArea= areaFi16
reinforcementB.p1= geom.Pos2d(0.95,0.95) # bottom layer.
reinforcementB.p2= geom.Pos2d(0.95,0.05)