def test_purelb(self):
global runSteps
self.integrator.run(runSteps)
# variables to hold average density and mass flux
av_den = 0.
av_j = Real3D(0.)
# lattice variables. halo is hard coded
halo = 1
myNi = self.lb.getMyNi
area_yz = (myNi[1] - 2 * halo) * (myNi[2] - 2 * halo)
for i in range(halo, myNi[0] - halo):
for j in range(halo, myNi[1] - halo):
for k in range(halo, myNi[2] - halo):
av_den += self.lb.getLBMom(Int3D(i, j, k), 0)
jx = self.lb.getLBMom(Int3D(i, j, k), 1)
jy = self.lb.getLBMom(Int3D(i, j, k), 2)
jz = self.lb.getLBMom(Int3D(i, j, k), 3)
av_j += Real3D(jx, jy, jz)
av_den /= area_yz
av_j /= area_yz
print av_den, av_j
self.assertAlmostEqual(av_den, initDen, places=2)
self.assertAlmostEqual(av_j[0], initVel, places=2)
self.assertAlmostEqual(av_j[1], initVel, places=2)
self.assertAlmostEqual(av_j[2], initVel, places=2)
av_den = 0.
av_j = Real3D(0.)
def setUp(self):
# set up system
system = espressopp.System()
system.rng = espressopp.esutil.RNG()
system.bc = espressopp.bc.OrthorhombicBC(system.rng, size)
system.skin = skin
comm = MPI.COMM_WORLD
nodeGrid = Int3D(1, 1, comm.size)
cellGrid = Int3D(calcNumberCells(size[0], nodeGrid[0], cutoff),
calcNumberCells(size[1], nodeGrid[1], cutoff),
calcNumberCells(size[2], nodeGrid[2], cutoff))
system.storage = espressopp.storage.DomainDecomposition(
system, nodeGrid, cellGrid)
pid = 0
system.storage.addParticle(
0, Real3D(6.1162456968, 3.9088541374, 9.4409851324))
system.storage.addParticle(
1, Real3D(5.9516473019, 4.2535440563, 9.4778266528))
system.storage.addParticle(
2, Real3D(5.8160837525, 4.1043280354, 9.8101428319))
system.storage.addParticle(
3, Real3D(6.0145256344, 4.0133146160, 9.4982604364))
system.storage.decompose()
self.system = system
def run_average(self, _vz):
# variables to hold average density and mass flux
av_den = 0.
av_j = Real3D(0.)
# lattice variables. halo is hard coded
halo = 1
myNi = self.lb.getMyNi
volume_xyz = (myNi[0] - 2 * halo) * (myNi[1] - 2 * halo) * (myNi[2] -
2 * halo)
for i in range(halo, myNi[0] - halo):
for j in range(halo, myNi[1] - halo):
for k in range(halo, myNi[2] - halo):
av_den += self.lb.getLBMom(Int3D(i, j, k), 0)
jx = self.lb.getLBMom(Int3D(i, j, k), 1)
jy = self.lb.getLBMom(Int3D(i, j, k), 2)
jz = self.lb.getLBMom(Int3D(i, j, k), 3)
av_j += Real3D(jx, jy, jz)
av_den /= volume_xyz
av_j /= volume_xyz
print av_den, av_j
self.assertAlmostEqual(av_den, initDen, places=2)
self.assertAlmostEqual(av_j[0], initVel, places=2)
self.assertAlmostEqual(av_j[1], initVel, places=2)
self.assertAlmostEqual(av_j[2], _vz, places=2)
def cellGrid(box_size, node_grid, rc, skin, halfCellInt=1):
rc_skin = rc + skin
if rc_skin == 0:
raise Error("interaction range (cutoff + skin) must be larger than 0")
if (node_grid[0] <= 0 or node_grid[1] <= 0 or node_grid[2] <= 0):
raise Error("invalid node grid %s" % str(node_grid))
ix = (box_size[0] * halfCellInt) / (rc_skin * node_grid[0])
if ix < 1:
raise Error(
"local box size in direction 0 (=%6f) is smaller than interaction range (cutoff + skin = %6f).\n \
hint: number of CPUs maybe too high or is prime, perhaps you could also try with Halfcells."
% (ix, rc_skin))
iy = (box_size[1] * halfCellInt) / (rc_skin * node_grid[1])
if iy < 1:
raise Error(
"local box size in direction 1 (=%6f) is smaller than interaction range (cutoff + skin = %6f).\n \
hint: number of CPUs maybe too high or is prime, perhaps you could also try with Halfcells."
% (iy, rc_skin))
iz = (box_size[2] * halfCellInt) / (rc_skin * node_grid[2])
if iz < 1:
raise Error(
"local box size in direction 2 (=%6f) is smaller than interaction range (cutoff + skin = %6f).\n \
hint: number of CPUs maybe too high or is prime, perhaps you could also try with Halfcells."
% (iz, rc_skin))
return Int3D(ix, iy, iz)
def __init__(self, system,
nodeGrid='auto',
cellGrid='auto',
halfCellInt = 'auto',
nocheck=False):
# do sanity checks for the system first
if nocheck:
self.next_id = 0
self.pmiinit(system, nodeGrid, cellGrid, halfCellInt)
else:
if check.System(system, 'bc'):
if nodeGrid == 'auto':
nodeGrid = decomp.nodeGridSimple(system.comm.rank)
else:
nodeGrid = toInt3DFromVector(nodeGrid)
if cellGrid == 'auto':
cellGrid = Int3D(2,2,2)
else:
cellGrid = toInt3DFromVector(cellGrid)
if halfCellInt == 'auto':
halfCellInt = 1
# minimum image convention check:
for k in range(3):
if nodeGrid[k]*cellGrid[k] == 1 :
print(("Warning! cellGrid[{}] has been "
"adjusted to 2 (was={})".format(k, cellGrid[k])))
cellGrid[k] = 2
self.next_id = 0
self.pmiinit(system, nodeGrid, cellGrid, halfCellInt)
else:
print('Error: could not create DomainDecomposition object')
def __init__(self,
system,
nodeGrid='auto',
cellGrid='auto',
neiListx='auto',
neiListy='auto',
neiListz='auto'):
if nodeGrid == 'auto':
nodeGrid = Int3D(system.comm.rank, 1, 1)
else:
nodeGrid = toInt3DFromVector(nodeGrid)
if cellGrid == 'auto':
# TODO: Implement
raise 'Automatic cell size calculation not yet implemented'
else:
cellGrid = toInt3DFromVector(cellGrid)
if neiListx == 'auto':
neiListx = 0
else:
neiListx = neiListx
if neiListy == 'auto':
neiListy = 0
else:
neiListy = neiListy
if neiListz == 'auto':
neiListz = 0
else:
neiListz = neiListz
self.next_id = 0
self.pmiinit(system, nodeGrid, cellGrid, neiListx, neiListy,
neiListz)
def modifyParticle(self, pid, property, value):
if not (pmi._PMIComm and pmi._PMIComm.isActive()
) or pmi._MPIcomm.rank in pmi._PMIComm.getMPIcpugroup():
if (self.particleExists(pid)):
#try:
#if not particle.isGhost:
particle = self.getParticle(pid)
self.logger.info("particle pid=%i rank=%i" % (pid, pmi.rank))
if property.lower() == "id":
raise "particles pid cannot be modified !"
elif property.lower(
) == "pos": # alway assume unfolded coordinates
particle.pos = value
particle.imageBox = Int3D(0, 0, 0)
elif property.lower() == "modepos":
particle.modepos = value
elif property.lower() == "img":
particle.imageBox = value
elif property.lower() == "type":
particle.type = value
elif property.lower() == "pib":
particle.pib = value
elif property.lower() == "mass":
particle.mass = value
elif property.lower() == "varmass":
particle.varmass = value
elif property.lower() == "v":
particle.v = value
elif property.lower() == "modemom":
particle.modemom = value
elif property.lower() == "f":
particle.f = value
elif property.lower() == "q":
particle.q = value
elif property.lower() == "radius":
particle.radius = value
elif property.lower() == "fradius":
particle.fradius = value
elif property.lower() == "vradius":
particle.vradius = value
elif property.lower() == "lambda_adr":
particle.lambda_adr = value
elif property.lower() == "lambda_adrd":
particle.lambda_adrd = value
elif property.lower() == "state":
particle.state = value
else:
raise SyntaxError(
'unknown particle property: %s' % property
) # UnknownParticleProperty exception is not implemented
def nodeGridSimple(n):
ijkmax = 3 * n * n + 1
d1 = 1
d2 = 1
d3 = 1
for i in xrange(1, n + 1):
for j in xrange(i, n + 1):
for k in xrange(j, n + 1):
if (i * j * k == n) and (i * i + j * j + k * k < ijkmax):
d1 = k
d2 = j
d3 = i
ijkmax = i * i + j * j + k * k
return Int3D(d1, d2, d3)
def nodeGridSimple(n): # Mainly used for Lattice-Boltzmann and cubic geometries
ijkmax = 3 * n * n + 1
d1 = 1
d2 = 1
d3 = 1
for i in range(1, n + 1):
for j in range(i, n + 1):
for k in range(j, n + 1):
if (i * j * k == n) and (i * i + j * j + k * k < ijkmax):
d1 = k
d2 = j
d3 = i
ijkmax = i * i + j * j + k * k
print("nodeGrid reads as follows: ",d1, d2, d3,".... BTW, You are not using HeSpaDDA")
return Int3D(d1, d2, d3)
def __init__(self, system, nodeGrid, cellGrid, neiListx, neiListy,
neiListz):
if not (pmi._PMIComm and pmi._PMIComm.isActive()
) or pmi._MPIcomm.rank in pmi._PMIComm.getMPIcpugroup():
p1 = pmi._MPIcomm.rank % nodeGrid[0]
aux1 = pmi._MPIcomm.rank / nodeGrid[
0] # HDD comment: Getting the order of processors
p2 = aux1 % nodeGrid[1]
aux2 = aux1 / nodeGrid[1]
p3 = aux2 # HDD comment: Obtaining the processors per axes (x,y,z)
cellGrid = Int3D(neiListx[p1 + 1] - neiListx[p1],
neiListy[p2 + 1] - neiListy[p2],
neiListz[p3 + 1] - neiListz[p3])
cxxinit(self, storage_DomainDecompositionNonBlocking, system,
nodeGrid, cellGrid, neiListx, neiListy, neiListz)
def setUp(self):
# set up system
system = espressopp.System()
system.rng = espressopp.esutil.RNG()
system.bc = espressopp.bc.OrthorhombicBC(system.rng, size)
system.skin = skin
comm = MPI.COMM_WORLD
nodeGrid = Int3D(1, 1, comm.size)
cellGrid = Int3D(calcNumberCells(size[0], nodeGrid[0], cutoff),
calcNumberCells(size[1], nodeGrid[1], cutoff),
calcNumberCells(size[2], nodeGrid[2], cutoff))
system.storage = espressopp.storage.DomainDecomposition(
system, nodeGrid, cellGrid)
pid = 0
system.storage.addParticle(0, Real3D(0.15, 0.1, 0))
system.storage.addParticle(1, Real3D(0.4, 0.1, 0))
system.storage.decompose()
# integrator
integrator = espressopp.integrator.VelocityVerlet(system)
integrator.dt = 0.001
# now build Verlet List
# ATTENTION: you must not add the skin explicitly here
logging.getLogger("Interpolation").setLevel(logging.INFO)
vl = espressopp.VerletList(system, cutoff=cutoff)
scaling_cv = 1.5
alpha = 0.1
# ATTENTION: auto shift was enabled
# bonds
writeTabFile(tabBonds[0], k=100000, x0=0.26, N=500, low=0.01, high=0.6)
writeTabFile(tabBonds[1], k=50000, x0=0.24, N=500, low=0.01, high=0.6)
fpl = espressopp.FixedPairList(system.storage)
fpl.addBonds([(0, 1)])
potBond = espressopp.interaction.TabulatedSubEns()
potBond.addInteraction(
1, tabBonds[0],
espressopp.RealND([0.262, 0., 0., scaling_cv * 0.424, 0., 0.]))
potBond.addInteraction(1, tabBonds[1],
espressopp.RealND([0., 0., 0., 0., 0., 0.]))
potBond.alpha_set(alpha)
cv_bl = espressopp.FixedPairList(system.storage)
cv_bl.addBonds([])
potBond.colVarBondList = cv_bl
cv_al = espressopp.FixedTripleList(system.storage)
cv_al.addTriples([])
potBond.colVarAngleList = cv_al
# Renormalize the CVs
potBond.colVarSd_set(0, 0.0119)
# Target probabilities
potBond.targetProb_set(0, tgt_probs[0])
potBond.targetProb_set(1, tgt_probs[1])
interBond = espressopp.interaction.FixedPairListTabulatedSubEns(
system, fpl, potBond)
system.addInteraction(interBond)
temp = espressopp.analysis.Temperature(system)
temperature = temp.compute()
Ek = 0.5 * temperature * (2 * numParticles)
Ep = interBond.computeEnergy()
# langevin thermostat
langevin = espressopp.integrator.LangevinThermostat(system)
integrator.addExtension(langevin)
langevin.gamma = 1.0
langevin.temperature = 2.479 # in kJ/mol
# sock = espressopp.tools.vmd.connect(system)
configurations = espressopp.analysis.Configurations(system)
self.configuration = configurations
self.system = system
self.temp = temp
self.integrator = integrator
self.interBond = interBond
self.potBond = potBond
def neiListAdress(node_grid, cell_grid,rc,skin,eh_size,adrCenter,ratioMS,idealGasFlag=True,sphereAdr=False,slabMSDims=[1,0,0]):
# dataStructure Initialization
print "HDD message: Current heterogeneous NodeGrid (X,Y,Z) -> powered by HeSpaDDA:",node_grid
rc_skin=rc+skin
#define Neighbor vectors
neiListx=[0]*(node_grid[0]+1)
neiListy=[0]*(node_grid[1]+1)
neiListz=[0]*(node_grid[2]+1)
# Check adress regions
adrCenter=[adrCenter[0],adrCenter[1],adrCenter[2]]
# Midle point DD
cursor=[adrCenter[0]*2,adrCenter[1]*2,adrCenter[2]*2]
#cg_sizeR=adrCenter[0]+eh_size # for further devs
#cg_sizeL=adrCenter[0]-eh_size # for further devs
cellsX=round(cursor[0]/ rc_skin-0.5)#round(cg_sizeL/rc_skin-0.5)+round((cursor[0]-cg_sizeR)/ rc_skin-0.5)+round((cg_sizeR-cg_sizeL)/rc_skin-0.5) # old implementation rounded # Cells too much!
cellsY=round(cursor[1] / rc_skin-0.5)
cellsZ=round(cursor[2] / rc_skin-0.5)
print "HDD message: Current heterogeneous CellGrid (X,Y,Z) -> powered by HeSpaDDA:",cellsX,cellsY,cellsZ
# This condition checks if the Sys is a Slab or a Sphere. It should work for any middle based Sys
if not sphereAdr:
if slabMSDims[0]==1:
halfneilListx=halfDecomp(adrCenter[0],rc_skin,eh_size,int(round(node_grid[0]/2.-0.5)),cellsX,ratioMS,cursor[0],idealGasFlag)
print "HDD message: My halfneilListx called a half decomposition of the first half of the sim box as (algorithm S.1)...,",halfneilListx
# Next instruction is doubling(by unfolding halfDecomp) the halfspace based DD
neiListxin=addHsymmetry(halfneilListx,eh_size,rc_skin,node_grid[0],cellsX,ratioMS,cursor[0],idealGasFlag)
print "HDD message: My neiListxin if it make sense your heterogenous system can be splitted in 2 equal parts (algorithm S.2)...,",neiListxin
else:
neiListxin=reDistCellsHom(node_grid[0],cursor[0],rc_skin)
neiListx=adaptNeiList(neiListxin) #Contains cores Neighbor List in full format for X
if slabMSDims[1]==1:
halfneilListy=halfDecomp(adrCenter[1],rc_skin,eh_size,int(round(node_grid[1]/2.-0.5)),cellsY,ratioMS,cursor[1],idealGasFlag)
print "HDD message: My halfneilListx called a half decomposition of the first half of the sim box as (algorithm S.1)...,",halfneilListy
# Next instruction is doubling(by unfolding halfDecomp) the halfspace based DD
neiListyin=addHsymmetry(halfneilListy,eh_size,rc_skin,node_grid[1],cellsY,ratioMS,cursor[1],idealGasFlag)
print "HDD message: My neiListxin if it make sense your heterogenous system can be splitted in 2 equal parts (algorithm S.2)...,",neiListyin
else:
neiListyin=reDistCellsHom(node_grid[1],cursor[1],rc_skin)
neiListy=adaptNeiList(neiListyin) #Contains the homogeneously decomp cores Neighbor List in full format for Y
if slabMSDims[2]==1:
halfneilListz=halfDecomp(adrCenter[2],rc_skin,eh_size,int(round(node_grid[2]/2.-0.5)),cellsZ,ratioMS,cursor[2],idealGasFlag)
print "HDD message: My halfneilListx called a half decomposition of the first half of the sim box as (algorithm S.1)...,",halfneilListz
# Next instruction is doubling(by unfolding halfDecomp) the halfspace based DD
neiListzin=addHsymmetry(halfneilListz,eh_size,rc_skin,node_grid[2],cellsZ,ratioMS,cursor[2],idealGasFlag)
print "HDD message: My neiListxin if it make sense your heterogenous system can be splitted in 2 equal parts (algorithm S.2)...,",neiListzin
else:
neiListzin=reDistCellsHom(node_grid[2],cursor[2],rc_skin)
neiListz=adaptNeiList(neiListzin) #Contains the homogeneously decomp cores Neighbor List in full format for Z
# NOTE that additional DD options for slabs can be furhter added
elif sphereAdr:
flx,fly,flz=nodeGridSizeCheck(node_grid[0],node_grid[1],node_grid[2])
print "HDD message: Is it worthy to use an advanced DD? Flags for it in each dir X,Y,Z (0 means OK for heterogenoeus DD)...,",flx,fly,flz
#on X-axis
if flx==0:
halfneilListx=halfDecomp(adrCenter[0],rc_skin,eh_size,int(round(node_grid[0]/2.-0.5)),cellsX,ratioMS,cursor[0],idealGasFlag)
print "HDD message: My halfneilListx called a half decomposition of the first half of the sim box as (algorithm S.1)...,",halfneilListx
neiListxin=addHsymmetry(halfneilListx,eh_size,rc_skin,node_grid[0],cellsX,ratioMS,cursor[0],idealGasFlag)
print "HDD message: My neiListxin if it make sense your heterogenous system can be splitted in 2 equal parts (algorithm S.2)...,",neiListxin
elif flx>1:
neiListxin=reDistCellsHom(node_grid[0],cursor[0],rc_skin)
neiListx=adaptNeiList(neiListxin)
#on Y-axis
if fly==0:
halfneilListy=halfDecomp(adrCenter[1],rc_skin,eh_size,int(round(node_grid[1]/2.-0.5)),cellsY,ratioMS,cursor[1],idealGasFlag)
print "HDD message: My halfneilListx called a half decomposition of the first half of the sim box as (algorithm S.1)...,",halfneilListy
neiListyin=addHsymmetry(halfneilListy,eh_size,rc_skin,node_grid[1],cellsY,ratioMS,cursor[1],idealGasFlag)
print "HDD message: My neiListxin if it make sense your heterogenous system can be splitted in 2 equal parts (algorithm S.2)...,",neiListyin
elif fly>1:
neiListyin=reDistCellsHom(node_grid[1],cursor[1],rc_skin)
neiListy=adaptNeiList(neiListyin)
#on Z-axis
if flz==0:
halfneilListz=halfDecomp(adrCenter[2],rc_skin,eh_size,int(round(node_grid[2]/2.-0.5)),cellsZ,ratioMS,cursor[2],idealGasFlag)
print "HDD message: My halfneilListx called a half decomposition of the first half of the sim box as (algorithm S.1)...,",halfneilListz
neiListzin=addHsymmetry(halfneilListz,eh_size,rc_skin,node_grid[2],cellsZ,ratioMS,cursor[2],idealGasFlag)
print "HDD message: My neiListxin if it make sense your heterogenous system can be splitted in 2 equal parts (algorithm S.2)...,",neiListzin
elif flz>1:
neiListzin=reDistCellsHom(node_grid[2],cursor[2],rc_skin)
neiListz=adaptNeiList(neiListzin)
print "HDD message: neiListX:",map(int,neiListx),"\n neiListY",map(int,neiListy),"\n neiListZ",map(int,neiListz)
return Int3D(cellsX,cellsY,cellsZ),map(int,neiListx),map(int,neiListy),map(int,neiListz)
def nodeGrid(box_size,rc,skin,n,eh_size=0,ratioMS=0,idealGas=0,slabMSDims=[0,0,0]):
ijkmax = 3*n*n+1
boxList=[box_size[0],box_size[1],box_size[2]]
ratioEH2CG=[(2.*eh_size)/(abs(box_size[0]-(2.*eh_size))),(2.*eh_size)/(abs(box_size[1]-(2.*eh_size))),(2.*eh_size)/(abs(box_size[2]-(2.*eh_size)))]
ratioEHCG=min(ratioEH2CG)
if idealGas==0: # Non ideal Gas Simulation
# This condition checks if the sys is AdResS, if afirmative it resizes box accordingly
if ratioMS>1: # Spatially heterogeneous simulation
#print ratioEHCG
# This condition checks if the sys is slab based or cubic and resizes the box accordingly
if sum(slabMSDims)>0.1:
boxList=[slabMSDims[0]*(box_size[0]+(2.*eh_size)*(pow(ratioMS,0.3333)-1.)),slabMSDims[1]*(box_size[1]+(2.*eh_size)*(pow(ratioMS,0.3333)-1.)),slabMSDims[2]*(box_size[2]+(2.*eh_size)*(pow(ratioMS,0.3333)-1.))]
boxList=[(1-slabMSDims[0])*box_size[0]*(pow(ratioMS,0.3333))+boxList[0],(1-slabMSDims[1])*box_size[1]*(pow(ratioMS,0.3333))+boxList[1],(1-slabMSDims[2])*box_size[2]*(pow(ratioMS,0.3333))+boxList[2]] # Flag NOR
else:
boxList=[box_size[0]+(2.*eh_size)*(ratioMS-1.),box_size[1]+(2.*eh_size)*(ratioMS-1.),box_size[2]+(2.*eh_size)*(ratioMS-1.)]
else:
print "HDD message: Non AdResS DD...entering Homogeneous DD...3, 2, 1 "
# Ideal Gas HeSpaDDA (idealGas==1)
else:
if ratioMS>1:
# This condition checks if the sys is slab based or cubic and resizes the box accordingly
if sum(slabMSDims)>0:
if n<=round((2.*eh_size)/(rc+skin)-0.5+2.) and min(boxList)*ratioEHCG/(rc+skin)>=1.:
boxList=[slabMSDims[0]*((2.*eh_size)+2.*(rc+skin)),slabMSDims[1]*((2.*eh_size)+2.*(rc+skin)),slabMSDims[2]*((2.*eh_size)+2.*(rc+skin))]
boxList=[(1-slabMSDims[0])*box_size[0]+boxList[0],(1-slabMSDims[1])*box_size[1]+boxList[1],(1-slabMSDims[2])*box_size[2]+boxList[2]]
elif n>round((2.*eh_size)/(rc+skin)-0.5+2.) and min(boxList)/(rc+skin)>=4. and round((2.*eh_size)/(rc+skin)-0.5+2.)>min(boxList)/(rc+skin):
boxList=[slabMSDims[0]*((2.*eh_size)+2.*(rc+skin)),slabMSDims[1]*((2.*eh_size)+2.*(rc+skin)),slabMSDims[2]*((2.*eh_size)+2.*(rc+skin))]
boxList=[(1-slabMSDims[0])*box_size[0]*(pow(ratioMS,0.3333))+boxList[0],(1-slabMSDims[1])*box_size[1]*(pow(ratioMS,0.3333))+boxList[1],(1-slabMSDims[2])*box_size[2]*(pow(ratioMS,0.3333))+boxList[2]]
#boxList=[box_size[0],box_size[1],box_size[2]] # UJ is here
print "this option TWO"
elif n>round((2.*eh_size)/(rc+skin)-0.5+2.) and min(boxList)/(rc+skin)<4.:
boxList=[slabMSDims[0]*((2.*eh_size)+2.*(rc+skin)),slabMSDims[1]*((2.*eh_size)+2.*(rc+skin)),slabMSDims[2]*((2.*eh_size)+2.*(rc+skin))]
boxList=[(1-slabMSDims[0])*box_size[0]+boxList[0],(1-slabMSDims[1])*box_size[1]+boxList[1],(1-slabMSDims[2])*box_size[2]+boxList[2]]
#boxList=[box_size[0],box_size[1],box_size[2]] # UJ is here
print "this option THREE"
else:
print "HDD message: No more space for distributing Cores...look if you could use some HalfCells, or reduce the nr. of processors used and try again"
else:
boxList=[(2.*eh_size)+2.*(rc+skin),(2.*eh_size)+2.*(rc+skin),(2.*eh_size)+2.*(rc+skin)] # IDEA: multiply here by the cells refina
else:
print "HDD message: Non AdResS DD!"
# Here starts the new Dimensional aware HDD algorithm which. Dependencies: loadbal
LoN_Avgmin=sum(boxList)
# ima and imi sort values according to the box dimensions
ima=boxList.index(max(boxList))
imi=boxList.index(min(boxList))
dN = [1,1,1]
fdN=[0,0,0]
for i in xrange(1,n+1):
for j in xrange(i,n+1):
for k in xrange(j,n+1):
if (i*j*k == n) and (i*i + j*j + k*k < ijkmax):
dN[0] = k
dN[1] = j
dN[2] = i
ijkmax = i*i + j*j + k*k
# This checks if the system's box is cubic if not add weighted averages
# NOTE: It could be further optimized on a system by system basis as f(deltaCellSize beteween cores) this corresponds to the general version.
if qbicity(box_size,rc,skin)==False:
ndN=changeIndex(dN,ima,imi)[:]
LoN_norm=[boxList[0]/ndN[0],boxList[1]/ndN[1],boxList[2]/ndN[2]]
LoN_Avg=sum(LoN_norm)/3.0
if LoN_Avg<=LoN_Avgmin:
LoN_Avgmin=LoN_Avg
fdN=ndN[:]
ijkmax = fdN[0]*fdN[0]+fdN[1]*fdN[1]+fdN[2]*fdN[2]
print fdN
else:
ijkmax = fdN[0]*fdN[0]+fdN[1]*fdN[1]+fdN[2]*fdN[2]
print 'HDD message: No update of dN req ...'
else:
print 'qbicity check passed -> powered by HeSpaDDA'
fdN=[k,j,i]
if abs(box_size[1]-box_size[2])<(2*(rc+skin)):
if fdN[2]>fdN[1]:
aux=fdN[2]
fdN[2]=fdN[1]
fdN[1]=aux
#print 'ordered fdN:',fdN[0],fdN[1],fdN[2]
else:
print 'HDD message: Size Lenghts are eq. while ordering axis with preference on X, Y and Z!'
else:
print 'HDD message: Size Lenghts are different in Y and Z!'
return Int3D(fdN[0],fdN[1],fdN[2])
thermostat = espressopp.integrator.LangevinThermostat(system)
thermostat.gamma = 1.0
thermostat.temperature = 1.0
integrator.addExtension(thermostat)
#integrator.dt = 0.000001
#integrator.run(10000)
#print "Finished with warming up"
#integrator.dt = 0.005
thermostat.disconnect()
# define a LB grid
nodeGrid = espressopp.tools.decomp.nodeGrid(espressopp.MPI.COMM_WORLD.size)
lb = espressopp.integrator.LatticeBoltzmann(system,
nodeGrid,
Ni=Int3D(20, 20, 20))
# add extension to the integrator
integrator.addExtension(lb)
initPop = espressopp.integrator.LBInitPopUniform(system, lb)
#initPop = espressopp.integrator.LBInitPopWave(system,lb)
initPop.createDenVel(1.0, Real3D(0., 0., 0.))
#initPop.createDenVel(1.0, Real3D(0.,0.,0.001))
lboutputScreen = espressopp.analysis.LBOutputScreen(system, lb)
OUT3 = espressopp.integrator.ExtAnalyze(lboutputScreen, 200)
integrator.addExtension(OUT3)
# declare gammas responsible for viscosities (if they differ from 0)
lb.gamma_b = 0.5
lb.gamma_s = 0.5
# specify desired temperature (set the fluctuations if any)
# run simulation for all interpolation types
for spline in range(1, len(splinetypes) + 1):
print('\nSpline interpolation (%0d/%0d): %0s' %
(spline, len(splinetypes), splinetypes[spline - 1]))
# set up system
system = espressopp.System()
system.rng = espressopp.esutil.RNG()
system.bc = espressopp.bc.OrthorhombicBC(system.rng, size)
system.skin = skin
comm = MPI.COMM_WORLD
nodeGrid = Int3D(1, 1, comm.size)
cellGrid = Int3D(calcNumberCells(size[0], nodeGrid[0], cutoff),
calcNumberCells(size[1], nodeGrid[1], cutoff),
calcNumberCells(size[2], nodeGrid[2], cutoff))
system.storage = espressopp.storage.DomainDecomposition(
system, nodeGrid, cellGrid)
pid = 0
for i in range(int(N)):
for j in range(int(N)):
for k in range(int(N)):
m = (i + 2 * j + 3 * k) % 11
r = 0.45 + m * 0.01
x = (i + r) / N * size[0]
y = (j + r) / N * size[1]
def nodeGrid(n=None, box_size=None, rc=None, skin=None, eh_size=0, ratioMS=0, idealGas=0, slabMSDims=[0, 0, 0,]):
if isinstance(n, numbers.Number) and box_size is None:
return nodeGridSimple(n)
else:
if eh_size!=0:
print("################################################# --> | HeSpaDDA: Domain Decomposition method | <-- #####################################################")
ijkmax = 3 * n * n + 1
boxList = [box_size[0], box_size[1], box_size[2]]
ratioEH2CG = [(2. * eh_size) / (abs(box_size[0] - (2. * eh_size))), (2. * eh_size)/(abs(box_size[1] - (2. * eh_size))), (2. * eh_size) / (abs(box_size[2] - (2. * eh_size)))]
ratioEHCG = min(ratioEH2CG)
if not idealGas: # Non ideal Gas Simulation
# This condition checks if the sys is AdResS, if afirmative it resizes box accordingly
if ratioMS > 1: # Spatially heterogeneous simulation
# print ratioEHCG
# This condition checks if the sys is slab based or cubic and resizes the box accordingly
if sum(slabMSDims) > 0.1:
boxList = [slabMSDims[0] * (box_size[0] + (2. * eh_size) * (pow(ratioMS, 0.3333) - 1.)), slabMSDims[1] * (box_size[1] + (2. * eh_size) * (pow(ratioMS, 0.3333) - 1.)), slabMSDims[2] * (box_size[2] + (2. * eh_size) * (pow(ratioMS, 0.3333) - 1.))]
boxList = [(1 - slabMSDims[0]) * box_size[0] * (pow(ratioMS, 0.3333)) + boxList[0], (1 - slabMSDims[1]) * box_size[1] * (pow(ratioMS, 0.3333)) + boxList[1], (1 - slabMSDims[2]) * box_size[2] * (pow(ratioMS, 0.3333)) + boxList[2]] # Flag NOR
else:
boxList = [box_size[0] + (2. * eh_size) * (ratioMS - 1.), box_size[1] + (
2. * eh_size) * (ratioMS - 1.), box_size[2] + (2. * eh_size) * (ratioMS - 1.)]
else:
print("HeSpaDDA message: Non AdResS DD...entering Homogeneous DD...3, 2, 1 ")
# Ideal Gas HeSpaDDA (idealGas==1)
else:
if ratioMS > 1:
# This condition checks if the sys is slab based or cubic and resizes the box accordingly
if sum(slabMSDims) > 0:
if n <= round((2. * eh_size) / (rc + skin) - 0.5 + 2.) and min(boxList) * ratioEHCG / (rc + skin) >= 1.:
boxList = [slabMSDims[0] * ((2. * eh_size) + 2. * (rc + skin)), slabMSDims[1] * ((2. * eh_size) + 2. * (rc + skin)), slabMSDims[2] * ((2. * eh_size) + 2. * (rc + skin))]
boxList = [(1 - slabMSDims[0]) * box_size[0] + boxList[0], (1 - slabMSDims[1])* box_size[1] + boxList[1], (1 - slabMSDims[2]) * box_size[2] + boxList[2]]
print("HeSpaDDA message: this option ONE of the ideal gas size box your low resolution region is small")
elif n > round((2. * eh_size) / (rc + skin) - 0.5 + 2.) and min(boxList) / (rc + skin) >= 4. and round((2. * eh_size) / (rc + skin) - 0.5 + 2.) > min(boxList) / (rc + skin):
boxList = [slabMSDims[0] * ((2. * eh_size) + 2. * (rc + skin)), slabMSDims[1] * ((2. * eh_size) + 2. * (rc + skin)), slabMSDims[2] * ((2. * eh_size) + 2. * (rc + skin))]
boxList = [(1 - slabMSDims[0]) * box_size[0] * (pow(ratioMS, 0.3333)) + boxList[0], (1 - slabMSDims[1]) * box_size[1] * (pow(ratioMS, 0.3333)) + boxList[1], (1 - slabMSDims[2]) * box_size[2] * (pow(ratioMS, 0.3333)) + boxList[2]]
# boxList=[box_size[0],box_size[1],box_size[2]] # UJ is here
print("HeSpaDDA message: this option TWO of the ideal gas size box your low resolution region is big")
elif n > round((2. * eh_size) / (rc + skin) - 0.5 + 2.) and min(boxList) / (rc + skin) < 4.:
boxList = [slabMSDims[0] * ((2. * eh_size) + 2. * (rc + skin)), slabMSDims[1] * ((2. * eh_size) + 2. * (rc + skin)), slabMSDims[2] * ((2. * eh_size) + 2. * (rc + skin))]
boxList = [(1 - slabMSDims[0]) * box_size[0] + boxList[0], (1 - slabMSDims[1]) * box_size[1] + boxList[1], (1 - slabMSDims[2]) * box_size[2] + boxList[2]]
# boxList=[box_size[0],box_size[1],box_size[2]] # UJ is here
print("HeSpaDDA message: this option THREE of the ideal gas size box your low resolution region is just sufficiently big")
else:
print("HeSpaDDA message: No more space for distributing Cores...look if you could use some HalfCells, or reduce the nr. of processors used and try again")
else:
boxList = [(2. * eh_size) + 2. * (rc + skin), (2. * eh_size) + 2. * (rc + skin), (2. * eh_size) + 2. * (rc + skin)] # IDEA: multiply here by the cells refina
else:
print("HeSpaDDA message: Non AdResS DD!")
# Here starts the new Dimensional aware HDD algorithm which. Dependencies: loadbal
LoN_Avgmin = sum(boxList)
# ima and imi sort values according to the box dimensions
ima = boxList.index(max(boxList))
imi = boxList.index(min(boxList))
dN = [1, 1, 1]
fdN = [0, 0, 0]
if ((abs(box_size[1] - box_size[2]) < (1.0* (rc + skin))) or (abs(box_size[0] - box_size[1]) < (1.0* (rc + skin))) or (abs(box_size[0] - box_size[2]) < (1* (rc + skin)))) and not ((abs(box_size[1] - box_size[2]) < (1.0* (rc + skin))) and (abs(box_size[0] - box_size[1]) < (1.0* (rc + skin)))):
print('HeSpaDDA message: AdResS DD with 2 equal dimensions!')
for i in range(1, n + 1):
for j in range(i, n + 1):
if (i * i * j == n) and (i * i + j * j + i * i < ijkmax):
dN[0] = j
dN[1] = i
dN[2] = i
ijkmax = i * i + j * j + i * i
# This checks if the system's box is cubic if not add weighted averages
# NOTE: It could be further optimized on a system by system basis as f(deltaCellSize beteween cores) this corresponds to the general version.
if qbicity(box_size, rc, skin) == False:
ndN = changeIndex(dN, ima, imi)[:]
redDi= [float(boxList[0]) / sum(boxList), float(boxList[1]) / sum(boxList), float(boxList[2]) / sum(boxList)]
LoN_norm = [boxList[0]*redDi[0] / ndN[0], boxList[1]*redDi[1] / ndN[1], boxList[2]*redDi[2] / ndN[2]]
LoN_Avg = sum(LoN_norm) / 3.0
if LoN_Avg <= LoN_Avgmin:
LoN_Avgmin = LoN_Avg
fdN = ndN[:]
ijkmax = fdN[0] * fdN[0] + fdN[1] * fdN[1] + fdN[2] * fdN[2]
print(fdN)
else:
ijkmax = fdN[0] * fdN[0] + fdN[1] * fdN[1] + fdN[2] * fdN[2]
print('HeSpaDDA message: No update of dN req ...')
else:
print('Cubicity check passed -> powered by HeSpaDDA')
fdN = [j, i, i]
else:
for i in range(1, n + 1):
for j in range(i, n + 1):
for k in range(j, n + 1):
if (i * j * k == n) and (i * i + j * j + k * k < ijkmax):
dN[0] = k
dN[1] = j
dN[2] = i
ijkmax = i * i + j * j + k * k
# This checks if the system's box is cubic if not add weighted averages
# NOTE: It could be further optimized on a system by system basis as f(deltaCellSize beteween cores) this corresponds to the general version.
if qbicity(box_size, rc, skin) == False:
ndN = changeIndex(dN, ima, imi)[:]
redDi= [float(boxList[0]) / sum(boxList), float(boxList[1]) / sum(boxList), float(boxList[2]) / sum(boxList)]
LoN_norm = [boxList[0]*redDi[0] / ndN[0], boxList[1]*redDi[1] / ndN[1], boxList[2]*redDi[2] / ndN[2]]
LoN_Avg = sum(LoN_norm) / 3.0
if LoN_Avg <= LoN_Avgmin:
LoN_Avgmin = LoN_Avg
fdN = ndN[:]
ijkmax = fdN[0] * fdN[0] + fdN[1] * fdN[1] + fdN[2] * fdN[2]
print(fdN)
else:
ijkmax = fdN[0] * fdN[0] + fdN[1] * fdN[1] + fdN[2] * fdN[2]
print('HeSpaDDA message: No update of dN req ...')
else:
print('Cubicity check passed -> powered by HeSpaDDA')
fdN = [k, j, i]
if abs(box_size[1] - box_size[2]) < (2 * (rc + skin)):
if fdN[2] > fdN[1]:
aux = fdN[2]
fdN[2] = fdN[1]
fdN[1] = aux
else:
print('HeSpaDDA message: Size Lenghts are eq. while ordering axis with preference on X, Y and Z!')
else:
print('HeSpaDDA message: Size Lenghts are different in Y and Z!')
return Int3D(fdN[0], fdN[1], fdN[2])
elif eh_size==0:
ijkmax = 3 * n * n + 1
boxList = [box_size[0], box_size[1], box_size[2]]
# Here starts the new Dimensional aware HDD algorithm which. Dependencies: loadbal
LoN_Avgmin = sum(boxList)
# ima and imi sort values according to the box dimensions
ima = boxList.index(max(boxList))
imi = boxList.index(min(boxList))
dN = [1, 1, 1]
fdN = [0, 0, 0]
if ((abs(box_size[1] - box_size[2]) < (1.0* (rc + skin))) or (abs(box_size[0] - box_size[1]) < (1.0* (rc + skin))) or (abs(box_size[0] - box_size[2]) < (1* (rc + skin)))) and not ((abs(box_size[1] - box_size[2]) < (1.0* (rc + skin))) and (abs(box_size[0] - box_size[1]) < (1.0* (rc + skin)))):
print('HeSpaDDA message: Non AdResS DD with 2 equal dimensions!')
for i in range(1, n + 1):
for j in range(i, n + 1):
if (i * i * j == n) and (i * i + j * j + i * i < ijkmax):
dN[0] = j
dN[1] = i
dN[2] = i
ijkmax = i * i + j * j + i * i
# This checks if the system's box is cubic if not add weighted averages
# NOTE: It could be further optimized on a system by system basis as f(deltaCellSize beteween cores) this corresponds to the general version.
if qbicity(box_size, rc, skin) == False:
ndN = changeIndex(dN, ima, imi)[:]
redDi= [float(boxList[0]) / sum(boxList), float(boxList[1]) / sum(boxList), float(boxList[2]) / sum(boxList)]
LoN_norm = [boxList[0]*redDi[0] / ndN[0], boxList[1]*redDi[1] / ndN[1], boxList[2]*redDi[2] / ndN[2]]
LoN_Avg = sum(LoN_norm) / 3.0
if LoN_Avg <= LoN_Avgmin:
LoN_Avgmin = LoN_Avg
fdN = ndN[:]
ijkmax = fdN[0] * fdN[0] + fdN[1] * fdN[1] + fdN[2] * fdN[2]
print(fdN)
else:
ijkmax = fdN[0] * fdN[0] + fdN[1] * fdN[1] + fdN[2] * fdN[2]
print('HeSpaDDA message: No update of dN req ...')
else:
print('Cubicity check passed -> powered by HeSpaDDA')
fdN = [j, i, i]
else:
for i in range(1, n + 1):
for j in range(i, n + 1):
for k in range(j, n + 1):
if (i * j * k == n) and (i * i + j * j + k * k < ijkmax):
dN[0] = k
dN[1] = j
dN[2] = i
ijkmax = i * i + j * j + k * k
# This checks if the system's box is cubic if not add weighted averages
# NOTE: It could be further optimized on a system by system basis as f(deltaCellSize beteween cores) this corresponds to the general version.
if qbicity(box_size, rc, skin) == False:
ndN = changeIndex(dN, ima, imi)[:]
redDi= [float(boxList[0]) / sum(boxList), float(boxList[1]) / sum(boxList), float(boxList[2]) / sum(boxList)]
LoN_norm = [boxList[0]*redDi[0] / ndN[0], boxList[1]*redDi[1] / ndN[1], boxList[2]*redDi[2] / ndN[2]]
LoN_Avg = sum(LoN_norm) / 3.0
if LoN_Avg <= LoN_Avgmin:
LoN_Avgmin = LoN_Avg
fdN = ndN[:]
ijkmax = fdN[0] * fdN[0] + fdN[1] * fdN[1] + fdN[2] * fdN[2]
print(fdN)
else:
ijkmax = fdN[0] * fdN[0] + fdN[1] * fdN[1] + fdN[2] * fdN[2]
print('HeSpaDDA message: No update of dN req ...')
else:
print('Cubicity check passed -> powered by HeSpaDDA')
fdN = [k, j, i]
if abs(box_size[1] - box_size[2]) < (2 * (rc + skin)):
if fdN[2] > fdN[1]:
aux = fdN[2]
fdN[2] = fdN[1]
fdN[1] = aux
else:
print('HeSpaDDA message: Size Lenghts are eq. while ordering axis with preference on X, Y and Z!')
else:
print('HeSpaDDA message: Size Lenghts are different in Y and Z!')
return Int3D(fdN[0], fdN[1], fdN[2])
interFENE = espressopp.interaction.FixedPairListFENE(system, bondlist, potFENE)
system.addInteraction(interFENE)
for k in range(5):
espressopp.tools.analyse.info(system, integrator)
cmvel = Real3D(0., 0., 0.)
for i in range(1, num_particles + 1):
particle = system.storage.getParticle(i)
cmvel += particle.v
print "centre of mass velocity is ", cmvel
integrator.run(100)
#thermostat.disconnect() # disconnect md-thermostat as we want to run lb-md coupled system
# define a LB grid
lb = espressopp.integrator.LatticeBoltzmann(system, Ni=Int3D(16, 16, 16))
initPop = espressopp.integrator.LBInitPopUniform(system, lb)
initPop.createDenVel(1.0, Real3D(0., 0., 0.0))
# declare gammas responsible for viscosities (if they differ from 0)
lb.gamma_b = 0.5
lb.gamma_s = 0.5
# specify desired temperature (set the fluctuations if any)
lb.lbTemp = 0.000025
lb.fricCoeff = 20.
# add extension to the integrator
integrator.addExtension(lb)
print integrator.dt
import espressopp
from espressopp import Int3D
from espressopp import Real3D
# create default Lennard Jones (WCA) system with 0 particles and cubic box (L=40)
system, integrator = espressopp.standard_system.LennardJones(100,
box=(s, s, s),
temperature=1.)
system.rng.seed = 123456
integrator = espressopp.integrator.VelocityVerlet(system)
integrator.dt = 0.01
# define a LB grid
nodeGrid = espressopp.tools.decomp.nodeGrid(espressopp.MPI.COMM_WORLD.size)
lb = espressopp.integrator.LatticeBoltzmann(system,
nodeGrid,
Ni=Int3D(s, s, s))
# add extension to the integrator
integrator.addExtension(lb)
lb.visc_b = 3.
lb.visc_s = 3.
lb.profStep = 5000
#initPop = espressopp.integrator.LBInitPopUniform(system,lb)
initPop = espressopp.integrator.LBInitPopWave(system, lb)
initPop.createDenVel(1.0, Real3D(0., 0., 0.))
#initPop.createDenVel(1.0, Real3D(0.,0.,0.001))
lboutputScreen = espressopp.analysis.LBOutputScreen(system, lb)
OUT3 = espressopp.integrator.ExtAnalyze(lboutputScreen, 5000)