def setUp(self):
print "--------------------------------------------------------------------------------"
print "2-D %s regular cylindrical test." % self._NeighborType
print "--------------------------------------------------------------------------------"
self.ncheck = 50
self.noverlapcheck = 2
from GenerateNodeDistribution2d import GenerateNodeDistribution2d
from DistributeNodes import distributeNodes2d
self.eos = GammaLawGasMKS2d(2.0, 2.0)
self.WT = TableKernel2d(BSplineKernel2d(), 100)
self.nodes1 = makeFluidNodeList2d(
"cylindrical nodes 1",
self.eos,
NeighborType=NeighborCylindrical2d._NeighborType)
self.kernelExtent = 2.0
generator = GenerateNodeDistribution2d(
nRadial=100,
nTheta=100,
rho=1.0,
distributionType="constantDTheta",
rmin=0.0,
rmax=1.0,
theta=0.5 * pi,
nNodePerh=2.01)
distributeNodes2d((self.nodes1, generator))
self.dataBase = DataBase2d()
self.dataBase.appendNodeList(self.nodes1)
return
rho1,
distributionType="lattice",
xmin=(x0, x0),
xmax=(x1, x2),
nNodePerh=nPerh,
SPH=True)
gen2 = GenerateNodeDistribution2d(nx2,
2 * nx2,
rho2,
distributionType="lattice",
xmin=(x1, x0),
xmax=(x2, x2),
nNodePerh=nPerh,
SPH=True)
gen = CompositeNodeDistribution(gen1, gen2)
distributeNodes2d((nodes1, gen))
elif testDim == "3d":
from DistributeNodes import distributeNodes3d
from GenerateNodeDistribution3d import GenerateNodeDistribution3d
from CompositeNodeDistribution import CompositeNodeDistribution
gen1 = GenerateNodeDistribution3d(nx1,
nx1,
nx1,
rho1,
distributionType="lattice",
xmin=(x0, x0, x0),
xmax=(x1, x1, x2),
nNodePerh=nPerh,
SPH=True)
gen2 = GenerateNodeDistribution3d(nx2,
myRejecter = Rejecter(holeRadius)
generator = GenerateNodeDistribution2d(nx,ny,rho0,"lattice",
rmin = rmin,
rmax = rmax,
xmin = xmin,
xmax = xmax,
theta = 2*pi,
nNodePerh = nPerh,
SPH = (not ASPH),
rejecter = myRejecter)
if mpi.procs > 1:
from VoronoiDistributeNodes import distribueNodes2d
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)")
for nodeID in xrange(nodes1.numInternalNodes):
eps[nodeID] = eps0
#-------------------------------------------------------------------------------
# Construct a DataBase to hold our node list
#-------------------------------------------------------------------------------
db = DataBase()
output("db")
output("db.appendNodeList(nodes1)")
output("db.numNodeLists")
output("db.numFluidNodeLists")
def setUp(self):
self.ndim = 2
self.genxmin = (0.0, 0.0)
self.genxmax = (1.0, 1.0)
self.xmin = Vector2d(0.2, 0.2)
self.xmax = Vector2d(0.8, 0.8)
self.nsample = vector_of_int()
[self.nsample.append(x) for x in (100, 100)]
# Tolerances for the test
self.scalarTol = 1.0e-2
self.vectorTol = 1.0e-2
self.tensorTol = 1.0e-2
nx, ny = 50, 50
self.rho0 = 10.0
self.v0 = Vector2d(1.0, -1.0)
self.eps0 = -1.0
self.gradv0 = Tensor2d(8.5, -4.0, 2.2, 1.3)
# Create the nodes and such.
self.eos = GammaLawGasMKS2d(5.0 / 3.0, 1.0)
self.WT = TableKernel2d(BSplineKernel2d())
self.nodes = makeFluidNodeList2d("nodes", self.eos)
self.neighbor = self.nodes.neighbor()
# Distribute the nodes.
from GenerateNodeDistribution2d import GenerateNodeDistribution2d
from DistributeNodes import distributeNodes2d
generator = GenerateNodeDistribution2d(nx,
ny,
self.rho0,
"lattice",
xmin=self.genxmin,
xmax=self.genxmax,
nNodePerh=2.01)
distributeNodes2d((self.nodes, generator))
# Set the velocities and energies.
self.nodes.velocity(VectorField2d("tmp", self.nodes, self.v0))
self.nodes.specificThermalEnergy(
ScalarField2d("tmp", self.nodes, self.eps0))
self.db = DataBase2d()
self.db.appendNodeList(self.nodes)
# Create the boundary conditions.
px0 = Plane2d(Vector2d(0.0, 0.0), Vector2d(1.0, 0.0))
px1 = Plane2d(Vector2d(1.0, 0.0), Vector2d(-1.0, 0.0))
py0 = Plane2d(Vector2d(0.0, 0.0), Vector2d(0.0, 1.0))
py1 = Plane2d(Vector2d(0.0, 1.0), Vector2d(0.0, -1.0))
xbc = PeriodicBoundary2d(px0, px1)
ybc = PeriodicBoundary2d(py0, py1)
self.bcs = [xbc, ybc]
try:
dbc = TreeDistributedBoundary2d.instance()
self.bcs.append(dbc)
except:
if mpi.procs > 1:
raise RuntimeError, "Unable to get parallel boundary condition"
else:
pass
# Enforce boundaries.
db = DataBase2d()
db.appendNodeList(self.nodes)
for bc in self.bcs:
bc.setAllGhostNodes(db)
bc.finalizeGhostBoundary()
self.neighbor.updateNodes()
for bc in self.bcs:
bc.applyGhostBoundary(self.nodes.mass())
bc.applyGhostBoundary(self.nodes.massDensity())
bc.applyGhostBoundary(self.nodes.specificThermalEnergy())
bc.applyGhostBoundary(self.nodes.velocity())
for bc in self.bcs:
bc.finalizeGhostBoundary()
self.H0 = self.nodes.Hfield()[0]
return
nodes1 = SphNodeList2d(0, eos)
nodes2 = SphNodeList2d(0, eos)
from DistributeNodes import distributeNodes2d
generator1 = GenerateNodeDistribution2d(nx1, ny1, rho0, seed,
rmin = rmin1,
rmax = rmax1,
nNodePerh = nPerh)
generator2 = GenerateNodeDistribution2d(nx2, ny2, rho0, seed,
rmin = rmin2,
rmax = rmax2,
nNodePerh = nPerh)
n1 = generator1.globalNumNodes()
n2 = generator2.globalNumNodes()
nodeTuples = [(nodes1, n1, generator1),
(nodes2, n2, generator2)]
nodeInfo = distributeNodes2d(nodeTuples)
output('nodes1.numInternalNodes')
output('nodes2.numInternalNodes')
assert len(nodeInfo[nodes1]['globalNodeListID']) == nodes1.numInternalNodes
assert len(nodeInfo[nodes2]['globalNodeListID']) == nodes2.numInternalNodes
for tup in nodeTuples:
nodes = tup[0]
gen = tup[2]
for i in xrange(nodes.numInternalNodes):
globalID = nodeInfo[nodes]['globalNodeListID'][i]
nodes.mass[i] = gen.mass(globalID)
Hi = gen.Htensor(globalID)
h = sqrt(Hi.Determinant())
Hi = SymTensor2d(h, 0, 0, h)
nodes.Hfield[i] = Hi
#-------------------------------------------------------------------------------
# Set node properties (positions, masses, H's, etc.)
#-------------------------------------------------------------------------------
if restoreCycle is None:
print "Generating node distribution."
from GenerateNodeDistribution2d import *
from DistributeNodes import distributeNodes2d
generator = GenerateNodeDistribution2d(nx,
ny,
rho0,
seed,
xmin = xmin,
xmax = xmax,
nNodePerh = nPerh)
n = generator.globalNumNodes()
nodeInfo = distributeNodes2d([(nodes, n, generator)])
output('mpi.reduce(nodes.numInternalNodes, mpi.MIN)')
output('mpi.reduce(nodes.numInternalNodes, mpi.MAX)')
output('mpi.reduce(nodes.numInternalNodes, mpi.SUM)')
# Set the node masses.
nodes.setMass(ScalarField2d("tmp", nodes, m0))
# Set the smoothing scales.
nodes.setHfield(SymTensorField2d("tmp", nodes, H0))
# Set the node mass densities.
nodes.setMassDensity(ScalarField2d("tmp", nodes, rho0))
nodes.updateWeight()
# Set node specific thermal energies
# Set node properties (positions, masses, H's, etc.)
#-------------------------------------------------------------------------------
eps0 = 0.0
if restoreCycle is None:
print "Generating node distribution."
from GenerateNodeDistribution2d import *
from DistributeNodes import distributeNodes2d
generator = GenerateNodeDistribution2d(nx,
ny,
rho0,
seed,
xmin = xmin,
xmax = xmax,
nNodePerh = nPerh)
n = generator.globalNumNodes()
distributeNodes2d([(nodes, generator)])
output('mpi.reduce(nodes.numInternalNodes, mpi.MIN)')
output('mpi.reduce(nodes.numInternalNodes, mpi.MAX)')
output('mpi.reduce(nodes.numInternalNodes, mpi.SUM)')
# Set node specific thermal energies
eps0 = eos.specificThermalEnergy(rho0, 300.0)
nodes.setSpecificThermalEnergy(ScalarField2d("tmp", nodes, eps0))
# Set node velocites.
for i in xrange(nodes.numInternalNodes):
xi = nodes.positions()[i]
r = xi.magnitude()
runit = xi.unitVector()
vunit = Vector2d(-runit.y, runit.x)
nodes.velocity()[i] = vunit*r*omega0
elif testDim == "2d":
from DistributeNodes import distributeNodes2d
from GenerateNodeDistribution2d import GenerateNodeDistribution2d
gen1 = GenerateNodeDistribution2d(nx1, nx1 + nx2, rho1,
distributionType = "lattice",
xmin = (x0, x0),
xmax = (x1, x2),
nNodePerh = nPerh,
SPH = True)
gen2 = GenerateNodeDistribution2d(nx2, nx1 + nx2, rho2,
distributionType = "lattice",
xmin = (x1, x0),
xmax = (x2, x2),
nNodePerh = nPerh,
SPH = True)
distributeNodes2d((nodes1, gen1),
(nodes2, gen2))
elif testDim == "3d":
from DistributeNodes import distributeNodes3d
from GenerateNodeDistribution3d import GenerateNodeDistribution3d
gen1 = GenerateNodeDistribution3d(nx1, nx1 + nx2, nx1 + nx2, rho1,
distributionType = "lattice",
xmin = (x0, x0, x0),
xmax = (x1, x2, x2),
nNodePerh = nPerh,
SPH = True)
gen2 = GenerateNodeDistribution3d(nx2, nx1 + nx2, nx1 + nx2, rho2,
distributionType = "lattice",
xmin = (x1, x0, x0),
xmax = (x2, x2, x2),
nNodePerh = nPerh,
