1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
|
/**
@defgroup Init mpqc.Init
Supports initialization of MPQC. Provides initialization of various runtime components (ThreadGrp, MessageGrp, MADNESS, etc.)
as well as translation of simple traditional quantum-chemistry input to the MPQC object-oriented KeyVal input.
*/
/**
@defgroup Chemistry mpqc.Chemistry
@anchor labelmpqcChemistry
Provides functionality related to the domain of chemistry. This includes
- @ref labelmpqcChemistryMolecule "mpqc.Chemistry.Molecule"
- @ref labelmpqcChemistryBasis "mpqc.Chemistry.Basis"
- @ref labelmpqcChemistryElectronicStructure "mpqc.Chemistry.ElectronicStructure"
*/
/**
@defgroup ChemistryMolecule mpqc.Chemistry.Molecule
@ingroup Chemistry
@anchor labelmpqcChemistryMolecule
Provides Molecule class and related functionality.
*/
/**
@defgroup ChemistryBasis mpqc.Chemistry.Basis
@ingroup Chemistry
@anchor labelmpqcChemistryBasis
Classes/functions related to basis representations used in chemistry, i.e. atomic basis functions.
*/
/**
@defgroup ChemistryBasisGaussian mpqc.Chemistry.Basis.Gaussian
@ingroup ChemistryBasis
Classes/functions related to Gaussian AO basis representations.
*/
/**
@defgroup ChemistryBasisIntegral mpqc.Chemistry.Basis.Integral
@ingroup ChemistryBasis
Classes/functions related to integrals over atomic basis function.
Synopsis:
@code
// get the default Integral factory. MPQC supports several factories that
// may not be interoperable with each other, to be safe use the same one throughout
Ref<Integral> integral_factory = Integral::get_default_integral();
// need to compute overlap integrals between 2 basis sets?
integral_factory->set_basis(bs1, bs2);
Ref<OneBodyInt> overlap_12 = integral_factory->overlap();
// loop over shell combinations, call overlap_12->compute_shell()
const double* ints_buffer = overlap_12->buffer();
for(int s1=0; s1<bs1->nshell(); ++s1) {
for(int s2=0; s2<bs2->nshell(); ++s2) {
// compute shell block
overlap_12->compute_shell(s1, s2);
// read integrals from ints_buffer
for(int f1=0, f12=0; f1<bs1->shell(s1).nfunction(); ++f1) {
for(int f2=0; f2<bs2->shell(s2).nfunction(); ++f2, ++f12) {
const double v = ints_buffer[f12];
// integral in v corresponds to these basis functions:
// bra index = f1 + bs1->shell_to_function(s1)
// ket index = f2 + bs2->shell_to_function(s2)
// use v here
}
}
}
}
@endcode
In this example the computed integrals are extracted one-by-one. Often you want to copy the entire shell block
of integrals to another array. This can be done using new range-style access described
in @ref ChemistryBasisIntegralRange "mpqc.Chemistry.Basis.Integral.Range".
*/
/**
@defgroup ChemistryBasisIntegralRange mpqc.Chemistry.Basis.Integral.Range
@ingroup ChemistryBasisIntegral
Provides new range-style compute wrapper to the mpqc.Chemistry.Basis.Integral functionality.
Synopsys:
@code
// get the default Integral factory. MPQC supports several factories that
// may not be interoperable with each other, to be safe use the same one throughout
Ref<Integral> integral_factory = Integral::get_default_integral();
// need to compute overlap integrals between 2 basis sets?
integral_factory->set_basis(bs1, bs2);
Ref<OneBodyInt> overlap_12 = integral_factory->overlap();
// to be continued
@endcode
*/
/**
@defgroup ChemistryBasisIntegralTA mpqc.Chemistry.Basis.Integral.TiledArray
@ingroup ChemistryBasisIntegral
* Provides interface to get atomic basis integrals into TiledArray tensors.
* @code
* IntegralEnginePool<Engine_type> engine_pool(seed_engine);
* TiledArray::Array<double, 2> array = Integrals(world, engine_pool);
* @endcode
*/
/**
@defgroup ChemistryElectronicStructure mpqc.Chemistry.ElectronicStructure
@ingroup Chemistry
@anchor labelmpqcChemistryElectronicStructure
Classes/functions related to state of electrons in Molecule.
*/
/**
@defgroup ChemistryElectronicStructureOneBody mpqc.Chemistry.ElectronicStructure.OneBody
@ingroup ChemistryElectronicStructure
Classes/functions related to one-body models of electronic structure.
*/
/**
@defgroup ChemistryElectronicStructureOneBodyHF mpqc.Chemistry.ElectronicStructure.OneBody.HF
@ingroup ChemistryElectronicStructureOneBody
Classes/functions related to Hartree-Fock (HF) one-body models of electronic structure.
*/
/**
@defgroup ChemistryElectronicStructureOneBodyHFCADF mpqc.Chemistry.ElectronicStructure.OneBody.HF.CADF
@ingroup ChemistryElectronicStructureOneBody
Classes/functions related to concentric atomic density fitting (CADF) formulation of Hartree-Fock
*/
/**
@defgroup ChemistryElectronicStructureNBody mpqc.Chemistry.ElectronicStructure.NBody
@ingroup ChemistryElectronicStructure
Classes/functions related to many-body models of electronic structure.
*/
/**
@defgroup CI mpqc.Chemistry.ElectronicStructure.NBody.CI
@ingroup ChemistryElectronicStructureNBody
Configuration Interaction (CI) implementation
*/
/**
@defgroup TAWFN mpqc.Chemistry.ElectronicStructure.TAWFN
@ingroup ChemistryElectronicStructure
TiledArray-based wavefunctions
*/
/**
@defgroup TAWFN.OneBody mpqc.Chemistry.ElectronicStructure.TAWFN.OneBody
@ingroup TAWFN
TiledArray-based one-body wave functions
*/
/**
@defgroup ChemistryElectronicStructureSpin mpqc.Chemistry.ElectronicStructure.Spin
@ingroup ChemistryElectronicStructure
Functionality related to spin states of electrons.
*/
/**
@defgroup Core mpqc.Core
@anchor labelmpqcCore
Provides core, domain-independent functionality: core libraries for managing memory,
saving and restoring the state of objects, reading objects from an input file, parallel communication, among others.
mpqc.Core was also known as the Scientific Toolkit (SC) in the past.
*/
/**
@defgroup CoreKeyVal mpqc.Core.KeyVal
@ingroup Core
Classes/functions for managing structured sets of keyword-value associations, such as encoded in the MPQC object-oriented input format.
*/
/**
@defgroup CoreState mpqc.Core.State
@ingroup Core
Classes/functions used for serialization/deserialization.
*/
/**
@defgroup CoreMPI mpqc.Core.MPI
@ingroup Core
<a href=http://www.mpi-forum.org>MPI</a> wrappers/stubs.
*/
/**
@defgroup CoreFile mpqc.Core.File
@ingroup Core
Implementation of hierarchical file objects based on
<a href="http://www.hdfgroup.org/HDF5/">HDF5</a>.
To work with files:
- create a file object
- create a dataset in that file (where actual data resides)
- write/read data to/from the dataset
@code
File file("file.h5");
std::vector<size_t> dims{m,n};
File::Dataset<double> ds(file, "my dataset", dims);
Vector v(m*n);
ds.write(v.data());
ds.read(v.data());
// or
ds << v; // write v to ds
ds >> v; // read ds to v
@endcode
*/
/**
@defgroup CoreUtility mpqc.Core.Util
@ingroup Core
Miscellaneous utilities
*/
/**
@defgroup Math mpqc.Math
@anchor labelmpqcMath
Provides mathematical functionality, e.g. Matrix and Tensor classes, linear algebra, etc.
*/
/** @defgroup MathMatrix mpqc.Math.Matrix
@ingroup Math
Matrix and Vector classes and function,
derived from <a href="http://eigen.tuxfamily.org">Eigen</a>.
@anchor MatrixOperators
The matrix and vector objects overide <c>operator()</c>,
s.t. if one of the arguments is a range, a block is returned rather
than a single element.
Example:
@code
matrix(0,range(0,4)); // returns 1x4 sub-matrix (0,0:3)
matrix(0,0); // returns matrix element (0,0);
vector(range(2,4)); // returns sub-vector (2:3)
@endcode
*/
/**
@defgroup MathTensor mpqc.Math.Tensor
@ingroup Math
Tensor objects and functions.
*/
/**
@defgroup MathArray mpqc.Math.Array
@ingroup Math
Distributed/serial array implementation.
*/
/**
@defgroup MathRange mpqc.Math.Range
@ingroup Math
Range objects for iterating or accessing slices of data.
*/
/**
@defgroup MathBLAS mpqc.Math.BLAS
@ingroup Math
BLAS bindings.
The BLAS biding are meant to serve as a safer way to interface
C++ Matrix objects, namely Eigen::Matrix and mpqc::matrix, with
BLAS libraries, eg:
@code
auto a = MatrixXd::Map(data, m, k);
Eigen::MatrixXd b(k,n);
mpqc::Matrix c(m,n);
// c = 1.0*a*b + 0.0*c;
blas::gemm(1.0, a, b, 0.0, c);
@endcode
BLAS bindings can be disabled and Eigen expression equivalents will
be used instead by setting the value of <code>MPQCMATH_USE_BLAS</code> macro to 0. This gives
a good way to test if interface is working correctly.
BLAS bindings are implemented on top of
<a href=http://svn.boost.org/svn/boost/sandbox/numeric_bindings/>
Boost.Numeric.Bindings</a>.
*/
/**
@defgroup MathTiledArray mpqc.Math.TiledArray
@ingroup Math
Supports the use of <a href="https://github.com/ValeevGroup/tiledarray">TiledArray</a>, a new massively-parallel
runtime for dense and block-sparse tensor computing.
*/
|
