def __init__(self, loadCaseName, loadCaseDescr, loadCaseExpr,
setsToDispLoads, setsToDispDspRot, setsToDispIntForc):
self.loadCaseName = loadCaseName
self.loadCaseDescr = loadCaseDescr
self.loadCaseExpr = loadCaseExpr
self.setsToDispLoads = setsToDispLoads
self.setsToDispBeamLoads = []
self.compElLoad = 'transComponent'
self.unitsScaleLoads = 1.0
self.unitsLoads = 'units:[m,kN]'
self.vectorScaleLoads = 1.0
self.vectorScalePointLoads = 1.0
self.multByElemAreaLoads = False
self.listDspRot = ['uX', 'uY', 'uZ']
self.setsToDispDspRot = setsToDispDspRot
self.unitsScaleDispl = 1.0
self.unitsDispl = '[m]'
self.listIntForc = ['N1', 'N2', 'M1', 'M2', 'Q1', 'Q2']
self.setsToDispIntForc = setsToDispIntForc
self.listBeamIntForc = ['N', 'My', 'Mz', 'Qy', 'Qz', 'T']
self.setsToDispBeamIntForc = []
self.scaleDispBeamIntForc = (1.0, 1.0, 1.0)
self.unitsScaleForc = 1.0
self.unitsForc = '[kN/m]'
self.unitsScaleMom = 1.0
self.unitsMom = '[kN.m/m]'
self.cameraParameters = vtk_graphic_base.CameraParameters('XYZPos')
self.cameraParametersBeams = vtk_graphic_base.CameraParameters(
'XYZPos')
def __init__(self,setsToDispLoads= None, setsToDispDspRot= None ,setsToDispIntForc= None):
super(RecordDisp,self).__init__()
if(setsToDispLoads):
self.setsToDispLoads= setsToDispLoads
else:
self.setsToDispLoads= list()
if(setsToDispDspRot):
self.setsToDispDspRot= setsToDispDspRot
else:
self.setsToDispDspRot= list()
if(setsToDispIntForc):
self.setsToDispIntForc= setsToDispIntForc
else:
self.setsToDispIntForc= list()
self.setsToDispBeamLoads= list()
self.compElLoad='transComponent'
self.multByElemAreaLoads=False
self.listDspRot=['uX', 'uY', 'uZ']
self.setsToDispDspRot=setsToDispDspRot
self.listIntForc=['N1', 'N2', 'M1', 'M2', 'Q1', 'Q2']
self.setsToDispIntForc= setsToDispIntForc
self.listBeamIntForc=['N', 'My', 'Mz', 'Qy', 'Qz','T']
self.setsToDispBeamIntForc=[]
self.setsToDispReactions=[]
self.setsToDispEigenvectors=[]
self.cameraParameters= vtk_graphic_base.CameraParameters('XYZPos')
self.cameraParametersBeams= vtk_graphic_base.CameraParameters('XYZPos')
def getDefaultCameraParameters(self):
'''Return the default camera parameters.'''
if (self.modelSpace.getSpaceDimension() == 3): # 3D problem
return vtk_graphic_base.CameraParameters('XYZPos')
else: # 2D or 1D problem
retval = vtk_graphic_base.CameraParameters('Custom')
retval.viewUpVc = [0, 1, 0] #[0,0,1]
retval.posCVc = [0, 0, 100] #[0,-100,0]
return retval
def display_axes(vectorField,
preprocessor,
setToDisplay=None,
vectorScale=1.0,
viewDef=vtk_graphic_base.CameraParameters("XYZPos", 1.0),
caption='',
fileName=None,
defFScale=0.0):
'''vector field display of the loads applied to the chosen set of elements in the load case passed as parameter
:param vectorField: function that generates the vector field.
:param setToDisplay: set of elements to be displayed (defaults to total set)
:param vectorScale: factor to apply to the vectors length in the
representation.
:param viewDef: camera parameters.
:param fileName: full name of the graphic file to generate. Defaults to
`None`, in this case it returns a console output graphic.
:param caption: text to display in the graphic
: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)
'''
defDisplay = vtk_FE_graphic.RecordDefDisplayEF()
defDisplay.setupGrid(setToDisplay)
defDisplay.cameraParameters = viewDef
defDisplay.defineMeshScene(None, defFScale)
vectorField.addToDisplay(defDisplay)
defDisplay.displayScene(caption, fileName)
return defDisplay
def displayLocalAxes(self,setToDisplay=None,vectorScale=1.0,viewDef= vtk_graphic_base.CameraParameters('XYZPos'), caption= '',fileName=None,defFScale=0.0):
'''vector field display of the loads applied to the chosen set of elements in the load case passed as parameter
:param setToDisplay: set of elements to be displayed (defaults to total set)
:param vectorScale: factor to apply to the vectors length in the representation
:param viewDef: parameters that define the view to use
predefined view names: 'XYZPos','XNeg','XPos','YNeg','YPos',
'ZNeg','ZPos'
:param fileName: full name of the graphic file to generate. Defaults to `None`, in this case it returns a console output graphic.
:param caption: text to display in the graphic
: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.getPreprocessor().getSets.getSet('total')
setToDisplay.fillDownwards()
lmsg.warning('set to display not defined; using total set.')
defDisplay= vtk_FE_graphic.RecordDefDisplayEF()
defDisplay.setupGrid(setToDisplay)
if setToDisplay.color.Norm()==0:
setToDisplay.color=xc.Vector([rd.random(),rd.random(),rd.random()])
vField=lavf.LocalAxesVectorField(setToDisplay.name+'_localAxes',vectorScale)
vField.dumpVectors(setToDisplay)
defDisplay.cameraParameters= viewDef
defDisplay.defineMeshScene(None,defFScale,color=setToDisplay.color)
vField.addToDisplay(defDisplay)
defDisplay.displayScene(caption,fileName)
return defDisplay
def display_local_axes(prep,
setToDisplay=None,
vectorScale=1.0,
viewDef=vtk_graphic_base.CameraParameters(
"XYZPos", 1.0),
caption='',
fileName=None,
defFScale=0.0):
'''vector field display of the loads applied to the chosen set of elements in the load case passed as parameter
:param setToDisplay: set of elements to be displayed (defaults to total set)
:param vectorScale: factor to apply to the vectors length in the
representation.
:param viewDef: camera parameters.
:param fileName: full name of the graphic file to generate.
Defaults to `None`, in this case it returns a console output graphic.
:param caption: text to display in the graphic
: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)
'''
setToDisplay = checkSetToDisp(prep, setToDisplay)
vField = lavf.LocalAxesVectorField(setToDisplay.name + '_localAxes',
vectorScale)
vField.dumpVectors(setToDisplay)
return display_axes(vField, prep, setToDisplay, vectorScale, viewDef,
caption, fileName, defFScale)
def display_strong_weak_axis(preprocessor,
setToDisplay=None,
vectorScale=1.0,
viewDef=vtk_graphic_base.CameraParameters(
"XYZPos", 1.0),
caption='',
fileName=None,
defFScale=0.0):
'''vector field display of the loads applied to the chosen set of elements
in the load case passed as parameter
:param setToDisplay: set of elements to be displayed (defaults to total set)
:param vectorScale: factor to apply to the vectors length in the
representation.
:param viewDef: camera parameters.
:param fileName: full name of the graphic file to generate. Defaults to
`None`, in this case it returns a console output graphic.
:param caption: text to display in the graphic
: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 = preprocessor.getSets.getSet('total')
setToDisplay.fillDownwards()
lmsg.warning('set to display not defined; using total set.')
vField = lavf.StrongWeakAxisVectorField(
setToDisplay.name + '_strongWeakAxis', vectorScale)
vField.dumpVectors(setToDisplay)
return display_axes(vField, preprocessor, setToDisplay, vectorScale,
viewDef, caption, fileName, defFScale)
def displayEigenvectors(
self,
mode=1,
setToDisplay=None,
fConvUnits=1.0,
scaleFactor=1.0,
viewDef=vtk_graphic_base.CameraParameters('XYZPos'),
fileName=None,
defFScale=0.0):
self.checkSetToDisp(setToDisplay)
preprocessor = setToDisplay.getPreprocessor
#auto-scale
LrefModSize = self.xcSet.getBnd(1.0).diagonal.getModulus(
) #representative length of set size (to autoscale)
maxAbs = 0.0
dispPairs = list()
rotPairs = list()
threshold = LrefModSize / 1000.0
for n in self.xcSet.nodes:
disp3d = n.getEigenvectorDisp3dComponents(mode)
rot3d = n.getEigenvectorRot3dComponents(mode)
modDisp3d = disp3d.getModulus()
if (modDisp3d > threshold):
p = n.getCurrentPos3d(defFScale)
dispPairs.append(([p.x, p.y,
p.z], [disp3d.x, disp3d.y, disp3d.z]))
modRot3d = rot3d.getModulus()
if (modRot3d > threshold):
p = n.getCurrentPos3d(defFScale)
rotPairs.append(([p.x, p.y, p.z], [rot3d.x, rot3d.y, rot3d.z]))
modR = max(modDisp3d, modRot3d)
if (modR > maxAbs):
maxAbs = modR
if maxAbs > 0:
scaleFactor *= 0.15 * LrefModSize / (maxAbs * fConvUnits)
#
caption = 'Mode ' + str(
mode) + ' eigenvectors' + ' ' + self.xcSet.description
vFieldD = vf.VectorField(name='Deigenvectors',
fUnitConv=fConvUnits,
scaleFactor=scaleFactor,
showPushing=True,
symType=vtk.vtkArrowSource()) #Force
vFieldR = vf.VectorField(name='Reigenvectors',
fUnitConv=fConvUnits,
scaleFactor=scaleFactor,
showPushing=True,
symType=vtk.vtkArrowSource())
vFieldD.populateFromPairList(dispPairs)
vFieldR.populateFromPairList(rotPairs)
defDisplay = self.getDisplay(viewDef)
defDisplay.setupGrid(self.xcSet)
defDisplay.defineMeshScene(None, defFScale, color=self.xcSet.color)
if (len(dispPairs) > 0):
vFieldD.addToDisplay(defDisplay)
if (len(rotPairs) > 0):
vFieldR.addToDisplay(defDisplay, 'V')
defDisplay.displayScene(caption, fileName)
def displayIntForc(self,
itemToDisp='',
setToDisplay=None,
fConvUnits=1.0,
unitDescription='',
viewDef=vtk_graphic_base.CameraParameters('XYZPos'),
fileName=None,
defFScale=0.0):
'''displays the component of internal forces in the
set of entities as a scalar field (i.e. appropiated for 2D elements;
shells...).
:param itemToDisp: component of the internal forces ('N1', 'N2', 'N12',
'M1', 'M2', 'M12', 'Q1', 'Q2') to be depicted
:param setToDisplay: set of entities to be represented (default to all
entities)
:param fConvUnits: factor of conversion to be applied to the results
(defalts to 1)
:param unitDescription: string like '[kN/m] or [kN m/m]'
:param viewDef: camera parameters.
: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):
self.xcSet = setToDisplay
else:
lmsg.warning(
'QuickGraphics::displayIntForc; set to display not defined; using previously defined set (total if None).'
)
vCompDisp = self.getIntForceComponentFromName(itemToDisp)
elSet = self.xcSet.getElements.pickElemsOfDimension(2)
if (len(elSet) > 0):
propName = 'propToDisp_' + str(itemToDisp)
for e in elSet:
if (e.getDimension == 2):
e.getResistingForce()
mat = e.getPhysicalProperties.getVectorMaterials
e.setProp(propName,
mat.getMeanGeneralizedStressByName(vCompDisp))
else:
lmsg.warning(
'QuickGraphics::displayIntForc; not a 2D element; ignored.'
)
field = Fields.ExtrapolatedProperty(propName,
"getProp",
self.xcSet,
fUnitConv=fConvUnits)
defDisplay = self.getDisplay(viewDef)
field.display(defDisplay=defDisplay,
fName=fileName,
caption=self.loadCaseName + ' ' + itemToDisp + ' ' +
unitDescription + ' ' + self.xcSet.description,
defFScale=defFScale)
def displayReactions(self,
setToDisplay=None,
fConvUnits=1.0,
scaleFactor=1.0,
unitDescription='',
viewDef=vtk_graphic_base.CameraParameters('XYZPos'),
fileName=None,
defFScale=0.0):
self.checkSetToDisp(setToDisplay)
preprocessor = setToDisplay.getPreprocessor
preprocessor.getNodeHandler.calculateNodalReactions(True, 1e-7)
#auto-scale
LrefModSize = self.xcSet.getBnd(1.0).diagonal.getModulus(
) #representative length of set size (to autoscale)
maxAbs = 0.0
forcePairs = list()
momentPairs = list()
threshold = LrefModSize / 1000.0
for n in self.xcSet.nodes:
f3d = n.getReactionForce3d
m3d = n.getReactionMoment3d
modF3d = f3d.getModulus()
if (modF3d > threshold):
p = n.getCurrentPos3d(defFScale)
forcePairs.append(([p.x, p.y, p.z], [f3d.x, f3d.y, f3d.z]))
modM3d = m3d.getModulus()
if (modM3d > threshold):
p = n.getCurrentPos3d(defFScale)
momentPairs.append(([p.x, p.y, p.z], [m3d.x, m3d.y, m3d.z]))
modR = max(modF3d, modF3d)
if (modR > maxAbs):
maxAbs = modR
if (maxAbs > 0):
scaleFactor *= 0.15 * LrefModSize / (maxAbs * fConvUnits)
#
caption = self.loadCaseName + ' Reactions' + ' ' + unitDescription + ' ' + self.xcSet.description
vFieldF = vf.VectorField(name='Freact',
fUnitConv=fConvUnits,
scaleFactor=scaleFactor,
showPushing=True,
symType=vtk.vtkArrowSource()) # Force
vFieldM = vf.VectorField(name='Mreact',
fUnitConv=fConvUnits,
scaleFactor=scaleFactor,
showPushing=True,
symType=vtk.vtkArrowSource()) # Moment
vFieldF.populateFromPairList(forcePairs)
vFieldM.populateFromPairList(momentPairs)
defDisplay = self.getDisplay(viewDef)
defDisplay.setupGrid(self.xcSet)
defDisplay.defineMeshScene(None, defFScale, color=self.xcSet.color)
if (len(forcePairs) > 0):
vFieldF.addToDisplay(defDisplay)
if (len(momentPairs) > 0):
vFieldM.addToDisplay(defDisplay, 'V')
defDisplay.displayScene(caption, fileName)
def displayDispRot(self,
itemToDisp='',
setToDisplay=None,
fConvUnits=1.0,
unitDescription='',
viewDef=vtk_graphic_base.CameraParameters(
'XYZPos', 1.0),
fileName=None,
defFScale=0.0,
rgMinMax=None):
'''displays the component of the displacement or rotations in the
set of entities.
:param itemToDisp: component of the displacement ('uX', 'uY' or 'uZ')
or the rotation ('rotX', rotY', 'rotZ') to be depicted
:param setToDisplay: set of entities to be represented (defaults to all
entities)
:param fConvUnits: factor of conversion to be applied to the results
(defaults to 1)
:param unitDescription: string describing units like '[mm] or [cm]'
: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)
:param rgMinMax: range (vmin,vmax) with the maximum and minimum values of
the field to be represented. All the values less than vmin are
displayed in blue and those greater than vmax in red
(defaults to None)
'''
if (setToDisplay):
self.xcSet = setToDisplay
else:
lmsg.warning(
'QuickGraphics::displayDispRot; set to display not defined; using previously defined set (total if None).'
)
vCompDisp = self.getDispComponentFromName(itemToDisp)
nodSet = self.xcSet.getNodes
for n in nodSet:
n.setProp('propToDisp', n.getDisp[vCompDisp])
field = Fields.ScalarField(name='propToDisp',
functionName="getProp",
component=None,
fUnitConv=fConvUnits,
rgMinMax=rgMinMax)
defDisplay = self.getDisplay(viewDef)
defDisplay.displayMesh(xcSets=self.xcSet,
field=field,
diagrams=None,
fName=fileName,
caption=self.loadCaseName + ' ' + itemToDisp +
' ' + unitDescription + ' ' +
self.xcSet.description,
defFScale=defFScale)
def getDisplay(self,
wmDef=vtk_graphic_base.CameraParameters('XYZPos', 1.0)):
'''Returns a suitable display to show the graphics.
:param vwDef: camera parameters.
'''
defDisplay = vtk_FE_graphic.RecordDefDisplayEF()
defDisplay.cameraParameters = wmDef
return defDisplay
def displayFieldDirs1and2Base(
limitStateLabel,
argument,
elementSet,
genDescr,
sectDescr,
component,
fUnitConv,
captionTexts,
fileName,
defFScale=0.0,
viewDef=vtk_graphic_base.CameraParameters('XYZPos'),
rgMinMax=None):
'''Display a field defined over bi-dimensional elements in its two directions.
:param limitStateLabel: label that identifies the limit state.
:param argument: name of the control var to represent.
:param xcSet: represent the field over those elements.
:param genDescr: text to identify the set (i.e 'deck' or 'west wall').
:param sectDescr: text list to identify each direction (as ['vertical reinforcement', 'horizontal reinforcement']).
:param component: component of the control var to represent.
:param fUnitConv: unit conversion factor (i.e N->kN => fUnitConv= 1e-3).
:param captionTexts: dictionary of caption texts.
:param fileName: file name to store the image. If none -> window on screen.
: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)
:param viewDef: camera parameters (position, orientation,...)
:param rgMinMax: range (vmin,vmax) with the maximum and minimum values
of the scalar field (if any) to be represented. All the values
less than vmin are displayed in blue and those greater than vmax
in red (defaults to None)
'''
defDisplay = vtk_FE_graphic.RecordDefDisplayEF()
defDisplay.cameraParameters = viewDef
attributeName = limitStateLabel + 'Sect1' #Normal stresses limit state direction 1.
field = Fields.getScalarFieldFromControlVar(attributeName, argument,
elementSet, component,
fUnitConv, rgMinMax)
captionBaseText = captionTexts[limitStateLabel] + ', ' + captionTexts[
argument] + '. ' + genDescr.capitalize()
field.display(defDisplay,
caption=captionBaseText + ', ' + sectDescr[0],
fileName=fileName,
defFScale=defFScale)
attributeName = limitStateLabel + 'Sect2' #Normal stresses limit state direction 2
field = Fields.getScalarFieldFromControlVar(attributeName, argument,
elementSet, component,
fUnitConv, rgMinMax)
field.display(defDisplay,
caption=captionBaseText + ', ' + sectDescr[1],
fileName=fileName,
defFScale=defFScale)
def __init__(self, loadCaseName, loadCaseDescr, loadCaseExpr,
setsToDispLoads, setsToDispDspRot, setsToDispIntForc):
super(RecordLoadCaseDisp, self).__init__()
self.loadCaseName = loadCaseName
self.loadCaseDescr = loadCaseDescr
self.loadCaseExpr = loadCaseExpr
self.setsToDispLoads = setsToDispLoads
self.setsToDispBeamLoads = []
self.compElLoad = 'transComponent'
self.multByElemAreaLoads = False
self.listDspRot = ['uX', 'uY', 'uZ']
self.setsToDispDspRot = setsToDispDspRot
self.listIntForc = ['N1', 'N2', 'M1', 'M2', 'Q1', 'Q2']
self.setsToDispIntForc = setsToDispIntForc
self.listBeamIntForc = ['N', 'My', 'Mz', 'Qy', 'Qz', 'T']
self.setsToDispBeamIntForc = []
self.cameraParameters = vtk_graphic_base.CameraParameters('XYZPos')
self.cameraParametersBeams = vtk_graphic_base.CameraParameters(
'XYZPos')
def display_beam_result(attributeName,
itemToDisp,
beamSetDispRes,
setToDisplay=None,
fConvUnits=1.0,
scaleFactor=1.0,
caption=None,
viewDef=vtk_graphic_base.CameraParameters('XYZPos'),
fileName=None,
defFScale=0.0):
'''display results for beam elements from a limit state verification file.
:param attributeName:attribute name(e.g. 'ULS_normalStressesResistance')
:param itemToDisp: result item to display (e.g. 'N', 'My', ...)
:param beamSetDispRes:set of linear elements to which display results
:param setToDisplay: set of elements (any type) to be depicted
(defaults to None, in that case only elements in beamSetDispRes
are displayed)
:param fConvUnits: factor of conversion to be applied to the results
(defaults to 1)
:param scaleFactor: factor of scale to apply to the auto-scaled display
(defaults to 1)
:param caption: caption to display
(defaults to 'attributeName + itemToDisp')
:param viewDef: instance of class CameraParameters
(defaults to 'XYZPos')
:param fileName: file to dump the display (defaults to screen display)
: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)
'''
#auto-scale parameters
LrefModSize = setToDisplay.getBnd(1.0).diagonal.getModulo(
) #representative length of set size (to autoscale)
lstArgVal = [
e.getProp(attributeName + 'Sect1')(itemToDisp)
for e in beamSetDispRes.getElements
]
maxAbs = max(abs(max(lstArgVal)), abs(min(lstArgVal)))
if maxAbs > 0:
scaleFactor *= 0.15 * LrefModSize / (maxAbs * fConvUnits)
if not setToDisplay:
setToDisplay = beamSetDispRes
if not caption:
if hasattr(beamSetDispRes, 'description'):
descrSet = beamSetDispRes.description.capitalize()
else:
descrSet = ''
caption = attributeName + ', ' + itemToDisp + '. ' + descrSet
display_diagram(scaleFactor, fConvUnits, beamSetDispRes, setToDisplay,
attributeName, itemToDisp, caption, viewDef, defFScale,
fileName)
def displayIntForcDiag(self,
itemToDisp='',
setToDisplay=None,
fConvUnits=1.0,
scaleFactor=1.0,
unitDescription='',
viewDef=vtk_graphic_base.CameraParameters('XYZPos'),
fileName=None,
defFScale=0.0):
'''displays the component of internal forces in the set of entities as a
diagram over lines (i.e. appropiated for beam elements).
:param itemToDisp: component of the internal forces
('N', 'Qy' (or 'Vy'), 'Qz' (or 'Vz'), 'My', 'Mz', 'T') to be depicted
:param setToDisplay: set of entities (elements of type beam) to be
represented
:param fConvUnits: factor of conversion to be applied to the results
(defaults to 1)
:param scaleFactor: factor of scale to apply to the diagram display
:param unitDescription: string like '[kN/m] or [kN m/m]'
:param vwDef: camera parameters.
: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)
'''
self.checkSetToDisp(setToDisplay)
#auto-scale parameters
LrefModSize = self.xcSet.getBnd(1.0).diagonal.getModulus(
) #representative length of set size (to autoscale)
diagAux = cvd.ControlVarDiagram(scaleFactor=scaleFactor,
fUnitConv=fConvUnits,
sets=[self.xcSet],
attributeName="intForce",
component=itemToDisp)
maxAbs = diagAux.getMaxAbsComp()
if maxAbs > 0:
scaleFactor *= 0.15 * LrefModSize / (maxAbs * fConvUnits)
#
caption = self.loadCaseName + ' ' + itemToDisp + ' ' + unitDescription + ' ' + self.xcSet.description
display_diagram(scaleFactor=scaleFactor,
fConvUnits=fConvUnits,
setToDispRes=self.xcSet,
setDisp=self.xcSet,
attributeName="intForce",
component=itemToDisp,
caption=caption,
viewDef=viewDef,
defFScale=defFScale,
fileName=fileName)
def display_load(preprocessor,
setToDisplay=None,
loadCaseNm='',
unitsScale=1.0,
vectorScale=1.0,
multByElemArea=False,
viewDef=vtk_graphic_base.CameraParameters("XYZPos", 1.0),
caption='',
fileName=None,
defFScale=0.0):
'''vector field display of the loads applied to the chosen set of elements in the load case passed as parameter
:param setToDisplay: set of elements to be displayed (defaults to total set)
:param loadCaseNm: name of the load case to be depicted
:param unitsScale: factor to apply to the results if we want to change the
unit system.
:param vectorScale: factor to apply to the vectors length in the
representation
:param multByElemArea: boolean value that must be `True` if we want to
represent the total load on each element (=load multiplied by
element area) and `False` if we are going to depict the value of
the uniform load per unit area
:param viewDef: camera parameters.
:param fileName: full name of the graphic file to generate. Defaults to
` None`, in this case it returns a console output graphic.
:param caption: text to display in the graphic
: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 = preprocessor.getSets.getSet('total')
setToDisplay.fillDownwards()
lmsg.warning('set to display not defined; using total set.')
LrefModSize = setToDisplay.getBnd(1.0).diagonal.getModulo(
) #representative length of set size (to auto-scale)
vectorScale *= LrefModSize / 10.
if setToDisplay.color.Norm() == 0:
setToDisplay.color = xc.Vector([rd.random(), rd.random(), rd.random()])
defDisplay = vtk_FE_graphic.RecordDefDisplayEF()
defDisplay.setupGrid(setToDisplay)
vField = lvf.LoadVectorField(loadCaseNm, unitsScale, vectorScale)
vField.multiplyByElementArea = multByElemArea
vField.dumpLoads(preprocessor, defFScale)
defDisplay.cameraParameters = viewDef
defDisplay.defineMeshScene(None, defFScale, color=setToDisplay.color)
vField.addToDisplay(defDisplay)
defDisplay.displayScene(caption, fileName)
return defDisplay
def displayNodeValueDiagram(
self,
itemToDisp='',
setToDisplay=None,
fConvUnits=1.0,
scaleFactor=1.0,
unitDescription='',
viewDef=vtk_graphic_base.CameraParameters('XYZPos'),
fileName=None,
defFScale=0.0):
'''displays the a displacement (uX,uY,...) or a property defined in nodes
as a diagram over lines (i.e. appropiated for beam elements).
:param itemToDisp: item to display.
:param setToDisplay: set of entities (elements of type beam) to be
represented
:param fConvUnits: factor of conversion to be applied to the results
(defalts to 1)
:param scaleFactor: factor of scale to apply to the diagram display of
:param unitDescription: string like '[m]' or '[rad]' or '[m/s2]'
:param viewDef: camera parameters.
: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):
self.xcSet = setToDisplay
if self.xcSet.color.Norm() == 0:
self.xcSet.color = xc.Vector(
[rd.random(), rd.random(),
rd.random()])
else:
lmsg.warning(
'QuickGraphics::displayNodeValueDiagram; set to display not defined; using previously defined set (total if None).'
)
diagram = npd.NodePropertyDiagram(scaleFactor=scaleFactor,
fUnitConv=fConvUnits,
sets=[self.xcSet],
attributeName=itemToDisp)
diagram.addDiagram()
defDisplay = self.getDisplay(viewDef)
defDisplay.setupGrid(self.xcSet)
defDisplay.defineMeshScene(None, defFScale, color=self.xcSet.color)
defDisplay.appendDiagram(diagram) #Append diagram to the scene.
caption = self.loadCaseName + ' ' + itemToDisp + ' ' + unitDescription + ' ' + self.xcSet.description
defDisplay.displayScene(caption=caption, fName=fileName)
def FEmeshGraphic(self,xcSet,caption= '',cameraParameters= vtk_graphic_base.CameraParameters('XYZPos'),defFScale=0.0):
''' Graphic of the FE mesh
:param xcSet: XC set of elements to be displayed
:param caption: text to write in the graphic
:param cameraParameters: camera parameters (position, orientation,...).
: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)
'''
self.cameraParameters= cameraParameters
self.setupGrid(xcSet)
self.displayGrid(caption)
def FEmeshGraphic(self,setToDisplay,caption= '',cameraParameters= vtk_graphic_base.CameraParameters('XYZPos'),defFScale=0.0):
''' Graphic of the FE mesh
:param setToDisplay: XC set of elements to be displayed
:param caption: text to write in the graphic
:param cameraParameters: camera parameters (position, orientation,...).
: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)
'''
lmsg.warning('FEmeshGraphic DEPRECATED use displayFEMesh.')
self.cameraParameters= cameraParameters
self.displayFEMesh(setToDisplay,caption,defFScale)
def displayLocalAxes(self,xcSet,caption= '',cameraParameters= vtk_graphic_base.CameraParameters('XYZPos'), vectorScale=1.0):
'''vector field display of the loads applied to the chosen set of elements in the load case passed as parameter
:param xcSet: set of elements to be displayed (defaults to total set)
:param caption: text to display in the graphic
:param cameraParameters: camera parameters (position, orientation,...).
:param vectorScale: factor to apply to the vectors length in the representation
'''
self.cameraParameters= cameraParameters
self.setupGrid(xcSet)
vField=lavf.LocalAxesVectorField(xcSet.name+'_localAxes',vectorScale)
vField.dumpVectors(xcSet)
self.cameraParameters= cameraParameters
self.defineMeshScene(None)
vField.addToDisplay(self)
self.displayScene(caption)
def __init__(self,pLabel,limitStateLabel,figDescr,reinfDescr=None,units=None,sz= "90mm"):
''' Figure base constructor.
pLabel: part label; something like 'wall' or '2ndFloorDeck'
limitStateLabel; limit state check label; Something like "Fatigue" or "CrackControl"
figDescr: figure description; text to insert as caption in the figure file and int the LaTeX file.
units: units displayed; something like '[MPa]' or 'radians'...
reinfDescr: reinforcement description; sSomething like "horizontal reinforcement."
sz: LaTeX size for the figure.
'''
self.partLabel= pLabel #Something like 'wall' or '2ndFloorDeck'
self.limitStateLabel= limitStateLabel #Something like "Fatigue" or "CrackControl"
self.attributeName= ''
self.figDescription= figDescr #Text to insert as caption in the LaTeX file.
self.unitsLabel= units # Somethin like '[MPa]' or 'radians'...
self.reinforcementDescription= reinfDescr #Something like "horizontal reinforcement."
self.figSize= sz #LaTeX size for the figure.
self.cameraParameters= vtk_graphic_base.CameraParameters('XYZPos')
def displayMesh(self,partToDisplay,caption= '',viewDef= vtk_graphic_base.CameraParameters('XYZPos'),defFScale=0.0):
'''return a graphical representation of the mesh
:param partToDisplay: XC set of elements to be displayed
:param caption: text to write in the graphic
:param viewDef: parameters that define the view to use
predefined view names: 'XYZPos','XNeg','XPos','YNeg','YPos',
'ZNeg','ZPos'
: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)
'''
defDisplay= vtk_FE_graphic.RecordDefDisplayEF()
defDisplay.FEmeshGraphic(partToDisplay,caption,viewDef,defFScale)
return defDisplay
def displayFieldDirs1and2(limitStateLabel,
argument,
elementSet,
component,
fUnitConv,
captionTexts,
fileName,
defFScale=0.0,
viewDef=vtk_graphic_base.CameraParameters('XYZPos'),
rgMinMax=None):
'''Display a field defined over bi-dimensional elements in its two directions.
:param limitStateLabel: label that identifies the limit state.
:param argument: name of the control var to represent.
:param xcSet: represent the field over those elements with "genDescr" and "sectDescr" attributes.
:param component: component of the control var to represent.
:param fUnitConv: unit conversion factor (i.e N->kN => fUnitConv= 1e-3).
:param captionTexts: dictionary of caption texts.
:param fileName: file name to store the image. If none -> window on screen.
: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)
:param viewDef: camera parameters (position, orientation,...)
:param rgMinMax: range (vmin,vmax) with the maximum and minimum values
of the scalar field (if any) to be represented. All the values
less than vmin are displayed in blue and those greater than vmax
in red (defaults to None)
'''
# displayFieldDirs1and2Base(limitStateLabel,argument,elementSet,elementSet.description,elementSet.sectDescr,component,fUnitConv,captionTexts, fileName,defFScale=defFScale ) #21/07/2017 needs revision
displayFieldDirs1and2Base(limitStateLabel,
argument,
elementSet,
elementSet.description, ['dir. 1', 'dir. 2'],
component,
fUnitConv,
captionTexts,
fileName,
defFScale=defFScale,
viewDef=viewDef,
rgMinMax=rgMinMax)
def display_load(preprocessor,
setToDisplay=None,
loadCaseNm='',
unitsScale=1.0,
vectorScale=1.0,
multByElemArea=False,
viewDef=vtk_graphic_base.CameraParameters("XYZPos", 1.0),
caption='',
fileName=None,
defFScale=0.0):
'''vector field display of the loads applied to the chosen set of elements in the load case passed as parameter
:param setToDisplay: set of elements to be displayed (defaults to total set)
:param loadCaseNm: name of the load case to be depicted
:param unitsScale: factor to apply to the results if we want to change the
unit system.
:param vectorScale: factor to apply to the vectors length in the
representation
:param multByElemArea: boolean value that must be `True` if we want to
represent the total load on each element (=load multiplied by
element area) and `False` if we are going to depict the value of
the uniform load per unit area
:param viewDef: camera parameters.
:param fileName: full name of the graphic file to generate. Defaults to
` None`, in this case it returns a console output graphic.
:param caption: text to display in the graphic
: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)
'''
setToDisplay = checkSetToDisp(preprocessor, setToDisplay)
LrefModSize = setToDisplay.getBnd(1.0).diagonal.getModulus(
) #representative length of set size (to auto-scale)
vectorScale *= LrefModSize / 10.
vField = lvf.LoadVectorField(loadCaseNm, unitsScale, vectorScale)
vField.multiplyByElementArea = multByElemArea
display_vector_field(preprocessor, vField, setToDisplay, viewDef, caption,
fileName, defFScale)
cameraParametersBeams: parameters that define the position and orientation of the
camera for beam elements displays (defaults to "XYZPos")
'''
G1=graphical_reports.LoadCaseDispParameters(loadCaseName='GselfWeight',loadCaseDescr='G1: self weight',loadCaseExpr='1.0*GselfWeight',setsToDispLoads=[deck,found],setsToDispDspRot=[deck,found],setsToDispIntForc=[])
G1.unitsScaleLoads=1e-3
G1.unitsScaleDispl=1e3
G1.unitsDispl='[mm]'
G1.unitsScaleMom=1e-3
G1.unitsMom='[m.kN]'
G1.unitsScaleForc=1e-3
G1.unitsForc='[kN]'
G1.setsToDispBeamIntForc=[columnZ,beamX,beamY]
G1.listBeamIntForc=['My','Mz','Qy','Qz','N']
G1.cameraParameters= vtk_graphic_base.CameraParameters('XYZPos')
G1.setsToDispBeamLoads=[beamY]
G1.vectorScalePointLoads=0.005
G1.compElLoad='axialComponent'
Q1=graphical_reports.LoadCaseDispParameters(loadCaseName='Qdeck',loadCaseDescr='Q1: uniform load on the deck',loadCaseExpr='1.0*Qdeck',setsToDispLoads=[overallSet],setsToDispDspRot=[overallSet],setsToDispIntForc=[deck,found])
Q1.unitsScaleLoads=1e-3
Q1.unitsScaleDispl=1e3
Q1.unitsDispl='[mm]'
Q1.unitsScaleMom=1e-3
Q1.unitsMom='[m.kN]'
Q1.unitsScaleForc=1e-3
Q1.unitsForc='[kN]'
Q1.setsToDispBeamIntForc=[columnZ,beamX,beamY]
Q1.listBeamIntForc=['My','Mz','Qy','Qz','N']
#Load properties to display:
preprocessor= model.getPreprocessor()
fName= cfg.projectDirTree.getVerifCrackQpermFile()
execfile(fName)
execfile('../captionTexts.py')
limitStateLabel= lsd.quasiPermanentLoadsCrackControl.label
#Possible arguments: 'getCF', 'getMaxSteelStress'
argument= 'getMaxSteelStress'
setDispRes=colsSet #set of linear elements to which display results
setDisp=xcTotalSet #set of elements (any type) to be displayed
diagram= cvd.ControlVarDiagram(scaleFactor= 1,fUnitConv= 1,sets=[setDispRes.elSet],attributeName= limitStateLabel,component= argument)
diagram.addDiagram()
displaySettings= vtk_FE_graphic.DisplaySettingsFE()
#predefined view names: 'XYZPos','XNeg','XPos','YNeg','YPos',
# 'ZNeg','ZPos' (defaults to 'XYZPos')
displaySettings.cameraParameters= vtk_graphic_base.CameraParameters('YPos') #Point of view.
displaySettings.setupGrid(setDisp.elSet)
displaySettings.defineMeshScene(None)
displaySettings.appendDiagram(diagram) #Append diagram to the scene.
caption= capTexts[limitStateLabel] + ', ' + capTexts[argument] + '. '+ setDispRes.genDescr.capitalize() + ', ' + setDispRes.sectDescr[0]
displaySettings.displayScene(caption)
G1 = graphical_reports.LoadCaseDispParameters(loadCaseName='lcase01',
loadCaseDescr='G1: self weight',
loadCaseExpr='1.0*lcase01',
setsToDispLoads=[],
setsToDispDspRot=[beamSet],
setsToDispIntForc=[])
G1.unitsScaleLoads = 1e-3
G1.unitsScaleDispl = 1e3
G1.unitsDispl = '[mm]'
G1.unitsScaleMom = 1e-3
G1.unitsMom = '[m.kN]'
G1.unitsScaleForc = 1e-3
G1.unitsForc = '[kN]'
G1.setsToDispBeamIntForc = [beamSet]
G1.listBeamIntForc = ['My', 'Mz', 'Qy', 'Qz', 'N']
G1.cameraParameters = vtk_graphic_base.CameraParameters('XYZPos')
G1.setsToDispBeamLoads = [beamSet]
G1.vectorScalePointLoads = 0.005
G1.compElLoad = 'axialComponent'
G2 = graphical_reports.LoadCaseDispParameters(loadCaseName='lcase02',
loadCaseDescr='G2: self weight',
loadCaseExpr='1.0*lcase02',
setsToDispLoads=[],
setsToDispDspRot=[beamSet],
setsToDispIntForc=[])
G2.unitsScaleLoads = 1e-3
G2.unitsScaleDispl = 1e3
G2.unitsDispl = '[mm]'
G2.unitsScaleMom = 1e-3
G2.unitsMom = '[m.kN]'
diag10.sectionArea= diagArea
diag11= elements.newElement("CorotTruss",xc.ID([11,12]))
diag11.sectionArea= diagArea
diag12= elements.newElement("CorotTruss",xc.ID([10,12]))
diag12.sectionArea= diagArea
diag13= elements.newElement("CorotTruss",xc.ID([1,7]))
diag13.sectionArea= diagArea
# Displaying of the mesh
from postprocess.xcVtk.FE_model import vtk_FE_graphic
from postprocess.xcVtk import vtk_graphic_base
displaySettings= vtk_FE_graphic.DisplaySettingsFE()
totalSet= prep.getSets.getSet('total')
displaySettings.FEmeshGraphic(xcSet=totalSet,caption= 'All elements',cameraParameters= vtk_graphic_base.CameraParameters('XYZPos'))
quit()
# Plotting of CAD entities
# from postprocess.xcVtk.CAD_model import vtk_CAD_graphic
# displaySettings= vtk_CAD_graphic.DisplaySettingsBlockTopo()
# totalSet= prep.getSets.getSet('total')
# displaySettings.displayBlocks(setToDisplay=totalSet,caption= 'Model grid')
# Seed element for struts
seedElemHandler= prep.getElementHandler.seedElemHandler
seedElemHandler.defaultMaterial= "strutMat"
seedElemHandler.dimElem= 3
seedElemHandler.defaultTag= 1
strutTruss= seedElemHandler.newElement("CorotTruss",xc.ID([0,0]))
# -*- coding: utf-8 -*-
from postprocess.reports import graphical_reports as gr
from postprocess.xcVtk import vtk_graphic_base
from postprocess.xcVtk.FE_model import quick_graphics as qg
execfile('./cantilever_mesh_generation.py')
#available components: 'axialComponent', 'transComponent', 'transYComponent',
# 'transZComponent'
rlcd = gr.getRecordLoadCaseDispFromLoadPattern(lp0)
rlcd.cameraParameters = vtk_graphic_base.CameraParameters('Custom')
rlcd.cameraParameters.viewUpVc = [0, 1, 0]
rlcd.cameraParameters.posCVc = [-100, 100, 100]
loadCasesToDisplay = [rlcd]
#End data
for lc in loadCasesToDisplay:
for st in lc.setsToDispLoads:
# capt=lc.loadCaseDescr + ', ' + st.genDescr + ', ' + lc.unitsLoads
capt = lc.loadCaseDescr + ', ' + lc.unitsLoads
qg.displayLoad(preprocessor,
setToDisplay=st,
loadCaseNm=lc.loadCaseName,
unitsScale=lc.unitsScaleLoads,
vectorScale=lc.vectorScaleLoads,
multByElemArea=lc.multByElemAreaLoads,
viewDef=lc.cameraParameters,
