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))