def parallel_listener(self,result_queue):
qtk.progress("MonteCarlo", "waiting results from",
self.parallel, "threads")
# check result every 0.01 second, HARD CODED
while result_queue.empty():
sleep(0.01)
result = result_queue.get() # collect results
qtk.done() # indicate job done
# return results to master
return result[0], result[1], result[2]
def parallel_listener(self, result_queue):
qtk.progress("MonteCarlo", "waiting results from", self.parallel,
"threads")
# check result every 0.01 second, HARD CODED
while result_queue.empty():
sleep(0.01)
result = result_queue.get() # collect results
qtk.done() # indicate job done
# return results to master
return result[0], result[1], result[2]
def run(self):
while not self.converged():
pop = self.get_pop()
qtk.progress("Optimizer", "GE iteration with %d new points" % len(pop))
self.register(pop)
fit, info = self.fitness(pop)
print pop
print fit
print info
if type(fit) is list:
self.update(pop, fit, info)
else:
self.update(pop, [fit], [info])
def __init__(self, path=':memory:', db_str=None, **kwargs):
if not db_str:
db_str = 'sqlite:///' + path
self.engine = create_engine(db_str, **kwargs)
self.name = db_str
if os.path.exists(path):
qtk.progress('DB', 'loading existing database: %s' % path)
Base.metadata.create_all(self.engine)
self.session = self.get_session(new=True)
def eeKernel(self, coord=None, batch_size=1):
if coord is None:
coord = self.molecule.R
else:
coord = np.atleast_2d(coord).astype(float)
out = []
itr = 1
for chunk in np.array_split(coord, batch_size):
if itr > 1:
qtk.progress("eeKernel", "processing batch: %d\n" % itr)
itr += 1
out.append(eeKernel(self.basis, chunk))
return np.concatenate(out)
def eeKernel(self, coord=None, batch_size=1, **kwargs):
if coord is None:
coord = self.molecule.R
else:
coord = np.atleast_2d(coord).astype(float)
out = []
itr = 1
for chunk in np.array_split(coord, batch_size):
if itr > 1:
qtk.progress("eeKernel", "processing batch: %d\n" % itr)
itr += 1
out.append(eeKernel(self.basis, chunk))
return np.concatenate(out)
def sys_run(cmd_str, log_file=None):
if log_file:
log = open(log_file, 'w')
try:
qtk.progress("QMRun", cmd_str)
if log_file:
run = sp.Popen(cmd_str, shell=True, stdout=log)
else:
run = sp.Popen(cmd_str, shell=True)
run.wait()
except Exception as err:
qtk.warning('%s failed with error: %s' % (cmd_str, err))
if log_file:
log.close()
def iterate(self, size=0.005):
dv = self.dv
oldE = self.E()
if self.new_deltadv is None:
self.old_deltadv = self.dE_ddv()
else:
self.old_deltadv = self.new_deltadv
self.dv = self.normalize(dv - self.old_deltadv * size)
self.update(self.dv)
self.new_deltadv = self.dE_ddv()
newE = self.E()
norm1 = np.linalg.norm(self.old_deltadv)
norm2 = np.linalg.norm(self.new_deltadv)
angle = np.dot(self.old_deltadv, self.new_deltadv) / (norm1 * norm2)
angle = np.arccos(angle) * 180 / np.pi
msg = "E=% 13.6E, grad_angle=% 8.3f, |grad|=%8.3f\n" % \
(newE, angle, norm1)
qtk.progress("ofdft", msg)
def iterate(self, size=0.005):
dv = self.dv
oldE = self.E()
if self.new_deltadv is None:
self.old_deltadv = self.dE_ddv()
else:
self.old_deltadv = self.new_deltadv
self.dv = self.normalize(dv - self.old_deltadv*size)
self.update(self.dv)
self.new_deltadv = self.dE_ddv()
newE = self.E()
norm1 = np.linalg.norm(self.old_deltadv)
norm2 = np.linalg.norm(self.new_deltadv)
angle = np.dot(self.old_deltadv, self.new_deltadv) / (norm1 * norm2)
angle = np.arccos(angle) * 180 / np.pi
msg = "E=% 13.6E, grad_angle=% 8.3f, |grad|=%8.3f\n" % \
(newE, angle, norm1)
qtk.progress("ofdft", msg)
def read_gaussian(fchk, **kwargs):
if 'name' in kwargs:
cube = kwargs['name']
root, ext = os.path.splitext(cube)
if ext != '.cube':
print ext
qtk.warning("extension .cube is required for many " + \
"visualization programs")
else:
root, ext = os.path.splitext(fchk)
cube = root + '.cube'
qtk.progress("CUBE", "writing file %s\n" % cube)
if 'flag' not in kwargs:
flag = 'density=scf'
else:
flag = kwargs['flag']
if 'grid' in kwargs:
grid = kwargs['grid']
cmd = '%s 1 %s %s %s -1' % (qtk.gaussian_cubegen_exe,
flag, fchk, cube)
run = sp.Popen(cmd, shell=True, stdin=sp.PIPE)
for i in range(len(grid)):
vec = grid[i]
if i == 0:
# for formated output
msg = '-1 %f %f %f\n' % (vec[1], vec[2], vec[3])
elif i == 1:
# for Bohr as grid unit
msg = '%d %f %f %f\n' % (-vec[0], vec[1], vec[2], vec[3])
else:
msg = '%d %f %f %f\n' % (vec[0], vec[1], vec[2], vec[3])
run.stdin.write(msg)
else:
cmd = '%s 1 %s %s %s' % (qtk.gaussian_cubegen_exe,
flag, fchk, cube)
run = sp.Popen(cmd, shell=True, stdin=sp.PIPE)
run.stdin.flush()
run.communicate()
run.wait()
q = qtk.CUBE(cube, format='cube')
zcoord = np.hstack([q.molecule.Z[:, np.newaxis], q.molecule.R])
zcoord[:,1:4] = zcoord[:,1:4] / 0.529177249
return q.data, zcoord, q.grid
def e_coulomb(self, gridpoints, **kwargs):
new, occ, kw, gridpoints = self._e_setting(gridpoints, **kwargs)
if 'batch_size' in kwargs:
batch_size = kwargs['batch_size']
del kwargs['batch_size']
else:
batch_size = 1
out = []
itr = 1
coord = gridpoints
for chunk in np.array_split(coord, batch_size):
qtk.progress("e_coulomb", "processing batch: %d\n" % itr)
itr += 1
kernel = new.coulombKernel(chunk / 1.8897261245650618, **kwargs)
rho = new.getRho(gridpoints=chunk, **kw)
out.append(0.5 * rho * kernel)
return np.concatenate(out)
def read_gaussian(fchk, **kwargs):
if 'name' in kwargs:
cube = kwargs['name']
root, ext = os.path.splitext(cube)
if ext != '.cube':
print ext
qtk.warning("extension .cube is required for many " + \
"visualization programs")
else:
root, ext = os.path.splitext(fchk)
cube = root + '.cube'
qtk.progress("CUBE", "writing file %s\n" % cube)
if 'flag' not in kwargs:
flag = 'density=scf'
else:
flag = kwargs['flag']
if 'grid' in kwargs:
grid = kwargs['grid']
cmd = '%s 1 %s %s %s -1' % (qtk.gaussian_cubegen_exe, flag, fchk, cube)
run = sp.Popen(cmd, shell=True, stdin=sp.PIPE)
for i in range(len(grid)):
vec = grid[i]
if i == 0:
# for formated output
msg = '-1 %f %f %f\n' % (vec[1], vec[2], vec[3])
elif i == 1:
# for Bohr as grid unit
msg = '%d %f %f %f\n' % (-vec[0], vec[1], vec[2], vec[3])
else:
msg = '%d %f %f %f\n' % (vec[0], vec[1], vec[2], vec[3])
run.stdin.write(msg)
else:
cmd = '%s 1 %s %s %s' % (qtk.gaussian_cubegen_exe, flag, fchk, cube)
run = sp.Popen(cmd, shell=True, stdin=sp.PIPE)
run.stdin.flush()
run.communicate()
run.wait()
q = qtk.CUBE(cube, format='cube')
zcoord = np.hstack([q.molecule.Z[:, np.newaxis], q.molecule.R])
zcoord[:, 1:4] = zcoord[:, 1:4] / 0.529177249
return q.data, zcoord, q.grid
def Molecules(file_name, **kwargs):
"""read nested xyz file and return molecule list"""
xyz = open(file_name, 'r')
content = xyz.readlines()
content = [line.replace('\t', ' ') for line in content]
xyz.close()
itr = 0
more_data = True
mols = []
while more_data:
try:
N = int(content[itr])
prop_list = content[itr + 1]
try:
prop_list = np.array(prop_list.split(' ')).astype(float)
except Exception as err:
qtk.warning(str(err))
prop_list = prop_list
coord_list = content[itr + 2:itr + N + 2]
coord = [
filter(None, [a for a in entry.split(' ')])
for entry in coord_list
]
type_list = list(np.array(coord)[:, 0])
type_list = [str(elem) for elem in type_list]
Z = np.array([qtk.n2Z(elem) for elem in type_list])
R = np.array(coord)[:, 1:4].astype(float)
mol_data = {}
for var in ['N', 'type_list', 'Z', 'R']:
mol_data[str(var)] = eval(var)
itr += N + 2
mols.append(qtk.Molecule(molecule_data=mol_data))
except Exception as err:
qtk.progress(
"Molecules", "%d molecules have been loaded with message %s." %
(len(mols), str(err)))
more_data = False
return mols
def e_coulomb(self, gridpoints, **kwargs):
new, occ, kw, gridpoints = self._e_setting(gridpoints, **kwargs)
if 'batch_size' in kwargs:
batch_size = kwargs['batch_size']
del kwargs['batch_size']
else:
batch_size = 1
out = []
itr = 1
coord = gridpoints
for chunk in np.array_split(coord, batch_size):
qtk.progress("e_coulomb", "processing batch: %d\n" % itr)
itr += 1
kernel = new.coulombKernel(
chunk / 1.8897261245650618,
**kwargs
)
rho = new.getRho(gridpoints = chunk, **kw)
out.append(0.5 * rho * kernel)
return np.concatenate(out)
def push(self, content=None, data=None, comment=None, date=None):
if date is None:
date = dt.now()
entry = Entry(date=date, content=content, comment=comment, data=data)
qtk.progress("DB", "adding entry", content, data, comment)
self.session.add(entry)
try:
qtk.progress("DB", "attempt to commit...")
self.session.commit()
qtk.progress("DB", "done")
except Exception as err:
qtk.warning('can not commit, error: %s' % err)
def pack_list(data_list, **kwargs):
if isinstance(data_list[0], qtk.Molecule):
typ = 'molecule'
Z = [m.Z for m in data_list]
max_N = max(map(len, Z))
elif isinstance(data_list[0], qtk.QMOutput):
typ = 'output'
Z = [o.molecule.Z for o in data_list if hasattr(o, 'molecule')]
max_N = max(map(len, Z))
else:
qtk.exit("not supported datatype")
if 'output' not in kwargs:
kwargs['output'] = 'dictionary'
xyzs = []
Zs = []
Es = []
xyzStr = []
for i in range(len(data_list)):
if i % 5000 == 0:
qtk.progress("processing %d" % (i + 1))
if typ == 'output':
if hasattr(data_list[i], 'molecule'):
molecule = data_list[i].molecule
else:
molecule = None
Es.append(data_list[i].Et)
elif typ == 'molecule':
molecule = data_list[i]
if molecule is not None:
zeroR = np.zeros([max_N - molecule.N, 3])
zeroZ = np.zeros(max_N - molecule.N)
xyz = np.vstack([molecule.R, zeroR]).tolist()
Z = np.hstack([molecule.Z, zeroZ])
if len(xyzs) == 0:
#xyzs = xyz
Zs = Z
else:
#xyzs = np.stack([xyzs,xyz])
Zs = np.vstack([Zs, Z])
xyzs.append(xyz)
if kwargs['output'] == 'extended_xyz':
xyzStr.append('%d\n' % molecule.N)
if typ == 'output':
xyzStr.append('%f\n' % data_list[i].Et)
elif typ == 'molecule':
xyzStr.append('\n')
for I in range(molecule.N):
r = molecule.R[I]
xyzStr.append('%-2s % 8.4f % 8.4f % 8.4f\n'\
% (molecule.type_list[I], r[0], r[1], r[2]))
xyzs = np.array(xyzs)
if len(Es) > 0:
Es = np.array(Es)
if len(xyzStr) > 0:
xyzStr = ''.join(xyzStr)
if kwargs['output'] == 'dictionary':
out = {'xyz': xyzs, 'Z': Zs}
if len(Es) > 0:
out['E'] = np.array(Es)
elif kwargs['output'] == 'extended_xyz':
out = xyzStr
else:
qtk.warning('not supported output format:%s' % kwargs['output'])
out = None
return out
def predict(self, size, **kwargs):
template = copy.deepcopy(self.rest_set)
index = range(len(self.rest_set))
rd.shuffle(index)
test_list = index[:size]
i = 0
self.test_set = [self.rest_set[i] for i in test_list]
self.kernelVectors = np.atleast_2d([])
self.testCoord = np.array([data.getVector() for data in self.test_set])
rrows, rcolumns = self.refCoord.shape
trows, tcolumns = self.testCoord.shape
# exteral C module
qtk.progress("Predition", "generating",\
"%dx%d" % (trows, rrows),\
"kernel projection..." )
self.kernelVectors = kv.kernel_vectors(self.refCoord, rrows, rcolumns,
self.testCoord, trows, tcolumns,
self.kernel, self.klargs)
qtk.done()
test_true = []
test_pred = []
for i in range(len(self.test_set)):
prediction = np.dot(self.kernelVectors[i], self.alphas)
self.test_set[i].prediction = prediction
test_true.append(self.test_set[i].ref)
test_pred.append(prediction)
# analize and status report
self.testTrue = np.array(test_true)
self.testPred = np.array(test_pred)
self.error = abs(self.testPred - self.testTrue)
self.MAE = sum(self.error) / len(self.error)
self.RMSE = np.sqrt(sum(self.error**2) / len(self.testTrue))
max_index = list(self.error).index(max(self.error))
min_index = list(self.error).index(min(self.error))
max_name = self.test_set[max_index].getName()
min_name = self.test_set[min_index].getName()
qtk.report("predicted MAE", self.MAE)
qtk.report("predicted RMSE", self.RMSE)
qtk.report("Maximum error", max(self.error), max_name)
qtk.report("Minimum error", min(self.error), min_name)
def error_estimate(ker, vec):
tmp = np.vstack([ker, vec])
K = np.vstack([tmp.T, np.append(vec, 1)]).T
old = np.linalg.det(ker)
new = np.linalg.det(K)
#kvec = np.dot(ker, vec.T)
#nvec = np.linalg.norm(vec)
#nkvec = np.linalg.norm(kvec)
# angle
#return np.arccos(np.dot(kvec,vec)/nvec/nkvec)
# length
return new / old
#ee = error_estimate(self.kernelMatrix, self.kernelVectors[0])
def error_i(i):
return error_estimate(self.kernelMatrix, self.kernelVectors[i])
verror = np.vectorize(error_i)
self.errorEstimate = verror(range(trows))
def training(self, size, **kwargs):
"""
set up training set, test set, and calculate alphas
"""
# 'lambda' is a python keyword...
if 'deviation' in kwargs:
self._lambda = kwargs['deviation']
else:
self._lambda = 0
qtk.report("Deviation parameter", self._lambda)
template = copy.deepcopy(self.data)
index = range(self.data_size)
rd.shuffle(index)
max_index = size
i = 0
self.training_set = []
self.training_index = []
reference_vector = []
ref_coord = []
# keep the flexibility for unset reference datapoint
while i < max_index:
if i == self.data_size:
qtk.exit("reference not set")
data_point = template[index[i]]
if not np.isnan(data_point.ref):
self.training_set.append(data_point)
self.training_index.append(index[i])
reference_vector.append(data_point.getRef())
ref_coord.append(data_point.getVector())
else:
max_index += 1
i += 1
self.refVector = np.array(reference_vector)
self.refCoord = np.array(ref_coord)
self.rest_set = [
data for i, data in enumerate(template)
if i not in self.training_index
]
def reset_alpha(i):
self.rest_set[i].alpha = np.nan
vreset_alpha = np.vectorize(reset_alpha)
vreset_alpha(range(len(self.rest_set)))
rows, columns = self.refCoord.shape
qtk.progress("Kernel", "generating",\
"%dx%d" % (size, size), "kernel matrix...")
# exteral C module
self.kernelMatrix = km.kernel_matrix(self.refCoord, rows, columns,
self.kernel, self.klargs)
qtk.done()
if 'eigen' in kwargs and kwargs['eigen']:
qtk.progress("Kernel", "proceed diagonalization...")
self.kernelEW, self.kernelEV =\
np.linalg.eigh(self.kernelMatrix)
qtk.done()
qtk.progress("Kernel", "inverting...")
self.alphas = np.dot(np.linalg.inv(self.kernelMatrix\
+ self._lambda*np.eye(size))\
,self.refVector)
qtk.done()
def set_alpha(i):
self.training_set[i].alpha = self.alphas[i]
vset_alpha = np.vectorize(set_alpha)
vset_alpha(range(len(self.training_set)))
def predict(self, size, **kwargs):
template = copy.deepcopy(self.rest_set)
index = range(len(self.rest_set))
rd.shuffle(index)
test_list = index[:size]
i = 0
self.test_set = [self.rest_set[i] for i in test_list]
self.kernelVectors = np.atleast_2d([])
self.testCoord = np.array(
[data.getVector() for data in self.test_set])
rrows, rcolumns = self.refCoord.shape
trows, tcolumns = self.testCoord.shape
# exteral C module
qtk.progress("Predition", "generating",\
"%dx%d" % (trows, rrows),\
"kernel projection..." )
self.kernelVectors = kv.kernel_vectors(self.refCoord,
rrows, rcolumns,
self.testCoord,
trows, tcolumns,
self.kernel,self.klargs)
qtk.done()
test_true = []
test_pred = []
for i in range(len(self.test_set)):
prediction = np.dot(self.kernelVectors[i], self.alphas)
self.test_set[i].prediction = prediction
test_true.append(self.test_set[i].ref)
test_pred.append(prediction)
# analize and status report
self.testTrue = np.array(test_true)
self.testPred = np.array(test_pred)
self.error = abs(self.testPred - self.testTrue)
self.MAE = sum(self.error)/len(self.error)
self.RMSE = np.sqrt(sum(self.error**2)/len(self.testTrue))
max_index = list(self.error).index(max(self.error))
min_index = list(self.error).index(min(self.error))
max_name = self.test_set[max_index].getName()
min_name = self.test_set[min_index].getName()
qtk.report("predicted MAE", self.MAE)
qtk.report("predicted RMSE", self.RMSE)
qtk.report("Maximum error", max(self.error), max_name)
qtk.report("Minimum error", min(self.error), min_name)
def error_estimate(ker, vec):
tmp = np.vstack([ker, vec])
K = np.vstack([tmp.T, np.append(vec,1)]).T
old = np.linalg.det(ker)
new = np.linalg.det(K)
#kvec = np.dot(ker, vec.T)
#nvec = np.linalg.norm(vec)
#nkvec = np.linalg.norm(kvec)
# angle
#return np.arccos(np.dot(kvec,vec)/nvec/nkvec)
# length
return new/old
#ee = error_estimate(self.kernelMatrix, self.kernelVectors[0])
def error_i(i):
return error_estimate(self.kernelMatrix,
self.kernelVectors[i])
verror = np.vectorize(error_i)
self.errorEstimate = verror(range(trows))
def training(self, size, **kwargs):
"""
set up training set, test set, and calculate alphas
"""
# 'lambda' is a python keyword...
if 'deviation' in kwargs:
self._lambda = kwargs['deviation']
else:
self._lambda = 0
qtk.report("Deviation parameter", self._lambda)
template = copy.deepcopy(self.data)
index = range(self.data_size)
rd.shuffle(index)
max_index = size
i = 0
self.training_set = []
self.training_index = []
reference_vector = []
ref_coord = []
# keep the flexibility for unset reference datapoint
while i<max_index:
if i==self.data_size:
qtk.exit("reference not set")
data_point = template[index[i]]
if not np.isnan(data_point.ref):
self.training_set.append(data_point)
self.training_index.append(index[i])
reference_vector.append(data_point.getRef())
ref_coord.append(data_point.getVector())
else:
max_index += 1
i += 1
self.refVector = np.array(reference_vector)
self.refCoord = np.array(ref_coord)
self.rest_set = [data for i, data in enumerate(template)
if i not in self.training_index]
def reset_alpha(i):
self.rest_set[i].alpha = np.nan
vreset_alpha = np.vectorize(reset_alpha)
vreset_alpha(range(len(self.rest_set)))
rows, columns = self.refCoord.shape
qtk.progress("Kernel", "generating",\
"%dx%d" % (size, size), "kernel matrix...")
# exteral C module
self.kernelMatrix = km.kernel_matrix(self.refCoord,
rows, columns,
self.kernel,self.klargs)
qtk.done()
if 'eigen' in kwargs and kwargs['eigen']:
qtk.progress("Kernel", "proceed diagonalization...")
self.kernelEW, self.kernelEV =\
np.linalg.eigh(self.kernelMatrix)
qtk.done()
qtk.progress("Kernel", "inverting...")
self.alphas = np.dot(np.linalg.inv(self.kernelMatrix\
+ self._lambda*np.eye(size))\
,self.refVector)
qtk.done()
def set_alpha(i):
self.training_set[i].alpha = self.alphas[i]
vset_alpha = np.vectorize(set_alpha)
vset_alpha(range(len(self.training_set)))
def QMRun(inp, program=setting.qmcode, **kwargs):
"""
interface to run qmcode with written inp files. It manages to start
qmcode in **cwd**, write to output, collect result,
clean up scratch, tmp files according to setup.
However, each code require different implementation.
input:
inp(str): path to input file
code(str): qmcode to run, default set to setting.qmcode
kwargs (optional):
threads=n(int): number of threads per job
bigmem=Boolean: big memory request, implemented for CPMD and others
CPMD:
save_restart=Boolean
scr=/path/to/scratch
"""
if 'threads' in kwargs:
_threads = kwargs['threads']
else:
_threads = 1
if 'bigmem' in kwargs:
_bigmem = kwargs['bigmem']
else:
if setting.memory > 16:
_bigmem = True
else:
_bigmem = False
if 'omp' in kwargs:
omp = kwargs['omp']
else:
omp = 1
if 'save_restart' in kwargs:
_save_restart = kwargs['save_restart']
else:
_save_restart = False
if 'save_density' in kwargs:
_save_density = kwargs['save_density']
else:
_save_density = False
if 'chdir' in kwargs and kwargs['chdir']\
or 'run_dir' in kwargs and kwargs['run_dir']:
dest_dir = os.path.splitext(inp)[0]
cwd = os.getcwd()
os.chdir(dest_dir)
###########################################
# SYSTEM CALL SUBPROCESS: Running mpi job #
###########################################
def compute(exestr, outpath, threads_per_job, **kwargs):
"""
initiate a single MPI job, wait for it, and write to output
"""
os.environ["OMP_NUM_THREADS"] = str(omp)
outfile = open(outpath, "w")
if threads_per_job > 1:
mpi_cmd = "%s %d" % (setting.mpistr, threads_per_job)
for mpi_flag in setting.mpi_flags:
if mpi_flag == '--cpus-per-proc':
flag = mpi_flag + ' ' + str(threads_per_job)
else:
flag = mpi_flag
mpi_cmd = mpi_cmd + ' ' + flag
cmd = mpi_cmd + ' ' + exestr
else:
cmd = exestr
ut.progress('QMInp.run', 'running job with command: %s\n' % cmd)
if 'env' in kwargs:
run = sp.Popen(cmd, shell=True, stdout=outfile, env=kwargs['env'])
else:
run = sp.Popen(cmd, shell=True, stdout=outfile)
# wait each mpijob to finish before lauching another
# otherwise all mpijobs will be launched simutaniously
run.wait()
outfile.close()
########## END OF SYSTEM CALL ##########
#################################
# SYSTEM CALL for post analysis #
#################################
def sys_run(cmd_str, log_file=None):
if log_file:
log = open(log_file, 'w')
try:
qtk.progress("QMRun", cmd_str)
if log_file:
run = sp.Popen(cmd_str, shell=True, stdout=log)
else:
run = sp.Popen(cmd_str, shell=True)
run.wait()
except Exception as err:
qtk.warning('%s failed with error: %s' % (cmd_str, err))
if log_file:
log.close()
########## END OF SYSTEM CALL ##########
#######################
# CPMD IMPLEMENTATION #
#######################
if program.lower() == 'cpmd':
if 'exe' in kwargs:
exe = kwargs['exe']
else:
exe = setting.cpmd_exe
if 'scr' in kwargs and kwargs['scr']:
scrdir = kwargs['scr']
ut.delete(inpname, 'FILEPATH', 2)
ut.insert(inpname, 'CPMD', ' FILEPATH\n %s' % scrdir)
inp_list = sorted(glob.glob('*.inp'))
for job in inp_list:
out = os.path.splitext(job)[0] + '.out'
exestr = "%s %s" % (exe, job)
compute(exestr, out, _threads)
if (len(inp_list) > 1):
rst_list = sorted(glob.glob('RESTART.*'))
if rst_list:
rst_n = rst_list[-1]
if os.path.exists('RESTART'):
os.remove('RESTART')
os.link(rst_n, 'RESTART')
final_out = re.sub(r'_[0-9][0-9].out$', '.out', out)
if final_out != out:
os.copy(out, final_out)
# clean up files
files = sorted(glob.glob('*'))
tmp = filter(\
lambda x: '.out' not in x \
and '.inp' not in x\
and '.psp' not in x\
and '.xyz' not in x\
and 'KPTS_GENERATION' not in x\
and 'RESTART' not in x\
and 'DENSITY' not in x\
and 'SPINDEN' not in x, files
)
for f in tmp:
os.remove(f)
if not _save_restart:
rst_list = sorted(glob.glob("RESTART*"))
for rfile in rst_list:
os.remove(rfile)
densities = sorted(glob.glob('*DEN*'))
for i in range(len(densities)):
exe = setting.cpmd_cpmd2cube_exe
cmd = "%s -fullmesh %s" % (exe, densities[i])
log_name = densities[i] + '_%02d.log' % i
sys_run(cmd, log_name)
#log = open(log_name, 'w')
#try:
# run = sp.Popen("%s -fullmesh %s" % (exe, densities[i]),
# shell=True,
# stdout=log)
# run.wait()
#except Exception as err:
# qtk.warning('%s failed with error: %s' % (exe, err))
#log.close()
if os.path.exists(out):
qio_out = qio.QMOut(out, program='cpmd')
else:
qio_out = None
#######################
# VASP IMPLEMENTATION #
#######################
elif program.lower() == 'vasp':
if 'exe' in kwargs:
exestr = kwargs['exe']
else:
exestr = setting.vasp_exe
qmoutput = inp + '.out'
qmlog = inp + '.log'
compute(exestr, qmoutput, _threads)
qio_out = qio.QMOut('vasprun.xml', program='vasp')
if not _save_restart:
try:
os.remove('WAVECAR')
except:
pass
try:
os.remove('POTCAR')
except:
pass
os.rename(qmoutput, qmlog)
shutil.copyfile('vasprun.xml', qmoutput)
#########################
# NWChem IMPLEMENTATION #
#########################
elif program.lower() == 'nwchem':
if 'exe' in kwargs:
exe = kwargs['exe']
else:
exe = setting.nwchem_exe
exestr = "%s %s" % (exe, inp)
qmoutput = os.path.splitext(inp)[0] + '.out'
compute(exestr, qmoutput, _threads)
qio_out = qio.QMOut(qmoutput, program='nwchem')
files = sorted(glob.glob('*.*'))
tmp = filter(\
lambda x: '.out' not in x \
and '.inp' not in x\
and '.cube' not in x\
and '.movecs' not in x, files
)
for f in tmp:
os.remove(f)
movecs = sorted(glob.glob('*.movecs'))
for f in movecs:
exe = setting.nwchem_mov2asc_exe
nb = qio_out.n_basis
out = re.sub('\.movecs', '.modat', f)
exestr = "%s %d %s %s" % (exe, nb, f, out)
sys_run(exestr)
#try:
# run = sp.Popen(exestr, shell=True)
# run.wait()
# qio_out.getMO(out)
#except Exception as err:
# qtk.warning('%s failed with error: %s' % (exe, err))
if not _save_restart:
os.remove(f)
#########################
# BigDFT IMPLEMENTATION #
#########################
elif program.lower() == 'bigdft':
if 'exe' in kwargs:
exe = kwargs['exe']
else:
exe = setting.bigdft_exe
env = os.environ.copy()
inp = os.path.splitext(inp)[0]
exestr = "%s %s" % (exe, inp)
qmoutput = inp + '.out'
qmlog = 'log-%s.yaml' % inp
compute(exestr, qmoutput, _threads, env=env)
qio_out = qio.QMOut(qmlog, program='bigdft')
#########################
# Abinit IMPLEMENTATION #
#########################
elif program.lower() == 'abinit':
if 'exe' in kwargs:
exe = kwargs['exe']
else:
exe = setting.abinit_exe
inp = os.path.splitext(inp)[0]
exestr = "%s < %s" % (exe, inp + '.files')
qmlog = inp + '.log'
qmoutput = inp + '.out'
compute(exestr, qmlog, _threads)
# unfold bandstructure
if 'unfold' in kwargs and kwargs['unfold']:
folds = kwargs['unfold']
exe = setting.abinit_f2b_exe
wfk_list = sorted(glob.glob("*_WFK"))
if len(wfk_list) > 0:
wfk = wfk_list[-1]
qtk.progress("QMRun",
"linking wfk file %s to unfold_WFK" % wfk)
os.link(wfk, 'unfold_WFK')
wfk_root = wfk.replace('_WFK', '')
log_name = '%s_f2b.log' % wfk_root
fold_str = [str(f) for f in folds]
cmd_str = "%s unfold_WFK %s" % (exe, ':'.join(fold_str))
sys_run(cmd_str, log_name)
qtk.progress("QMRun", "Done, remove unfold_WFK")
os.remove('unfold_WFK')
#try:
# qtk.progress("QMRun", cmd_str)
# run = sp.Popen(cmd_str, shell=True, stdout=log)
# run.wait()
#except Exception as err:
# qtk.warning('%s failed with error: %s' % (exe, err))
#log.close()
else:
qtk.warning('unfolding but no wavefunction file found...')
if 'unfold_cleanup' in kwargs and kwargs['unfold_cleanup']:
qtk.progress("QMRun", "deleting all WFK files")
for wfk in sorted(glob.glob("*_WFK")):
os.remove(wfk)
# clean up files
files = sorted(glob.glob('*'))
tmp = filter(\
lambda x: '.out' not in x \
and '.f2b' not in x\
and '.log' not in x\
and '.inp' not in x\
and '.files' not in x\
and 'psp' not in x\
and '_EIG' not in x\
and '_WFK' not in x\
and '_DOS' not in x\
and '_DEN' not in x, files
)
for f in tmp:
os.remove(f)
if not _save_restart:
for rst in sorted(glob.glob('*_WFK')):
os.remove(rst)
if not _save_density:
for den in sorted(glob.glob('*_DEN')):
os.remove(den)
densities = sorted(glob.glob('*_DEN'))
if len(densities) > 0:
i = len(densities) - 1
exe = setting.abinit_cut3d_exe
#den_inp = densities[i] + '.cov'
den_inp = densities[-1] + '.cov'
cube_file = inp + '.cube'
den_inp_file = open(den_inp, 'wb')
den_inp_file.write("%s\n14\n%s\n0" % (densities[i], cube_file))
den_inp_file.close()
log_name = densities[i] + '.log'
cmd = "%s < %s" % (exe, den_inp)
sys_run(cmd, log_name)
#log = open(log_name, 'w')
#try:
# run = sp.Popen("%s < %s" % (exe, den_inp),
# shell=True,
# stdout=log)
# run.wait()
#except Exception as err:
# qtk.warning('%s failed with error: %s' % (exe, err))
#log.close()
qio_out = qtk.QMOut(qmoutput, program='abinit')
#############################
# Gaussian09 IMPLEMENTATION #
#############################
elif program.lower() == 'gaussian':
if 'exe' in kwargs:
exe = kwargs['exe']
else:
exe = setting.gaussian_exe
exestr = "%s %s" % (exe, inp)
qmoutput = os.path.splitext(inp)[0] + '.out'
qmlog = os.path.splitext(inp)[0] + '.log'
compute(exestr, qmoutput, _threads)
os.rename(qmlog, qmoutput)
chks = sorted(glob.glob('*.chk'))
for chk in chks:
exe = setting.gaussian_formchk_exe
exestr = "%s %s" % (exe, chk)
sys_run(exestr)
#run = sp.Popen(exestr, shell=True)
#run.wait()
if _save_density:
fchk = sorted(glob.glob("*.fchk"))[-1]
q = qtk.CUBE(fchk)
qio_out = qio.QMOut(qmoutput, program='gaussian')
##################################
# QuantumESPRESSO IMPLEMENTATION #
##################################
elif program.lower() == 'espresso':
if 'exe' in kwargs:
exe = kwargs['exe']
else:
exe = setting.espresso_exe
inp_list = sorted(glob.glob('*.inp'))
for job in inp_list:
out = os.path.splitext(job)[0] + '.out'
exestr = "%s < %s" % (exe, job)
compute(exestr, out, _threads)
qio_out = qio.QMOut(out, program='espresso')
if not _save_restart:
rst_list = sorted(glob.glob("*.wfc*"))
rst_list.extend(sorted(glob.glob("*.restart_*")))
else:
rst_list = []
for r in rst_list:
os.remove(r)
#########################
# GAMESS IMPLEMENTATION #
#########################
elif program.lower() == 'gamess':
ut.exit("ERROR! program '%s' not implemented" % program)
# and others... #
else:
ut.exit("ERROR! program '%s' not recognized" % program)
if 'cwd' in locals():
os.chdir(cwd)
qio_out.path = inp
return qio_out
def pack(data_list, **kwargs):
if isinstance(data_list[0], qtk.Molecule):
typ = 'molecule'
Z = [m.Z for m in data_list]
max_N = max(map(len, Z))
elif isinstance(data_list[0], qtk.QMOutput):
typ = 'output'
Z = [o.molecule.Z for o in data_list if hasattr(o, 'molecule')]
max_N = max(map(len, Z))
else:
qtk.warning("not supported datatype")
if 'output' not in kwargs:
kwargs['output'] = 'dictionary'
xyzs = []
Zs = []
Es = []
xyzStr = []
for i in range(len(data_list)):
if i % 5000 == 0:
qtk.progress("processing %d" % (i + 1))
if typ == 'output':
if hasattr(data_list[i], 'molecule'):
molecule = data_list[i].molecule
else:
molecule = None
Es.append(data_list[i].Et)
elif typ == 'molecule':
molecule = data_list[i]
if molecule is not None:
zeroR = np.zeros([max_N - molecule.N, 3])
zeroZ = np.zeros(max_N - molecule.N)
xyz = np.vstack([molecule.R, zeroR]).tolist()
Z = np.hstack([molecule.Z, zeroZ])
if len(xyzs) == 0:
#xyzs = xyz
Zs = Z
else:
#xyzs = np.stack([xyzs,xyz])
Zs = np.vstack([Zs,Z])
xyzs.append(xyz)
if kwargs['output'] == 'extended_xyz':
xyzStr.append('%d\n' % molecule.N)
if typ == 'output':
xyzStr.append('%f\n' % data_list[i].Et)
elif typ == 'molecule':
xyzStr.append('\n')
for I in range(molecule.N):
r = molecule.R[I]
xyzStr.append('%-2s % 8.4f % 8.4f % 8.4f\n'\
% (molecule.type_list[I], r[0], r[1], r[2]))
xyzs = np.array(xyzs)
if len(Es) > 0:
Es = np.array(Es)
if len(xyzStr) > 0:
xyzStr = ''.join(xyzStr)
if kwargs['output'] == 'dictionary':
out = {'xyz': xyzs, 'Z': Zs}
if len(Es) > 0:
out['E'] = np.array(Es)
elif kwargs['output'] == 'extended_xyz':
out = xyzStr
else:
qtk.warning('not supported output format:%s' % kwargs['output'])
out = None
return out
def close(self, **kwargs):
"""
finalize input content by either 1) creating folder,
coping dependent files and write input content to file
with correct name or 2) print to screen
Note that is returns full path to the file is writes to
for posprocessing
"""
self.path = os.getcwd()
if self.output:
# process file name
if 'name' in kwargs:
name = kwargs['name']
else:
name = self.file_name
if self.prefix:
name = self.prefix + name
self.root_dir = self.prefix + self.root_dir
if self.suffix:
name = name + self.suffix
self.root_dir = self.root_dir + self.suffix
if self.extension:
name = name + '.' + self.extension
self.final_name = name
full_dir_path = self.path
# process directory name and clean up
if self.root_dir:
full_dir_path = os.path.join(self.path, self.root_dir)
if name:
full_path = os.path.join(full_dir_path, name)
if not 'no_cleanup' in kwargs or not kwargs['no_cleanup']:
if self.root_dir:
self.cleanPath(full_dir_path, self.overwrite)
self.cleanPath(full_path, self.overwrite)
if not os.path.exists(full_dir_path):
os.makedirs(full_dir_path)
self.final_path = full_dir_path
# copy dependent files
if 'dependent_files' in kwargs:
self.dependent_files.extend(kwargs['dependent_files'])
for dep_entry in self.dependent_files:
if type(dep_entry) is str:
# copy file directly
dep = dep_entry
dep_name = os.path.split(dep)[1]
dep_src = os.path.abspath(dep)
dep_tar = os.path.join(full_dir_path, dep_name)
elif type(dep_entry) is list:
# copy file to different name [src, name]
dep = dep_entry[1]
dep_name = os.path.split(dep)[1]
dep_src = os.path.abspath(dep_entry[0])
#dep_src = os.path.join(dep_src, dep_name)
dep_tar = os.path.join(full_dir_path, dep_name)
elif type(dep_entry) is dict:
# copy file to different path/name {src: path/name}
dep = dep_entry.keys()[0]
dep_name = os.path.split(dep)[1]
dep_src = os.path.abspath(dep)
dep_tar = os.path.join(full_dir_path, dep_entry[dep])
if os.path.exists(dep_src):
try:
shutil.copytree(dep_src, dep_tar)
except OSError:
if hasattr(self, 'link_dep') and self.link_dep:
try:
os.link(dep_src, dep_tar)
qtk.progress('QMInp', '%s is linked\n' % \
os.path.split(dep_tar)[-1])
except Exception as err:
qtk.warning('error when linking %s, ' \
% os.path.split(dep_tar)[-1]\
+ 'attempt to copy...')
try:
shutil.copy(dep_src, dep_tar)
qtk.progess('QMInp', 'done.')
except Exception as err:
qtk.warning('failed! skipping %s' % \
os.path.split(dep_tar)[-1])
else:
shutil.copy(dep_src, dep_tar)
else:
qtk.warning('dependent file: %s not found' % dep)
inp = sys.stdout if not self.output else open(full_path, 'w')
for string in self.content:
if string:
inp.write(string)
if self.output:
inp.close()
self.finalized = True
