rmin = rmin,
rmax = rmax,
xmin = xmin,
xmax = xmax,
theta = theta,
azimuthalOffsetFraction = azimuthalOffsetFraction,
nNodePerh = nPerh,
SPH = not asph)
if mpi.procs > 1:
from VoronoiDistributeNodes import distributeNodes2d
#from PeanoHilbertDistributeNodes import distributeNodes2d
else:
from DistributeNodes import distributeNodes2d
distributeNodes2d((nodes1, generator))
output("mpi.reduce(nodes1.numInternalNodes, mpi.MIN)")
output("mpi.reduce(nodes1.numInternalNodes, mpi.MAX)")
output("mpi.reduce(nodes1.numInternalNodes, mpi.SUM)")
# Set node specific thermal energies
nodes1.specificThermalEnergy(ScalarField("tmp", nodes1, eps0))
# Set node velocities
for nodeID in xrange(nodes1.numNodes):
vel[nodeID] = pos[nodeID].unitVector()*vr0
#-------------------------------------------------------------------------------
# Construct a DataBase to hold our node list
#-------------------------------------------------------------------------------
db = DataBase()
generatorInner = GenerateNodeDistribution2d(nx2,
ny2,
rho2,
distributionType="lattice",
xmin=(x1, y1),
xmax=(x2, y2),
nNodePerh=nPerh,
rejecter=EllipticalRejecter(
a, b, False),
SPH=not ASPH)
if mpi.procs > 1:
from VoronoiDistributeNodes import distributeNodes2d
else:
from DistributeNodes import distributeNodes2d
distributeNodes2d((outerNodes, generatorOuter), (innerNodes, generatorInner))
for nodes in nodeSet:
print nodes.name, ":"
output(" mpi.reduce(nodes.numInternalNodes, mpi.MIN)")
output(" mpi.reduce(nodes.numInternalNodes, mpi.MAX)")
output(" mpi.reduce(nodes.numInternalNodes, mpi.SUM)")
del nodes
# Set node specific thermal energies
for (nodes, gamma, rho, P) in ((outerNodes, gamma1, rho1, P1),
(innerNodes, gamma2, rho2, P2)):
eps0 = P / ((gamma - 1.0) * rho)
nodes.specificThermalEnergy(ScalarField("tmp", nodes, eps0))
del nodes
vel = outerNodes.velocity()
int(0.5 * ny2 + 0.5),
rho=rho1,
distributionType="lattice",
xmin=(0.0, 0.75),
xmax=(1.0, 1.0),
nNodePerh=nPerh,
SPH=(not ASPH))
generator2 = CompositeNodeDistribution(generator21, generator22)
if mpi.procs > 1:
from VoronoiDistributeNodes import distributeNodes2d
else:
from DistributeNodes import distributeNodes2d
if numNodeLists == 2:
distributeNodes2d((nodes1, generator1), (nodes2, generator2))
else:
gen = CompositeNodeDistribution(generator1, generator2)
distributeNodes2d((nodes1, gen))
# Finish initial conditions.
rhom = 0.5 * (rho1 - rho2)
vxm = 0.5 * (vx1 - vx2)
if numNodeLists == 2:
for (nodes, vx) in ((nodes1, vx1), (nodes2, vx2)):
pos = nodes.positions()
vel = nodes.velocity()
rho = nodes.massDensity()
eps = nodes.specificThermalEnergy()
mass = nodes.mass()
for i in xrange(nodes.numInternalNodes):
SPH=SPH)
generatorBottom = GenerateNodeDistribution2d(nx3,
ny3,
rho3,
distributionType="lattice",
xmin=(x1, y0),
xmax=(x2, y1),
nNodePerh=nPerh,
SPH=SPH)
if mpi.procs > 1:
from VoronoiDistributeNodes import distributeNodes2d
else:
from DistributeNodes import distributeNodes2d
distributeNodes2d((leftNodes, generatorLeft), (topNodes, generatorTop),
(bottomNodes, generatorBottom))
for nodes in nodeSet:
print nodes.name, ":"
output(" mpi.reduce(nodes.numInternalNodes, mpi.MIN)")
output(" mpi.reduce(nodes.numInternalNodes, mpi.MAX)")
output(" mpi.reduce(nodes.numInternalNodes, mpi.SUM)")
del nodes
# Set node specific thermal energies
for (nodes, gamma, rho, P) in ((leftNodes, gamma1, rho1,
P1), (topNodes, gamma2, rho2, P2),
(bottomNodes, gamma3, rho3, P3)):
eps0 = P / ((gamma - 1.0) * rho)
nodes.specificThermalEnergy(ScalarField("tmp", nodes, eps0))
del nodes
rmax=rmax1,
nNodePerh=nPerh,
SPH=SPH))
gen2 = RZGenerator(
GenerateNodeDistribution2d(n2 + nrind,
n2,
rho2,
"constantDTheta",
xmin=(0.0, 0.0),
xmax=(rmax2, rmax2),
rmin=rmax1,
rmax=rmax2 + nrind * dr2,
nNodePerh=nPerh,
SPH=SPH))
distributeNodes2d((nodes1, gen1), (nodes2, gen2))
for n in nodeSet:
output("mpi.reduce(n.numInternalNodes, mpi.MIN)")
output("mpi.reduce(n.numInternalNodes, mpi.MAX)")
output("mpi.reduce(n.numInternalNodes, mpi.SUM)")
del n
# Set node specific thermal energies
for n, eps in ((nodes1, eps1), (nodes2, eps2)):
n.specificThermalEnergy(ScalarField("tmp", n, eps))
del n
#-------------------------------------------------------------------------------
# Construct a DataBase to hold our node list
#-------------------------------------------------------------------------------
db = DataBase()
xmin=xminFoamAnvil,
xmax=xmaxFoamAnvil,
nNodePerh=nPerh,
SPH=(NodeListConstructor is SphNodeList))
generatorCuAnvil = GenerateNodeDistribution2d(
nlCuAnvil,
nrCuAnvil,
rho0Cu,
"lattice",
xmin=xminCuAnvil,
xmax=xmaxCuAnvil,
nNodePerh=nPerh,
SPH=(NodeListConstructor is SphNodeList))
distributeNodes2d(
(nodesSteel, generatorTube), (nodesPlug, generatorPlug),
(nodesProj, generatorProj), (nodesSteelAnvil, generatorSteelAnvil),
(nodesFoamAnvil, generatorFoamAnvil), (nodesCuAnvil, generatorCuAnvil))
nGlobalNodes = 0
for n in nodeSet:
print "Generator info for %s" % n.name
output(" mpi.allreduce(n.numInternalNodes, mpi.MIN)")
output(" mpi.allreduce(n.numInternalNodes, mpi.MAX)")
output(" mpi.allreduce(n.numInternalNodes, mpi.SUM)")
nGlobalNodes += mpi.allreduce(n.numInternalNodes, mpi.SUM)
del n
print "Total number of (internal) nodes in simulation: ", nGlobalNodes
# Bevel the inner opening surface of the target tube.
numNodesBeveled = bevelTubeEntrance(nodesSteel, 2, tubeOpeningAngle,
rtubeInner, tubeThickness, xBevelBegin)
print "Beveled %i nodes in the tube opening." % mpi.allreduce(
thetamax = pi
if seed == "constantDTheta":
nx = nr
gen = RZGenerator(
GenerateNodeDistribution2d(nx,
nx,
rho0Be,
distributionType=seed,
xmin=xmin,
xmax=xmax,
theta=thetamax,
rmin=R0,
rmax=R1))
distributeNodes2d((nodesBe, gen))
output("mpi.reduce(nodesBe.numInternalNodes, mpi.MIN)")
output("mpi.reduce(nodesBe.numInternalNodes, mpi.MAX)")
output("mpi.reduce(nodesBe.numInternalNodes, mpi.SUM)")
# Set node velocites.
pos = nodesBe.positions()
vel = nodesBe.velocity()
for i in xrange(nodesBe.numInternalNodes):
ri = pos[i].magnitude()
rhat = pos[i].unitVector()
vel[i] = -u0 * (R0 / ri)**2 * rhat
#-------------------------------------------------------------------------------
# Construct a DataBase to hold our node list
#-------------------------------------------------------------------------------
generatorInner = GenerateNodeDistribution2d(nx2,
ny2,
rho2,
distributionType="lattice",
xmin=(x1, y1),
xmax=(x2, y2),
nNodePerh=nPerh,
SPH=SPH)
if mpi.procs > 1:
from VoronoiDistributeNodes import distributeNodes2d
else:
from DistributeNodes import distributeNodes2d
distributeNodes2d((innerNodes, generatorInner))
print innerNodes.name, ":"
output(" mpi.reduce(innerNodes.numInternalNodes, mpi.MIN)")
output(" mpi.reduce(innerNodes.numInternalNodes, mpi.MAX)")
output(" mpi.reduce(innerNodes.numInternalNodes, mpi.SUM)")
# Set node specific thermal energies
eps0 = P2 / ((gamma2 - 1.0) * rho2)
innerNodes.specificThermalEnergy(ScalarField("tmp", innerNodes, eps0))
#for nodes in nodeSet:
# vel = nodes.velocity()
# for i in xrange(nodes.numInternalNodes):
# vel[i]=Vector(velx,vely)
vel = innerNodes.velocity()
for i in xrange(innerNodes.numInternalNodes):
rho=rho0,
distributionType=seed,
xmin=(-rlength, 0.0),
xmax=(rlength, zlength),
nNodePerh=nPerh)
stuff2distribute = [(nodes1, generator1)]
if not reflect:
generator2 = GenerateNodeDistribution2d(2 * nr,
nz,
rho=rho0,
distributionType=seed,
xmin=(-rlength, -zlength),
xmax=(rlength, 0.0),
nNodePerh=nPerh)
stuff2distribute.append((nodes2, generator2))
distributeNodes2d(*tuple(stuff2distribute))
for n in nodeSet:
output('n.name')
output(' mpi.reduce(n.numInternalNodes, mpi.MIN)')
output(' mpi.reduce(n.numInternalNodes, mpi.MAX)')
output(' mpi.reduce(n.numInternalNodes, mpi.SUM)')
del n
nodes1.specificThermalEnergy(ScalarField("tmp", nodes1, eps0))
nodes1.velocity(VectorField("tmp", nodes1, Vector(0.0, -vz0)))
if not reflect:
nodes2.specificThermalEnergy(ScalarField("tmp", nodes2, eps0))
nodes2.velocity(VectorField("tmp", nodes2, Vector(0.0, vz0)))
#-------------------------------------------------------------------------------
# Create boundary conditions.
