# with analytical one for i in range(0, nred): def f(x): q0i,Bi = force_field.getRedundantInternalCoordinates(x,0) return q0i[i] dqi_dx = utils.numerical_gradient(f,x0) err = la.norm(B[i,:] - dqi_dx) print "Internal coordinate %d" % i print " |dqi/dx (numerical) - dqi/dx (analytical)|= %e" % err assert err < 1.0e-8 if __name__ == "__main__": import sys atomlist0 = XYZ.read_xyz(sys.argv[1])[-1] x0 = XYZ.atomlist2vector(atomlist0) IC = InternalValenceCoords(atomlist0, verbose=3) test_wilson_bmatrix(IC.force_field, x0) # 1) transform cartesian to internal coordinates, x0 ~ q0 q0 = IC.cartesian2internal(x0) # 2) Take a step along the last internal coordinate, # this will only work if the coordinate is not coupled # to any other. dq = np.zeros(len(q0)) dq[-1] = 0.1 q = q0+dq
print " copy the atom type assignments of the monomer (in monomer.ff) to all" print " monomeric units in oligomer.xyz and save the result to <oligomer.ff>" print "" exit(-1) # input files monomer_ff = sys.argv[1] oligomer_xyz = sys.argv[2] # output file oligomer_ff = sys.argv[3] atomlist_mono, atomtypes_mono, partial_charges_mono, lattice_vectors = PFF.read_force_field( monomer_ff) nat = len(atomlist_mono) atomlist_oligo = XYZ.read_xyz(oligomer_xyz)[0] # number of units nunit = len(atomlist_oligo) / len(atomlist_mono) assert nunit * len(atomlist_mono) == len( atomlist_oligo ), "Number of atoms must be multiple of number of atoms in monomer" atomtypes_oligo = [] partial_charges_oligo = [] for i in range(0, nunit): atomtypes_oligo += atomtypes_mono partial_charges_oligo += partial_charges_mono PFF.write_force_field(oligomer_ff, atomlist_oligo,
def opt(xyzfile, optionfile): """performs an optimization""" outputfile = open("output_dftb.txt", "a") # redirect output to file sys.stdout = outputfile try: I = 0 # index of electronic state (ground state) atomlist = XYZ.read_xyz(xyzfile)[0] # read atomlist kwds = XYZ.extract_keywords_xyz( xyzfile) # read keywords from xyz-file (charge) options = read_options(optionfile) # read options scf_options = extract_options(options, SCF_OPTIONLIST) # get scf-options # optimization (taken from optimize.py) pes = MyPES(atomlist, options, Nst=max(I + 1, 2), **kwds) x0 = XYZ.atomlist2vector(atomlist) #convert geometry to a vector def f(x): save_xyz(x) # also save geometries from line searches if I == 0 and type(pes.tddftb.XmY) != type(None): # only ground state is needed. However, at the start # a single TD-DFT calculation is performed to initialize # all variables (e.g. X-Y), so that the program does not # complain about non-existing variables. enI, gradI = pes.getEnergyAndGradient_S0(x) else: energies, gradI = pes.getEnergiesAndGradient(x, I) enI = energies[I] print "E = %2.7f" % (enI) return enI, gradI xyz_trace = xyzfile.replace(".xyz", "_trace.xyz") # This is a callback function that is executed by numpy for each optimization step. # It appends the current geometry to an xyz-file. def save_xyz(x, mode="a"): atomlist_opt = XYZ.vector2atomlist(x, atomlist) XYZ.write_xyz(xyz_trace, [atomlist_opt], title="charge=%s" % kwds.get("charge", 0), mode=mode) save_xyz(x0, mode="w") # write original geometry Nat = len(atomlist) min_options = {'gtol': 1.0e-7, 'norm': 2} # The "BFGS" method is probably better than "CG", but the line search in BFGS is expensive. res = optimize.minimize(f, x0, method="CG", jac=True, callback=save_xyz, options=min_options) # res = optimize.minimize(f, x0, method="BFGS", jac=True, callback=save_xyz, options=options) xopt = res.x save_xyz(xopt) print "Intermediate geometries written into file {}".format(xyz_trace) # write optimized geometry into file atomlist_opt = XYZ.vector2atomlist(xopt, atomlist) xyz_opt = xyzfile.replace(".xyz", "_opt.xyz") XYZ.write_xyz(xyz_opt, [atomlist_opt], title="charge=%s" % kwds.get("charge", 0), mode="w") # calculate energy for optimized geometry dftb2 = DFTB2(atomlist_opt, **options) # create dftb object dftb2.setGeometry(atomlist_opt, charge=kwds.get("charge", 0.0)) dftb2.getEnergy(**scf_options) energies = list(dftb2.getEnergies()) # get partial energies if dftb2.long_range_correction == 1: # add long range correction to partial energies energies.append(dftb2.E_HF_x) return str(energies) except: print sys.exc_info() return "error"
return self.mm_energy def get_MM_Gradient(self): return self.mm_gradient def get_MM_Charges(self): return self.mm_charges if __name__ == "__main__": import sys """ log_file = sys.argv[1] print read_geometry(log_file) # print read_forces(log_file) # print read_force_constants(log_file) """ xyz_file = sys.argv[1] atomlist = XYZ.read_xyz(xyz_file)[0] uff_handler = UFF_handler(atomlist) print uff_handler.get_MM_Charges() uff_handler.calc(atomlist) print uff_handler.get_MM_Gradient() print uff_handler.get_MM_Energy() uff_handler.calc(atomlist) print uff_handler.get_MM_Gradient() print uff_handler.get_MM_Energy() # uff_handler.clean_up()
"--out_file", dest="out_file", help= "The table with the isomer assignments for each geometry is written to this file [default: %default]", type=str, default="isomer_classification.dat") (opts, args) = parser.parse_args() if len(args) != 2: print usage exit(-1) dynamics_file = args[0] isomer_file = args[1] isomers = XYZ.read_xyz(isomer_file) # determined canonical connectivities of isomers isomer_connectivities = [] for isomer in isomers: isomer_can, A_can = MolecularGraph.morgan_ordering(isomer, hydrogen_bonds=True) isomer_connectivities.append(A_can) # all isomers should have different connectivities n = len(isomers) for i in range(0, n): for j in range(i + 1, n): if np.sum( (isomer_connectivities[i] - isomer_connectivities[j])**2) == 0: print "WARNING: Isomer %d and %d in file '%s' have the same adjacency matrices!" % ( i + 1, j + 1, isomer_file)
if len(args) < 2: print "Missing arguments:" print " xyz_input xyz_output" exit(-1) xyz_in = args[0] xyz_out = args[1] if len(args) < 3: print "possible commands: 'scale', 'dislocate'" exit(-1) cmd = args[2] # the remaining command line arguments depend cmd_args = map(eval, args[3:]) atomlist0 = XYZ.read_xyz(xyz_in)[-1] PG = PerturbedGeometries(atomlist0) kwds = XYZ.extract_keywords_xyz(xyz_in) if cmd == "scale": if len(cmd_args) < 3: print "Arguments for 'scale':" print " smin smax N" exit(-1) geometries = PG.scale(*cmd_args) elif cmd == "dislocate": if len(cmd_args) < 4: print "Arguments for 'dislocate':" print " atom radius nshells N" exit(-1)
#!/usr/bin/env python """ print xyz-coordinates in a format that can be pasted into python scripts """ from DFTB import XYZ import pprint if __name__ == "__main__": import sys usage = "Usage: python %s <xyz input>\n" % sys.argv[0] if len(sys.argv) < 2: print usage exit(-1) xyz = sys.argv[1] atomlist = XYZ.read_xyz(xyz)[0] pprint.pprint(atomlist)
# load cube files for components of vector potential print "load magnetic vector potential from cube files..." atomlist, origin, axes, Ax_data = Cube.readCube(Ax_cube_file) atomlist, origin, axes, Ay_data = Cube.readCube(Ay_cube_file) atomlist, origin, axes, Az_data = Cube.readCube(Az_cube_file) # extract positions of points and values of A points, Ax = Cube.get_points_and_values(origin, axes, Ax_data) points, Ay = Cube.get_points_and_values(origin, axes, Ay_data) points, Az = Cube.get_points_and_values(origin, axes, Az_data) # fit magnetic dipoles fitter = MagneticDipoleFitter() fitter.setFitPoints(points, Ax, Ay, Az) # fitting centers if opts.fit_centers != "": print "loading fit centers from '%s'" % opts.fit_centers atomlist = XYZ.read_xyz(opts.fit_centers)[0] fitter.setAtomicCenters(atomlist) magnetic_dipoles = fitter.fitVectorPotential(mtot) # save magnetic dipoles fh = open(dat_file, "w") print >> fh, "# atom-centered magnetic dipoles fitted to the vector potential A(r)" print >> fh, "# The dipoles were projected onto principle axes of rotation (with all masses = 1) " print >> fh, "# Mx My Mz" np.savetxt(fh, magnetic_dipoles) fh.close() print "magnetic dipoles saved to '%s'" % dat_file
""" % basename(sys.argv[0]) args = sys.argv[1:] if len(args) < 3: print usage exit(-1) xyz_file = args[0] # path to xyz-file state1 = int(args[1]) # index of lower electronic state state2 = int(args[2]) # index of upper electronic state # load initial geometry, we take the last geometry, so it is # easier to restart a previous MECI calculation. atomlist0 = XYZ.read_xyz(xyz_file)[-1] # read the charge of the molecule from the comment line in the xyz-file kwds = XYZ.extract_keywords_xyz(xyz_file) # initialize the TD-DFTB calculator pes = PotentialEnergySurfaces(atomlist0, Nst=state2 + 1, **kwds) meci = MECI( atomlist0, pes, #coord_system='internal', coord_system='cartesian', state1=state1, state2=state2) meci.opt(step_size=0.1, gtol=0.001)
txt = " %d C\n" % Nat txt += " O N C H\n" for i, (Zi, posi) in enumerate(atomlist): # x,y,z = posi x, y, z = map(lambda v: AtomicData.bohr_to_angs * v, posi) txt += " %d %d %20.7f %20.7f %20.7f\n" % (i + 1, atomtypes[Zi], x, y, z) txt += "%d\n" % (3 * Nat) for i in range(0, Nat): txt += "%d 1\n" % (i + 1) txt += "%d 2\n" % (i + 1) txt += "%d 3\n" % (i + 1) fh = open(gen_out, "w") print >> fh, txt fh.close() if __name__ == "__main__": import sys usage = "Usage: python %s <xyz input> <gen output>\n" % sys.argv[0] usage += " converts and xyz-file to the gen-format expected by Seifert's DFTB program\n" if len(sys.argv) < 3: print usage exit(-1) xyz_in = sys.argv[1] gen_out = sys.argv[2] write_gen(gen_out, XYZ.read_xyz(xyz_in)[0])
redirect = " 2> /dev/null" else: redirect = "" print "Optimizing geometries in %s with UFF force field => %s" % ( dynamic_file, opt_file) ret = os.system( "obminimize -ff UFF %s %s | sed -e \"/^WARNING:/ d\" > %s" % (dynamic_file, redirect, opt_file)) assert ret == 0, "Optimization with obminimize failed!" else: print "found optimized %s" % opt_file dynamic_file = opt_file print "Identifying and classifying fragments in %s" % dynamic_file try: geometries = XYZ.read_xyz(dynamic_file) except IOError: print "WARNING: could not open %s. - skipped" % dynamic_file continue geometries = [geometries[-1]] fragtraj, fragdic = MolecularGraph.fragment_trajectory(geometries) fragment_geometries.update(fragdic) # length of the i-th trajectory nt = max(len(fragtraj), len(ntraj)) # extend fraction list so that it has as many time steps as the longest trajectory if len(ntraj) < nt: nadd = nt - len(ntraj) ntraj = np.hstack((ntraj, np.zeros(nadd))) ntraj[:len(fragtraj)] += 1 # fragments for k, fracs in fragment_fractions.iteritems():
cut_atomlist = [] for i,(Zi,posi) in enumerate(atomlist): if i in removed: pass else: cut_atomlist.append( (Zi, posi) ) return cut_atomlist if __name__ == "__main__": import sys from os.path import expandvars, expanduser from DFTB import XYZ usage = "python %s <in .xyz> <out .xyz> <radius in bohr>\n" % sys.argv[0] usage += " removes all atoms outside sphere of radius R and all connected atoms\n" if len(sys.argv) < 4: print usage exit(-1) xyz_in = expandvars(expanduser(sys.argv[1])) xyz_out = expandvars(expanduser(sys.argv[2])) R = float(sys.argv[3]) atomlist = XYZ.read_xyz(xyz_in)[0] cut_atomlist = cut_sphere(atomlist, R) print "Removed %d atoms" % (len(atomlist) - len(cut_atomlist)) XYZ.write_xyz(xyz_out, [cut_atomlist])
type=str, default="cartesian") (opts, args) = parser.parse_args() if len(args) < 4: parser.print_help() exit(-1) xyz0 = args[0] xyz1 = args[1] N = int(args[2]) xyz_interp = args[3] # read initial geometry atomlist0 = XYZ.read_xyz(xyz0)[0] x0 = XYZ.atomlist2vector(atomlist0) # read final geometry atomlist1 = XYZ.read_xyz(xyz1)[0] x1 = XYZ.atomlist2vector(atomlist1) # interpolation parameter rs = np.linspace(0.0, 1.0, N) geometries_interp = [] if opts.coord_system == "cartesian": for r in rs: xr = x0 + r * (x1 - x0) geometries_interp.append(XYZ.vector2atomlist(xr, atomlist0))
from DFTB import XYZ import sys frame = 433 geometries = XYZ.read_xyz("dynamics.xyz") XYZ.write_xyz("frame_%d.xyz" % frame, [geometries[433]])
def __init__(self, xyz_file, dyson_file=None): super(Main, self).__init__() self.settings = Settings({ "Continuum Orbital": { "Ionization transitions": [0, ["only intra-atomic", "inter-atomic"]] }, "Averaging": { "Euler angle grid points": 5, "polar angle grid points": 1000, "sphere radius Rmax": 300.0, }, "Scan": { "nr. points": 20 }, "Cube": { "extra space / bohr": 15.0, "points per bohr": 3.0 } }) # perform DFTB calculation # BOUND ORBITAL = H**O self.atomlist = XYZ.read_xyz(xyz_file)[0] # shift molecule to center of mass print "shift molecule to center of mass" pos = XYZ.atomlist2vector(self.atomlist) masses = AtomicData.atomlist2masses(self.atomlist) pos_com = MolCo.shift_to_com(pos, masses) self.atomlist = XYZ.vector2atomlist(pos_com, self.atomlist) self.tddftb = LR_TDDFTB(self.atomlist) self.tddftb.setGeometry(self.atomlist, charge=0) options = {"nstates": 1} try: self.tddftb.getEnergies(**options) except DFTB.Solver.ExcitedStatesNotConverged: pass self.valorbs, radial_val = load_pseudo_atoms(self.atomlist) if dyson_file == None: # Kohn-Sham orbitals are taken as Dyson orbitals self.H**O, self.LUMO = self.tddftb.dftb2.getFrontierOrbitals() self.bound_orbs = self.tddftb.dftb2.getKSCoefficients() self.orbe = self.tddftb.dftb2.getKSEnergies() orbital_names = [] norb = len(self.orbe) for o in range(0, norb): if o < self.H**O: name = "occup." elif o == self.H**O: name = "H**O" elif o == self.LUMO: name = "LUMO " else: name = "virtual" name = name + " " + str(o).rjust(4) + ( " %+10.3f eV" % (self.orbe[o] * 27.211)) orbital_names.append(name) initially_selected = self.H**O else: # load coefficients of Dyson orbitals from file names, ionization_energies, self.bound_orbs = load_dyson_orbitals( dyson_file) self.orbe = np.array(ionization_energies) / 27.211 orbital_names = [] norb = len(self.orbe) for o in range(0, norb): name = names[o] + " " + str(o).rjust(4) + ( " %4.2f eV" % (self.orbe[o] * 27.211)) orbital_names.append(name) initially_selected = 0 self.photo_kinetic_energy = slako_tables_scattering.energies[0] self.epol = np.array([15.0, 0.0, 0.0]) # Build Graphical User Interface main = QtGui.QWidget() mainLayout = QtGui.QHBoxLayout(main) # selectionFrame = QtGui.QFrame() selectionFrame.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Preferred) mainLayout.addWidget(selectionFrame) selectionLayout = QtGui.QVBoxLayout(selectionFrame) # label = QtGui.QLabel(selectionFrame) label.setText("Select bound MO:") selectionLayout.addWidget(label) # bound orbitals self.orbitalSelection = QtGui.QListWidget(selectionFrame) self.orbitalSelection.itemSelectionChanged.connect( self.selectBoundOrbital) norb = len(self.orbe) self.orbital_dict = {} for o in range(0, norb): name = orbital_names[o] self.orbital_dict[name] = o item = QtGui.QListWidgetItem(name, self.orbitalSelection) if o == initially_selected: selected_orbital_item = item selectionLayout.addWidget(self.orbitalSelection) ### VIEWS center = QtGui.QWidget() mainLayout.addWidget(center) centerLayout = QtGui.QGridLayout(center) # boundFrame = QtGui.QFrame() centerLayout.addWidget(boundFrame, 1, 1) boundLayout = QtGui.QVBoxLayout(boundFrame) # "Bound Orbital" label = QtGui.QLabel(boundFrame) label.setText("Bound Orbital") boundLayout.addWidget(label) # self.boundOrbitalViewer = QCubeViewerWidget(boundFrame) boundLayout.addWidget(self.boundOrbitalViewer) # continuum orbital continuumFrame = QtGui.QFrame() centerLayout.addWidget(continuumFrame, 1, 2) continuumLayout = QtGui.QVBoxLayout(continuumFrame) # "Dipole-Prepared Continuum Orbital" label = QtGui.QLabel(continuumFrame) label.setText("Dipole-Prepared Continuum Orbital") continuumLayout.addWidget(label) self.continuumOrbitalViewer = QCubeViewerWidget(continuumFrame) continuumLayout.addWidget(self.continuumOrbitalViewer) self.efield_objects = [] self.efield_actors = [] self.selected = None # picker self.picker = self.continuumOrbitalViewer.visualization.scene.mayavi_scene.on_mouse_pick( self.picker_callback) self.picker.tolerance = 0.01 # PHOTO KINETIC ENERGY sliderFrame = QtGui.QFrame(continuumFrame) continuumLayout.addWidget(sliderFrame) sliderLayout = QtGui.QHBoxLayout(sliderFrame) # label self.pke_label = QtGui.QLabel() self.pke_label.setText("PKE: %6.4f eV" % (self.photo_kinetic_energy * 27.211)) sliderLayout.addWidget(self.pke_label) # Slider for changing the PKE self.pke_slider = QtGui.QSlider(QtCore.Qt.Horizontal) self.pke_slider.setMinimum(0) self.pke_slider.setMaximum(len(slako_tables_scattering.energies) - 1) self.pke_slider.setValue(0) self.pke_slider.sliderReleased.connect(self.changePKE) self.pke_slider.valueChanged.connect(self.searchPKE) sliderLayout.addWidget(self.pke_slider) # # molecular frame photoangular distribution mfpadFrame = QtGui.QFrame() centerLayout.addWidget(mfpadFrame, 2, 1) mfpadLayout = QtGui.QVBoxLayout(mfpadFrame) mfpadLayout.addWidget(QtGui.QLabel("Molecular Frame PAD")) mfpadTabs = QtGui.QTabWidget() mfpadLayout.addWidget(mfpadTabs) # 2D map mfpadFrame2D = QtGui.QFrame() mfpadTabs.addTab(mfpadFrame2D, "2D") mfpadLayout2D = QtGui.QVBoxLayout(mfpadFrame2D) self.MFPADfig2D = Figure() self.MFPADCanvas2D = FigureCanvas(self.MFPADfig2D) mfpadLayout2D.addWidget(self.MFPADCanvas2D) self.MFPADCanvas2D.draw() NavigationToolbar(self.MFPADCanvas2D, mfpadFrame2D, coordinates=True) # 3D mfpadFrame3D = QtGui.QFrame() mfpadTabs.addTab(mfpadFrame3D, "3D") mfpadLayout3D = QtGui.QVBoxLayout(mfpadFrame3D) self.MFPADfig3D = Figure() self.MFPADCanvas3D = FigureCanvas(self.MFPADfig3D) mfpadLayout3D.addWidget(self.MFPADCanvas3D) self.MFPADCanvas3D.draw() NavigationToolbar(self.MFPADCanvas3D, mfpadFrame3D, coordinates=True) # orientation averaged photoangular distribution avgpadFrame = QtGui.QFrame() centerLayout.addWidget(avgpadFrame, 2, 2) avgpadLayout = QtGui.QVBoxLayout(avgpadFrame) self.activate_average = QtGui.QCheckBox("Orientation Averaged PAD") self.activate_average.setToolTip( "Check this box to start averaging of the molecular frame PADs over all orientations. This can take a while." ) self.activate_average.setCheckState(QtCore.Qt.Unchecked) self.activate_average.stateChanged.connect(self.activateAveragedPAD) avgpadLayout.addWidget(self.activate_average) avgpadTabs = QtGui.QTabWidget() avgpadLayout.addWidget(avgpadTabs) # 1D map avgpadFrame1D = QtGui.QFrame() avgpadTabs.addTab(avgpadFrame1D, "1D") avgpadLayout1D = QtGui.QVBoxLayout(avgpadFrame1D) self.AvgPADfig1D = Figure() self.AvgPADCanvas1D = FigureCanvas(self.AvgPADfig1D) avgpadLayout1D.addWidget(self.AvgPADCanvas1D) self.AvgPADCanvas1D.draw() NavigationToolbar(self.AvgPADCanvas1D, avgpadFrame1D, coordinates=True) # 2D map avgpadFrame2D = QtGui.QFrame() avgpadFrame2D.setToolTip( "The averaged PAD should have no phi-dependence anymore. A phi-dependence is a sign of incomplete averaging." ) avgpadTabs.addTab(avgpadFrame2D, "2D") avgpadLayout2D = QtGui.QVBoxLayout(avgpadFrame2D) self.AvgPADfig2D = Figure() self.AvgPADCanvas2D = FigureCanvas(self.AvgPADfig2D) avgpadLayout2D.addWidget(self.AvgPADCanvas2D) self.AvgPADCanvas2D.draw() NavigationToolbar(self.AvgPADCanvas2D, avgpadFrame2D, coordinates=True) # Table avgpadFrameTable = QtGui.QFrame() avgpadTabs.addTab(avgpadFrameTable, "Table") avgpadLayoutTable = QtGui.QVBoxLayout(avgpadFrameTable) self.avgpadTable = QtGui.QTableWidget(0, 6) self.avgpadTable.setToolTip( "Activate averaging and move the PKE slider above to add a new row with beta values. After collecting betas for different energies you can save the table or plot a curve beta(PKE) for the selected orbital." ) self.avgpadTable.setHorizontalHeaderLabels( ["PKE / eV", "sigma", "beta1", "beta2", "beta3", "beta4"]) avgpadLayoutTable.addWidget(self.avgpadTable) # Buttons buttonFrame = QtGui.QFrame() avgpadLayoutTable.addWidget(buttonFrame) buttonLayout = QtGui.QHBoxLayout(buttonFrame) deleteButton = QtGui.QPushButton("Delete") deleteButton.setToolTip("clear table") deleteButton.clicked.connect(self.deletePADTable) buttonLayout.addWidget(deleteButton) buttonLayout.addSpacing(3) scanButton = QtGui.QPushButton("Scan") scanButton.setToolTip( "fill table by scanning automatically through all PKE values") scanButton.clicked.connect(self.scanPADTable) buttonLayout.addWidget(scanButton) saveButton = QtGui.QPushButton("Save") saveButton.setToolTip("save table as a text file") saveButton.clicked.connect(self.savePADTable) buttonLayout.addWidget(saveButton) plotButton = QtGui.QPushButton("Plot") plotButton.setToolTip("plot beta2 column as a function of PKE") plotButton.clicked.connect(self.plotPADTable) buttonLayout.addWidget(plotButton) """ # DOCKS self.setDockOptions(QtGui.QMainWindow.AnimatedDocks | QtGui.QMainWindow.AllowNestedDocks) # selectionDock = QtGui.QDockWidget(self) selectionDock.setWidget(selectionFrame) selectionDock.setFeatures(QtGui.QDockWidget.DockWidgetFloatable | QtGui.QDockWidget.DockWidgetMovable) self.addDockWidget(QtCore.Qt.DockWidgetArea(1), selectionDock) # boundDock = QtGui.QDockWidget(self) boundDock.setWidget(boundFrame) boundDock.setFeatures(QtGui.QDockWidget.DockWidgetFloatable | QtGui.QDockWidget.DockWidgetMovable) boundDock.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred) self.addDockWidget(QtCore.Qt.DockWidgetArea(2), boundDock) # continuumDock = QtGui.QDockWidget(self) continuumDock.setWidget(continuumFrame) continuumDock.setFeatures(QtGui.QDockWidget.DockWidgetFloatable | QtGui.QDockWidget.DockWidgetMovable) continuumDock.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred) self.addDockWidget(QtCore.Qt.DockWidgetArea(2), continuumDock) """ self.setCentralWidget(main) self.status_bar = QtGui.QStatusBar(main) self.setStatusBar(self.status_bar) self.default_message = "Click on the tip of the green arrow in the top right figure to change the orientation of the E-field" self.statusBar().showMessage(self.default_message) # Menu bar menubar = self.menuBar() exitAction = QtGui.QAction('&Exit', self) exitAction.setShortcut('Ctrl+Q') exitAction.setStatusTip('Exit program') exitAction.triggered.connect(exit) fileMenu = menubar.addMenu('&File') fileMenu.addAction(exitAction) settingsMenu = menubar.addMenu('&Edit') settingsAction = QtGui.QAction('&Settings...', self) settingsAction.setStatusTip('Edit settings') settingsAction.triggered.connect(self.editSettings) settingsMenu.addAction(settingsAction) self.loadContinuum() # select H**O selected_orbital_item.setSelected(True)
window = QtGui.QMainWindow() viewer = QCubeViewerWidget(window) files = sys.argv[1:] cubes = [] molecules = [] charge_lists = [] for f in files: if ".cub" in f: cube = CubeData() cube.loadFromFile(f) cubes.append(cube) molecules.append(cube.atomlist) elif ".xyz" in f: atomlist = XYZ.read_xyz(f)[-1] molecules.append(atomlist) elif ".chg" in f: atomlist, charges = XYZ.read_charges(f) molecules.append(atomlist) charge_lists.append(charges) else: print "Unknown file type: %s" % f window.setWindowTitle(window.windowTitle() + " %s " % f) viewer.setCubes(cubes) viewer.setGeometries(molecules) if len(charge_lists) > 0: viewer.setGeometriesAndCharges(molecules, charge_lists) viewer.selectShowOptions(options=["surfaces", "charges", "transition charges"])
""" fragtraj = [] fragdic = { } # dictionary that translates fragment identifiers into molecular geometries for atomlist in geometries: fragments = disconnected_fragments(atomlist) fragment_labels = [ identifier(*morgan_ordering(atomlist)) for atomlist in fragments ] # for ifrag, fl in enumerate(fragment_labels): if fl not in fragdic: fragdic[fl] = fragments[ifrag] # fragtraj.append(fragment_labels) return fragtraj, fragdic if __name__ == "__main__": import sys atomlist = XYZ.read_xyz(sys.argv[1])[0] fragments = disconnected_fragments(atomlist) atomlists_ordered = [ morgan_ordering(atomlist)[0] for atomlist in fragments ] XYZ.write_xyz("/tmp/fragments.xyz", atomlists_ordered) #atomlists_frag) print((fragment_trajectory(XYZ.read_xyz(sys.argv[1]))))
def has_Cn(atomlist): pass def has_reflection(atomlist): pass ######################################## def write_atomlist(atomlist): Nat = len(atomlist) pos = XYZ.atomlist2vector(atomlist) txt = " in Angstrom:\n" txt += "Atom X Y Z\n" for i in range(0, Nat): txt += (" %s " % i).rjust(3) txt += "%+4.7f %+4.7f %+4.7f\n" % tuple(pos[3*i:3*(i+1)]*AtomicData.bohr_to_angs) txt += "\n" return txt ######################################## if __name__ == "__main__": import sys atomlist = XYZ.read_xyz(sys.argv[1])[0] atomlist_std = MolCo.standard_orientation(atomlist) group = detect_symmetry_brute_force(atomlist_std) # group = C2v() group.check_symmetry(atomlist_std) # atomlist_std_trans = group.elems[1].transform(atomlist_std)
if len(args) < 3: print usage exit(-1) geom_file = args[0] energy_file = args[1] force_file = args[2] print "Compute forces with DFTB" print "========================" print "" fh_en = open(energy_file, "w") print >> fh_en, "# ELECTRONIC ENERGY / HARTREE" # first geometry atomlist = XYZ.read_xyz(geom_file)[0] # read charge from title line in .xyz file kwds = XYZ.extract_keywords_xyz(geom_file) charge = kwds.get("charge", opts.charge) pes = PotentialEnergySurfaces(atomlist, charge=charge) # dftbaby needs one excited states calculation to set all variables x = XYZ.atomlist2vector(atomlist) pes.getEnergies(x) for i, atomlist in enumerate(XYZ.read_xyz(geom_file)): # compute electronic ground state forces with DFTB x = XYZ.atomlist2vector(atomlist) en = pes.getEnergy_S0(x) # total ground state energy including repulsive potential en_tot = en[0]
if line.strip()[0] == "#": # ignore comments continue molname, geom_file, dftb_force_file, force_file, keywords_str = line.strip( ).split(None, 4) molname = molname.replace("__", " ") keywords = dict( map( lambda s: tuple( s.replace(" ", "").replace("\t", "").split("=")), keywords_str.split())) weight = float(keywords.get("weight", 1.0)) max_error = float(keywords.get("max_error", 0.01)) active_atoms_str = keywords.get("active_atoms", "") if active_atoms_str == "": # include all atoms active_atoms = [] else: active_atoms = map(int, active_atoms_str.split(",")) print "weight = %s" % weight print "max_error = %s" % max_error geometries = XYZ.read_xyz(geom_file) forces_wo_frep = XYZ.read_xyz(dftb_force_file, units="hartree/bohr") forces_with_frep = XYZ.read_xyz(force_file, units="hartree/bohr") print "add geometries from %s" % geom_file Fitter.add_polyatomic_curve(geometries, forces_wo_frep, forces_with_frep, \ curve_name=molname, weight=weight, max_error=max_error, active_atoms=active_atoms) # Fitter.fit(3.0, 30.0) Fitter.fit(**options)
if __name__ == "__main__": import sys from optparse import OptionParser usage = "Usage: python %s <monomer geometry .xyz> <polymer geometry .xyz> <pattern for monomer transition densities> <pattern for polymer transition densities>\n" % sys.argv[0] usage += " The excited states of the polymer are analysed in terms of the excited states of the monomer\n" parser = OptionParser(usage) (opts, args) = parser.parse_args() if len(args) < 4: print(usage) exit(-1) atomlist_mono = XYZ.read_xyz(args[0])[0] atomlist_poly = XYZ.read_xyz(args[1])[0] monomer_pattern = args[2] polymer_pattern = args[3] print("load transition densities for monomer states") Ptrans_mono = [] # list of transition densities matrices in AO basis, one for each state for tdense_file in glob.glob(monomer_pattern+"*.mat"): print(tdense_file) PtransI = np.loadtxt(tdense_file) # remove hydrogen orbitals nao,nao = PtransI.shape nhyd = count_hydrogens(atomlist_mono) print(("remove %d hydrogens" % nhyd)) PtransI = PtransI[:(nao-nhyd),:][:,:(nao-nhyd)] Ptrans_mono.append(PtransI)
parser = OptionParser(usage) parser.add_option( "--convert", dest="convert", help= "Type of conversion: 'b2a' - from bohr to Angstrom, 'a2b' - from Angstrom to bohr [default: %default]", default="b2a") (opts, args) = parser.parse_args() if len(args) < 2: print(usage) exit(-1) xyz_in = args[0] xyz_out = args[1] if xyz_in[-2:] == "in": # initial conditions file ###.in coords, vels = XYZ.read_initial_conditions(xyz_in, units="") structures = [coords] else: structures = XYZ.read_xyz(xyz_in, units="") unit_fac, units = unit_conversion[opts.convert] for i, atomlist_in in enumerate(structures): vec_in = XYZ.atomlist2vector(atomlist_in) vec_out = unit_fac * vec_in atomlist_out = XYZ.vector2atomlist(vec_out, atomlist_in) if i == 0: mode = "w" else: mode = "a" XYZ.write_xyz(xyz_out, [atomlist_out], units="", mode=mode)
""" compute gradients along a trajectory of geometries using Gaussian """ from DFTB import XYZ import Gaussian if __name__ == "__main__": import sys import os if len(sys.argv) < 3: print "Usage: %s <geometry file> <gradient file>" % sys.argv[0] print "Compute gradients for all geometries in <geometry file> and write them to <gradient file>" exit(-1) geom_file = sys.argv[1] grad_file = sys.argv[2] tmp_dir = "/scratch/humeniuka/dftb/" os.system("module load g09") for atomlist in XYZ.read_xyz(geom_file): tmp_com = tmp_dir + "gaussian.com" tmp_out = tmp_dir + "gaussian.log" Gaussian.write_input(tmp_com, atomlist, \ route="# PBE/6-311G(3df,3pd)++ Force", \ title="Gradients for fitting repulsive potential") # compute forces with gaussian os.system("g09 < %s > %s" % (tmp_com, tmp_out)) try: forces = Gaussian.read_forces(tmp_com) except Gaussian.FormatError as e: print e XYZ.write(grad_file, [forces], title="forces", units="forces", mode='a')
def hessian(xyzfile, optionfile): """calculates hessian matrix""" outputfile = open("output_dftb.txt", "a") # redirect output to file sys.stdout = outputfile try: I = 0 # index of electronic state (ground state) atomlist = XYZ.read_xyz(xyzfile)[0] # read xyz file kwds = XYZ.extract_keywords_xyz(xyzfile) # read keywords (charge) options = read_options(optionfile) # read options scf_options = extract_options(options, SCF_OPTIONLIST) # get scf-options pes = MyPES(atomlist, options, Nst=max(I + 1, 2), **kwds) # create PES atomvec = XYZ.atomlist2vector(atomlist) # convert atomlist to vector # FIND ENERGY MINIMUM # f is the objective function that should be minimized # it returns (f(x), f'(x)) def f(x): if I == 0 and type(pes.tddftb.XmY) != type(None): # only ground state is needed. However, at the start # a single TD-DFT calculation is performed to initialize # all variables (e.g. X-Y), so that the program does not # complain about non-existing variables. enI, gradI = pes.getEnergyAndGradient_S0(x) else: energies, gradI = pes.getEnergiesAndGradient(x, I) enI = energies[I] return enI, gradI minoptions = {'gtol': 1.0e-7, 'norm': 2} # somehow numerical_hessian does not work without doing this mimimization before res = optimize.minimize(f, atomvec, method="CG", jac=True, options=minoptions) # COMPUTE HESSIAN AND VIBRATIONAL MODES # The hessian is calculated by numerical differentiation of the # analytical gradients def grad(x): if I == 0: enI, gradI = pes.getEnergyAndGradient_S0(x) else: energies, gradI = pes.getEnergiesAndGradient(x, I) return gradI print "Computing Hessian" # calculate hessians from gradients hess = HarmonicApproximation.numerical_hessian_G(grad, atomvec) string = "" # create string that is to be written into file for line in hess: for column in line: string += str(column) + " " string = string[:-1] + "\n" with open("hessian.txt", "w") as hessianfile: # write hessian matrix to file hessianfile.write(string) # this would look nicer but is not as exact #hessianfile.write(annotated_hessian(atomlist, hess)) # calculate energy for optimized geometry dftb2 = DFTB2(atomlist, **options) # create dftb object dftb2.setGeometry(atomlist, charge=kwds.get("charge", 0.0)) dftb2.getEnergy(**scf_options) energies = list(dftb2.getEnergies()) # get partial energies if dftb2.long_range_correction == 1: # add long range correction to partial energies energies.append(dftb2.E_HF_x) return str(energies) except: print sys.exc_info() return "error"
usage += " To see a list of all available fragments run the program without the list parameter.\n" usage += " Type --help to see all options." parser = optparse.OptionParser(usage) parser.add_option( "--filter_mode", dest="filter_mode", help= "Determines whether the filter should 'keep' or 'delete' the selected fragments [default: %default]", default="keep") parser.add_option( "--out_xyz", dest="out_xyz", help="Filtered geometry is written to this file [default: %default]", default="filtered.xyz") (opts, args) = parser.parse_args() if len(args) < 1: print(usage) exit(-1) xyz_in = args[0] selected_fragments = args[1:] atomlist_full = XYZ.read_xyz(xyz_in)[-1] atomlist_filtered = filter_fragments(atomlist_full, selected_fragments, filter_mode=opts.filter_mode) if len(selected_fragments) > 0: XYZ.write_xyz(opts.out_xyz, [atomlist_filtered]) print("filtered geometry written to %s" % opts.out_xyz)
print """ **************************** * * * Nudged Elastic Band * * * **************************** """ print opts # path to xyz-file xyz_file = args[0] # name = basename(xyz_file.replace(".xyz", "")) # Read the geometry from the xyz-file atomlists = XYZ.read_xyz(xyz_file) atomlist = atomlists[0] neb = NEB(force_constant=opts.force_constant, mass=opts.mass, nr_processors=opts.nr_processors) neb.setGeometry(atomlist) neb.setName(name) images = [XYZ.atomlist2vector(atomlist) for atomlist in atomlists] neb.setImages(images, states=[0 for im in images]) neb.addImagesLinearly(2) # save initial path neb.plot() neb.findMEP(tolerance=opts.tolerance, nsteps=opts.nsteps,
""" split an xyz file that contains many structures into separate files """ from DFTB import XYZ if __name__ == "__main__": import sys import optparse usage = "Usage: python %s <xyz file with many structures> <output prefix>\n" % sys.argv[ 0] usage += " splits the input file into output prefix_####.xyz" parser = optparse.OptionParser(usage) parser.add_option( "--step", dest="step", help="Only every N-th geometry is extracted [default: %default]", type=int, default=1) (opts, args) = parser.parse_args() if len(args) < 2: print usage exit(-1) xyz_file = sys.argv[1] prefix = sys.argv[2] structures = XYZ.read_xyz(xyz_file) for i, atomlist in enumerate(structures): if (i + 1) % opts.step == 0 or i == 0: XYZ.write_xyz(prefix + "%.4d.xyz" % (i + 1), [atomlist])
def test_scattering_orbitals(): from DFTB.LR_TDDFTB import LR_TDDFTB from DFTB import XYZ atomlist = XYZ.read_xyz("h2.xyz")[0] tddftb = LR_TDDFTB(atomlist) tddftb.setGeometry(atomlist, charge=0) options = {"nstates": 1} tddftb.getEnergies(**options) valorbs, radial_val = load_pseudo_atoms(atomlist) E = 5.0 / 27.211 bs = AtomicScatteringBasisSet(atomlist, E) print bs.bfs SKT_bf, SKT_ff = load_slako_scattering(atomlist, E) S_bb, H0_bb = tddftb.dftb2._constructH0andS() S_bf, H0_bf = ScatteringHamiltonianMatrix(atomlist, valorbs, SKT_bf) # invS_bb = la.inv(S_bb) # (H-E*S)^t . Id . (H-E*S) HmE2 = np.dot(H0_bf.conjugate().transpose(), np.dot(invS_bb, H0_bf)) \ - E * np.dot( S_bf.conjugate().transpose(), np.dot(invS_bb, H0_bf)) \ - E * np.dot(H0_bf.conjugate().transpose(), np.dot(invS_bb, S_bf)) \ + E**2 * np.dot(S_bf.conjugate().transpose(), np.dot(invS_bb, S_bf)) Scont = continuum_flux(atomlist, SKT_bf) S2 = np.dot(S_bf.conjugate().transpose(), np.dot(la.inv(S_bb), S_bf)) """ # H2 = np.dot(H0_bf.transpose(), np.dot(la.inv(S_bb), H0_bf)) S2 = np.dot( S_bf.transpose(), np.dot(la.inv(S_bb), S_bf)) print "H2" print H2 print "S2" print S2 scat_orbe2, scat_orbs = sla.eig(H2) #, S2) print "PKE = %s" % E print "Energies^2 = %s" % scat_orbe2 scat_orbe = np.sqrt(scat_orbe2) sort_indx = np.argsort(scat_orbe) scat_orbe = scat_orbe[sort_indx] scat_orbs = scat_orbs[:,sort_indx] print "Energies of scattering orbitals: %s" % scat_orbe orbE = np.argmin(abs(scat_orbe-E)) """ assert np.sum(abs(HmE2.conjugate().transpose() - HmE2)) < 1.0e-10 assert np.sum(abs(S2.conjugate().transpose() - S2)) < 1.0e-10 lambdas, scat_orbs = sla.eigh(HmE2) print "lambdas = %s" % lambdas from DFTB.Scattering import PAD for i in range(0, len(lambdas)): if abs(lambdas[i]) > 1.0e-8: print "%d lambda = %s" % (i, lambdas[i]) ### def wavefunction(grid, dV): # evaluate orbital amp = Cube.orbital_amplitude(grid, bs.bfs, scat_orbs[:, i], cache=False) return amp PAD.asymptotic_density(wavefunction, 20, E) ### for (flm, l, m) in classify_lm(bs, scat_orbs[:, i]): if abs(flm).max() > 1.0e-4: print " %s %s %s" % (l, m, abs(flm)) Cube.orbital2grid(atomlist, bs.bfs, scat_orbs[:,i], \ filename="/tmp/scattering_orbital_%d.cube" % i, dbuff=25.0) delattr(Cube.orbital_amplitude, "cached_grid")
positions, velocities = velocities_finite_diff(fragment_atomlists[f], dt) for i in range(0, Nt): vm = velocities[i] * masses vel_com = np.array( [np.sum(vm[0::3]), np.sum(vm[1::3]), np.sum(vm[2::3])]) / M ekin_com_f = 1.0 / 2.0 * M * np.sum(vel_com**2) ekin_tot_f = 1.0 / 2.0 * np.sum(masses * velocities[i]**2) ekin_com[i, f] += ekin_com_f ekin_tot[i, f] += ekin_tot_f return ekin_com, ekin_tot if __name__ == "__main__": import sys traj_file = sys.argv[1] dt = float(sys.argv[2]) atomlists = XYZ.read_xyz(traj_file) ekin_com, ekin_tot = partition_kinetic_energy(atomlists, 3.0) print((ekin_com[:100, 0])) print((ekin_com[:100, 1])) import matplotlib.pyplot as plt for f in range(0, 2): plt.plot(ekin_com[:, f] / ekin_com[:, f].max(), ls="-.") plt.show()