def getMaxAbsComp(self,preprocessor):
'''Return the maximum absolute value of the component.
It is used for calculating auto-scale parameter
'''
maxV=0
activeLoadPatterns= preprocessor.getDomain.getConstraints.getLoadPatterns
if(len(activeLoadPatterns)<1):
lmsg.warning('No active load patterns.')
for lp in activeLoadPatterns: #Iterate over loaded elements.
lIter= lp.data().loads.getElementalLoadIter
eLoad= lIter.next()
while(eLoad):
tags= eLoad.elementTags
for i in range(0,len(tags)):
if(self.component=='axialComponent'):
vComp= eLoad.axialComponent
elif(self.component=='transComponent'):
vComp= eLoad.transComponent
elif(self.component=='transYComponent'):
vComp=eLoad.transYComponent
elif(self.component=='transZComponent'):
vComp=eLoad.transZComponent
else:
lmsg.error("LinearLoadDiagram :'"+self.component+"' unknown.")
maxV=max(abs(vComp),maxV)
eLoad= lIter.next()
return maxV
def defElasticShearSection3d(self, preprocessor, material):
'''elastic section appropiate for 3D beam analysis, including shear
deformations
:param preprocessor: preprocessor object.
:param material: material (for which E is the Young's modulus and G() the shear modulus)
'''
if (not self.xc_material):
materialHandler = preprocessor.getMaterialHandler
if (materialHandler.materialExists(self.sectionName)):
lmsg.warning("Section: " + self.sectionName +
" already defined.")
self.xc_material = materialHandler.getMaterial(
self.sectionName)
else:
self.xc_material = typical_materials.defElasticShearSection3d(
preprocessor,
self.sectionName,
self.A(),
material.E,
material.G(),
self.Iz(),
self.Iy(),
self.J(),
self.alphaY(),
linearRho=material.rho * self.A())
else:
lmsg.warning('Material: ' + self.sectionName +
' already defined as:' + str(self.xc_material))
return self.xc_material
def defElasticShearSection2d(self, preprocessor, material, majorAxis=True):
'''elastic section appropiate for 2D beam analysis, including shear deformations
:param preprocessor: preprocessor object.
:param material: material constitutive model (for which
E is the Young's modulus and G() the shear modulus).
:param majorAxis: true if bending occurs in the section major axis.
'''
if (not self.xc_material):
materialHandler = preprocessor.getMaterialHandler
if (materialHandler.materialExists(self.sectionName)):
lmsg.warning("Section: " + self.sectionName +
" already defined.")
self.xc_material = materialHandler.getMaterial(
self.sectionName)
else:
I = self.Iz()
if (not majorAxis):
I = self.Iy()
self.xc_material = typical_materials.defElasticShearSection2d(
preprocessor,
self.sectionName,
self.A(),
material.E,
material.G(),
I,
self.alphaY(),
linearRho=material.rho * self.A())
else:
lmsg.warning('Material: ' + self.sectionName +
' already defined as:' + str(self.xc_material))
return self.xc_material
def getLoadedSides(xcSet):
''' Return the sides affected by loads.'''
retval = dict()
for s in xcSet.surfaces:
if (s.hasProp('load_tag')): # is loaded
loadTag = s.getProp('load_tag')
loadDirI = s.getProp('load_dir_i')
loadDirJ = s.getProp('load_dir_j')
loadDirK = s.getProp('load_dir_k')
## Get the lines pointed by the load direction: loaded sides.
faceCenter = s.getCentroid()
sideList = list()
if (loadTag in retval):
sideList.extend(retval[loadTag]['sideList'])
for side in s.getSides:
sideCenter = side.getCentroid()
sideDir = sideCenter - faceCenter
angle = loadDirI.getAngle(sideDir)
if (abs(angle) < 1e-3):
sideList.append(side)
if (len(sideList) == 0):
lmsg.warning('side list empty for load tag: ' + str(loadTag))
retval[loadTag] = {
'I': loadDirI,
'J': loadDirJ,
'K': loadDirK,
'sideList': sideList
}
return retval
def defConcrete02(preprocessor, name, epsc0, fpc, fpcu, epscu, ratioSlope, ft,
Ets):
''''Constructs an uniaxial concrete material with linear tension
softening. Compressive concrete parameters should be input as negative values.
The initial slope for this model is (2*fpc/epsc0)
:param preprocessor: preprocessor
:param name: name identifying the material
:param epsc0: concrete strain at maximum strength
:param fpc: concrete compressive strength at 28 days (compression is negative)
:param fpcu: concrete crushing strength
:param epscu: concrete strain at crushing strength
:param ratioSlope: ratio between unloading slope at epscu and initial slope
:param ft: tensile strength
:param Ets: tension softening stiffness (absolute value) (slope of the linear tension softening branch)
'''
materialHandler = preprocessor.getMaterialHandler
retval = materialHandler.newMaterial("concrete02_material", name)
retval.epsc0 = epsc0
retval.fpc = fpc
retval.fpcu = fpcu
retval.epscu = epscu
retval.ratioSlope = ratioSlope
retval.ft = ft
retval.Ets = Ets
if fpc == fpcu:
lmsg.warning(
"concrete02 compressive strength fpc is equal to crushing strength fpcu => the solver can return wrong stresses or have convergence problems "
)
return retval
def selectKPoints(self):
'''Selects the k-points to be used in the model. All the points that
are closer than the threshold distance are melted into one k-point.
'''
points, layers= self.extractPoints()
if(len(points)>0):
self.kPoints= [points[0]]
pointName= layers[0][1]
layerName= layers[0][0]
self.labelDict[pointName]= [layerName]
indexDict= dict()
indexDict[0]= pointName
for p, l in zip(points, layers):
pointName= l[1]
layerName= l[0]
indexNearestPoint= self.getIndexNearestPoint(p)
nearestPoint= self.kPoints[indexNearestPoint]
dist= cdist([p],[nearestPoint])[0][0]
if(dist>self.threshold):
indexNearestPoint= len(self.kPoints) # The point itself.
self.kPoints.append(p)
self.labelDict[pointName]= [layerName]
indexDict[indexNearestPoint]= pointName
else:
pointName= indexDict[indexNearestPoint]
layers= self.labelDict[pointName]
if(not layerName in layers):
layers.append(layerName)
else:
lmsg.warning('No points in DXF file.')
return indexDict
def defCircularLayers(self,
reinforcement,
code,
diagramName,
extRad,
anglePairs=None):
'''
Definition of the reinforcement layers
:param reinforcement: XC section reinforcement.
:param code: identifier for the layer.
:param diagramName: name of the strain-stress diagram of the steel.
:param points: end points for each row.
'''
if (len(self.rebarRows) > 0):
if (not anglePairs):
for rbRow in self.rebarRows:
layer = rbRow.defCircularLayer(reinforcement, code,
diagramName, extRad)
self.reinfLayers.append(layer)
else:
for rbRow, angles in zip(self.rebarRows, anglePairs):
initAngle = anglePairs[0]
finalAngle = anglePairs[1]
layer = rbRow.defCircularLayer(reinforcement, code,
diagramName, extRad,
initAngle, finalAngle)
self.reinfLayers.append(layer)
else:
lmsg.warning('No longitudinal reinforcement.')
def getElementComponentData(self,elem):
'''Returns the data to use to represent the diagram over the element
:param elem: element to deal with.
:param component: component to represent:
'''
# default values.
elemVDir= elem.getJVector3d(True) #initialGeometry= True
value1= 0.0
value2= 0.0
if(self.component == 'N'):
value1= elem.getN1
value2= elem.getN2
elif(self.component == 'Qy'):
elemVDir= elem.getJVector3d(True) # initialGeometry= True
value1= elem.getVy1
value2= elem.getVy2
elif(self.component == 'Qz'):
elemVDir= elem.getKVector3d(True) # initialGeometry= True
value1= elem.getVz1
value2= elem.getVz2
elif(self.component == 'T'):
value1= elem.getT1
value2= elem.getT2
elif(self.component == 'My'):
elemVDir= elem.getKVector3d(True) # initialGeometry= True
value1= elem.getMy1
value2= elem.getMy2
elif(self.component == 'Mz'):
elemVDir= elem.getJVector3d(True) # initialGeometry= True
value1= elem.getMz1
value2= elem.getMz2
else:
lmsg.warning("'component :'"+ self.component+ "' unknown.")
return [elemVDir,value1,value2]
def exportBlockTopology(self, name):
retval = bte.BlockData()
retval.name = name
retval.dxfFileName = self.dxfFileName
counter = 0
if (self.kPoints):
for p in self.kPoints:
key = self.kPointsNames[counter]
retval.appendPoint(id=counter,
x=p[0],
y=p[1],
z=p[2],
labels=self.labelDict[key])
counter += 1
counter = 0
for key in self.lines:
line = self.lines[key]
block = bte.BlockRecord(counter, 'line', line,
self.labelDict[key])
retval.appendBlock(block)
counter += 1
for name in self.layersToImport:
fg = self.facesByLayer[name]
for key in fg:
face = fg[key]
block = bte.BlockRecord(counter, 'face', face,
self.labelDict[key])
retval.appendBlock(block)
counter += 1
else:
lmsg.warning('Nothing to export.')
return retval
def gdls_elasticidad2D(nodes):
'''Defines the dimension of the space: nodes by two coordinates (x,y) and two DOF for each node (Ux,Uy)
:param nodes: nodes handler
'''
lmsg.warning('gdls_elasticidad2D DEPRECATED; use SolidMechanics2D.')
return SolidMechanics2D(nodes)
def getStressComponentFromName(self, compName):
'''Return the component index from the
stress name.'''
lmsg.warning('getStressComponentFromName not tested yet.')
retval = 0
self.N = 0 # generalized strains; axial strain,
self.Mz = 1 # curvature about z-axis,
self.Vy = 2 # shear along y-axis.
self.My = 3 # curvature about y-axis,
self.Vz = 4 # shear along z-axis.
self.T = 5 # torsion along x-axis.
if ((compName == 'N') or (compName == 'P')):
retval = self.N
elif (compName == 'Mz'):
retval = self.Mz
elif ((compName == 'Qy') or (compName == 'Vy')):
retval = self.Qy
elif (compName == 'My'):
retval = self.My
elif ((compName == 'Qz') or (compName == 'Vz')):
retval = self.Qz
elif (compName == 'T'):
retval = self.Qz
else:
lmsg.error(
'Item ' + str(compName) +
' is not a valid component. Available components are: N, Mz, Qy, My, Qz, T.'
)
return retval
def setUniaxialBearing2D(self, iNod, bearingMaterial, direction):
'''Modelize an uniaxial bearing on the defined direction.
:param iNod (int): node identifier (tag).
:param bearingMaterial (str): material name for the zero length
element.
:return rtype: (int, int) new node tag, new element tag.
'''
nodes = self.preprocessor.getNodeHandler
newNode = nodes.duplicateNode(iNod) # new node.
# Element definition
elems = self.preprocessor.getElementHandler
elems.dimElem = self.preprocessor.getNodeHandler.dimSpace # space dimension.
if (elems.dimElem > 2):
lmsg.warning("Not a bi-dimensional space.")
elems.defaultMaterial = bearingMaterial
zl = elems.newElement("ZeroLength", xc.ID([newNode.tag, iNod]))
zl.setupVectors(xc.Vector([direction[0], direction[1], 0]),
xc.Vector([-direction[1], direction[0], 0]))
zl.clearMaterials()
zl.setMaterial(0, bearingMaterial)
# Boundary conditions
numDOFs = self.preprocessor.getNodeHandler.numDOFs
for i in range(0, numDOFs):
spc = self.constraints.newSPConstraint(newNode.tag, i, 0.0)
return newNode.tag, zl.tag
def defineLocalAxes(self, setToDisplay):
''' Define the local axes of the blocks.
:param setToDisplay: set of elements to be displayed.
'''
lineAxesField = None
surfAxesField = None
numKPts = setToDisplay.getPoints.size
if (numKPts > 0):
avgSize = setToDisplay.getEntities.getAverageSize()
vectorScale = avgSize / 4.0
## Draw lines local axes.
lineAxesField = lavf.LinesLocalAxesVectorField(
setToDisplay.name + '_lineLocalAxes', scaleFactor=vectorScale)
lineAxesField.dumpVectors(setToDisplay)
## Draw quad surfaces local axes.
surfAxesField = lavf.SurfacesLocalAxesVectorField(
setToDisplay.name + '_surfLocalAxes', scaleFactor=vectorScale)
surfAxesField.dumpVectors(setToDisplay)
else:
lmsg.warning(
"Error when drawing set: '" + setToDisplay.name +
"' it has not key points so I can't get set geometry (use fillDownwards?)"
)
return lineAxesField, surfAxesField
def dumpLoads(self, preprocessor, indxDiagram):
''' Dump loads over elements.'''
activeLoadPatterns= preprocessor.getDomain.getConstraints.getLoadPatterns
if(len(activeLoadPatterns)<1):
lmsg.warning('No active load patterns.')
for lp in activeLoadPatterns: #Iterate over loaded elements.
self.dumpElementalLoads(preprocessor,lp.data(),indxDiagram)
def ic(self, deltaB, deltaL, Hload, Beff, Leff):
'''Factor that introduces the effect of load inclination on
the cohesion component.
:param deltaB: angle between the load and the foundation width
atan(HloadB/VLoad).
:param deltaL: angle between the load and the foundation length
atan(HloadL/VLoad).
:param Hload: Horizontal load.
:param Beff: Width of the effective foundation area
(see figure 12 in page 44 of reference[2]).
:param Leff: Length of the effective foundation area
(see figure 12 in page 44 of reference[2]).
'''
if (self.getDesignPhi() != 0.0):
iq = self.iq(deltaB, deltaL)
return (iq * self.Nq() - 1.0) / (self.Nq() - 1.0)
else: #See expresion (15) in reference [2]
resist = Beff * Leff * self.getDesignC()
if (Hload <= resist):
twoAlpha = math.acos(Hload / resist)
return 0.5 + (twoAlpha + math.sin(twoAlpha)) / (math.pi + 2.0)
else:
lmsg.warning('Load (H= ' + str(Hload) +
') greater than soil strength R=' + str(resist) +
' returns 0.0')
return 0.0
def VtkDibujaIdsKPts(uGrid, setToDraw, renderer):
'''Draw the point labels.'''
numKPtsDI = setToDraw.getPoints.size
if (numKPtsDI > 0):
ids = vtk.vtkIdFilter()
ids.SetInput(uGrid)
ids.CellIdsOff()
ids.PointIdsOff()
VtkCargaIdsKPts(uGrid, setToDraw)
visPts = vtk.vtkSelectVisiblePoints()
visPts.SetInputConnection(ids.GetOutputPort())
visPts.SetRenderer(renderer)
visPts.SelectionWindowOff()
#Create the mapper to display the point ids. Specify the format to
# use for the labels. Also create the associated actor.
ldm = vtk.vtkLabeledDataMapper()
ldm.SetInputConnection(visPts.GetOutputPort())
ldm.GetLabelTextProperty().SetColor(0.1, 0.1, 0.1)
pointLabels = vtk.vtkActor2D()
pointLabels.SetMapper(ldm)
renderer.AddActor2D(pointLabels)
else:
lmsg.warning("El conjunto: '" + setToDraw.name + "' no tiene KPts.")
def createElementSet(self):
'''Create the attributes 'length' and 'elemSet' that
represent the length of the beam and the set of elements included in it.'''
prep = self.getPreprocessor()
if self.lstLines:
lstLn = self.lstLines
lstP3d = gu.lstP3d_from_lstLns(lstLn)
elif self.lstPoints:
lstP3d = [p.getPos for p in self.lstPoints]
lstLn = gu.lstLns_from_lstPnts(self.lstPoints)
else:
lmsg.warning(
'Incomplete member definition: list of lines or points required'
)
#set of elements included in the member
s = prep.getSets.defSet(self.name + 'Set')
self.elemSet = s.elements
for l in lstLn:
for e in l.elements:
self.elemSet.append(e)
pol = geom.Polyline3d()
for p in lstP3d:
pol.append(p)
self.length = pol.getLength()
return pol
def getLoadData(self, internalForces, origin):
''' Extracts the internal forces for this member from the
argument.
:param internalForces: internal forces of the connected elements.
:param origin: connection origin.
'''
originPos = origin.getInitialPos3d
orientation = self.getOrientation(originPos)
self.internalForces = dict()
for comb in internalForces:
loads = internalForces[comb]
for elemId in loads:
if (int(elemId) == self.eTag): # loads for this member
elemLoads = loads[elemId]
elemInternalForces = elemLoads['internalForces']
iForces = None
if (orientation > 0):
iForces = elemInternalForces['0']
else:
iForces = elemInternalForces['1']
loadPos = [originPos.x, originPos.y, originPos.z]
self.internalForces[comb] = (loadPos, iForces)
if (len(self.internalForces) == 0):
lmsg.warning('No internal forces found for element: ' +
str(self.eTag))
return self.internalForces
def checkSetFromIntForcFile(self, intForcCombFileName, setCalc=None):
'''Launch checking.
:param setCalc: set of elements to check
'''
intForcItems = lsd.readIntForcesFile(intForcCombFileName, setCalc)
internalForcesValues = intForcItems[2]
for e in setCalc.elements:
sh = e.getProp('crossSection')
sc = e.getProp('sectionClass')
elIntForc = internalForcesValues[e.tag]
if (len(elIntForc) == 0):
lmsg.warning('No internal forces for element: ' + str(e.tag) +
' of type: ' + e.type())
for lf in elIntForc:
CFtmp = sh.getYShearEfficiency(sc, lf.Vy)
if lf.idSection == 0:
if (CFtmp > e.getProp(self.limitStateLabel + 'Sect1').CF):
e.setProp(
self.limitStateLabel + 'Sect1',
cv.ShearYControlVars('Sects1', lf.idComb, CFtmp,
lf.Vy))
else:
if (CFtmp > e.getProp(self.limitStateLabel + 'Sect2').CF):
e.setProp(
self.limitStateLabel + 'Sect2',
cv.ShearYControlVars('Sects2', lf.idComb, CFtmp,
lf.Vy))
def qu(self,q,D,Beff,Leff,Vload,HloadB,HloadL,NgammaCoef= 1.5,psi= 0.0,eta= 0.0):
'''Ultimate bearing capacity pressure of the soil.
:param D: foundation depth.
:param Beff: Width of the effective foundation area
(see figure 12 in page 44 of reference[2]).
:param Leff: Length of the effective foundation area
(see figure 12 in page 44 of reference[2]).
:param Vload: Vertical load (positive downwards).
:param HloadB: Horizontal load on Beff direction.
:param HloadL: Horizontal load on Leff direction.
:param NgammaCoef: 1.5 in reference [1], 1.8 in reference 2
and 2 in reference 3
:param psi: angle of the line on wich the q load acts
(see figure 4.7 in page 102 of reference [3])
must be determined by iterations.
'''
if(Vload<0.0):
lmsg.warning('Negative vertical load (V= '+str(Vload)+') means pushing upwards.')
deltaB= math.atan(HloadB/Vload)
deltaL= math.atan(HloadL/Vload)
Hload= math.sqrt(HloadB**2+HloadL**2)
gammaComp= self.quGamma(D,Beff,Leff,Vload,HloadB,HloadL,NgammaCoef,psi,eta)
cComp= self.quCohesion(D,Beff,Leff,Vload,HloadB,HloadL,psi,eta)
qComp= self.quQ(q,D,Beff,Leff,Vload,HloadB,HloadL,psi,eta)
return gammaComp+cComp+qComp
def getBlocks(self, blockProperties=None):
''' Creates the block data for later meshing.
:param blockProperties: labels and attributes to assign to the newly created blocks.
'''
originNodeTag = str(self.originNode.tag)
properties = bte.BlockProperties.copyFrom(blockProperties)
properties.appendAttribute('jointId', originNodeTag)
retval = bte.BlockData()
# Column blocks.
columnShapeBlocks = self.getColumnShapeBlocks(
self.columnLengthFactor, blockProperties=properties)
retval.extend(columnShapeBlocks)
# Beam blocks.
beamShapeBlocks = self.getBeamShapeBlocks(self.beamLengthFactor,
blockProperties=properties)
retval.extend(beamShapeBlocks)
# Diagonal blocks.
for e in self.diagonals:
retval.extend(
self.getGussetBlocksForDiagonal(e, blockProperties=properties))
if (hasattr(self, 'basePlate')):
retval.extend(
self.getBasePlateBlocks(columnShapeBlocks,
blockProperties=properties))
else:
lmsg.warning('base plate not found.')
return retval
def solve(self):
self.modelSpace.removeAllLoadPatternsFromDomain()
self.modelSpace.addNewLoadCaseToDomain(self.loadCaseName,self.loadCaseExpr)
#Solution
lmsg.warning('Here we use a simple linear static solution that is not always a suitable method.')
analysis= predefined_solutions.simple_static_linear(self.feProblem)
result= analysis.analyze(1)
def dumpVectors(self,
preprocessor,
defFScale,
showElementalLoads=True,
showNodalLoads=True):
''' Iterate over loads dumping them into the graphic.
:param preprocessor: preprocessor of the FE problem.
:param defFScale: factor to apply to current displacement of nodes
so that the display position of each node equals to
the initial position plus its displacement multiplied
by this factor.
:param showElementalLoads: if true show loads over elements.
:param showNodalLoads: if true show loads over nodes.
'''
count = 0
activeLoadPatterns = preprocessor.getDomain.getConstraints.getLoadPatterns
if (len(activeLoadPatterns) < 1):
lmsg.warning('No active load patterns.')
else:
for lp in activeLoadPatterns: #Iterate over loaded elements.
numberOfLoads = self.populateLoads(lp.data())
if (numberOfLoads > 0):
maxLoad = self.getMaxLoad()
if (maxLoad != 0):
self.data.scaleFactor /= self.getMaxLoad()
#Iterate over loaded elements.
count += self.dumpElementalPositions(lp.data())
#Iterate over loaded nodes.
count += self.dumpNodalPositions(lp.data(), defFScale)
if (count == 0):
lmsg.warning(
'LoadVectorField.dumpVectors: no loads defined.')
return count
def selectKPoints(self):
'''Selects the k-points to be used in the model. All the points that
are closer than the threshold distance are melted into one k-point.
'''
points, layers= self.extractPoints()
indexDict= None
if(len(points)>0):
self.kPoints= [points[0]]
pointName= layers[0][0]
objProperties= layers[0][1]
self.propertyDict[pointName]= objProperties
indexDict= dict()
indexDict[0]= pointName
for p, l in zip(points, layers):
pointName= l[0]
objProperties= l[1]
indexNearestPoint= self.getIndexNearestPoint(p)
nearestPoint= self.kPoints[indexNearestPoint]
dist= cdist([p],[nearestPoint])[0][0]
if(dist>self.threshold): # new point.
indexNearestPoint= len(self.kPoints) # The point itself.
self.kPoints.append(p)
self.propertyDict[pointName]= objProperties
indexDict[indexNearestPoint]= pointName
else:
pointName= indexDict[indexNearestPoint]
self.propertyDict[pointName].extend(objProperties)
else:
lmsg.warning('No points in :'+self.fileName+' file.')
return indexDict
def AsSimpleBending(M, fcd, fsd, b, d):
''' Return the required reinforcement for a rectangular section
subjected to simple bending.
:param M: bending moment to resist.
:param fcd: concrete design compressive strength (absolute value).
:param fsd: steel design yield strength.
:param b: section width.
:param d: section depth.
'''
if (fcd < 0.0):
lmsg.warning(
'positive value expected for concrete design strength fcd= ' +
str(fcd / 1e6) + ' MPa.')
Ml = Mlim(fcd, b, d)
if (M > Ml):
lmsg.warning('compression reinforcement needed Ml= ' + str(Ml / 1e3) +
' kN m < ' + str(M / 1e3) + ' kN m')
T = 1e9
else:
c = 0.85 * fcd * b
T = c * (d - math.sqrt(d**2 - 2 * M / c))
xpl = T / c
assert xpl <= d, "xpl bigger than section depth."
return T / fsd
def exportBlockTopology(self, name):
retval= bte.BlockData()
retval.name= name
retval.fileName= self.fileName
retval.logMessage= '# imported from file: '+self.fileName+' on '
retval.logMessage+= str(datetime.datetime.now())
counter= 0
if(self.kPoints):
for p in self.kPoints:
key= self.kPointsNames[counter]
bp= bte.BlockProperties(labels= self.labelDict[key])
retval.appendPoint(id= counter,x= p[0],y= p[1],z= p[2], pointProperties= bp)
counter+= 1
counter= 0
for key in self.lines:
line= self.lines[key]
bp= bte.BlockProperties(labels= self.labelDict[key])
block= bte.BlockRecord(counter,'line',line, blockProperties= bp)
retval.appendBlock(block)
counter+= 1
for name in self.getNamesToImport():
fg= self.facesTree[name]
for key in fg:
face= fg[key]
bp= bte.BlockProperties(labels= self.labelDict[key])
block= bte.BlockRecord(counter,'face',face, blockProperties= bp)
retval.appendBlock(block)
counter+= 1
else:
lmsg.warning('Nothing to export.')
return retval
def defElasticSection1d(self, preprocessor, material):
''' Return an elastic section appropiate for truss analysis.
:param preprocessor: preprocessor object.
:param material: material constitutive model
(for which E is the Young's modulus)
'''
if (not self.xc_material):
materialHandler = preprocessor.getMaterialHandler
if (materialHandler.materialExists(self.sectionName)):
lmsg.warning("Section: " + self.sectionName +
" already defined.")
self.xc_material = materialHandler.getMaterial(
self.sectionName)
else:
self.xc_material = typical_materials.defElasticSection1d(
preprocessor,
self.sectionName,
self.A(),
material.E,
linearRho=material.rho * self.A())
else:
lmsg.warning('Material: ' + self.sectionName +
' already defined as:' + str(self.xc_material))
return self.xc_material
def displayNodeValueDiagram(self, itemToDisp, setToDisplay=None,caption= None,fileName=None,defFScale=0.0):
'''displays the a displacement (uX,uY,...) or a property defined in nodes
as a diagram over lines.
:param itemToDisp: item to display (uX,uY,...).
:param setToDisplay: set of entities (elements of type beam) to be
represented
:param fileName: name of the file to plot the graphic. Defaults to None,
in that case an screen display is generated
:param defFScale: factor to apply to current displacement of nodes
so that the display position of each node equals to
the initial position plus its displacement multiplied
by this factor. (Defaults to 0.0, i.e. display of
initial/undeformed shape)
'''
if(setToDisplay==None):
setToDisplay= self.modelSpace.getTotalSet()
unitConversionFactor, unitDescription= self.outputStyle.getUnitParameters(itemToDisp)
lmsg.warning("Auto scale not implemented yet.")
LrefModSize= setToDisplay.getBnd(1.0).diagonal.getModulus() #representative length of set size (to autoscale)
scaleFactor= LrefModSize/unitConversionFactor
diagram= npd.NodePropertyDiagram(scaleFactor= scaleFactor,fUnitConv= unitConversionFactor,sets=[setToDisplay], attributeName= itemToDisp)
diagram.addDiagram()
displaySettings= vtk_FE_graphic.DisplaySettingsFE()
displaySettings.cameraParameters= self.getCameraParameters()
grid= displaySettings.setupGrid(setToDisplay)
displaySettings.defineMeshScene(None,defFScale,color=setToDisplay.color)
displaySettings.appendDiagram(diagram) #Append diagram to the scene.
loadCaseName= self.modelSpace.preprocessor.getDomain.currentCombinationName
if(not caption):
caption= loadCaseName+' '+itemToDisp+' '+unitDescription +' '+setToDisplay.description
displaySettings.displayScene(caption=caption,fileName=fileName)
def alphaZ(self):
'''Return shear shape factor with respect to local z-axis'''
msg = 'alphaZ: shear shape factor not implemented for section: '
msg += self.sectionName
msg += '. 5/6 returned'
lmsg.warning(msg)
return 5.0 / 6.0
def create_attribute_at_nodes(xcSet, attributeName, initialValue):
''' Create an attribute on the nodes of the set passed as parameter.
return tags of the affected nodes.
:param xcSet: nodes that will receive the attribute.
:param attributeName: name of the attribute to define.
:param initialValue: initial value to assign to the attribute.
'''
touchedNodesTags = {}
for e in xcSet:
elemNodes = e.getNodes
sz = len(elemNodes)
for i in range(0, sz):
n = elemNodes[i]
tag = n.tag
if tag not in touchedNodesTags:
touchedNodesTags[tag] = 1
if (n.hasProp(attributeName)):
lmsg.warning('node: ' + str(n.tag) +
' already has a property named: \'' +
attributeName + '\'.')
n.setProp(attributeName, initialValue)
else:
touchedNodesTags[tag] += 1
return touchedNodesTags
