def integrate_data(self,quantity,*domains,**kwargs):
return_list = False
if 'domains' in kwargs:
domains = kwargs['domains']
return_list = True
#end if
if 'return_list' in kwargs:
return_list = kwargs['return_list']
#end if
if quantity not in SpaceGridBase.quantities:
msg = 'requested integration of quantity '+quantity+'\n'
msg +=' '+quantity+' is not a valid SpaceGrid quantity\n'
msg +=' valid quantities are:\n'
msg +=' '+str(SpaceGridBase.quantities)
self.error(msg)
#end if
q = self.data[quantity]
results = list()
nblocks = q.shape[-1]
qi = zeros((nblocks,))
if len(domains)==0:
for b in xrange(nblocks):
qi[b] = q[...,b].sum()
#end for
(mean,var,error,kappa)=simstats(qi)
else:
for domain in domains:
for b in xrange(nblocks):
qb = q[...,b]
qi[b] = qb[domain].sum()
#end for
(mean,var,error,kappa)=simstats(qi)
res = QAobject()
res.mean = mean
res.error = error
res.data = qi.copy()
results.append(res)
#end for
#end for
if len(domains)<2:
return mean,error
else:
if not return_list:
return tuple(results)
else:
means = list()
errors = list()
for res in results:
means.append(res.mean)
errors.append(res.error)
#end for
return means,errors
def integrate_data(self, quantity, *domains, **kwargs):
return_list = False
if 'domains' in kwargs:
domains = kwargs['domains']
return_list = True
#end if
if 'return_list' in kwargs:
return_list = kwargs['return_list']
#end if
if quantity not in SpaceGridBase.quantities:
msg = 'requested integration of quantity ' + quantity + '\n'
msg += ' ' + quantity + ' is not a valid SpaceGrid quantity\n'
msg += ' valid quantities are:\n'
msg += ' ' + str(SpaceGridBase.quantities)
self.error(msg)
#end if
q = self.data[quantity]
results = list()
nblocks = q.shape[-1]
qi = zeros((nblocks, ))
if len(domains) == 0:
for b in xrange(nblocks):
qi[b] = q[..., b].sum()
#end for
(mean, var, error, kappa) = simstats(qi)
else:
for domain in domains:
for b in xrange(nblocks):
qb = q[..., b]
qi[b] = qb[domain].sum()
#end for
(mean, var, error, kappa) = simstats(qi)
res = QAobject()
res.mean = mean
res.error = error
res.data = qi.copy()
results.append(res)
#end for
#end for
if len(domains) < 2:
return mean, error
else:
if not return_list:
return tuple(results)
else:
means = list()
errors = list()
for res in results:
means.append(res.mean)
errors.append(res.error)
#end for
return means, errors
def analyze_local(self):
structure = QAanalyzer.run_info.system.structure
jnames = {'One-Body': 'J1', 'Two-Body': 'J2', 'Three-Body': 'J3'}
jastrows = QAobject()
for jt, jn in jnames.iteritems():
jastrows[jn] = QAobject()
#end for
del jastrows.J3
if len(structure.axes) == 3:
rcut_cell = structure.rwigner()
else:
rcut_cell = 10
#end if
J1, J2, J3 = self.info.wfn_xml.get(['J1', 'J2', 'J3'])
if J1 != None:
jname = 'J1'
func = J1.function.lower()
if func == 'bspline':
for jn, corr in J1.correlations.iteritems():
if 'rcut' in corr:
rcut = corr.rcut
else:
rcut = rcut_cell
#end if
coeff = corr.coefficients.coeff
jastrows[jname][jn] = Jastrow1B(func, coeff, rcut)
#end for
#end if
#end if
if J2 != None:
jname = 'J2'
func = J2.function.lower()
if func == 'bspline':
for jn, corr in J2.correlations.iteritems():
if 'rcut' in corr:
rcut = corr.rcut
else:
rcut = rcut_cell
#end if
s1 = corr.speciesa
s2 = corr.speciesb
coeff = corr.coefficients.coeff
jastrows[jname][jn] = Jastrow2B(func, coeff, s1, s2, rcut)
#end for
#end if
#end if
self._transfer_from(jastrows)
def interpolate(self,points,quantities=None):
if quantities==None:
quantities=SpaceGridBase.quantities
#end if
npoints,ndim = points.shape
ind = empty((npoints,2),dtype=int)
out = ones((npoints,) ,dtype=int)
nin = self.points2domains(points,ind,out)
result = QAobject()
for q in quantities:
result._add_attribute(q,QAobject())
result[q].mean = zeros((npoints,))
result[q].error = zeros((npoints,))
result[q].mean[ind[0:nin,0]] = self[q].mean[ind[0:nin,1]].copy()
result[q].error[ind[0:nin,0]] = self[q].error[ind[0:nin,1]].copy()
#end for
return result
def plot_jastrow_convergence(self,
title=None,
saveonly=False,
optconv=True):
if title is None:
tsin = None
else:
tsin = title
#end if
from matplotlib.pyplot import figure, subplot, xlabel, ylabel, plot, errorbar, title, xticks, xlim
opt = self.opts
nopt = len(opt)
if nopt == 0:
return
#end if
if optconv:
self.plot_opt_convergence(saveonly=saveonly)
#end if
#plot Jastrow functions
w = opt[0].wavefunction
jtypes = w.jastrow_types
order = QAobject()
for jt in jtypes:
if jt in w:
order[jt] = list(w[jt].__dict__.keys())
order[jt].sort()
#end if
#end for
cs = array([1., 0, 0])
ce = array([0, 0, 1.])
for jt in jtypes:
if jt in w:
figure()
nsubplots = len(order[jt])
n = 0
for o in order[jt]:
n += 1
subplot(nsubplots, 1, n)
if n == 1:
if tsin is None:
ts = 'Optimization: ' + jt + ' Convergence'
else:
ts = tsin
#end if
title(ts)
#end if
for i in range(len(opt)):
f = float(i) / len(opt)
c = f * ce + (1 - f) * cs
J = opt[i].wavefunction[jt][o]
J.plot(color=c)
#end for
ylabel(o)
#end for
xlabel('r (Bohr)')
def interpolate(self, points, quantities=None):
if quantities == None:
quantities = SpaceGridBase.quantities
#end if
npoints, ndim = points.shape
ind = empty((npoints, 2), dtype=int)
out = ones((npoints, ), dtype=int)
nin = self.points2domains(points, ind, out)
result = QAobject()
for q in quantities:
result._add_attribute(q, QAobject())
result[q].mean = zeros((npoints, ))
result[q].error = zeros((npoints, ))
result[q].mean[ind[0:nin, 0]] = self[q].mean[ind[0:nin, 1]].copy()
result[q].error[ind[0:nin, 0]] = self[q].error[ind[0:nin,
1]].copy()
#end for
return result
def __init__(self,initobj,options):
if options==None:
options = QAobject()
options.wasNone = True
options.points = None
options.exit_on_fail = True
options.nblocks_exclude = 0
else:
if 'points' not in options:
options.points = None
if 'exit_on_fail' not in options:
options.exit_on_fail = True
if 'nblocks_exclude' not in options:
options.nblocks_exclude = 0
#end if
self.points = options.points
self.init_exit_fail = options.exit_on_fail
self.nblocks_exclude = options.nblocks_exclude
self.keep_data = True
delvars = ['init_exit_fail','keep_data']
self.coord = None # string
self.coordinate = None
self.ndomains = None
self.domain_volumes = None
self.domain_centers = None
self.nvalues_per_domain = -1
self.nblocks = -1
self.D = QAobject() #Number Density
self.T = QAobject() #Kinetic Energy Density
self.V = QAobject() #Potential Energy Density
self.E = QAobject() #Energy Density, T+V
self.P = QAobject() #Local Pressure, (Volume)*P=(2*T+V)/3
self.init_special()
if initobj==None:
return
#end if
self.DIM=3
iname = initobj.__class__.__name__
self.iname=iname
if iname==self.__class__.__name__+'Initializer':
self.init_from_initializer(initobj)
elif iname==self.__class__.__name__:
self.init_from_spacegrid(initobj)
elif iname=='HDFgroup':
self.init_from_hdfgroup(initobj)
elif iname=='XMLelement':
self.init_from_xmlelement(initobj)
else:
self.error('Spacegrid cannot be initialized from '+iname)
#end if
delvars.append('iname')
self.check_complete()
for dv in delvars:
del self[dv]
#end for
self._reset_dynamic_methods()
self._register_dynamic_methods()
return
def test(self):
from enthought.mayavi import mlab
from numpy import array,dot,arange,sin,ogrid,mgrid,zeros
n=10
n2=2*n
s = '-'+str(n)+':'+str(n)+':'+str(n2)+'j'
exec 'x, y, z = ogrid['+s+','+s+','+s+']'
del s
#x, y, z = ogrid[-10:10:20j, -10:10:20j, -10:10:20j]
#x, y, z = mgrid[-10:11:1, -10:11:1, -10:11:1]
s = sin(x*y*z)/(x*y*z)
#xl = [-5.0,-4.2,-3.5,-2.1,-1.7,-0.4,0.7,1.8,2.6,3.7,4.3,5.0]
#yl = [-5.0,-4.3,-3.6,-2.2,-1.8,-0.3,0.8,1.7,2.7,3.6,4.4,5.0]
#zl = [-5.0,-4.4,-3.7,-2.3,-1.9,-0.4,0.9,1.6,2.8,3.5,4.5,5.0]
dx = 2.0*n/(2.0*n-1.0)
xl = arange(-n,n+dx,dx)
yl = xl
zl = xl
x,y,z = ndgrid(xl,yl,zl)
s2 = sin(x*y*z)/(x*y*z)
#shear the grid
nx,ny,nz = x.shape
A = array([[1,1,-1],[1,-1,1],[-1,1,1]])
#A = array([[3,2,1],[0,2,1],[0,0,1]])
#A = array([[4,7,2],[8,4,3],[2,5,3]])
#A = 1.0*array([[1,2,3],[4,5,6],[7,8,9]]).transpose()
r = zeros((3,))
np=0
for i in range(nx):
for j in range(ny):
for k in range(nz):
r[0] = x[i,j,k]
r[1] = y[i,j,k]
r[2] = z[i,j,k]
#print np,r[0],r[1],r[2]
np+=1
r = dot(A,r)
x[i,j,k] = r[0]
y[i,j,k] = r[1]
z[i,j,k] = r[2]
#end for
#end for
#end for
s2 = sin(x*y*z)/(x*y*z)
mlab.contour3d(x,y,z,s2)
mlab.show()
out = QAobject()
out.x=x
out.y=y
out.z=z
out.s=s2
out.A=A
return out
def analyze_local(self):
from spacegrid import SpaceGrid
nbe = QAanalyzer.method_info.nblocks_exclude
self.info.nblocks_exclude = nbe
data = self.data
#why is this called 3 times?
print nbe
#transfer hdf data
sg_pattern = re.compile(r'spacegrid\d*')
nspacegrids=0
# add simple data first
for k,v in data._iteritems():
if not sg_pattern.match(k):
self._add_attribute(k,v)
else:
nspacegrids+=1
#end if
#end for
# add spacegrids second
opts = QAobject()
opts.points = self.reference_points
opts.nblocks_exclude = nbe
self.spacegrids=[]
if nspacegrids==0:
self.spacegrids.append(SpaceGrid(data.spacegrid,opts))
else:
for ig in range(nspacegrids):
sg=SpaceGrid(data['spacegrid'+str(ig+1)],opts)
self.spacegrids.append(sg)
#end for
#end if
#reorder atomic data to match input file for Voronoi grids
if self.run_info.type=='bundled':
self.info.reordered=True
#end if
if not self.info.reordered:
self.reorder_atomic_data()
#end if
#convert quantities outside all spacegrids
outside = QAobject()
iD,iT,iV = tuple(range(3))
outside.D = QAobject()
outside.T = QAobject()
outside.V = QAobject()
outside.E = QAobject()
outside.P = QAobject()
value = self.outside.value.transpose()[...,nbe:]
#mean,error = simplestats(value)
mean,var,error,kappa = simstats(value)
outside.D.mean = mean[iD]
outside.D.error = error[iD]
outside.T.mean = mean[iT]
outside.T.error = error[iT]
outside.V.mean = mean[iV]
outside.V.error = error[iV]
E = value[iT,:]+value[iV,:]
#mean,error = simplestats(E)
mean,var,error,kappa = simstats(E)
outside.E.mean = mean
outside.E.error = error
P = 2./3.*value[iT,:]+1./3.*value[iV,:]
#mean,error = simplestats(P)
mean,var,error,kappa = simstats(P)
outside.P.mean = mean
outside.P.error = error
self.outside = outside
self.outside.data = obj(
D = value[iD,:],
T = value[iT,:],
V = value[iV,:],
E = E,
P = P
)
return
def __init__(self, initobj, options):
if options == None:
options = QAobject()
options.wasNone = True
options.points = None
options.exit_on_fail = True
options.nblocks_exclude = 0
else:
if 'points' not in options:
options.points = None
if 'exit_on_fail' not in options:
options.exit_on_fail = True
if 'nblocks_exclude' not in options:
options.nblocks_exclude = 0
#end if
self.points = options.points
self.init_exit_fail = options.exit_on_fail
self.nblocks_exclude = options.nblocks_exclude
self.keep_data = True
delvars = ['init_exit_fail', 'keep_data']
self.coord = None # string
self.coordinate = None
self.ndomains = None
self.domain_volumes = None
self.domain_centers = None
self.nvalues_per_domain = -1
self.nblocks = -1
self.D = QAobject() #Number Density
self.T = QAobject() #Kinetic Energy Density
self.V = QAobject() #Potential Energy Density
self.E = QAobject() #Energy Density, T+V
self.P = QAobject() #Local Pressure, (Volume)*P=(2*T+V)/3
self.init_special()
if initobj == None:
return
#end if
self.DIM = 3
iname = initobj.__class__.__name__
self.iname = iname
if iname == self.__class__.__name__ + 'Initializer':
self.init_from_initializer(initobj)
elif iname == self.__class__.__name__:
self.init_from_spacegrid(initobj)
elif iname == 'HDFgroup':
self.init_from_hdfgroup(initobj)
elif iname == 'XMLelement':
self.init_from_xmlelement(initobj)
else:
self.error('Spacegrid cannot be initialized from ' + iname)
#end if
delvars.append('iname')
self.check_complete()
for dv in delvars:
del self[dv]
#end for
self._reset_dynamic_methods()
self._register_dynamic_methods()
return
def init_from_hdfgroup(self, init):
#copy all datasets from hdf group
value_pattern = re.compile('value')
gmap_pattern = re.compile(r'gmap\d*')
for k, v in init._iteritems():
exclude = k[0] == '_' or gmap_pattern.match(
k) or value_pattern.match(k)
if not exclude:
self.__dict__[k] = v
#end if
#end for
#convert 1x and 1x1 numpy arrays to just numbers
#convert Nx1 and 1xN numpy arrays to Nx arrays
array_type = type(array([]))
exclude = set(['value', 'value_squared'])
for k, v in self._iteritems():
if k[0] != '_' and type(v) == array_type and k not in exclude:
sh = v.shape
ndim = len(sh)
if ndim == 1 and sh[0] == 1:
self.__dict__[k] = v[0]
elif ndim == 2:
if sh[0] == 1 and sh[1] == 1:
self.__dict__[k] = v[0, 0]
elif sh[0] == 1 or sh[1] == 1:
self.__dict__[k] = v.reshape((sh[0] * sh[1], ))
#end if
#end if
#end if
#end for
#set coord string
self.coord = SpaceGridBase.coord_n2s[self.coordinate]
#determine if chempot grid
chempot = 'min_part' in init
self.chempot = chempot
if chempot:
npvalues = self.max_part - self.min_part + 1
self.npvalues = npvalues
#end if
#process the data in hdf value,value_squared
nbe = self.nblocks_exclude
nquant = self.nvalues_per_domain
ndomains = self.ndomains
nblocks, ntmp = init.value.shape
self.nblocks = nblocks
if not chempot:
value = init.value.reshape(nblocks, ndomains,
nquant).transpose(2, 1, 0)
else:
value = init.value.reshape(nblocks, ndomains, npvalues,
nquant).transpose(3, 2, 1, 0)
#end if
value = value[..., nbe:]
#(mean,error)=simplestats(value)
(mean, var, error, kappa) = simstats(value)
quants = ['D', 'T', 'V']
for i in range(len(quants)):
q = quants[i]
self[q].mean = mean[i, ...]
self[q].error = error[i, ...]
exec 'i' + q + '=' + str(i)
#end for
E = value[iT, ...] + value[iV, ...]
# (mean,error)=simplestats(E)
(mean, var, error, kappa) = simstats(E)
self.E.mean = mean
self.E.error = error
P = 2. / 3. * value[iT, ...] + 1. / 3. * value[iV, ...]
#(mean,error)=simplestats(P)
(mean, var, error, kappa) = simstats(P)
self.P.mean = mean
self.P.error = error
#convert all quantities into true densities
ovol = 1. / self.domain_volumes
sqovol = sqrt(ovol)
for q in SpaceGridBase.quantities:
self[q].mean *= ovol
self[q].error *= sqovol
#end for
#keep original data, if requested
if self.keep_data:
self.data = QAobject()
for i in range(len(quants)):
q = quants[i]
self.data[q] = value[i, ...]
#end for
self.data.E = E
self.data.P = P
#end if
#print 'sg'
#import code
#code.interact(local=locals())
return
