eljost / pysisyphus

Python suite for optimization of stationary points on ground- and excited states PES and determination of reaction paths.

pysisyphus is a software-suite for the exploration of potential energy surfaces in ground- and excited states. It implements several methods to search for stationary points (minima and first order saddle points) and the calculation of minimum energy paths by means of IRC and Chain of States methods like Nudged Elastic Band and Growing String. Furthermore it provides tools to easily analyze & modify geometries (aligning, translating, interpolating, ...) and to visualize the calculation results/progress.

Further information can be found in the Open Access pysisyphus paper.

Required energies, gradients and hessians are calculated by calling external quantum chemistry codes. Alternatively pysisyphus can also be used as a library to implement custom quantum chemistry workflows.

If any issues arise please open an issue and I'll try to fix it if possible and my time permits it. Contributions are welcome, so feel free to submit a PR.

This software is still work in progress. Use at your own risk.

Example

Fully internal coordinate transition state search for the famous alanine dipeptide isomerization reaction, using the xtb calculator and the growing string method.

Documentation

Please have a look at the documentation.

pysisyphus's Issues

Overhaul dimer implementation

The current implementation of the dimer_method looks quite adventurous. Maybe it can implement the Calculator interface, so the translation can be done using pre-existing optimizer classes.

Handle turbomole in testing.py

As Turbomole doesn't appear in .pysisyphusrc I have to think of a different way to handle this in testing.py

RS-PRFO with hessian from previous calculation

Right now this crashes, as RS-PRFO asserts hessian_init == "calc".

Determination of initial root from HEI tangent

Running a COS optimization with cartesian coordinates may run into problems when determining the initial mode by overlaps in redundand internals.

Improve pysis --cp

Right now several files are not recognized/copied when using pysis --cp

• initial hessians
• control path from turbomol
• several files like gbw and fchks

Remove current_geometry.xyz after successful optimization

Remove the .xyz file when everything finished smoothly.

Supply initial hessian to IRC calculation

Add the ability to use a pre-existing (cartesian) hessian to avoid costly recalculation.

Move restricted-step alpha calculation to HessianOptimizer

Right now the same code for the gradient of alpha is implemented three times in RSPRFO, RSIF and RSRFO. It should reside in its own method in HessianOptimizer.py

Dask test

Add a test that uses a COS method with a dask cluster.

Wrong cos-Cutoffs in gdiis.py

Right now COS_CUTOFFS are first defined correctly and then accidentally overwritten with much looser cutoffs. Check if renabling the tighter cutoffs makes a difference.

Interactive dumping/extraction of geometries with pysistrj

Add ability to quickly dump a certain optimization step with pysistrj. Maybe interactively.

Define primitive internals from multiple reference geometries

Allow the input of multiple reference geometries, that are used to define primitive internals, e.g. for TS searches. This way one could input educts and products and then define the union of both primitives for the TS search. Then the chance to miss important coordinates may be decreased.

fix logging for internal coordinate classes

Right now the logfile create is done in optimizers/init.py ...
Move this stuff to intcoords.

Transition vector from overlap with lower-level TV

TS optimizations may start from TS guesses obtained at a lower level of theory. Using a new/different level of theory will probably lead too many more imaginary frequencies at the TS-guess-geometry.

Check if the transition vector at the new/different level of theory can be selected by calculating the overlaps with the old transition vector.

For this the Hessian of the lower-level TS is needed.

Allow filtering in pysistrj --internals

Allow for atom filtering in pysistrj --internals to get a quick impression what coordinates are formed for the specified atoms.

Support add_prims in pysistrj

Support --add_prims in pysistrj, so it can be used with --internals to see also derived coordinates that are formed from the added primitives.

Calculator logging and multiprocessing parallelization

calculator.log get recreated multiple times when using multiprocessing parallelization.

Method to retrieve covalent radii for Geometry.atoms

Refactor main in run.py

Refactor the function so that it can be called with a dictionary input instead of relying on the argparse input.

Write out intermediate calculated Hessians

Don't save only the intially calculated hessian but also all hessians that were recalculated in between.

Completely remove (calls) to propagate_wavefunction()

This is superseeded by get/set_chkfile

no energies in cycle_*

While the image_.trj have the energies included and thus can nicely be viewed with molden, the cycle_.trj files do not have this feature, yet. Could you please include it? Maybe this only happens, if xtb is used; don't know. :)

Refactor guess_hessians

get_pair_covalent_radii() and get_bond_mat() should probably reside somewhere else...

Fix intcoords.generate_derivatives.py

Moving from sympy 1.4 to 1.5/1.5.1 broke this script as the second derivative seems to be returned as array with shape (N, N) instead of (N*N, ). Then the cse step fails. It can be fixed by calling the cse with list(it.chain(*exprs)).

Remove sympy from cubic_fit

It is slow as hell. This wont matter for expensive optimizations, but severely slows done optimizations with analytical potentials.

Implement mem argument. for all relevant calculators

Right now not all calculators respect the mem argument.

ORCA: mem is given in blocks argument.
Turbomole: mem is set in control file. May need to distribute the whole amount onto maxcor/ricore/rpacor

Use prefix in Optimizer.py baseclass

Refactor Optimizer.py to use a potentially set prefix attribute.

Investigate if final calculation is done on stopped COS optimization

It seems that additional, albeit instantly converging, calculations are done on COS optimizations, when everything converged.

Remove save_also() from Optimizers

Remove the save_also() method from all Optimizers and replace it with get_restart_info(). Needed for #64

• BacktrackingOptimizer

• ConjugateGradient

• FIRE

• LBFGS

• QuickMin

• SteepestDescent

• HessianOptimizer

• TSHessianOptimizer

Investigate if intermediate PySCF chkfiles have to be deleted

Similar to deleting the first chkfile.

Retry capabilitiy in Calculator.run()

Some kind of retry capability for running calculations would be nice to make pysisyphus more resilient. E.g. one could specify retries=2 in the Calculator constructor for a maximum of two retries if a calculation failed. This could also be combined with some kind of timeout to detected hanging calculations.

Write ot geometry of current optimization step

Keep a continiously updated .xyz file that contains the geometry of the most recent optimization step.

Check where check_bends=False should be considered

Think about the correct place to return True when check_bends=False in InternalCoordinates.RedundantCoordinates.

Port augmentation of internal coordinates for TS optimizations

Port the code from tests/test_baker_ts/test_baker_ts.py to the main code base and enable it by default for TS optimizations.

Unify list updates from DIIS and poly_line_search

Right now there is some redundant code in RFOptimizer.py and HessianOptimizer.py that updates the appropriate lists with inter/extra-polated values. This should & could be unified.

Turbomole calculator and pal problem

Turbomole seems to hang with pal != 1 on my machine.

Failed to load key 'cmd' from section 'gaussian16'

When I try to run the program with Gaussian16 I get the following pysis.log file:

                           d8b                            888
                           Y8P                            888
                                                          888
88888b.  888  888 .d8888b  888 .d8888b  888  888 88888b.  88888b.  888  888 .d8888b
888 "88b 888  888 88K      888 88K      888  888 888 "88b 888 "88b 888  888 88K
888  888 888  888 "Y8888b. 888 "Y8888b. 888  888 888  888 888  888 888  888 "Y8888b.
888 d88P Y88b 888      X88 888      X88 Y88b 888 888 d88P 888  888 Y88b 888      X88
88888P"   "Y88888  88888P' 888  88888P'  "Y88888 88888P"  888  888  "Y88888  88888P'
888           888                            888 888
888      Y8b d88P                       Y8b d88P 888
888       "Y88P"                         "Y88P"  888                            

Version 0.3+14.g07ce301

{'calc': {'charge': 1,
          'mem': 8000,
          'mult': 1,
          'pal': 4,
          'route': 'BP86/def2SVP EmpiricalDispersion(GD3BJ) INT(UltraFine)',
          'type': 'g16'},
 'coord_type': 'cart',
 'cos': {'climb': True, 'parallel': 0, 'type': 'neb'},
 'dimer': None,
 'glob': None,
 'interpol': {'between': 15, 'type': 'lst'},
 'irc': None,
 'opt': {'align': True,
         'climb': True,
         'dump': True,
         'max_cycles': 100,
         'type': 'qm'},
 'overlaps': None,
 'shake': None,
 'stocastic': None,
 'tsopt': None,
 'xyz': ['start.xyz', 'end.xyz']}

Read 2 geometries.
f=0.0625, success: True
f=0.1250, success: True
f=0.1875, success: True
         'climb': True,
         'dump': True,
         'max_cycles': 100,
         'type': 'qm'},
 'overlaps': None,
 'shake': None,
 'stocastic': None,
 'tsopt': None,
 'xyz': ['start.xyz', 'end.xyz']}

Read 2 geometries.
f=0.0625, success: True
f=0.1250, success: True
f=0.1875, success: True
f=0.2500, success: True
f=0.3125, success: True
f=0.3750, success: True
f=0.4375, success: True
f=0.5000, success: True
f=0.5625, success: True
f=0.6250, success: True
f=0.6875, success: True
f=0.7500, success: True
f=0.8125, success: True
f=0.8750, success: True
f=0.9375, success: True
Wrote all geometries to interpolated.trj.
Wrote geom 000 to interpolated.geom_000.xyz.
Wrote geom 001 to interpolated.geom_001.xyz.
Wrote geom 002 to interpolated.geom_002.xyz.
Wrote geom 003 to interpolated.geom_003.xyz.
Wrote geom 004 to interpolated.geom_004.xyz.
Wrote geom 005 to interpolated.geom_005.xyz.
Wrote geom 006 to interpolated.geom_006.xyz.
Wrote geom 007 to interpolated.geom_007.xyz.
Wrote geom 008 to interpolated.geom_008.xyz.
Wrote geom 009 to interpolated.geom_009.xyz.
Wrote geom 010 to interpolated.geom_010.xyz.
Wrote geom 011 to interpolated.geom_011.xyz.
Wrote geom 012 to interpolated.geom_012.xyz.
Wrote geom 013 to interpolated.geom_013.xyz.
Wrote geom 014 to interpolated.geom_014.xyz.
Wrote geom 015 to interpolated.geom_015.xyz.
Wrote geom 016 to interpolated.geom_016.xyz.

Failed to load key 'cmd' from section 'gaussian16'. Exiting!

With the calculation obviously aborting. Has this behavior been observed previously during testing?

Support some kind of reference-section for YAML input

Allow specification of some reference values in YAML input, so YAML inputs could verify themselves.

Equivalent delocalized internal coordinates

This looks interesting: https://www.sciencedirect.com/science/article/pii/S0166128005008766

Restart capability

Reactivate the restart capability. This wasn't tested for a long time.

Restarting Calculators

• ORCA
• Turbomole
• Gaussian16
• PySCF
• OpenMolcas
• Psi4

Restarting Geometries / ChainOfStates

• Geometry
• ChainOfStates

Restarting TSOptimizers

• TSHessianOptimizer
• Dimer

Restarting IRC

Check COS convergence using modified_forces instead of perpendicular_forces

Use the recently introduced modified_forces list to check for COS convergence, so everything is consistent.

This may be more complicated. Different COS flavors have different "forces" implementations ... For NEB there is also the quenched DNEB force that should be considered.

Allow specification of charge/multiplicity for fragments

Right now opt_ends: fragments assumes charge 0 and multiplicity 1, but this may not always be true. This should be allowed to be specified.

Update to propagate_wavefunction in cos.GrowingString.get_new_image

Update the method to use the new get/set_restart_info.

Treatment of linesearch and GDIIS

Line-searches and GDIIS produce an intermediate geometry and its corresponding gradient. Maybe these methods should only return the correspondig step from the current geometry, instead of setting the intermediate coordinates on the Geometry object. After we created the "final" step from the inter-/extrapolated geometry we can just add both steps. This way we dont have to update any lists like self.coords and self.forces in the optimizers.

Refactor cur_step to cur_cycle in IRC classes

As the rest of the code uses cur_cycle, using cur_step in the IRC classes is inconsitent.

Turbomole parser crashes if gradient contains more than one cycle

this is my gradient file:
$grad cartesian gradients
cycle = 1 SCF energy = -78.5469489756 |dE/dxyz| = 0.011084
-1.24343979543875 0.00000000000000 0.00000000000000 c
1.24343979543875 0.00000000000000 0.00000000000000 c
-2.32247341731646 1.72531995932459 0.00000000000000 h
-2.32247341731646 -1.72531995932459 0.00000000000000 h
2.32247341731646 1.72531995932459 0.00000000000000 h
2.32247341731646 -1.72531995932459 0.00000000000000 h
0.54206405236883D-02 0.77493567118836D-13 -.56657581255684D-13
-.54206405234827D-02 -.12123635428907D-12 -.10562291294545D-13
0.18253704797031D-02 -.35625085610502D-02 0.11830936875874D-13
0.18253704796780D-02 0.35625085610698D-02 0.19393071175979D-13
-.18253704797327D-02 -.35625085610979D-02 0.00000000000000D+00
-.18253704797391D-02 0.35625085610707D-02 0.00000000000000D+00
cycle = 2 SCF energy = -78.5471031456 |dE/dxyz| = 0.000390
-1.25064626604651 -0.00156469323803 0.00000000000000 c
1.25064626604651 -0.00156469323803 0.00000000000000 c
-2.32795154440308 1.73774490864832 0.00000000000000 h
-2.33549344139942 -1.73618021541029 0.00000000000000 h
2.32795154440308 1.73774490864832 0.00000000000000 h
2.33549344139942 -1.73618021541029 0.00000000000000 h
0.95929134047879D-04 -.88092601660650D-04 0.16333203403010D-13
-.95929134413808D-04 -.88092601486789D-04 -.31177819748840D-13
-.18513340706239D-04 0.68376385047308D-05 0.38661100509657D-13
-.22803021622431D-03 0.81388166587537D-04 0.39119745143396D-13
0.18513340650825D-04 0.68376385558566D-05 0.00000000000000D+00
0.22803021631757D-03 0.81388166594198D-04 0.18803139539624D-13
$end

And this is the corresponding error:
pyparsing.ParseException: Expected "$end", found 'c' (at char 948), (line:15, col:3)
This means that gradient files from a geometry optimization will always crash the parser.

Check convergence with real (calculated) gradients

Right now the inter/extra-polated gradient is used for the convergence check, as it overwrites the "real" gradient. This is wrong.

IRC@yaml

Maybe I am missng something but I am correct that IRC calculations do not work not with yaml
input files? If they do.. could you pls provide an example? (I am not too much into python yet)

Thanks so much for providing the program & all your efforts !

Investigate PySCF with chkfile

Setting a chkfile and calculating a Hessian seems to crash everything.

Generation of final_geomtry filename when doing preoptimization

Check on how the final_geometry.xyz filename is generated in a preoptimization. Right now names like "first_prefinal_geometry.xyz" are generated.