Skip to content

Docs CSC now features an automatic Finnish translation. Click here for more information.

Warning!

Puhti and Mahti are being decommissioned in stages, and their storage areas will become fully unavailable from 15 October 2026. Clean up unnecessary files and move any data you need to keep by 31 August 2026. See the Roihu data migration guide for instructions on transferring your data to Roihu.

Puhti scratch is very full: keep only active data there and move or delete everything else. No new Puhti scratch quota will be granted.

MOLPRO

MOLPRO is a software package geared towards accurate ab initio quantum chemistry calculations. The emphasis in the program is on highly accurate computations, with extensive treatment of the electron correlation problem through the multireference configuration interaction, coupled cluster and associated methods.

Available

  • Puhti: 2024.3
  • Mahti: 2024.3
  • Roihu-CPU: 2025.4, 2026.1 (default)

License

  • The use of the software is restricted to non-commercial research.

Usage

Initialise MOLPRO on Puhti or Mahti:

module load molpro/2024.3

On Roihu, the default version is 2026.1:

module load molpro/2026.1

Molpro has been built with the Global Arrays toolkit (--with-mpi-pr) that allocates one helper process per node for parallel MPI runs.

Note

Although some parts of the code support shared memory parallelism (OpenMP), its use is not generally recommended.

Example batch scripts

Note

Wave function-based correlation methods, both single and multireference, often create a substantial amount of disk I/O. In order to achieve maximal performance for the job and to avoid excess load on the Lustre parallel file system it is advisable to use the local disk where available.

#!/bin/bash
#SBATCH --partition=test
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=40      # MPI tasks per node
#SBATCH --account=yourproject     # insert here the project to be billed
#SBATCH --time=00:15:00           # time as hh:mm:ss
module purge
module load molpro/2024.3

export MOLPRO_TMP=$PWD/MOLPRO_TMP_$SLURM_JOB_ID
mkdir -p $MOLPRO_TMP

$MOLPROP -d$MOLPRO_TMP -I$MOLPRO_TMP -W$PWD test.com
rm -rf $MOLPRO_TMP

#!/bin/bash
#SBATCH --partition=large
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=40
#SBATCH --account=yourproject     # insert here the project to be billed
#SBATCH --time=00:15:00           # time as hh:mm:ss
#SBATCH --gres=nvme:100           # requested local disk space in GB
module purge
module load molpro/2024.3

export MOLPRO_TMP=$LOCAL_SCRATCH/MOLPRO_TMP_$SLURM_JOB_ID
mkdir -p $MOLPRO_TMP

$MOLPROP -d$MOLPRO_TMP -I$MOLPRO_TMP -W$PWD test.com
rm -rf $MOLPRO_TMP

On Mahti, it is often necessary to undersubscribe cores per node to ensure sufficient memory per core. See the Mahti job script guidelines for more details.

#!/bin/bash
#SBATCH --partition=test
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=16
#SBATCH --cpus-per-task=8
#SBATCH --account=yourproject     # insert here the project to be billed
#SBATCH --time=0:10:00            # time as hh:mm:ss
# set --ntasks-per-node=X and --cpus-per-task=Y so that X * Y = 128
module purge
module load molpro/2024.3

export MOLPRO_TMP=$PWD/MOLPRO_TMP_$SLURM_JOB_ID
mkdir -p $MOLPRO_TMP

$MOLPROP -d$MOLPRO_TMP -I$MOLPRO_TMP -W$PWD test.com
rm -rf $MOLPRO_TMP

On Roihu, jobs must be submitted from the CPU login node (roihu-cpu). For a full list of available partitions and their limits, see the Roihu batch job partitions page.

Most Molpro jobs will run in the small (up to 72 h) or longrun (up to 10 days) partitions, both of which support up to 1500 GiB per job on M and L nodes with independent CPU and memory allocation (--mem-per-cpu). The hugemem and hugemem_longrun partitions provide access to XL nodes with up to 6037 GiB, but use a fixed memory-per-core allocation — you cannot set --mem-per-cpu independently there.

Note

Local NVMe disk is not yet available for standard M-node jobs on Roihu. Scratch I/O goes to Lustre, which is significantly faster than on Puhti or Mahti. NVMe support will be enabled in a future update.

Basic example — on small and longrun partitions (M and L nodes), CPU and memory are allocated independently. Simply set --mem-per-cpu to match the memory directive in your input file. No core undersubscription is needed:

#!/bin/bash
#SBATCH --partition=small         # see batch-job-partitions for all options
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=12
#SBATCH --mem-per-cpu=8000         # MB; 1000 MW * 8 / 1 core = 8000 MB/cpu
#SBATCH --account=yourproject
#SBATCH --time=02:00:00
module purge
module load molpro/2026.1

export MOLPRO_TMP=$PWD/MOLPRO_TMP_$SLURM_JOB_ID
mkdir -p $MOLPRO_TMP

$MOLPROP -n $SLURM_NTASKS -d$MOLPRO_TMP -I$MOLPRO_TMP -W$PWD test.com
rm -rf $MOLPRO_TMP

Undersubscribing cores — hugemem and hugemem_longrun only

The hugemem and hugemem_longrun partitions (XL nodes, up to 6037 GiB) use a fixed memory-per-core allocation (allocation type C). The only way to increase memory per MPI task is to reserve multiple cores per task with --cpus-per-task. Set --ntasks-per-node=X and --cpus-per-task=Y so that their product does not exceed 128 (the core limit for hugemem). Note that one MPI task per node is consumed by the Global Arrays helper process, so the actual number of worker tasks is --ntasks-per-node - 1.

Matching the Molpro memory directive to Slurm resources

The memory directive specifies memory per worker MPI process in words (1 word = 8 bytes), so the suffix m means MW (mega-words). The corresponding --mem-per-cpu value depends on the partition type:

  • small/longrun (type R, --cpus-per-task=1): --mem-per-cpu (MB) = memory_in_MW × 8
  • hugemem/hugemem_longrun (type C, --cpus-per-task=Y): --mem-per-cpu (MB) = memory_in_MW × 8 / --cpus-per-task

For example, memory,1000,m with --cpus-per-task=1 requires --mem-per-cpu=8000. The total memory reserved on the node is --mem-per-cpu × --cpus-per-task × --ntasks-per-node. See the Molpro manual for full details on the memory directive.

Example of scalability

The performance of Molpro depends a lot on the system size and which computational model is used. The following table shows the wall time (in seconds) for a single-point energy calculation on benzene (C6H6) at CCSD(T)/aug-cc-pVTZ level as a function of the number of cores, measured on Puhti. Results with Lustre and local NVMe scratch are shown separately. Note that parallel runs allocate one core per node as a helper process, so there is one core less per node available for the actual calculation.

Cores Wall time/Lustre (s) Wall time/NVMe (s)
1 11749 10962
5 3254 3228
10 1730 1561
20 1394 1239
40 1112 814
2×20 786 729
2×40 716 701

The following results were obtained on Roihu M-nodes with Lustre scratch. Jobs were run sequentially with no other jobs on the node. Wall times on shared nodes (typical in the small partition) may vary by ±20–50% due to I/O and memory bandwidth contention from co-located jobs.

Conventional CCSD(T)/aug-cc-pVQZ — benzene (756 basis functions), memory,1000,m:

MPI tasks Workers Wall time (s) Peak scratch
6 5 662 ~98 GB
12 11 552 ~98 GB
24 23 495 ~98 GB
48 47 521 ~98 GB

The input file is available at benzene_ccsd_t_avqz.inp.

CCSD(T)-F12b/cc-pVTZ-F12 — naphthalene (674 basis functions), memory,1000,m:

MPI tasks Workers Wall time (s) Peak scratch
6 5 1250 ~62 GB
12 11 761 ~62 GB
24 23 811 ~62 GB
48 47 842 ~62 GB

The input file is available at naphthalene_ccsd_t_f12b_vtz.inp.

For comparison, the same naphthalene calculation at the conventional CCSD(T)/aug-cc-pVQZ level would require ~400 GB of scratch disk. The F12 approach reduces this to ~62 GB while using a smaller basis set (674 vs ~1500 basis functions for aug-cc-pVQZ).

Estimating memory requirements

Molpro's internal memory statistics (printed at the end of the output file) only cover the CCSD steps and underestimate the true peak. After a completed run, check actual memory usage with:

sacct -j <jobid> --format=JobID,MaxRSS,Elapsed,State

Divide MaxRSS by the number of worker tasks and by 8 to get the equivalent value in MW for the memory directive. Use this to tune --mem-per-cpu and memory for future runs.

For naphthalene CCSD(T)-F12b/cc-pVTZ-F12 with 12 tasks, the minimum working memory is ~500 MW (--mem-per-cpu=4000). Using memory,1000,m (--mem-per-cpu=8000) gives the best performance.

References

All publications resulting from use of MOLPRO must acknowledge the following three references.

  1. H.-J. Werner, P. J. Knowles, G. Knizia, F. R. Manby and M. Schütz, WIREs Comput Mol Sci 2, 242–253 (2012), doi: 10.1002/wcms.82
  2. Hans-Joachim Werner, Peter J. Knowles, Frederick R. Manby, Joshua A. Black, et al., J. Chem. Phys. 152, 144107 (2020). doi:10.1063/5.0005081
  3. MOLPRO, version , a package of ab initio programs, H.-J. Werner, P. J. Knowles, and others, see https://www.molpro.net.

Depending on which programs are used, additional references should also be cited. For instructions see the manual.

More information