def test1(self): current_dir = os.path.dirname(__file__) db = Database() converter = OptimDBConverter(db, mindata=os.path.join(current_dir, "min.data"), tsdata=os.path.join(current_dir, "ts.data"), pointsmin=os.path.join(current_dir, "points.min"), pointsts=os.path.join(current_dir, "points.ts"), endianness="<") converter.convert() self.assertEqual(db.number_of_minima(), 2) self.assertEqual(db.number_of_transition_states(), 1) ts = db.transition_states()[0] self.assertAlmostEqual(ts.coords[0], 1.548324, 5) self.assertAlmostEqual(ts.coords[2], 0.18178001, 5) self.assertAlmostEqual(ts.coords[-1], -0.50953229, 5) self.assertEqual((180,), ts.coords.shape) m = db.minima()[0] print(repr(m.coords)) self.assertAlmostEqual(m.coords[0], 1.53700142, 5) self.assertAlmostEqual(m.coords[2], 0.87783657, 5) self.assertAlmostEqual(m.coords[-1], -0.50953229, 5) self.assertEqual((180,), m.coords.shape)
def main(): parser = argparse.ArgumentParser(description=""" convert an OPTIM database to a pele sqlite database. Four files are needed. Normally they are called: points.min : the coordinates of the minima in binary format min.data : additional information about the minima (like the energy) points.ts : the coordinates of the transition states min.ts : additional information about transition states (like which minima they connect) Other file names can optionally be passed. Some fortran compilers use non-standard endianness to save the binary data. If your coordinates are garbage, try changing the endianness. """, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument('--ndof', help='Number of total degrees of freedom (e.g. 3*number of atoms). This is simply the length of a coordinates vector.', type=int, default=None) parser.add_argument('--Database','-d', help = 'Name of database to write into', type = str, default="optimdb.sqlite") parser.add_argument('--Mindata','-m', help = 'Name of min.data file', type = str, default="min.data") parser.add_argument('--Tsdata','-t', help = 'Name of ts.data file', type = str, default="ts.data") parser.add_argument('--Pointsmin','-p', help = 'Name of points.min file', type = str, default="points.min") parser.add_argument('--Pointsts','-q', help = 'Name of points.ts file', type = str, default="points.ts") parser.add_argument('--endianness', help = 'set the endianness of the binary data. Can be "<" for little-endian or ">" for big-endian', type = str, default="=") args = parser.parse_args() db = Database(args.Database) cv = OptimDBConverter(database=db, ndof=args.ndof, mindata=args.Mindata, tsdata=args.Tsdata, pointsmin=args.Pointsmin, pointsts=args.Pointsts, endianness=args.endianness) cv.setAccuracy() cv.convert() cv.db.session.commit()
def main(): parser = argparse.ArgumentParser(description=desc, formatter_class=argparse.RawDescriptionHelpFormatter) # parser.add_argument('--ndof', help='Number of total degrees of freedom (e.g. 3*number of atoms). This is simply the length of a coordinates vector.', # type=int, default=1) # parser.add_argument('--Database','-d', help = 'Name of database to write into', type = str, default="optimdb.sqlite") # parser.add_argument('--Mindata','-m', help = 'Name of min.data file', type = str, default="min.data") # parser.add_argument('--Tsdata','-t', help = 'Name of ts.data file', type = str, default="ts.data") # parser.add_argument('--Pointsmin','-p', help = 'Name of points.min file', type = str, default="points.min") # parser.add_argument('--Pointsts','-q', help = 'Name of points.ts file', type = str, default="points.ts") parser.add_argument('--endianness', help = 'set the endianness of the binary data. Can be "<" for little-endian or ">" for big-endian', type = str, default="=") args = parser.parse_args() system = AMBERSystem(prmtopFname="coords.prmtop", inpcrdFname="coords.inpcrd") db = system.create_database() converter = OptimDBConverter(db, mindata="min.data", tsdata="ts.data", pointsmin="points.min", pointsts="points.ts", endianness=args.endianness) converter.convert() # system.get_ndof = lambda : args.ndof run_gui(system, db=db) print db.number_of_minima()
def test1(self): current_dir = os.path.dirname(__file__) db = Database() converter = OptimDBConverter( db, mindata=os.path.join(current_dir, "min.data"), tsdata=os.path.join(current_dir, "ts.data"), pointsmin=os.path.join(current_dir, "points.min"), pointsts=os.path.join(current_dir, "points.ts"), endianness="<") converter.convert() self.assertEqual(db.number_of_minima(), 2) self.assertEqual(db.number_of_transition_states(), 1) ts = db.transition_states()[0] self.assertAlmostEqual(ts.coords[0], 1.548324, 5) self.assertAlmostEqual(ts.coords[2], 0.18178001, 5) self.assertAlmostEqual(ts.coords[-1], -0.50953229, 5) self.assertEqual((180, ), ts.coords.shape) m = db.minima()[0] print repr(m.coords) self.assertAlmostEqual(m.coords[0], 1.53700142, 5) self.assertAlmostEqual(m.coords[2], 0.87783657, 5) self.assertAlmostEqual(m.coords[-1], -0.50953229, 5) self.assertEqual((180, ), m.coords.shape)
def main(): parser = argparse.ArgumentParser( description=desc, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument( '--ndof', help= 'Number of total degrees of freedom (e.g. 3*number of atoms). This is simply the length of a coordinates vector.', type=int, default=1) # parser.add_argument('--Database','-d', help = 'Name of database to write into', type = str, default="optimdb.sqlite") # parser.add_argument('--Mindata','-m', help = 'Name of min.data file', type = str, default="min.data") # parser.add_argument('--Tsdata','-t', help = 'Name of ts.data file', type = str, default="ts.data") # parser.add_argument('--Pointsmin','-p', help = 'Name of points.min file', type = str, default="points.min") # parser.add_argument('--Pointsts','-q', help = 'Name of points.ts file', type = str, default="points.ts") # parser.add_argument('--endianness', help = 'set the endianness of the binary data. Can be "<" for little-endian or ">" for big-endian', type = str, default="=") args = parser.parse_args() system = BaseSystem() db = system.create_database() converter = OptimDBConverter(db, mindata="min.data", tsdata="ts.data", pointsmin="points.min", pointsts="points.ts", endianness="=", assert_coords=False) converter.convert_no_coords() system.get_ndof = lambda: args.ndof run_gui(system, db=db) print(db.number_of_minima())
def setUp(self): from pele.utils.optim_compatibility import OptimDBConverter from pele.storage import Database ndof = 10 # wrong, but who cares. self.db = Database() current_dir = os.path.dirname(__file__) converter = OptimDBConverter(self.db, ndof=ndof, mindata=current_dir+"/collagen.min.data", tsdata=current_dir+"/collagen.ts.data", assert_coords=False) converter.convert_no_coords()
def test_nocoords(self): current_dir = os.path.dirname(__file__) db = Database() converter = OptimDBConverter(db, mindata=os.path.join(current_dir, "min.data"), tsdata=os.path.join(current_dir, "ts.data"), pointsmin="poo", pointsts="poo", assert_coords=False, endianness="<") converter.convert()
def test_nocoords(self): current_dir = os.path.dirname(__file__) db = Database() converter = OptimDBConverter( db, mindata=os.path.join(current_dir, "min.data"), tsdata=os.path.join(current_dir, "ts.data"), pointsmin="poo", pointsts="poo", assert_coords=False, endianness="<") converter.convert()
def test_nocoords_Fails(self): current_dir = os.path.dirname(__file__) db = Database() converter = OptimDBConverter(db, mindata=os.path.join(current_dir, "min.data"), tsdata=os.path.join(current_dir, "ts.data"), pointsmin="poo", pointsts="poo", assert_coords=True, endianness="<") with self.assertRaises(IOError): converter.convert()
def test_nocoords_Fails(self): current_dir = os.path.dirname(__file__) db = Database() converter = OptimDBConverter( db, mindata=os.path.join(current_dir, "min.data"), tsdata=os.path.join(current_dir, "ts.data"), pointsmin="poo", pointsts="poo", assert_coords=True, endianness="<") with self.assertRaises(IOError): converter.convert()
def test1(self): current_dir = os.path.dirname(__file__) db = Database() converter = OptimDBConverter( db, mindata=os.path.join(current_dir, "min.data"), tsdata=os.path.join(current_dir, "ts.data"), pointsmin=os.path.join(current_dir, "points.min"), pointsts=os.path.join(current_dir, "points.ts"), endianness="<") converter.convert() mdata = tempfile.NamedTemporaryFile(delete=True) tsdata = tempfile.NamedTemporaryFile(delete=True) pm = tempfile.NamedTemporaryFile(delete=True) pts = tempfile.NamedTemporaryFile(delete=True) print mdata.name, tsdata.name writer = WritePathsampleDB(db, mindata=mdata.name, tsdata=tsdata.name, pointsmin=pm.name, pointsts=pts.name, endianness="<") writer.write_db() d1 = np.genfromtxt(os.path.join(current_dir, "min.data"))[:, :3] d2 = np.genfromtxt(mdata.name)[:, :3] _base_test.assert_arrays_almost_equal(self, d1, d2) d1 = np.genfromtxt(os.path.join(current_dir, "ts.data")).reshape(-1, 8)[:, :5] d2 = np.genfromtxt(tsdata.name).reshape(-1, 8)[:, :5] print d1, d2 _base_test.assert_arrays_almost_equal(self, d1, d2) self.assertEqual(sha1_of_file(os.path.join(current_dir, "points.min")), sha1_of_file(pm.name)) self.assertEqual(sha1_of_file(os.path.join(current_dir, "points.ts")), sha1_of_file(pts.name))
def test1(self): current_dir = os.path.dirname(__file__) db = Database() converter = OptimDBConverter(db, mindata=os.path.join(current_dir, "min.data"), tsdata=os.path.join(current_dir, "ts.data"), pointsmin=os.path.join(current_dir, "points.min"), pointsts=os.path.join(current_dir, "points.ts"), endianness="<") converter.convert() mdata = tempfile.NamedTemporaryFile(delete=True) tsdata = tempfile.NamedTemporaryFile(delete=True) pm = tempfile.NamedTemporaryFile(delete=True) pts = tempfile.NamedTemporaryFile(delete=True) print(mdata.name, tsdata.name) writer = WritePathsampleDB(db, mindata=mdata.name, tsdata=tsdata.name, pointsmin=pm.name, pointsts=pts.name, endianness="<") writer.write_db() d1 = np.genfromtxt(os.path.join(current_dir, "min.data"))[:,:3] d2 = np.genfromtxt(mdata.name)[:,:3] _base_test.assert_arrays_almost_equal(self, d1, d2) d1 = np.genfromtxt(os.path.join(current_dir, "ts.data")).reshape(-1,8)[:,:5] d2 = np.genfromtxt(tsdata.name).reshape(-1,8)[:,:5] print(d1, d2) _base_test.assert_arrays_almost_equal(self, d1, d2) self.assertEqual(sha1_of_file(os.path.join(current_dir, "points.min")), sha1_of_file(pm.name)) self.assertEqual(sha1_of_file(os.path.join(current_dir, "points.ts")), sha1_of_file(pts.name))
def test2(self): from pele.utils.tests.test_disconnectivity_graph import create_random_database db = create_random_database(nmin=20, nts=15) delete = False mdata = tempfile.NamedTemporaryFile(delete=delete, suffix=".min.data") tsdata = tempfile.NamedTemporaryFile(delete=delete, suffix=".ts.data") pm = tempfile.NamedTemporaryFile(delete=delete) pts = tempfile.NamedTemporaryFile(delete=delete) print mdata.name, tsdata.name writer = WritePathsampleDB(db, mindata=mdata.name, tsdata=tsdata.name, pointsmin=pm.name, pointsts=pts.name, endianness="<") writer.write_db() newdb = Database() reader = OptimDBConverter(newdb, mindata=mdata.name, tsdata=tsdata.name, pointsmin=pm.name, pointsts=pts.name, endianness="<") reader.convert() for m1, m2 in izip(db.minima(), newdb.minima()): self.assertAlmostEqual(m1.energy, m2.energy) _base_test.assert_arrays_almost_equal(self, m1.coords, m2.coords) for ts1, ts2 in izip(db.transition_states(), newdb.transition_states()): self.assertAlmostEqual(ts1.energy, ts2.energy) _base_test.assert_arrays_almost_equal(self, ts1.coords, ts2.coords) self.assertAlmostEqual(ts1.minimum1.energy, ts2.minimum1.energy) self.assertAlmostEqual(ts1.minimum2.energy, ts2.minimum2.energy)
def test2(self): from pele.utils.tests.test_disconnectivity_graph import create_random_database db = create_random_database(nmin=20, nts=15) delete=False mdata = tempfile.NamedTemporaryFile(delete=delete, suffix=".min.data") tsdata = tempfile.NamedTemporaryFile(delete=delete, suffix=".ts.data") pm = tempfile.NamedTemporaryFile(delete=delete) pts = tempfile.NamedTemporaryFile(delete=delete) print(mdata.name, tsdata.name) writer = WritePathsampleDB(db, mindata=mdata.name, tsdata=tsdata.name, pointsmin=pm.name, pointsts=pts.name, endianness="<") writer.write_db() newdb = Database() reader = OptimDBConverter(newdb, mindata=mdata.name, tsdata=tsdata.name, pointsmin=pm.name, pointsts=pts.name, endianness="<") reader.convert() for m1, m2 in zip(db.minima(), newdb.minima()): self.assertAlmostEqual(m1.energy, m2.energy) _base_test.assert_arrays_almost_equal(self, m1.coords, m2.coords) for ts1, ts2 in zip(db.transition_states(), newdb.transition_states()): self.assertAlmostEqual(ts1.energy, ts2.energy) _base_test.assert_arrays_almost_equal(self, ts1.coords, ts2.coords) self.assertAlmostEqual(ts1.minimum1.energy, ts2.minimum1.energy) self.assertAlmostEqual(ts1.minimum2.energy, ts2.minimum2.energy)
def main(): parser = argparse.ArgumentParser(description=""" convert an OPTIM database to a pele sqlite database. Four files are needed. Normally they are called: points.min : the coordinates of the minima in binary format min.data : additional information about the minima (like the energy) points.ts : the coordinates of the transition states min.ts : additional information about transition states (like which minima they connect) Other file names can optionally be passed. Some fortran compilers use non-standard endianness to save the binary data. If your coordinates are garbage, try changing the endianness. """, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument('--ndof', help='Number of total degrees of freedom (e.g. 3*number of atoms). This is simply the length of a coordinates vector.', type=int, default=None) parser.add_argument('--parentDB', help = 'Name of parent pinned database from which the system properties will be copied. Choose a small one!') parser.add_argument('--Database','-d', help = 'Name of database to write into', type = str, default="optimdb.sqlite") parser.add_argument('--Mindata','-m', help = 'Name of min.data file', type = str, default="min.data") parser.add_argument('--Tsdata','-t', help = 'Name of ts.data file', type = str, default="ts.data") parser.add_argument('--Pointsmin','-p', help = 'Name of points.min file', type = str, default="points.min") parser.add_argument('--Pointsts','-q', help = 'Name of points.ts file', type = str, default="points.ts") parser.add_argument('--endianness', help = 'set the endianness of the binary data. Can be "<" for little-endian or ">" for big-endian', type = str, default="=") parser.add_argument('--nopoints', help = 'Load the metadata for minima and transition states without reading the coordinates (usually to save storage space)', action = 'store_true') args = parser.parse_args() system, basedb, x0 = create_frozenblj_system_from_db(args.parentDB) db = Database(args.Database) props = basedb.properties(as_dict=True) for key, prop in props.iteritems(): db.add_property(key, prop) cv = OptimDBConverter(database=db, ndof=args.ndof, mindata=args.Mindata, tsdata=args.Tsdata, pointsmin=args.Pointsmin, pointsts=args.Pointsts, endianness=args.endianness, coords_converter=system.coords_converter.get_reduced_coords) cv.setAccuracy() if args.nopoints: cv.convert_no_coords() else: cv.convert() cv.db.session.commit()
def main(): if len(sys.argv) < 2: usage() exit(1) kwargs = {} outfile = None OPTIM = False opts, args = getopt.gnu_getopt(sys.argv[1:], "ho:", ["help", "nlevels=", "subgraph_size=", "OPTIM", "order_by_basin_size", "order_by_energy", "include_gmin", "center_gmin", "Emax=", ]) for o, a in opts: if o == "-h" or o == "--help": usage() exit(1) if o == "-o": outfile = a elif o == "--nlevels": kwargs["nlevels"] = int(a) elif o == "--Emax": kwargs["Emax"] = float(a) elif o == "--subgraph_size": kwargs["subgraph_size"] = int(a) elif o == "--order_by_basin_size": kwargs["order_by_basin_size"] = True elif o == "--order_by_energy": kwargs["order_by_energy"] = True elif o == "--includer_gmin": kwargs["includer_gmin"] = True elif o == "--center_gmin": kwargs["center_gmin"] = True elif o == "--OPTIM": OPTIM = True else: print "don't understand", o, a print "" usage() exit(1) groups = None if OPTIM: #make database from min.data ts.data db = Database() converter = OptimDBConverter(db) converter.convert_no_coords() groups = read_AB(db) else: if len(args) == 0: print "you must specify database file" print "" usage() exit() dbfile = args[0] if not os.path.exists(dbfile): print "database file doesn't exist", dbfile exit() db = Database(dbfile) if outfile is None and use_gui: app = QApplication(sys.argv) kwargs["show_minima"] = False md = DGraphDialog(db, params=kwargs) md.rebuild_disconnectivity_graph() if groups is not None: md.dgraph_widget.dg.color_by_group(groups) md.dgraph_widget.redraw_disconnectivity_graph() md.show() sys.exit(app.exec_()) # make graph from database t0 = time.time() if "Emax" in kwargs and use_gui: graph = reduced_db2graph(db, kwargs['Emax']) else: graph = dg.database2graph(db) t1 = time.time() print "loading the data into a transition state graph took", t1-t0, "seconds" # do the disconnectivity graph analysis mydg = dg.DisconnectivityGraph(graph, **kwargs) print "doing disconnectivity graph analysis" sys.stdout.flush() t1 = time.time() mydg.calculate() t2 = time.time() print "d-graph analysis finished in", t2-t1, "seconds" print "number of minima:", mydg.tree_graph.number_of_leaves() print "plotting disconnectivigy graph" sys.stdout.flush() # make the figure and save it mydg.plot() if outfile is None: plt.show() else: plt.savefig(outfile) t3 = time.time() print "plotting finished in", t3-t2, "seconds"
if i == 0: nminima = int(line.split()[0]) else: sline = line.split() ids += map(int, sline) assert nminima == len(ids) print len(ids), "minima read from file:", fname return [db.getMinimum(mid) for mid in ids] db = Database() direc = "lj38/20000.minima" direc = "." if db.number_of_minima() == 0: converter = OptimDBConverter(db, mindata=direc+"/min.data", tsdata=direc+"/ts.data") converter.pointsmin_data = None converter.pointsts_data = None converter.ReadMinDataFast() converter.ReadTSdataFast() A = read_minA(direc+"/min.A", db) B = read_minA(direc+"/min.B", db) print len(A), "A minima" print len(B), "B minima"
help="output file name. The heat capacity will be written to output and output.pdf", default="Cv") parser.add_argument("--Tmin", type=float, help="Minimum temperature for the calculation.", default=0.02) parser.add_argument("--Tmax", type=float, help="Minimum temperature for the calculation.", default=1.0) parser.add_argument("--Tcount", type=int, help="Number of temperature points for the calculation.", default=300) parser.add_argument("--OPTIM", action="store_true", help="read data from a min.data file instead." "fname should be the filename of the min.data file") args = parser.parse_args() print args.fname print args k = args.k # get the list of minima if args.OPTIM: # fname is a min.data file db = Database() converter = OptimDBConverter(db, mindata=args.fname) converter.convert_no_coords() minima = db.minima() else: dbfname = args.fname db = Database(dbfname, createdb=False) minima = [m for m in db.minima() if m.fvib is not None and m.pgorder is not None] if len(minima) == 0: print "There are not minima with the necessary thermodynamic information in the database. Have you computed the normal mode"\ " frequencies and point group order for all the minima? See pele.thermodynamics "\ " for more information" exit(1) print "computing heat capacity from", len(minima), "minima" Tmin = args.Tmin Tmax = args.Tmax
def main(): if len(sys.argv) < 2: usage() exit(1) # The default is to use the largest connected component of the graph, # rather than the component which includes the global minimum. kwargs = {"include_gmin":False, "center_gmin":False} outfile, colourfile, groupcolourfile, idfile = None, None, None, None aspect = 6.0/7.0 width = 6 OPTIM = False opts, args = getopt.gnu_getopt(sys.argv[1:], "ho:", ["help", "nlevels=", "subgraph_size=", "OPTIM", "order_by_basin_size", "order_by_energy", "include_gmin", "center_gmin", "Emax=", "colourfile=", "groupcolourfile=", "idfile=", "shape=", "width=" ]) for o, a in opts: if o == "-h" or o == "--help": usage() exit(1) if o == "-o": outfile = a elif o == "--nlevels": kwargs["nlevels"] = int(a) elif o == "--Emax": kwargs["Emax"] = float(a) elif o == "--subgraph_size": kwargs["subgraph_size"] = int(a) elif o == "--order_by_basin_size": kwargs["order_by_basin_size"] = True elif o == "--order_by_energy": kwargs["order_by_energy"] = True elif o == "--include_gmin": kwargs["include_gmin"] = True elif o == "--center_gmin": kwargs["center_gmin"] = True elif o == "--OPTIM": OPTIM = True elif o == "--colourfile": colourfile = a print "Setting colourfile to ", colourfile elif o == "--groupcolourfile": if colourfile: raise AttributeError("Can't specify both colourfile and groupcolourfile") groupcolourfile = a elif o == '--idfile': idfile = a elif o == '--shape': aspect = float(a) elif o == '--width': width = float(a) else: print "don't understand", o, a print "" usage() exit(1) groups = None if OPTIM: #make database from min.data ts.data db = Database() converter = OptimDBConverter(db) converter.convert_no_coords() groups = read_AB(db) else: if len(args) == 0: print "you must specify database file" print "" usage() exit() dbfile = args[0] if not os.path.exists(dbfile): print "database file doesn't exist", dbfile exit() db = Database(dbfile) if outfile is None and use_gui: app = QApplication(sys.argv) kwargs["show_minima"] = False md = DGraphDialog(db, params=kwargs) md.rebuild_disconnectivity_graph() if groups is not None: md.dgraph_widget.dg.color_by_group(groups) md.dgraph_widget.redraw_disconnectivity_graph() md.show() sys.exit(app.exec_()) # make graph from database t0 = time.time() if "Emax" in kwargs and use_gui: graph = reduced_db2graph(db, kwargs['Emax']) else: graph = dg.database2graph(db) t1 = time.time() print "loading the data into a transition state graph took", t1-t0, "seconds" # do the disconnectivity graph analysis mydg = dg.DisconnectivityGraph(graph, **kwargs) print "doing disconnectivity graph analysis" sys.stdout.flush() t1 = time.time() mydg.calculate() t2 = time.time() print "d-graph analysis finished in", t2-t1, "seconds" print "number of minima:", mydg.tree_graph.number_of_leaves() print "plotting disconnectivity graph" sys.stdout.flush() if colourfile: print "Colouring tree according to file ", colourfile colourfetcher = get_colours_from_file(db, colourfile) colouredtree = dg.ColorDGraphByValue(mydg.tree_graph,colourfetcher,normalize_values=True) print "tree set up" colouredtree.run() print "Finished colouring" elif groupcolourfile: print "Colouring tree according to file ", colourfile grouplists = get_group_lists(groupcolourfile) colouredtree = dg.ColorDGraphByGroups(mydg.tree_graph,grouplists) colouredtree.run() print "Finished colouring" if idfile: labelminima = [] labels = {} fin = open(idfile,'r') for line in fin: minID = line.split()[0] labelminima.append(db.getMinimum(minID)) # labels[labelminima[-1]]=str(labelminim fin.close() print "Labelling ", len(labelminima), "minima" print "Creating axes with dimensions ", width, width/aspect fig = plt.figure(figsize=(width, width/aspect)) fig.set_facecolor('white') ax = fig.add_subplot(111, adjustable='box') # make the figure and save it mydg.plot(axes=ax) if idfile: print "Going into draw_minima" mydg.draw_minima(labelminima,labels=True) if outfile is None: plt.show() else: plt.savefig(outfile) t3 = time.time() print "plotting finished in", t3-t2, "seconds"
def main(): parser = argparse.ArgumentParser( description=""" convert an OPTIM database to a pele sqlite database. Four files are needed. Normally they are called: points.min : the coordinates of the minima in binary format min.data : additional information about the minima (like the energy) points.ts : the coordinates of the transition states min.ts : additional information about transition states (like which minima they connect) Other file names can optionally be passed. Some fortran compilers use non-standard endianness to save the binary data. If your coordinates are garbage, try changing the endianness. """, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument( '--ndof', help= 'Number of total degrees of freedom (e.g. 3*number of atoms). This is simply the length of a coordinates vector.', type=int, default=None) parser.add_argument('--Database', '-d', help='Name of database to write into', type=str, default="optimdb.sqlite") parser.add_argument('--Mindata', '-m', help='Name of min.data file', type=str, default="min.data") parser.add_argument('--Tsdata', '-t', help='Name of ts.data file', type=str, default="ts.data") parser.add_argument('--Pointsmin', '-p', help='Name of points.min file', type=str, default="points.min") parser.add_argument('--Pointsts', '-q', help='Name of points.ts file', type=str, default="points.ts") parser.add_argument( '--endianness', help= 'set the endianness of the binary data. Can be "<" for little-endian or ">" for big-endian', type=str, default="=") args = parser.parse_args() db = Database(args.Database) cv = OptimDBConverter(database=db, ndof=args.ndof, mindata=args.Mindata, tsdata=args.Tsdata, pointsmin=args.Pointsmin, pointsts=args.Pointsts, endianness=args.endianness) cv.setAccuracy() cv.convert() cv.db.session.commit()