What open source solvers (according to the generally accepted Open Source Definition i.e. licensed under a valid open source license) are available for full configuration interaction calculations? Ideally, I am looking for a package with a modular interface which could be easily included in quantum chemistry programs.

The solver should be able to return density matrices, for instance, since those are needed for complete-active-space self-consistent-field (CASSCF) calculations. Ideally, the code should also scale up to billion-determinant calculations.

Note again that this question is about open source packages, not proprietary programs.



Jeppe Olsen's LUCIA / LUCITA code has been included in e.g. Dalton, which is nowadays open source. The code has been successfully used in calculations including over one billion determinants, Chem. Phys. Lett. 169, 463 (1990).

A massively parallel version of thecode is in NWChem, and it has been used to solve (20e,20o) problems J. Chem. Phys. 147, 184111 (2017).

However, it doesn't look like the code is available as a separate module at the moment.



Peter Knowles' FCI program, published in Computer Physics Communications, 54, 75 (1989), is available at https://bitbucket.org/pjknowles/fci/src/master/

The code is Fortran 77 and can handle at least tens of millions of determinants. It uses FCIDUMP files as input.

It appears that some other implementations of the algorithm are available, such as one by Knizia at https://sites.psu.edu/knizia/software/.



One of my favorite FCI programs is the one in MRCC, because it has a few advantages over the MOLPRO FCI program (which uses the program you described in your answer).

When the entire calculation fits in memory and can be done reasonably quickly, MOLPRO's FCI program probably offers the best combination of speed and convenience (selected CI programs like Dice and Arrow can get you the same numerical energy faster, but among other issues, require you to know what you're doing in terms of checking that the selected CI convergence parameters were selected appropriately).

However, when the calculation does not fit in memory, MOLPRO doesn't offer much (or anything at all). The FCI program in MRCC will likely be a lot slower for small systems, but for large systems it will try various things to make the RAM requirements smaller, and surprisingly it can even be faster in some cases despite requiring less RAM. The reason it can be faster while still requiring less RAM, is because unlike MOLPRO which only offers CISD and FCI but nothing in between (except if you use the MRCC plug-in), MRCC calculates CISD, CISCDT, CISDTQ, CISDTQP, CISDTQPH, CISDTQPHS, CISDTQPHSO, etc. and can use the previous CI calculation to give an initial guess for the next one. Therefore CISD can be extremely fast, and then the result can be used as a starting guess for CISDT, and so on, meaning that fewer iterations are required (sometime close to zero of them, I mean, I'm sure I've seen the FCI step converge after 1 or 2 iterations because CISDTQPH was so close to being FCI, but I often worked with a small number of electrons in a big basis set rather than the other way around).

So not only can MRCC's FCI program can make adjustments for large FCI calculations so that they don't require as much memory, but the calculations can converge more quickly if they start from (for example) a CISDTQ result, and as a bonus, you also get the CI(n) energies for all values of n (which can be helpful despite those energies not being size-consistent, for example if you can't get the FCI energy but you find that CISDTQ, CISDTQP, and CISDTQPH all agree to within 1 nano-hartree, then you can be confident that you have the FCI energy despite not having enough computing power to calculate it). Additionally, I've found MRCC's FCI program to be a lot better in terms of parallelization (the MOLPRO versions I used, required a factor of N more RAM in order to run on N cores, whereas this is far from the case for MRCC). Finally, when MOLPRO's FCI calculation crashes after several iterations, I found myself simply restarting the calculation from scratch because restarts never worked as smoothly for me as they do in MRCC. In MRCC, I found restarts to be the smoothest out of all electronic structure programs I've used.

There's still disadvantages of MRCC over other programs, and one is the huge amount of disk space that it can use for temporary files. Also, the FCIDUMP format isn't precisely followed, but I regularly convert between FCIDUMP and MRCC's fort.55 format, and the other way around, using the method I described in my answer to: For software that does not support FCIDUMP format, what format is used and how can we get the software to interact with FCIDUMP integrals?. MRCC isn't available on GitHub, but you can get an academic license fairly easily, which means you'll get a password which allows you to download the entire source code.

I have done a CCSDTQ calculation in MRCC involving 28,466,110,261 > 28 billion configurations (and coupled cluster calculations are far more expensive than CI ones, so you can probably imagine having close to 1 trillion FCI determinants). This calculation used 747.255 GB of RAM and 23 CPU cores (seemingly not the smartest number of cores to use, I know).

  • 2
    $\begingroup$ MRCC is not open source, so it's out of the question. $\endgroup$ 2 days ago
  • $\begingroup$ It's free to get a license and the source is open to anyone with a license, but having now re-read the license agreement for the first time since 2016, I do see that it says that people with a license have to make sure the source code isn't visible to others! In terms of open-source software: OpenMolcas has a decent FCI solver for RASSCF calculations, and NECI, Dice and Arrow can get you FCI energies to all required digits without including every single determinant. All of those programs have a Davidson solver within them, which does include all determinants. Don't PySCF and Psi4 have too? $\endgroup$ yesterday
  • 1
    $\begingroup$ It's only free as in free beer, it is not open source; on the contrary, it requires you to sign a non-disclosure agreement like all other proprietary codes. The point here is redistributability: one needs to be able to take the solver and plug it in other codes. $\endgroup$ 22 hours ago
  • $\begingroup$ Don't PySCF and Psi4 have FCI solvers that can be plugged into other codes? OpenMolcas, NECI, Dice and Arrow do, and they're all hosted on GitHub. $\endgroup$ 22 hours ago

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.