def update_user(id_user):
# query for check username
query_db = db.read('users', 'id', id_user)
user = query_db[0] if len(query_db) == 1 else None
if(user == None):
return jsonify(error(404, 'User not exists'))
else:
json = request.get_json()
username = json['username']
name = json['name']
email = json['email']
date = user['date_creation']
if (user['username'] != username and db.verify_register('users', 'username', username)):
return jsonify(error(400, 'User invalid or user already exists'))
else:
user = User(id_user, username, name, email, date)
if(db.update('users', id_user, user.to_dict())):
return jsonify(user.to_dict())
else:
return jsonify(error(203, 'Not Allowed'))
def set_input_values(self, input_values):
if len(input_values) == self.input_layer:
self.input_values = input_values
else:
e.error(e.ERROR_ARRAY_SIZES,
"input_values size does not match with self.input_values")
def update_task(id_task):
if request.method == "POST":
# query for check id task
query_db = db.read("tasks", "id", id_task)
task = query_db[0] if len(query_db) == 1 else None
if task == None:
return jsonify(error(404, "Task not exists"))
else:
json = request.get_json()
id = task["id"]
title = json["title"]
description = json["description"]
date = task["date"]
id_list = task["id_list"]
status = json["status"]
task = Task(
id=id,
id_list=id_list,
title=title,
description=description,
date=date,
status=status,
)
if db.update("tasks", id_task, task.to_dict()):
return jsonify(task.to_dict())
else:
return jsonify(error(203, "Not Allowed"))
def delete_task(id_task):
# query for check task
query_db = db.read('tasks', 'id', id_task)
task = query_db[0] if len(query_db) == 1 else None
if (task == None):
return jsonify(error(404, 'Task not exists'))
else:
if (db.delete('tasks', id_task)):
return jsonify(error(200, "Removed"))
else:
return jsonify(error(400, "Not removed"))
def delete_task(id_task):
if request.method == "DELETE":
# query for check task
query_db = db.read("tasks", "id", id_task)
task = query_db[0] if len(query_db) == 1 else None
if task == None:
return jsonify(error(404, "Task not exists"))
else:
if db.delete("tasks", id_task):
return jsonify(error(200, "Removed"))
else:
return jsonify(error(400, "Not removed"))
def set_training_samples(self, input_values, output_values):
# Note: I wanted to check the whole data-set here but I will decide later where to put it
if len(input_values) == len(output_values) and len(
input_values) > 0 and len(output_values) > 0:
for x in range(len(input_values)):
if len(input_values[x]) != self.input_layer or len(
output_values[x]) != self.output_layer:
e.error(e.ERROR_ARRAY_SIZES,
"data-set and the neural network are not matched")
self.training_samples = []
for x in range(len(input_values)):
self.training_samples.append(
TrainingData(input_values[x], output_values[x]))
else:
e.error(e.ERROR_ARRAY_SIZES,
"Some info in training data-set is missing")
def create_list():
json = request.get_json()
id = db.create_id('lists')
title = json['title']
id_user = json['id_user']
if (db.verify_register('lists', 'id', id)):
return jsonify(error(400, 'List already exists'))
else:
# create instance
list_user = List(id, id_user, title, datetime.datetime.utcnow())
# insert into database
if(db.insert('lists', list_user.to_dict())):
return jsonify(list_user.to_dict())
else:
return jsonify(error(203, 'Not Allowed'))
def create_task():
json = request.get_json()
id = db.create_id('tasks')
title = json['title']
description = json['description']
id_list = json['id_list']
if (db.verify_register('task', 'id', id)):
return jsonify(error(400, 'Task already exists'))
else:
# create instance
task = Task(id, id_list, title, description, datetime.datetime.utcnow())
# insert into database
if(db.insert('tasks', task.to_dict())):
return jsonify(task.to_dict())
else:
return jsonify(error(203, 'Not Allowed'))
def create_user():
json = request.get_json()
id = db.create_id('users')
username = json['username']
name = json['name']
email = json['email']
if (db.verify_register('users', 'username', username)):
return jsonify(error(400, 'Username already exists'))
else:
# create instance
user = User(id, username, name, email, datetime.datetime.utcnow())
# insert into database
if(db.insert('users', user.to_dict())):
return jsonify(user.to_dict())
else:
return jsonify(error(203, 'Not Allowed'))
def __init__(self,
lattice=None,
species=None,
coords=None,
real_or_complex='Real',
mindistance=16):
if lattice is None:
self.lattice = []
print "No lattice is set up"
else:
self.lattice = lattice
if species is None:
self.species = []
print "No species in Structure"
else:
self.species = species
if coords is None:
self.coords = []
print "No coords in Structure"
else:
self.coords = coords
if real_or_complex == 'Complex':
self.kgrid = self.gen_complex_kpts_lattice([1, 1, 1])
elif real_or_complex == 'Real':
self.kgrid = self.gen_real_kpts_lattice([1, 1, 1])
else:
print "No kgrid"
self.mindistance = mindistance
if len(species) != len(coords):
print "Number of species is not equal to number of coordinates"
elif len(lattice) != 3:
print "Structure is not a 3D lattice"
else:
assert isinstance(lattice, list), error("")
assert isinstance(species, list), error("")
assert isinstance(coords, list), error("")
def delete_list(id_list):
# query for check list
query_db = db.read('lists', 'id', id_list)
list_user = query_db[0] if len(query_db) == 1 else None
if (list_user == None):
return jsonify(error(404, 'List not exists'))
else:
if (db.delete('lists', id_list)):
# delete all tasks
tasks = db.read('tasks', 'id_list', id_list)
if (len(tasks) > 0):
for task in tasks:
db.delete('tasks', task['id'])
return jsonify(error(200, "Removed"))
else:
return jsonify(error(400, "Not removed"))
def create_list():
json = request.get_json()
id = db.create_id("lists")
title = json["title"]
id_user = json["id_user"]
if not db.verify_register("users", "id", id_user):
return jsonify(error(400, "User not exists"))
elif db.verify_register("lists", "id", id):
return jsonify(error(400, "List already exists"))
else:
# create instance
list_user = List(id, id_user, title, datetime.datetime.utcnow())
# insert into database
if db.insert("lists", list_user.to_dict()):
return jsonify(list_user.to_dict())
else:
return jsonify(error(203, "Not Allowed"))
def delete_list(id_list):
if request.method == "DELETE":
# query for check list
query_db = db.read("lists", "id", id_list)
list_user = query_db[0] if len(query_db) == 1 else None
if list_user == None:
return jsonify(error(404, "List not exists"))
else:
if db.delete("lists", id_list):
# delete all tasks
tasks = db.read("tasks", "id_list", id_list)
if len(tasks) > 0:
for task in tasks:
db.delete("tasks", task["id"])
return jsonify(error(200, "Removed"))
else:
return jsonify(error(400, "Not removed"))
def create_task():
json = request.get_json()
id = db.create_id("tasks")
title = json["title"]
description = json["description"]
id_list = json["id_list"]
if not db.verify_register("lists", "id", id_list):
return jsonify(error(400, "List not exists"))
elif db.verify_register("tasks", "id", id):
return jsonify(error(400, "Task already exists"))
else:
# create instance
task = Task(id, id_list, title, description,
datetime.datetime.utcnow())
# insert into database
if db.insert("tasks", task.to_dict()):
return jsonify(task.to_dict())
else:
return jsonify(error(203, "Not Allowed"))
def delete_user(id_user):
# query for check username
query_db = db.read('users', 'id', id_user)
user = query_db[0] if len(query_db) == 1 else None
if (user == None):
return jsonify(error(404, 'User not exists'))
else:
if (db.delete('users', id_user)):
# delete all lists
lists = db.read('lists', 'id_user', id_user)
if (len(lists) > 0):
for list_user in lists:
print(list_user['id'])
db.delete('lists', list_user['id'])
return jsonify(error(200, "Removed"))
else:
return jsonify(error(400, "Not removed"))
def update_list(id_list):
if request.method == "POST":
# query for check username
query_db = db.read("lists", "id", id_list)
list_user = query_db[0] if len(query_db) == 1 else None
if list_user == None:
return jsonify(error(404, "List not exists"))
else:
json = request.get_json()
id = list_user["id"]
title = json["title"]
date = list_user["date"]
id_user = list_user["id_user"]
link = list_user["link"]
list_user = List(id, id_user, title, date)
if db.update("lists", id_list, list_user.to_dict()):
return jsonify(list_user.to_dict())
else:
return jsonify(error(203, "Not Allowed"))
def __init__(self, comment=None, scale=None, struct=None, iscartesian=True):
if comment is None:
self.comment = "Default VASP inp_str"
else:
self.comment = comment
if scale is None:
self.scale = 1.0
else:
self.scale = scale
assert isinstance(struct, structure.Structure), error("structure type is incorrect")
self.structure = struct
self.iscartesian = iscartesian
def __call__(self, **kwargs):
for key, value in kwargs.iteritems():
if key in settings_list:
settings_list[key] = value
for key, value in settings_list.iteritems():
setattr(self, key, value)
self.rootdir = os.path.abspath(self.rootdir)
if not os.path.exists(self.rootdir):
error("rootdir does not exist")
self.pspdir = os.path.abspath(self.pspdir)
if not os.path.exists(self.pspdir):
error("pspdir:(" + self.pspdir + ") does not exist")
self.pspname = str(self.pspname)
self.machinename = self.machinename
if not isinstance(self.pspcutoffs, int):
if not os.path.exists(self.pspcutoffs):
self.pspcutoffs = self.pspdir + '/' + self.pspname + '/' + self.pspcutoffs
if not os.path.exists(self.pspcutoffs):
error("pspcutoffs file does not exist")
psp_dict = dict()
with open(self.pspcutoffs, 'r') as inf:
for line in inf:
(key, val) = line.split()
psp_dict[str(key)] = int(val)
self.psp_dict = psp_dict
inf.close()
if not socket.gethostname() == self.machinename:
message = "System hostname (" + str(
socket.gethostname()
) + ") is different from input hostname (" + self.machinename + "), but running anyway!"
warning(message)
def read_poscar(filename):
"""
Reads VASP POSCAR files, and returns VASP object, currently only cartesian coordinates are supported
Input VASP file must be in the following format (Cartesian POSCAR output using VESTA, http://jp-minerals.org/vesta/en/, will suffice).
Whitespaces are not important:
Ni1 O2
1.0
4.8754000664 0.0000000000 0.0000000000
0.0000000000 2.8141000271 0.0000000000
-3.2680774749 0.0000000000 4.5253056414
Ni O
2 4
Cartesian
0.000000000 0.000000000 0.000000000
2.437700033 1.407050014 0.000000000
1.648646319 0.000000000 1.045345631
-0.041323873 0.000000000 3.479960010
4.086346498 1.407050014 1.045345631
-2.479023761 1.407050014 3.479960010
"""
filename=os.path.abspath(filename)
with open(filename) as f:
lines = f.read().splitlines()
comment = lines[0]
scale = lines[1]
lattice = [[float(x) for x in lines[2].split()], [float(x) for x in lines[3].split()], [float(x) for x in lines[4].split()]]
if not isinstance(lines[5], str):
"""If the fifth line is string, it means that there are no species information"""
error("No species information in the POSCAR")
species_strs = lines[5].split()
species_counts=[int(x) for x in lines[6].split()]
if len(species_strs) != len(species_counts):
error("Number of species and number of species strings do not match")
species = []
for i in range(0, len(species_counts)):
species += [species_strs[i]] * species_counts[i]
iscartesian = []
if lines[7].startswith("C") or lines[7].startswith("c"):
iscartesian = True
elif lines[7].startswith("R") or lines[7].startswith("D") or lines[7].startswith("r") or lines[7].startswith("d"):
iscartesian = False
else:
error("Coordinates are not Cartesian or Reciprocal!")
coords = []
if iscartesian:
for i in range(8,len(lines)):
coords += [[float(x) for x in lines[i].split()[0:3]]]
else:
for i in range(8,len(lines)):
coords += [[float(x) for x in lines[i].split()[0:3]]]
#Dot product with the lattice, always print Cartesian
crd=np.dot(np.array(coords),np.array(lattice))
coords=crd.tolist()
return Vasp(comment=comment, scale=scale, struct=structure.Structure(lattice=lattice, species=species, coords=coords), iscartesian=iscartesian)
def __init__(self,
name=None,
source=None,
supercell_size=None,
structdir=None,
folded=True,
real_or_complex='Real',
mindistance=16):
assert isinstance(name, str), error("System settings are wrong")
assert isinstance(source, str), error("System settings are wrong")
self.structdir = os.path.abspath(structdir + "/" + name + "/" +
source + "/")
self.scell_size = supercell_size
self.inputfile = None
self.real_or_complex = real_or_complex
self.mindistance = mindistance
vaspInput = False
for file in os.listdir(self.structdir):
if fnmatch.fnmatch(file, '*.vasp'):
self.inputfile = os.path.abspath(self.structdir + "/" + file)
vaspInput = True
if self.inputfile is not None:
# Reads only vasp input for now
if vaspInput:
unit_cell = Vasp.read_poscar(self.inputfile)
unit_cell = unit_cell.structure
#Transfer variables from System to structure
assert isinstance(unit_cell, structure.Structure)
self.scell = unit_cell.get_supercell(supercell_size)
if real_or_complex == 'Real':
unit_cell.kgrid = unit_cell.gen_real_kpts_lattice(
self.scell)
if real_or_complex == 'Complex':
unit_cell.kgrid = unit_cell.gen_complex_kpts_lattice(
self.scell, mindistance)
self.unitcell = unit_cell
self.structure = []
if not folded:
self.structure = unit_cell.make_scell(self.scell)
else:
self.structure = copy.deepcopy(unit_cell)
for file in glob.glob(self.inputfile):
self.inputfile = file
self.runpspdir = os.path.abspath(settings.rootdir + '/runs/' + name +
'/' + settings.pspname + '/' + "psps")
if not os.path.exists(self.runpspdir):
os.makedirs(self.runpspdir)
self.rundir = settings.rootdir + '/runs/' + name + '/' + settings.pspname + '/' + source + '/radius.' + str(
supercell_size)
if not os.path.exists(self.rundir):
os.makedirs(self.rundir)
def __init__(self,
dft=None,
qmc_prev=None,
qmc='',
job=None,
psi=None,
**kwargs):
if dft is None:
print "Previous DFT calculation must be provided"
sys.exit()
assert isinstance(dft, Pwscf), error(
"In generate_casino block, dft must be a Pwscf object")
assert isinstance(psi, pw2casino)
# Inputs
self.dft = dft
self.psi = psi
print psi.bwfn
self.qmc_prev = qmc_prev
self.job = job
self.rundir = []
if qmc == 'vmc_opt':
self.rundir = self.dft.system.rundir + '/vmc'
self.qmc = qmc
elif qmc == 'vmc_dmc':
self.rundir = self.dft.system.rundir + '/dmc'
self.qmc = qmc
else:
raise ValueError, 'qmc should be either "vmc_opt", "vmc_dmc"'
self.kwargs = kwargs
# Class derived parameters
self.system = dft.system
self.kwargs.update({'scell_num': self.system.scell_size})
self.qmc_inputs = []
self.complete = False
if self.can_run_casino():
if self.dft.system.real_or_complex == 'Complex':
self.kwargs.update({'complex_wf': True})
if qmc_prev is None:
# Then, no DMC calculation is performed until now, so perform VMC
if not os.path.exists(self.rundir):
os.mkdir(self.rundir)
self.kwargs.update({'opt_jastrow': True})
self.correlation = self.write_correlation()
# self.correlation=generate_default_correlation()
self.qmc_defaults = [
default_qmc_system, default_qmc_run, default_vmc_opt,
default_qmc_expectation_values
]
else:
assert isinstance(qmc_prev, Casino), error(
"In generate_casino block, qmc_prev must be a Casino object or None object"
)
if qmc_prev.qmc == "vmc_opt":
if self.qmc == "vmc_opt":
# Copying the correlation data file from a smaller cell vmc_opt file
if not os.path.exists(self.rundir):
os.mkdir(self.rundir)
self.kwargs.update({'opt_jastrow': True})
self.correlation = self.transfer_correlation()
self.qmc_defaults = [
default_qmc_system, default_qmc_run,
default_vmc_opt, default_qmc_expectation_values
]
elif self.qmc == "vmc_dmc":
# Previous calculation is VMC, then, this is a DMC calculation, jastrow already optimized
if not os.path.exists(self.rundir):
os.mkdir(self.rundir)
self.kwargs.update({'opt_jastrow': False})
self.type = "vmc_dmc"
self.correlation = self.best_correlation(qmc_prev)
self.qmc_defaults = [
default_qmc_system, default_qmc_run, default_dmc,
default_qmc_expectation_values
]
if self.qmc == 'vmc_opt':
for file in os.listdir(self.system.runpspdir):
if fnmatch.fnmatch(file, '*_pp.data'):
os.symlink(self.system.runpspdir + '/' + file,
self.rundir)
ran_num = 2
filename = self.dft.system.rundir + '/qe_wfns/bwfn.{0:0>3}.data'.format(
ran_num)
self.kwargs.update({'neu': self.psi.neu[filename]})
self.kwargs.update({'ned': self.psi.ned[filename]})
self.process_casino_inputs()
self.outputfile = self.rundir + '/out'
self.running = False
self.complete = False
if not self.complete and not self.running:
if not os.path.exists(self.rundir + 'bwfn.data'):
if not os.path.realpath(
self.psi.twists[ran_num]) == os.path.realpath(
self.rundir + '/bwfn.data'):
os.symlink(self.psi.twists[ran_num],
self.rundir + '/bwfn.data')
self.write_casino_inputs(self.rundir)
self.execute()
elif self.qmc == 'vmc_dmc':
self.rundir_list = []
for num, psi in enumerate(self.psi.twists):
if not os.path.exists(self.rundir +
'/{0:0>3}'.format(num)):
os.mkdir(self.rundir + '/{0:0>3}'.format(num))
self.rundir_list.append(self.rundir +
'/{0:0>3}'.format(num))
for file in os.listdir(self.system.runpspdir):
if fnmatch.fnmatch(file, '*_pp.data'):
os.symlink(self.system.runpspdir + '/' + file,
self.rundir_list[-1])
if not os.path.realpath(
self.psi.twists[num]) == os.path.realpath(
self.rundir + '/{0:0>3}'.format(num) +
'/bwfn.data'):
os.symlink(
self.psi.twists[num], self.rundir +
'/{0:0>3}'.format(num) + '/bwfn.data')
filename = self.dft.system.rundir + '/qe_wfns/bwfn.{0:0>3}.data'.format(
num)
self.kwargs.update({'neu': self.psi.neu[filename]})
self.kwargs.update({'ned': self.psi.ned[filename]})
self.outputfile = self.rundir + '/{0:0>3}'.format(
num) + '/out'
self.process_casino_inputs()
self.write_casino_inputs(self.rundir +
'/{0:0>3}'.format(num))
