def exportExt(scene,mIds,vtkDir,t):
Omega().stringToScene(scene)
mIntrs=export.VTKExporter(vtkDir+'ext_')
mIntrs.exportInteractions(
numLabel=t,
ids=[(i,j) for i,j in zip(mIds[:-1],mIds[1:])],
what=[('Tlimit','i.phys.normalForce.norm()/i.phys.normalAdhesion'),
])
def vtkExport(i):
base = '/tmp/multi1_yade_{:02d}'
from yade import export
for rvei in xrange(nREVs):
O.switchToScene(rvei)
name = base.format(rvei)
export.VTKExporter(name,
i).exportSpheres(useRef=True,
what=[('dspl', 'b.state.displ()')])
def exportInt(params):
scene = params[0]; vtkDir = params[1]; t = params[2]
Omega().stringToScene(scene)
pos = Omega().tags['id']
sIntrs = export.VTKExporter(vtkDir+'int_'+pos)
sIntrs.exportInteractions(
numLabel=t,
what=[('f_n','i.phys.normalForce.norm()'),
('f_s','i.phys.shearForce.norm()'),
])
def microstresses():
s = utils.bodyStressTensors()
TW = TesselationWrapper()
TW.triangulate()
TW.computeVolumes()
for b in O.bodies:
if type(b.shape) == Sphere:
b.microstresses = s[
b.id] * 4. * pi / 3. * b.shape.radius**3 / TW.volume(b.id)
b.TWvolume = TW.volume(b.id)
b.cc = b.shape.color[
0] + 0.5 * b.shape.color[1] + 2. * b.shape.color[2]
vtkExporter = export.VTKExporter(OUT + '_microstresses_' + str(O.iter))
vtkExporter.exportSpheres(what=[(
'TWvolume',
'b.TWvolume'), ('microstresses',
'b.microstresses'), ('young',
'b.mat.young'), ('color',
'b.cc')])
sorption.bodySat[bIndex] += sorption.incBodySorp[bIndex]/(0.8594*sorption.bodyMass0[bIndex])
s= sorption.bodySat[bIndex]
#
mult= (2.65*s + 1.08)/(2.65*s_previous + 1.08)
utils.growParticle(b, multiplier=mult, updateMass=False)
'''
flow.meshUpdateInterval = 100000
#bodyHeat.bodyTemp[-2]=150.
#bodyHeat.isoThermalList.append(4)
#
# saving results - missing temperature in the gas
vtkExporter = export.VTKExporter('vtkExporterTesting')
vtkExporter.exportSpheres(
what=[('pos', 'b.state.pos'), ('radius', 'b.shape.radius'),
('temp', 'bodyHeat.bodyTemp[bodyHeat.heatBodies.index(b.id)]')])
flow.saveVtk()
#
fileNr = 0
with open('VTK/out_' + str(fileNr) + '.vtk', 'a') as fTemp:
#fTemp.write('CELL_DATA 286')
fTemp.write('SCALARS Temperature float 1\n')
fTemp.write('LOOKUP_TABLE default\n')
vtkID = 0
for i in range(len(cellHeat.cellTemp)):
if flow.isDrawable(i):
fTemp.write(str(float(cellHeat.cellTemp[i])) + '\n')
vtkID += 1
def vtkExport(i):
from yade import export
name = '/tmp/vol1_yade'
export.VTKExporter(name,i).exportSpheres(what=[('dmg','b.state.normDmg if isinstance(b.state,CpmState) else 0')])
export.VTKExporter(name,i).exportInteractions()
def eraseFallenParticles():
for b in O.bodies:
if sqrt(b.state.pos[0]**2 + b.state.pos[1]**2) > 2 * length:
O.bodies.erase(b.id)
O.engines = O.engines + [
PyRunner(iterPeriod=500,
command='eraseFallenParticles()',
dead=True,
label='eFP')
]
# ────────────────────────────────────────────────────────────────────────────────────────────────────────── #
if recordVTK:
# Take snapshots
# O.engines=O.engines+[SnapshotEngine(iterPeriod=100,fileBase='vtk/jenga-',firstIterRun=10,label='snapshooter')]
# Export VTK results
from yade import export
vtkExporter = export.VTKExporter('./vtk/jengaTowerExample')
def vtkExport():
vtkExporter.exportPotentialBlocks(what=dict(n='b.id'))
O.engines = O.engines + [PyRunner(iterPeriod=500, command='vtkExport()')]
# ────────────────────────────────────────────────────────────────────────────────────────────────────────── #
O.saveTmp()
O.run()
def vtkExport(i):
name = '/tmp/surf7_yade'
from yade import export
export.VTKExporter(name, i).exportFacets()
export.VTKExporter(name, i).exportPolyhedra()
from yade import ymport, export
f, n, e = ymport.unv('shell.unv', returnElementMap=True)
O.bodies.append(f)
vtk = export.VTKExporter('test')
vtk.exportFacetsAsMesh(elements=e)
))
O.bodies[-1].state.pos = (-2, -2, -2)
O.bodies[-1].state.ori = Quaternion((1, 1, 2), 1)
O.bodies[-2].state.pos = (-2, -2, 3)
O.bodies[-2].state.ori = Quaternion((1, 2, 0), 1)
O.step()
O.bodies.append((
sphere((0, 0, 0), 1),
sphere((0, 3, 0), 1),
sphere((0, 2, 4), 2),
sphere((0, 5, 2), 1.5),
facet([Vector3(0, -3, -1),
Vector3(0, -2, 5),
Vector3(5, 4, 0)]),
facet([Vector3(0, -3, -1),
Vector3(0, -2, 5),
Vector3(-5, 4, 0)]),
))
for i, j in ((0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)):
createInteraction(i + 2, j + 2)
vtkExporter = export.VTKExporter('/tmp/vtkExporterTesting')
vtkExporter.exportSpheres(what=dict(dist='b.state.pos.norm()'))
vtkExporter.exportFacets(what={'pos': 'b.state.pos'})
vtkExporter.exportInteractions(what=dict(kn='i.phys.kn'))
vtkExporter.exportContactPoints(what={'nn': 'i.geom.normal'})
vtkExporter.exportPolyhedra(what=dict(n='b.id'))
s.shape.color = (1, 0, 0)
bot.append(s)
elif z > dimz - bcCoeff * radius:
s.state.blockedDOFs = 'zXYZ'
s.shape.color = (0, 1, 0)
top.append(s)
else:
s.shape.color = (0, 0, 1)
O.bodies.append(sphs)
O.dt = .5 * PWaveTimeStep()
O.step()
bo1.aabbEnlargeFactor = 1.
ig2.interactionDetectionFactor = 1.
vtk = export.VTKExporter(outBase)
def vtkExport():
vtk.exportSpheres(useRef=True,
what=[('dmg', 'b.state.normDmg'),
('dspl', 'b.state.displ()')])
def plotAddData():
dimx, dimy, dimz = size
area = dimx * dimy
dspl = 2 * top[0].state.displ()[2]
strain = dspl / dimz
stress = averageStress()[2, 2]
dmgTensor = averageDamageTensor()
def vtkExport(i):
name = '/tmp/contact1_yade'
from yade import export
export.VTKExporter(name, i).exportPolyhedra()
######################################################################
# Simple script to test VTK export of periodic cell
######################################################################
# enable periodic cell
O.periodic = True
# insert some bodies
sp = randomPeriPack(radius=1,
initSize=(10, 20, 30),
memoizeDb='/tmp/vtkPeriodicCell.sqlite')
sp.toSimulation()
# transform the cell a bit
O.cell.hSize *= Matrix3(1, .1, .1, .1, 1, 0, .1, 0,
1) # skew the cell in xy and xz plane
O.cell.hSize *= Matrix3(1, 0, 0, 0, .8, .6, 0, -.6,
.8) # rotate it along x axis
O.step()
# test of export.VTKExporter
from yade import export
vtk1 = export.VTKExporter('/tmp/vtkPeriodicCell-VTKExporter')
vtk1.exportSpheres()
vtk1.exportPeriodicCell()
# test of VTKReorder
vtk2 = VTKRecorder(fileName='/tmp/vtkPeriodicCell-VTKRecorder-',
recorders=['spheres', 'pericell'])
vtk2() # do the export