generator = GenerateRatioSphere3d(drCenter,
drRatio,
rho=rhoprofile,
rmin=rmin,
rmax=rmax,
thetamin=thetamin,
thetamax=thetamax,
phi=phi,
ntheta=ntheta,
center=(xcenter, ycenter, zcenter),
distributionType=distributionType,
nNodePerh=nPerh,
SPH=SPH)
distributeNodes((nodes, generator))
#-------------------------------------------------------------------------------
# Drop a viz file for inspection.
#-------------------------------------------------------------------------------
Hfield = nodes.Hfield()
HfieldInv = SymTensorField("H inverse", nodes)
for i in xrange(nodes.numNodes):
HfieldInv[i] = SymTensor(Hfield[i].Inverse())
vizfile = siloPointmeshDump(
baseName="ratio_sphere_test_" + distributionType,
baseDirectory="ratio_sphere_test_" + distributionType,
fields=[
nodes.massDensity(),
nodes.mass(),
nodes.velocity(),
rmin=rmin,
rmax=rmax,
nNodePerh=nPerh,
SPH=SPH)
else:
generator = GenerateNodesMatchingProfile2d(n,
diskProfile,
rmin=rmin,
rmax=rmax,
thetaMin=thetaMin,
thetaMax=thetaMax,
nNodePerh=nPerh)
n1 = generator.globalNumNodes()
print "Distributing nodes amongst processors."
distributeNodes((diskNodes, generator))
output('mpi.reduce(diskNodes.numInternalNodes, mpi.MIN)')
output('mpi.reduce(diskNodes.numInternalNodes, mpi.MAX)')
output('mpi.reduce(diskNodes.numInternalNodes, mpi.SUM)')
# Loop over the nodes, and set the specific energies and velocities.
for nodes in [diskNodes]:
for i in xrange(nodes.numInternalNodes):
r = nodes.positions()[i].magnitude()
runit = nodes.positions()[i].unitVector()
vunit = Vector(-runit.y, runit.x)
vt = diskProfile.vt(r)
nodes.specificThermalEnergy()[i] = diskProfile.eps(r)
nodes.velocity()[i] = Vector(vt * vunit.x, vt * vunit.y)
#-------------------------------------------------------------------------------
nNodePerh=nPerh)
generatorMantle = MultiScaleMedialGenerator2d(
n=nmantle,
rho=rhomantle,
gradrho=gradrhomantle, # This is not necessary, but we'll use it if provided
boundary=boundaryMantle,
holes=[boundaryCore],
centroidFrac=centroidFrac,
maxIterationsPerStage=maxIterations,
fracTol=fracTol,
tessellationFileName="test_medial2d_mantle_maxiter=%i_tol=%g" %
(maxIterations, fracTol),
nNodePerh=nPerh)
distributeNodes((nodesCore, generatorCore), (nodesMantle, generatorMantle))
#-------------------------------------------------------------------------------
# Drop a viz file for inspection.
#-------------------------------------------------------------------------------
db = DataBase()
for nodes in nodeSet:
db.appendNodeList(nodes)
vizfile = siloPointmeshDump(
baseName="test_medial_maxiter=%i_tol=%g" % (maxIterations, fracTol),
baseDirectory="test_medial2d_sphere_density",
fieldLists=[
db.fluidMassDensity, db.fluidMass, db.fluidVelocity,
db.fluidSpecificThermalEnergy, db.fluidHfield
])
fracTol=fracTol,
#tessellationFileName = "test_medial_nodes3_maxiter=%i_tol=%g" % (maxIterations, fracTol),
nNodePerh=nPerh)
print "Generator 4"
generator4 = MedialGenerator2d(
n=n4,
rho=0.1,
boundary=outerBox,
holes=[Hboundary, outerCircle],
maxIterations=maxIterations,
fracTol=fracTol,
#tessellationFileName = "test_medial_nodes4_maxiter=%i_tol=%g" % (maxIterations, fracTol),
nNodePerh=nPerh)
distributeNodes((nodes1, generator1), (nodes2, generator2),
(nodes3, generator3), (nodes4, generator4))
#-------------------------------------------------------------------------------
# Drop a viz file for inspection.
#-------------------------------------------------------------------------------
Hfield = nodes.Hfield()
HfieldInv = SymTensorField("H inverse", nodes)
domainField = IntField("Domain", nodes)
for i in xrange(nodes.numNodes):
HfieldInv[i] = Hfield[i].Inverse()
domainField[i] = mpi.rank
vizfile = siloPointmeshDump(
baseName="test_medial_maxiter=%i_tol=%g" % (maxIterations, fracTol),
baseDirectory="test_medial",
fields=([x.massDensity() for x in nodeSet] + [x.mass() for x in nodeSet] +
[x.velocity()
#-------------------------------------------------------------------------------
# Generate them nodes.
#-------------------------------------------------------------------------------
generator1 = AsciiFileNodeGenerator3D(filename=star1,
materialName="Default",
nNodePerh=nPerh,
nodes=nodes1)
#msum = mpi.allreduce(sum(generator1.m + [0.0]), mpi.SUM)
#assert msum > 0.0
#print "Found star1 mass = %g." % (msum)
#ehash1,eheps1 = hashEnergy(generator1)
distributeNodes((nodes1, generator1))
eps = nodes1.specificThermalEnergy()
for i in xrange(nodes1.numInternalNodes):
eps[i] = generator1.eps[i]
#energyHash(nodes1,ehash1,eheps1)
#-------------------------------------------------------------------------------
# Construct a DataBase to hold our node list
#-------------------------------------------------------------------------------
db = DataBase3d()
output("db")
output("db.appendNodeList(nodes1)")
output("db.numNodeLists")
output("db.numFluidNodeLists")
def rhofunc(posi):
return rho0 / max(posi.magnitude(), 1e-6)
gen = GenerateNodeDistribution3d(nx,
nx,
nx,
rho=rhofunc,
distributionType="lattice",
xmin=(-R0, -R0, -R0),
xmax=(R0, R0, R0),
rmin=0.0,
rmax=R0,
nNodePerh=nPerh,
SPH=not asph)
distributeNodes((nodes, gen))
# Force the mass to be exactly the desired total.
mass = nodes.mass()
M1 = mass.sumElements()
for i in xrange(nodes.numInternalNodes):
mass[i] *= M0 / M1
print "Num internal nodes for ", nodes.name, " : ", mpi.allreduce(
nodes.numInternalNodes, mpi.SUM)
print "Total mass: ", mass.sumElements()
# Set specific thermal energy.
eps0 = 0.05
eps = nodes.specificThermalEnergy()
for i in xrange(nodes.numInternalNodes):
thetaMax=thetaMax,
nNodePerh=nPerh)
n1 = generator1.globalNumNodes()
generator2 = GenerateNodesMatchingProfile2d(n * 0.75,
diskProfile2,
rmin=rmax * 0.27,
rmax=rmax,
thetaMin=thetaMin,
thetaMax=thetaMax,
nNodePerh=nPerh,
m0=generator1.m0)
n1 = generator1.globalNumNodes()
n2 = generator2.globalNumNodes()
print "Distributing nodes amongst processors."
distributeNodes((diskNodes1, generator1), (diskNodes2, generator2))
output('mpi.reduce(diskNodes1.numInternalNodes, mpi.MIN)')
output('mpi.reduce(diskNodes1.numInternalNodes, mpi.MAX)')
output('mpi.reduce(diskNodes1.numInternalNodes, mpi.SUM)')
# Loop over the nodes, and set the specific energies and velocities.
for nodes in [diskNodes1, diskNodes2]:
for i in xrange(nodes.numInternalNodes):
r = nodes.positions()[i].magnitude()
#nodes.specificThermalEnergy()[i] = diskProfile.eps(r)
#-------------------------------------------------------------------------------
# Set an external pressure on the disk equivalent to the pressure at the
# cutoff radius.
#-------------------------------------------------------------------------------
externalPressure = eos2.polytropicConstant * diskProfile2.rho(
if not reflect:
generator2 = GenerateNodeDistribution3d(nr, nz, 0,
rho = rho0,
distributionType = "cylindrical",
rmin = rmin,
rmax = rmax,
thetamin = 0.0,
thetamax = 2.0*pi,
zmin = -zmax,
zmax = -zmin,
nNodePerh = nPerh,
SPH = not asph)
stuff2distribute.append((nodes2, generator2))
#...............................................................................
distributeNodes(*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
#-------------------------------------------------------------------------------
# Set initial conditions
#-------------------------------------------------------------------------------
if geometry in ("2d", "RZ"):
v0 = Vector(-vz0, 0.0)
else:
v0 = Vector(0.0, 0.0, -vz0)
nodes1.specificThermalEnergy(ScalarField("tmp", nodes1, eps0))
offset=(x0He, y0He),
nNodePerh=nPerh,
SPH=(HydroConstructor == SPHHydro))
generatorAir = CompositeNodeDistribution(generatorAir1,
generatorAir1_interface)
generatorAir2 = GenerateNodeDistribution2d(
nxAir2,
nyAir2,
airDensity,
distributionType="lattice",
xmin=(x0Air2, y0),
xmax=(x1Air2, y1),
nNodePerh=nPerh,
SPH=(HydroConstructor == SPHHydro))
distributeNodes((nodesAir1, generatorAir), (nodesHe, generatorHe),
(nodesAir2, generatorAir2))
for nodes in nodeSet:
print "Num internal nodes for ", nodes.name, " : ", mpi.allreduce(
nodes.numInternalNodes, mpi.SUM)
# Set initial conditions.
nodesAir1.specificThermalEnergy(ScalarField("eps", nodesAir1, airEnergy))
nodesAir2.specificThermalEnergy(
ScalarField("eps", nodesAir2, airHighEnergy))
nodesHe.specificThermalEnergy(ScalarField("eps", nodesHe, HeEnergy))
#-------------------------------------------------------------------------------
# Construct a DataBase to hold our node list
#-------------------------------------------------------------------------------
db = DataBase()
output("db")
fracTol=fracTol,
#tessellationFileName = "test_medial_nodes1_maxiter=%i_tol=%g" % (maxIterations, fracTol),
nNodePerh=nPerh)
print "Generator 2"
generator2 = MedialGenerator3d(
n=n2,
rho=1.0,
boundary=outerBoundary,
holes=[innerBoundary],
maxIterations=maxIterations,
fracTol=fracTol,
#tessellationFileName = "test_medial_nodes2_maxiter=%i_tol=%g" % (maxIterations, fracTol),
nNodePerh=nPerh)
distributeNodes((nodes1, generator1), (nodes2, generator2))
#-------------------------------------------------------------------------------
# Drop a viz file for inspection.
#-------------------------------------------------------------------------------
Hfield = nodes.Hfield()
HfieldInv = SymTensorField("H inverse", nodes)
for i in xrange(nodes.numNodes):
HfieldInv[i] = Hfield[i].Inverse()
vizfile = siloPointmeshDump(
baseName="test_medial3d_maxiter=%i_tol=%g" % (maxIterations, fracTol),
baseDirectory="test_medial3d",
fields=([x.massDensity() for x in nodeSet] + [x.mass() for x in nodeSet] +
[x.velocity()
for x in nodeSet] + [x.specificThermalEnergy() for x in nodeSet] +
[x.Hfield() for x in nodeSet]))
