Procedures

Add a function call to registry

add an overlap entry to the map

add an entry to the maps collection

Calculate binomial coefficients using recursive algorithm by Sten Rettrup and Ruben Pauncz, Int. J. Quantum Chem., 60: 91–98 (1996) DOI: 10.1002/(SICI)1097-461X(1996)60:1<91::AID-QUA10>3.0.CO;2-A

compute center-of-charge of a set particles

compute center-of-mass of a set of particles

compute centroid of a set of particles

compute and store double factorials upto 12!!

compute multipole expansion of the electrostatic potential from an electronic density (which is represented on a grid) around an origin

compute and store factorials upto 12!

Computes folded tensor used in energy and potential computations

compute interaction energy between quantum fragment and long-range atoms

compute forces from long-range atoms on quantum fragment and vice versa

compute potential from long-range atoms on quantum fragment

computes minimum distance between two sets of particles

compute multipole expansion of the electrostatic potential from a set of nuclei around an origin

compute classical atom - quantum ion interaction energy

compute forces from classical atom - quantum electrons interactions (stored FION matrix (through pointers))

compute forces from classical atom - quantum ion interactions (stored in FION matrix (through pointers))

compute potential classical atom on quantum fragment

compute tensor coefficients needed to compute open-ended derivatives of $\frac{1}{|\mathbf{r}_{a}-\mathbf{r}_{b}|}$ (from C. E. Dykstra, J. Comput. Chem., 9 (1988), 476, where C^(n)_ij are stored as tensor_coefficient(j,i,n))

compute trinomial coefficients ($\frac{(i+j+k)!}{i!+j!+k!}$)

contract tensors A and B according to rank of C and return result in C

convert from multi-index to packed tensor index

Recursive function making a deep copy of stack_entry

add an overlap entry to the map

add an overlap entry to the map

destructor for the commlib

convert tensor to traceless tensor

routine sending an exit code to each client

Recursive function looking for the entry in array by hash

Compute folded multipole interaction tensor containing derivatives of $\frac{1}{r_{ab}} = \frac{1}{|\mathbf{r}_{b}-\mathbf{r}_{a}|}$, i.e. the da'th derivative wrt $\mathbf{r}_{a}$ and db'th derivative wrt $\mathbf{r}_{b}$. Tensor is returned in a one-dimensional array with elements in anticanonical ordering, e.g. xx, xy, xz, yy, yz, zz.

compute the fragment center-of-charge

compute the fragment center-of-mass

compute the fragment centroid

gather angle count from all clients

get the angle constraints data - atom indices and equilibrium values

gather atom count from all clients

get the number of atoms per each fragment in the system

get IDs of atoms per each fragment in the system

gather bond count from all clients

get the bond constraints data - atom indices and lengths

gather coordinates of atoms within the system (dealing with overlaps) and store result in the tau matrix through pointers

gather element number associated to MM atom types

gather MM energies from clients

gather forces acting on atoms within the system and store result in the forces matrix through pointers

gather fragment count from all clients

gather integer parameter from client codes

get the data about atoms in the system

get the data about atoms in the system

gather atom types count from all clients

Get the number of atoms per atomic species per code (with overlap treatment)

get the number of fragment per each of the client code

get the orders of multipoles used in each client code

Get current time

Subroutine to handle errors

Handler to treat any other kind of errors

Handler to treat incorrect argument errors

Handler to treat memory allocation issues

identify and connect clients

Calculate a hash of the string

Add new start time to the entry

initialize communication

Initializer of a stack entry

initialiaze error handler

intialize fragment

initialize overlap mapping

Initialize quantum fragment

initialize tensor module

Compute multipole interaction tensor containing derivatives of $\frac{1}{r_{ab}} = \frac{1}{|\mathbf{r}_{b}-\mathbf{r}_{a}|}$, i.e. the da'th derivative wrt $\mathbf{r}_{a}$ and db'th derivative wrt $\mathbf{r}_{b}$. Tensor is returned in a one-dimensional array with elements in anticanonical ordering, e.g. xx, xy, xz, yy, yz, zz.

issue a command to compute forces and energies

allocates fragments for MM part

allocates quantum fragment (at the moment one per simulation)

re-center the quantum box

wrapper to request coordinates of MM part

wrapper to request MM energies

wrapper to request MM forces

compute interaction energy

compute forces from electrostatic interactions

compute multipoles of the quantum fragment

compute electrostatic potential

compute folded tensors for long-range electrostatics

Routine to count the number of interdependent constraints amoung bonds

MiMiC destruction routine - deallocates all arrays and shuts down communicator

MiMiC initialization routine

initialize MiMiC

initialize error handling

initialize overlap maps using the input file data

apply MIC to the whole system with respect to a pivot point

Routine that prints timings accumulated during the current run of MiMiC

wrapper to request sizes of MM parts (number of atoms/species/fragments)

return data about atomic species, masses and multipoles in the MM part

set the number of clients (needed for non-root processes)

sort fragments into short- and long-range according to distance criterion

Routine that does translation of the whole system with a given vector

compute size of first degree polytensor with tensors up to maxmimum rank

Recursive function printing timing of the entry and its children

Print measured timings of function calls

Subroutine to print warning header

Writes a welcome message to the standard output together with the list of papers to cite.

compute quantum-fragment center-of-charge

compute quantum-fragment center-of-mass

compute quantum-fragment centroid

send a command via the CommLib

send coordinates of atoms to client codes (sends a flattened array)

gather integer parameter from client codes

Start a timer for a given function

Stop a timer for a given function (invalidates the pointer)

compute element of multipole interaction tensor (C. E. Dykstra, J. Comput. Chem., 9 (1988), 476) which in multi-index notation this is $\mathbf{T}^{(i,j,k)} = \frac{\mathrm{d}^{i}\mathrm{d}^{j}\mathrm{d}^{k}}{\mathrm{d}x_{a}^{i}\mathrm{d}y_{a}^{j}\mathrm{d}z_{a}^{k}} \frac{1}{|\mathbf{r}_{a} - \mathbf{r}_{b}|}$

compute rank of tensor

compute size of tensor of given rank

compute trace of a packed tensor

Print the call stack with timing information.

Start timing the routine with a given name. This procedure will start tracking the execution time of a given function in a call stack tree. Subsequent calls to this function will create additional entries in the call stack that are going to be shown as children of the original routine.

Stop timing last routine. This procedure will record the finishing time of the routine that was timed the last. Moreover, it will move one level up in the call stack hierarchy.

search for unique occurences in the array

Subroutine to print error header