Skip to content

Home

Jump to bottom
devinamatthews edited this page Aug 17, 2015 · 2 revisions

Installation

Aquarius can be installed on most systems using the usual ./configure && make procedure. General MPI compilers (mpi{cc,cxx,f70,f90} etc.) are searched for as well as the cc, CC, and ftn compiler wrappers on Cray. Any MPI 2.1 compiler should work, although only OpenMPI 1.6 and 1.8 and MPICH3 have been tested. Since C++11 features are required, currently only GCC 4.7+ and Intel 14+ compilers are supported although Clang 3.3+ may work too. IBM XL is not supported nor are Portland Group compilers. If it is necessary to specify the compiler explicitly during configuration, all of the compiler flags -- CC, CXX, FC, and F77 -- must be set to compatible compilers. Note that "make install" will technically work, although the Aquarius binary currently still looks in the original source directory for basis sets.

Additional optional packages can be specified by the --with-XXX=<path> and --with-XXX-libs=<libs> options to configure. These include:

--with-libint2 (https://github.com/evaleev/libint)

--with-elemental (http://libelemental.org/)

Also, one may specify external locations for the required packages (they will be downloaded automatically otherwise):

--with-marray (https://github.com/devinamatthews/marray)

--with-mpiwrap (https://github.com/devinamatthews/mpiwrap)

--with-lawrap (https://github.com/devinamatthews/lawrap)

--with-ctf (http://ctf.eecs.berkeley.edu/)

Input Files

Aquarius can be run on an input file by providing the file as the only argument, e.g. "aquarius test.aq". Example input files end in .aq but this is not required. Comments are denoted by the hash character (#) and span the remainder of the line. The input file syntax is tree-based, where each white-space-separated token (word) is a "node" in the tree. Each new node is assumed to be a child of the previous node, but this can be changed with the comma (,) and brace ({}) operators. The comma operator returns the anchor point (where the next node is attached) back to the last unclosed brace or the root of the tree if no such brace exists. For example, this input file has five nodes in a chain (each node is the child of the previous one):

child1 child2 child3
#new-line is just another white-space character
child4 child5

Instead, this input file has three nodes attached to the root, two of which have their own child:

node1 childof1,
node2, node3 childof3

The next input file has a more complicated structure using braces:

node1
{
    child1of1 subchild1,
    child2of1
}, #note that a comma is necessary here so that node2 is not a child of node1
node2 childof2 { subchild2 {subsubchild2}, #braces do not need surrounding white-space
                 subchild3 }

At the top level, every node is either a keyword or a task name. Currently the only keyword is "section" which creates an arbitrary name for a branch of the input tree (like a namespace in C++). Tasks are computations to be performed, and contain as their sub-tree all of the options such as convergence, molecular input, extrapolation, etc. The currently known tasks are:

  • molecule

    The molecule tasks specifies a molecular geometry and basis set. Examples:

    molecule
{
    units bohr,
    coords cartesian,
    # atoms are specified by: symbol, x, y, z[, charge]
    atom {H, 0.00000000, -1.18603436,  0.81555159},
    atom {O, 0.00000000, -0.00000000, -0.10277433},
    atom {H, 0.00000000,  1.18603436,  0.81555159},
    basis basis_set cc-pVTZ
}

molecule
{
    units angstrom,
    coords internal,
    charge -1,
    # atoms are specified by: symbol, distance_to, distance, angle_to, angle, dihed_to, dihed[, charge]
    atom {N},
    atom {O, 1, 1.0},
    atom {O, 1, 1.0, 2, 120.0},
    atom {O, 1, 1.0, 3, 120.0, 4, 180.0},
    basis basis_set cc-pVDZ
}

  • 1eints

  • 2eints

  • libint2eints (requires libint2)

    These tasks do not require any options and take their input from a molecule task in the same section.

  • localaouhf

  • elementalaouhf (requires Elemental)

    These tasks take an input sub-tree of the form (optional entries denoted by [], defaults by =<default>):

    {
    [convergence tol=1e-12],
    [frozen_core yesno=no],
    [max_iterations num=150],
    [diis
    {
        [damping val=0.0],
        [start iteration=8],
        [order size=6]
    }]
}

  • aomoints

  • sparseaomoints

    These tasks take no options and convert the integrals (from [libint]2eints) to the MO-basis.

  • ccd

  • lccd

  • ccsd

  • ccsdt

  • ccsdtq

  • lambdaccsd

  • lambdaccsdt

  • lambdaccsdtq

    These tasks perform an iterative coupled cluster (CC) calculation or solve the CC Lambda equations and take an input sub-tree of the form:

    {
    [convergence tol=1e-9],
    [max_iterations num=50],
    [diis
    {
        [damping val=0.0],
        [start iteration=1],
        [order size=5]
    }]
}

  • mp3

  • mp4dq

  • ccsd(t)

  • ccsd(t)_l

  • ccsdt(q)

  • ccsdt(q)_l

    These tasks calculate non-iterative corrections to the HF or CC energy and do not take any options.

  • localtda

  • elementaltda (requires Elemental)

    These tasks compute the TDA (CIS) excitation energies and do not take any options.

  • eomeeccsd

    This task compute one or more excited states using the EOMEE-CCSD method. Guesses are taken from TDA. The option sub-tree is:

    {
    [multiroot yesno=no],
    [nroot num=0],
    [ntriplet num=0],
    [convergence tol=1e-9],
    [max_iterations num=150],
    [davidson
    {
        [order size=10],
        [num_reduce num=3], #reduce the subspace by this amount when full
        [compaction discrete|continuous=discrete]
    }]
}
Clone this wiki locally