MPQC 2.3.1

- Main Page
- Related Pages
- Classes
- Files

- File List

integral.h
1 //
2 // integral.h --- definition of the Integral class
3 //
4 // Copyright (C) 1996 Limit Point Systems, Inc.
5 //
6 // Author: Edward Seidl <seidl@janed.com>
7 // Maintainer: LPS
8 //
9 // This file is part of the SC Toolkit.
10 //
11 // The SC Toolkit is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU Library General Public License as published by
13 // the Free Software Foundation; either version 2, or (at your option)
14 // any later version.
15 //
16 // The SC Toolkit is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU Library General Public License for more details.
20 //
21 // You should have received a copy of the GNU Library General Public License
22 // along with the SC Toolkit; see the file COPYING.LIB. If not, write to
23 // the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24 //
25 // The U.S. Government is granted a limited license as per AL 91-7.
26 //
27
28 #ifndef _chemistry_qc_basis_integral_h
29 #define _chemistry_qc_basis_integral_h
30
31 #ifdef __GNUC__
32 #pragma interface
33 #endif
34
35 #include <stddef.h>
36
37 #include <util/state/state.h>
38 #include <util/group/message.h>
39 #include <chemistry/qc/basis/basis.h>
40 #include <chemistry/qc/basis/obint.h>
41 #include <chemistry/qc/basis/tbint.h>
42
43 namespace sc {
44
45 class SymmetryOperation;
46 class RefSymmSCMatrix;
47 class ShellRotation;
48 class CartesianIter;
49 class RedundantCartesianIter;
50 class RedundantCartesianSubIter;
51 class SphericalTransformIter;
52 class SphericalTransform;
53 class PointBag_double;
54 class PetiteList;
55
58 class Integral : public SavableState {
59 protected:
62 Integral(const Ref<GaussianBasisSet> &b1,
63 const Ref<GaussianBasisSet> &b2,
64 const Ref<GaussianBasisSet> &b3,
65 const Ref<GaussianBasisSet> &b4);
66 Ref<GaussianBasisSet> bs1_;
67 Ref<GaussianBasisSet> bs2_;
68 Ref<GaussianBasisSet> bs3_;
69 Ref<GaussianBasisSet> bs4_;
70
71 // the maximum number of bytes that should be used for
72 // storing intermediates
73 size_t storage_;
74 size_t storage_used_;
75
76 Ref<MessageGrp> grp_;
77 public:
79 Integral(StateIn&);
81 Integral(const Ref<KeyVal>&);
82
83 virtual ~Integral();
84
85 void save_data_state(StateOut&);
86
94 static Integral* initial_integral(int &argc, char **argv);
96 static void set_default_integral(const Ref<Integral>&);
98 static Integral* get_default_integral();
100 virtual Integral* clone() =0;
101
104 virtual int equiv(const Ref<Integral> &);
105
107 void set_storage(size_t i) { storage_=i; };
109 size_t storage_used() { return storage_used_; }
111 size_t storage_unused();
114 virtual size_t storage_required_eri(const Ref<GaussianBasisSet> &b1,
115 const Ref<GaussianBasisSet> &b2 = 0,
116 const Ref<GaussianBasisSet> &b3 = 0,
117 const Ref<GaussianBasisSet> &b4 = 0);
120 virtual size_t storage_required_grt(const Ref<GaussianBasisSet> &b1,
121 const Ref<GaussianBasisSet> &b2 = 0,
122 const Ref<GaussianBasisSet> &b3 = 0,
123 const Ref<GaussianBasisSet> &b4 = 0);
126 virtual size_t storage_required_eri_deriv(const Ref<GaussianBasisSet> &b1,
127 const Ref<GaussianBasisSet> &b2 = 0,
128 const Ref<GaussianBasisSet> &b3 = 0,
129 const Ref<GaussianBasisSet> &b4 = 0);
130
133 void adjust_storage(ptrdiff_t s) { storage_used_ += s; }
134
136 Ref<PetiteList> petite_list();
138 Ref<PetiteList> petite_list(const Ref<GaussianBasisSet>&);
141 ShellRotation shell_rotation(int am, SymmetryOperation&, int pure=0);
142
144 virtual void set_basis(const Ref<GaussianBasisSet> &b1,
145 const Ref<GaussianBasisSet> &b2 = 0,
146 const Ref<GaussianBasisSet> &b3 = 0,
147 const Ref<GaussianBasisSet> &b4 = 0);
148
149 // /////////////////////////////////////////////////////////////////////
150 // the following must be defined in the specific integral package
151
154 virtual CartesianIter * new_cartesian_iter(int) =0;
157 virtual RedundantCartesianIter * new_redundant_cartesian_iter(int) =0;
160 virtual RedundantCartesianSubIter*
161 new_redundant_cartesian_sub_iter(int) =0;
164 virtual SphericalTransformIter *
165 new_spherical_transform_iter(int l,
166 int inv=0, int subl=-1) =0;
169 virtual const SphericalTransform *
170 spherical_transform(int l,
171 int inv=0, int subl=-1) =0;
172
174 virtual Ref<OneBodyInt> overlap() =0;
175
177 virtual Ref<OneBodyInt> kinetic() =0;
178
181 virtual Ref<OneBodyInt> point_charge(const Ref<PointChargeData>&) =0;
182
185 virtual Ref<OneBodyOneCenterInt> point_charge1(const Ref<PointChargeData>&);
186
191 virtual Ref<OneBodyInt> nuclear() = 0;
192
194 virtual Ref<OneBodyInt> hcore() = 0;
195
198 virtual Ref<OneBodyInt> efield_dot_vector(const Ref<EfieldDotVectorData>&) =0;
199
202 virtual Ref<OneBodyInt> dipole(const Ref<DipoleData>&) =0;
203
206 virtual Ref<OneBodyInt> quadrupole(const Ref<DipoleData>&) =0;
207
209 virtual Ref<OneBodyDerivInt> overlap_deriv() =0;
210
212 virtual Ref<OneBodyDerivInt> kinetic_deriv() =0;
213
215 virtual Ref<OneBodyDerivInt> nuclear_deriv() =0;
216
218 virtual Ref<OneBodyDerivInt> hcore_deriv() =0;
219
222 virtual Ref<TwoBodyThreeCenterInt> electron_repulsion3();
223
226 virtual Ref<TwoBodyThreeCenterDerivInt> electron_repulsion3_deriv();
227
230 virtual Ref<TwoBodyTwoCenterInt> electron_repulsion2();
231
234 virtual Ref<TwoBodyTwoCenterDerivInt> electron_repulsion2_deriv();
235
237 virtual Ref<TwoBodyInt> electron_repulsion() =0;
238
240 virtual Ref<TwoBodyDerivInt> electron_repulsion_deriv() =0;
241
248 virtual Ref<TwoBodyInt> grt();
249
251 Ref<MessageGrp> messagegrp() { return grp_; }
252 };
253
254 }
255
256 #endif
257
258 // Local Variables:
259 // mode: c++
260 // c-file-style: "ETS"
261 // End: