MPQC  3.0.0-alpha
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 #include <stddef.h>
32 
33 #include <util/state/state.h>
34 #include <util/group/message.h>
35 #include <chemistry/qc/basis/basis.h>
36 #include <chemistry/qc/basis/obint.h>
37 #include <chemistry/qc/basis/tbint.h>
38 #include <chemistry/qc/basis/intparams.h>
39 #include <chemistry/qc/basis/operator.h>
40 
41 #define INTEGRALTHROWDEFAULT { throw ProgrammingError("not implemented in this particular factory", __FILE__, __LINE__); }
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 
60 template <int NumCenters> struct OneBodyIntEvalType;
61 template <> struct OneBodyIntEvalType<2> {
62  typedef OneBodyInt value;
63 };
64 template <> struct OneBodyIntEvalType<1> {
65  typedef OneBodyOneCenterInt value;
66 };
67 // forward declarations of auxiliary type functions
68 namespace detail {
69  template <int NumCenters> struct SEvalCreator;
70  template <int NumCenters> struct TEvalCreator;
71  template <int NumCenters> struct VEvalCreator;
72  template <int NumCenters> struct HCoreEvalCreator;
73  template <int NumCenters> struct MuEvalCreator;
74  template <int NumCenters> struct QEvalCreator;
75  template <int NumCenters> struct PhiEvalCreator;
76  template <int NumCenters> struct DPhiEvalCreator;
77  template <int NumCenters> struct DDPhiEvalCreator;
78  template <int NumCenters> struct P4EvalCreator;
79  template <int NumCenters, OneBodyOperSet::type Type> struct OneBodyEvalCreator;
80 };
81 
83 template <int NumCenters> struct TwoBodyIntEvalType;
84 template <> struct TwoBodyIntEvalType<4> {
85  typedef TwoBodyInt value;
86 };
87 template <> struct TwoBodyIntEvalType<3> {
88  typedef TwoBodyThreeCenterInt value;
89 };
90 template <> struct TwoBodyIntEvalType<2> {
91  typedef TwoBodyTwoCenterInt value;
92 };
93 // forward declarations of auxiliary type functions
94 namespace detail {
95  template <int NumCenters> struct ERIEvalCreator;
96  template <int NumCenters> struct R12EvalCreator;
97  template <int NumCenters> struct G12EvalCreator;
98  template <int NumCenters> struct G12NCEvalCreator;
99  template <int NumCenters> struct G12DKHEvalCreator;
100  template <int NumCenters> struct R120G12EvalCreator;
101  template <int NumCenters> struct R12m1G12EvalCreator;
102  template <int NumCenters> struct G12T1G12EvalCreator;
103  template <int NumCenters> struct DeltaFunctionEvalCreator;
104  template <int NumCenters, TwoBodyOperSet::type Type> struct TwoBodyEvalCreator;
105 };
106 
107 
111 class Integral : public SavableState {
112  protected:
115  Integral(const Ref<GaussianBasisSet> &b1,
116  const Ref<GaussianBasisSet> &b2,
117  const Ref<GaussianBasisSet> &b3,
118  const Ref<GaussianBasisSet> &b4);
119  Ref<GaussianBasisSet> bs1_;
120  Ref<GaussianBasisSet> bs2_;
121  Ref<GaussianBasisSet> bs3_;
122  Ref<GaussianBasisSet> bs4_;
123 
124  typedef enum {
125  MPQCSolidHarmonicsOrdering,
126  CCASolidHarmonicsOrdering
127  } SolidHarmonicsOrdering;
128  SolidHarmonicsOrdering sharmorder_;
129 
130  // the maximum number of bytes that should be used for
131  // storing intermediates
132  size_t storage_;
133  size_t storage_used_;
134  // in absence of atomic<> weapons use this to protect storage_ and storage_used_
135  Ref<ThreadLock> tlock_;
136 
137  Ref<MessageGrp> grp_;
138 
139  private:
144  static const SolidHarmonicsOrdering default_sharmorder_ = CCASolidHarmonicsOrdering;
145 
146  public:
148  Integral(StateIn&);
150  Integral(const Ref<KeyVal>&);
151 
152  virtual ~Integral();
153 
154  void save_data_state(StateOut&);
155 
163  static Integral* initial_integral(int &argc, char **argv);
165  static void set_default_integral(const Ref<Integral>&);
167  static Integral* get_default_integral();
169  virtual Integral* clone() =0;
170 
173  virtual int equiv(const Ref<Integral> &);
175  typedef enum {
176  IntV3CartesianOrdering,
177  CCACartesianOrdering,
178  GAMESSCartesianOrdering,
179  } CartesianOrdering;
181  virtual CartesianOrdering cartesian_ordering() const =0;
182 
184  virtual void set_storage(size_t i);
186  size_t storage_used() const { return storage_used_; }
188  size_t storage_unused() const;
189 
203  virtual size_t storage_required(TwoBodyOper::type opertype,
204  TwoBodyIntShape::value tbinttype,
205  size_t deriv_level = 0,
206  const Ref<GaussianBasisSet> &b1 = 0,
207  const Ref<GaussianBasisSet> &b2 = 0,
208  const Ref<GaussianBasisSet> &b3 = 0,
209  const Ref<GaussianBasisSet> &b4 = 0);
210 
213  virtual size_t storage_required_eri(const Ref<GaussianBasisSet> &b1,
214  const Ref<GaussianBasisSet> &b2 = 0,
215  const Ref<GaussianBasisSet> &b3 = 0,
216  const Ref<GaussianBasisSet> &b4 = 0);
219  virtual size_t storage_required_grt(const Ref<GaussianBasisSet> &b1,
220  const Ref<GaussianBasisSet> &b2 = 0,
221  const Ref<GaussianBasisSet> &b3 = 0,
222  const Ref<GaussianBasisSet> &b4 = 0);
225  virtual size_t storage_required_g12(const Ref<GaussianBasisSet> &b1,
226  const Ref<GaussianBasisSet> &b2 = 0,
227  const Ref<GaussianBasisSet> &b3 = 0,
228  const Ref<GaussianBasisSet> &b4 = 0);
231  virtual size_t storage_required_g12nc(const Ref<GaussianBasisSet> &b1,
232  const Ref<GaussianBasisSet> &b2 = 0,
233  const Ref<GaussianBasisSet> &b3 = 0,
234  const Ref<GaussianBasisSet> &b4 = 0);
237  virtual size_t storage_required_g12dkh(const Ref<GaussianBasisSet> &b1,
238  const Ref<GaussianBasisSet> &b2 = 0,
239  const Ref<GaussianBasisSet> &b3 = 0,
240  const Ref<GaussianBasisSet> &b4 = 0);
243  virtual size_t storage_required_eri_deriv(const Ref<GaussianBasisSet> &b1,
244  const Ref<GaussianBasisSet> &b2 = 0,
245  const Ref<GaussianBasisSet> &b3 = 0,
246  const Ref<GaussianBasisSet> &b4 = 0);
247 
250  void adjust_storage(ptrdiff_t s);
251 
253  Ref<PetiteList> petite_list();
255  Ref<PetiteList> petite_list(const Ref<GaussianBasisSet>&);
258  ShellRotation shell_rotation(int am, SymmetryOperation&, int pure=0);
259 
261  const Ref<GaussianBasisSet>& basis1() const { return bs1_; }
263  const Ref<GaussianBasisSet>& basis2() const { return bs2_; }
265  const Ref<GaussianBasisSet>& basis3() const { return bs3_; }
267  const Ref<GaussianBasisSet>& basis4() const { return bs4_; }
274  virtual void set_basis(const Ref<GaussianBasisSet> &b1,
275  const Ref<GaussianBasisSet> &b2 = 0,
276  const Ref<GaussianBasisSet> &b3 = 0,
277  const Ref<GaussianBasisSet> &b4 = 0);
278 
280  Ref<MessageGrp> messagegrp() { return grp_; }
281 
282  // /////////////////////////////////////////////////////////////////////
283  // the following must be defined in the specific integral package
284 
287  virtual CartesianIter * new_cartesian_iter(int) =0;
290  virtual RedundantCartesianIter * new_redundant_cartesian_iter(int) =0;
293  virtual RedundantCartesianSubIter*
294  new_redundant_cartesian_sub_iter(int) =0;
299  virtual SphericalTransformIter *
300  new_spherical_transform_iter(int l,
301  int inv=0, int subl=-1) =0;
306  virtual const SphericalTransform *
307  spherical_transform(int l,
308  int inv=0, int subl=-1) =0;
309 
311  virtual Ref<OneBodyInt> overlap() =0;
312 
314  virtual Ref<OneBodyInt> kinetic() =0;
315 
318  virtual Ref<OneBodyInt> point_charge(const Ref<PointChargeData>&) =0;
319 
322  virtual Ref<OneBodyOneCenterInt> point_charge1(const Ref<PointChargeData>&);
323 
329  virtual Ref<OneBodyInt> nuclear() = 0;
330 
333  virtual Ref<OneBodyInt> p_dot_nuclear_p();
334 
339  virtual Ref<OneBodyInt> p_cross_nuclear_p();
340 
342  virtual Ref<OneBodyInt> p4() =0;
343 
345  virtual Ref<OneBodyInt> hcore() = 0;
346 
355  virtual Ref<OneBodyInt> efield(const Ref<IntParamsOrigin>& O) =0;
356 
360  virtual Ref<OneBodyInt> efield_dot_vector(const Ref<EfieldDotVectorData>&) =0;
361 
372  virtual Ref<OneBodyInt> efield_gradient(const Ref<IntParamsOrigin>& O);
373 
382  virtual Ref<OneBodyInt> dipole(const Ref<IntParamsOrigin>& O = 0) =0;
383 
395  virtual Ref<OneBodyInt> quadrupole(const Ref<IntParamsOrigin>& O = 0) =0;
396 
398  virtual Ref<OneBodyDerivInt> overlap_deriv() =0;
399 
401  virtual Ref<OneBodyDerivInt> kinetic_deriv() =0;
402 
404  virtual Ref<OneBodyDerivInt> nuclear_deriv() =0;
405 
407  virtual Ref<OneBodyDerivInt> hcore_deriv() =0;
408 
415  DEPRECATED virtual Ref<TwoBodyThreeCenterInt> electron_repulsion3();
416 
419  virtual Ref<TwoBodyThreeCenterDerivInt> electron_repulsion3_deriv();
420 
426  DEPRECATED virtual Ref<TwoBodyTwoCenterInt> electron_repulsion2();
427 
430  virtual Ref<TwoBodyTwoCenterDerivInt> electron_repulsion2_deriv();
431 
437  DEPRECATED virtual Ref<TwoBodyInt> electron_repulsion();
438 
440  virtual Ref<TwoBodyDerivInt> electron_repulsion_deriv();
441 
454  virtual Ref<TwoBodyIntEval> make_eval(TwoBodyOper::type opertype,
455  TwoBodyIntShape::value tbinttype,
456  size_t deriv_level = 0,
457  const Ref<GaussianBasisSet> &b1 = 0,
458  const Ref<GaussianBasisSet> &b2 = 0,
459  const Ref<GaussianBasisSet> &b3 = 0,
460  const Ref<GaussianBasisSet> &b4 = 0);
461 
473  template <int NumCenters>
474  Ref< typename TwoBodyIntEvalType<NumCenters>::value > coulomb() {
475  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::ERI>::value EvalCreator;
476  return EvalCreator::eval(this,new IntParamsVoid);
477  }
478 
491  template <int NumCenters>
492  DEPRECATED Ref< typename TwoBodyIntEvalType<NumCenters>::value > grt() {
493  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12>::value EvalCreator;
494  return EvalCreator::eval(this,new IntParamsVoid);
495  }
500  template <int NumCenters>
501  DEPRECATED Ref< typename TwoBodyIntEvalType<NumCenters>::value > g12(const Ref<IntParamsG12>& p) {
502  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12>::value EvalCreator;
503  return EvalCreator::eval(this,p);
504  }
510  template <int NumCenters>
511  DEPRECATED Ref< typename TwoBodyIntEvalType<NumCenters>::value > g12nc(const Ref<IntParamsG12>& p) {
512  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12NC>::value EvalCreator;
513  return EvalCreator::eval(this,p);
514  }
519  template <int NumCenters>
520  Ref< typename TwoBodyIntEvalType<NumCenters>::value > g12dkh(const Ref<IntParamsG12>& p) {
521  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12DKH>::value EvalCreator;
522  return EvalCreator::eval(this,p);
523  }
524 
541  template <int NumCenters>
542  Ref< typename TwoBodyIntEvalType<NumCenters>::value > r12_k_g12(const Ref<IntParamsG12>& p, int k) {
543  if (k == 0) {
544  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12_0_G12>::value EvalCreator;
545  return EvalCreator::eval(this,p);
546  }
547  if (k == -1) {
548  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12_m1_G12>::value EvalCreator;
549  return EvalCreator::eval(this,p);
550  }
551  std::ostringstream oss;
552  oss << "Integral::r12_k_g12 can only be computed for k=-1 and 0 but k = " << k;
553  throw FeatureNotImplemented(oss.str().c_str(),
554  __FILE__, __LINE__);
555  }
556 
572  template <int NumCenters>
573  Ref< typename TwoBodyIntEvalType<NumCenters>::value > g12t1g12(const Ref<IntParamsG12>& p) {
574  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12_T1_G12>::value EvalCreator;
575  return EvalCreator::eval(this,p);
576  }
577 
591  template <int NumCenters>
592  Ref< typename TwoBodyIntEvalType<NumCenters>::value > delta_function() {
593  typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::DeltaFunction>::value EvalCreator;
594  return EvalCreator::eval(this, new IntParamsVoid);
595  }
596 
597  private:
598  template <int NumCenters> friend struct sc::detail::ERIEvalCreator;
599  template <int NumCenters> friend struct sc::detail::R12EvalCreator;
600  template <int NumCenters> friend struct sc::detail::G12EvalCreator;
601  template <int NumCenters> friend struct sc::detail::G12NCEvalCreator;
602  template <int NumCenters> friend struct sc::detail::G12DKHEvalCreator;
603  template <int NumCenters> friend struct sc::detail::R120G12EvalCreator;
604  template <int NumCenters> friend struct sc::detail::R12m1G12EvalCreator;
605  template <int NumCenters> friend struct sc::detail::G12T1G12EvalCreator;
606  template <int NumCenters> friend struct sc::detail::DeltaFunctionEvalCreator;
607 
616  virtual Ref<TwoBodyInt> grt_4() INTEGRALTHROWDEFAULT;
617  virtual Ref<TwoBodyThreeCenterInt> grt_3() INTEGRALTHROWDEFAULT;
618  virtual Ref<TwoBodyTwoCenterInt> grt_2() INTEGRALTHROWDEFAULT;
619 
624  virtual Ref<TwoBodyInt> g12_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
625  virtual Ref<TwoBodyThreeCenterInt> g12_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
626  virtual Ref<TwoBodyTwoCenterInt> g12_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
627 
633  virtual Ref<TwoBodyInt> g12nc_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
634  virtual Ref<TwoBodyThreeCenterInt> g12nc_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
635  virtual Ref<TwoBodyTwoCenterInt> g12nc_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
636 
641  virtual Ref<TwoBodyInt> g12dkh_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
642  virtual Ref<TwoBodyThreeCenterInt> g12dkh_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
643  virtual Ref<TwoBodyTwoCenterInt> g12dkh_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
644 
647  virtual Ref<TwoBodyInt> r120g12_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
648  virtual Ref<TwoBodyThreeCenterInt> r120g12_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
649  virtual Ref<TwoBodyTwoCenterInt> r120g12_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
650 
653  virtual Ref<TwoBodyInt> r12m1g12_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
654  virtual Ref<TwoBodyThreeCenterInt> r12m1g12_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
655  virtual Ref<TwoBodyTwoCenterInt> r12m1g12_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
656 
659  virtual Ref<TwoBodyInt> g12t1g12_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
660  virtual Ref<TwoBodyThreeCenterInt> g12t1g12_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
661  virtual Ref<TwoBodyTwoCenterInt> g12t1g12_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
662 
665  virtual Ref<TwoBodyInt> delta_function_4() INTEGRALTHROWDEFAULT;
666  virtual Ref<TwoBodyThreeCenterInt> delta_function_3() INTEGRALTHROWDEFAULT;
667  virtual Ref<TwoBodyTwoCenterInt> delta_function_2() INTEGRALTHROWDEFAULT;
668 
669 };
670 
671 // auxiliary type functions
672 namespace detail {
673 
674  template <> struct ERIEvalCreator<4> {
675  static Ref< TwoBodyIntEvalType<4>::value >
676  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
677  return factory->electron_repulsion();
678  }
679  };
680  template <> struct ERIEvalCreator<3> {
681  static Ref< TwoBodyIntEvalType<3>::value >
682  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
683  return factory->electron_repulsion3();
684  }
685  };
686  template <> struct ERIEvalCreator<2> {
687  static Ref< TwoBodyIntEvalType<2>::value >
688  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
689  return factory->electron_repulsion2();
690  }
691  };
692 
693  template <> struct R12EvalCreator<4> {
694  static Ref< TwoBodyIntEvalType<4>::value >
695  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
696  return factory->grt_4();
697  }
698  };
699  template <> struct R12EvalCreator<3> {
700  static Ref< TwoBodyIntEvalType<3>::value >
701  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
702  return factory->grt_3();
703  }
704  };
705  template <> struct R12EvalCreator<2> {
706  static Ref< TwoBodyIntEvalType<2>::value >
707  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
708  return factory->grt_2();
709  }
710  };
711 
712  template <> struct G12EvalCreator<4> {
713  static Ref< TwoBodyIntEvalType<4>::value >
714  eval(Integral* factory, const Ref<IntParamsG12>& params) {
715  return factory->g12_4(params);
716  }
717  };
718  template <> struct G12EvalCreator<3> {
719  static Ref< TwoBodyIntEvalType<3>::value >
720  eval(Integral* factory, const Ref<IntParamsG12>& params) {
721  return factory->g12_3(params);
722  }
723  };
724  template <> struct G12EvalCreator<2> {
725  static Ref< TwoBodyIntEvalType<2>::value >
726  eval(Integral* factory, const Ref<IntParamsG12>& params) {
727  return factory->g12_2(params);
728  }
729  };
730 
731  template <> struct G12NCEvalCreator<4> {
732  static Ref< TwoBodyIntEvalType<4>::value >
733  eval(Integral* factory, const Ref<IntParamsG12>& params) {
734  return factory->g12nc_4(params);
735  }
736  };
737  template <> struct G12NCEvalCreator<3> {
738  static Ref< TwoBodyIntEvalType<3>::value >
739  eval(Integral* factory, const Ref<IntParamsG12>& params) {
740  return factory->g12nc_3(params);
741  }
742  };
743  template <> struct G12NCEvalCreator<2> {
744  static Ref< TwoBodyIntEvalType<2>::value >
745  eval(Integral* factory, const Ref<IntParamsG12>& params) {
746  return factory->g12nc_2(params);
747  }
748  };
749 
750  template <> struct G12DKHEvalCreator<4> {
751  static Ref< TwoBodyIntEvalType<4>::value >
752  eval(Integral* factory, const Ref<IntParamsG12>& params) {
753  return factory->g12dkh_4(params);
754  }
755  };
756  template <> struct G12DKHEvalCreator<3> {
757  static Ref< TwoBodyIntEvalType<3>::value >
758  eval(Integral* factory, const Ref<IntParamsG12>& params) {
759  return factory->g12dkh_3(params);
760  }
761  };
762  template <> struct G12DKHEvalCreator<2> {
763  static Ref< TwoBodyIntEvalType<2>::value >
764  eval(Integral* factory, const Ref<IntParamsG12>& params) {
765  return factory->g12dkh_2(params);
766  }
767  };
768 
769  template <> struct R120G12EvalCreator<4> {
770  static Ref< TwoBodyIntEvalType<4>::value >
771  eval(Integral* factory, const Ref<IntParamsG12>& params) {
772  return factory->r120g12_4(params);
773  }
774  };
775  template <> struct R120G12EvalCreator<3> {
776  static Ref< TwoBodyIntEvalType<3>::value >
777  eval(Integral* factory, const Ref<IntParamsG12>& params) {
778  return factory->r120g12_3(params);
779  }
780  };
781  template <> struct R120G12EvalCreator<2> {
782  static Ref< TwoBodyIntEvalType<2>::value >
783  eval(Integral* factory, const Ref<IntParamsG12>& params) {
784  return factory->r120g12_2(params);
785  }
786  };
787 
788  template <> struct R12m1G12EvalCreator<4> {
789  static Ref< TwoBodyIntEvalType<4>::value >
790  eval(Integral* factory, const Ref<IntParamsG12>& params) {
791  return factory->r12m1g12_4(params);
792  }
793  };
794  template <> struct R12m1G12EvalCreator<3> {
795  static Ref< TwoBodyIntEvalType<3>::value >
796  eval(Integral* factory, const Ref<IntParamsG12>& params) {
797  return factory->r12m1g12_3(params);
798  }
799  };
800  template <> struct R12m1G12EvalCreator<2> {
801  static Ref< TwoBodyIntEvalType<2>::value >
802  eval(Integral* factory, const Ref<IntParamsG12>& params) {
803  return factory->r12m1g12_2(params);
804  }
805  };
806 
807  template <> struct G12T1G12EvalCreator<4> {
808  static Ref< TwoBodyIntEvalType<4>::value >
809  eval(Integral* factory, const Ref<IntParamsG12>& params) {
810  return factory->g12t1g12_4(params);
811  }
812  };
813  template <> struct G12T1G12EvalCreator<3> {
814  static Ref< TwoBodyIntEvalType<3>::value >
815  eval(Integral* factory, const Ref<IntParamsG12>& params) {
816  return factory->g12t1g12_3(params);
817  }
818  };
819  template <> struct G12T1G12EvalCreator<2> {
820  static Ref< TwoBodyIntEvalType<2>::value >
821  eval(Integral* factory, const Ref<IntParamsG12>& params) {
822  return factory->g12t1g12_2(params);
823  }
824  };
825 
826  template <> struct DeltaFunctionEvalCreator<4> {
827  static Ref< TwoBodyIntEvalType<4>::value >
828  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
829  return factory->delta_function_4();
830  }
831  };
832  template <> struct DeltaFunctionEvalCreator<3> {
833  static Ref< TwoBodyIntEvalType<3>::value >
834  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
835  return factory->delta_function_3();
836  }
837  };
838  template <> struct DeltaFunctionEvalCreator<2> {
839  static Ref< TwoBodyIntEvalType<2>::value >
840  eval(Integral* factory, const Ref<IntParamsVoid>& params) {
841  return factory->delta_function_2();
842  }
843  };
844 
845  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::ERI> {
846  typedef ERIEvalCreator<NumCenters> value;
847  };
848  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12> {
849  typedef R12EvalCreator<NumCenters> value;
850  };
851  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12> {
852  typedef G12EvalCreator<NumCenters> value;
853  };
854  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12NC> {
855  typedef G12NCEvalCreator<NumCenters> value;
856  };
857  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12DKH> {
858  typedef G12DKHEvalCreator<NumCenters> value;
859  };
860  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12_0_G12> {
861  typedef R120G12EvalCreator<NumCenters> value;
862  };
863  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12_m1_G12> {
864  typedef R12m1G12EvalCreator<NumCenters> value;
865  };
866  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12_T1_G12> {
867  typedef G12T1G12EvalCreator<NumCenters> value;
868  };
869  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::DeltaFunction> {
870  typedef DeltaFunctionEvalCreator<NumCenters> value;
871  };
872 
873 };
874 
876 // end of addtogroup ChemistryBasisIntegral
877 
878 }
879 
880 #endif
881 
882 // Local Variables:
883 // mode: c++
884 // c-file-style: "ETS"
885 // End:
sc::Integral::g12nc
DEPRECATED Ref< typename TwoBodyIntEvalType< NumCenters >::value > g12nc(const Ref< IntParamsG12 > &p)
Return a TwoBodyInt that computes two-electron integrals specific to explicitly correlated methods wh...
Definition: integral.h:511
sc::Integral::point_charge1
virtual Ref< OneBodyOneCenterInt > point_charge1(const Ref< PointChargeData > &)
Return a OneBodyInt that computes the integrals for interactions with point charges.
sc::Integral::g12dkh
Ref< typename TwoBodyIntEvalType< NumCenters >::value > g12dkh(const Ref< IntParamsG12 > &p)
Return a TwoBodyInt that computes two-electron integrals specific to relativistic explicitly correlat...
Definition: integral.h:520
sc::Integral::kinetic_deriv
virtual Ref< OneBodyDerivInt > kinetic_deriv()=0
Return a OneBodyDerivInt that computes kinetic energy derivatives.
sc::Integral::grt
DEPRECATED Ref< typename TwoBodyIntEvalType< NumCenters >::value > grt()
Return a 2-body evaluator that computes two-electron integrals specific to linear R12 methods.
Definition: integral.h:492
sc::Integral::efield_dot_vector
virtual Ref< OneBodyInt > efield_dot_vector(const Ref< EfieldDotVectorData > &)=0
Return a OneBodyInt that computes the electric field integrals at a given position dotted with a give...
sc::Integral::storage_required_eri
virtual size_t storage_required_eri(const Ref< GaussianBasisSet > &b1, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Returns how much storage will be needed to initialize a two-body integrals evaluator for electron rep...
sc::TwoBodyOperSet
Known two-body operator sets.
Definition: operator.h:343
sc::TwoBodyInt
This is an abstract base type for classes that compute integrals involving two electrons and 2 functi...
Definition: tbint.h:61
sc::detail::PhiEvalCreator
Definition: integral.h:75
sc::Integral::electron_repulsion3
virtual DEPRECATED Ref< TwoBodyThreeCenterInt > electron_repulsion3()
Return a TwoBodyThreeCenterInt that computes electron repulsion integrals.
sc::RedundantCartesianIter
RedundantCartesianIter objects loop through all possible combinations of a given number of axes.
Definition: cartiter.h:82
sc::Integral::nuclear_deriv
virtual Ref< OneBodyDerivInt > nuclear_deriv()=0
Return a OneBodyDerivInt that computes nuclear repulsion derivatives.
sc::Integral::make_eval
virtual Ref< TwoBodyIntEval > make_eval(TwoBodyOper::type opertype, TwoBodyIntShape::value tbinttype, size_t deriv_level=0, const Ref< GaussianBasisSet > &b1=0, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Creates an evaluator for opertype.
sc::Integral::messagegrp
Ref< MessageGrp > messagegrp()
Return the MessageGrp used by the integrals objects.
Definition: integral.h:280
sc::Integral::storage_required_eri_deriv
virtual size_t storage_required_eri_deriv(const Ref< GaussianBasisSet > &b1, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Returns how much storage will be needed to initialize a two-body integrals evaluator for derivative e...
sc::Integral::initial_integral
static Integral * initial_integral(int &argc, char **argv)
Create an integral factory.
sc::TwoBodyTwoCenterInt
This is an abstract base type for classes that compute integrals involving two electrons in two Gauss...
Definition: tbint.h:305
sc::IntParamsVoid
Passes params to Integral::electron_repulsion() and other factory methods which do not need parameter...
Definition: intparams.h:107
sc::OneBodyOneCenterInt
OneBodyOneCenterInt is an abstract base class for objects that compute integrals between two basis fu...
Definition: obint.h:124
sc::Integral::overlap
virtual Ref< OneBodyInt > overlap()=0
Return a OneBodyInt that computes the overlap.
sc::Integral::basis4
const Ref< GaussianBasisSet > & basis4() const
retrieves basis for center 4
Definition: integral.h:267
sc::SymmetryOperation
The SymmetryOperation class provides a 3 by 3 matrix representation of a symmetry operation,...
Definition: pointgrp.h:66
sc::CartesianIter
CartesianIter gives the ordering of the Cartesian functions within a shell for the particular integra...
Definition: cartiter.h:35
sc::detail::DPhiEvalCreator
Definition: integral.h:76
sc::ShellRotation
Compute the transformation matrices that maps a set of Cartesian functions to another set of Cartesia...
Definition: shellrot.h:39
sc::Ref
A template class that maintains references counts.
Definition: ref.h:361
sc::detail::P4EvalCreator
Definition: integral.h:78
sc::detail::HCoreEvalCreator
Definition: integral.h:72
sc::Integral::g12t1g12
Ref< typename TwoBodyIntEvalType< NumCenters >::value > g12t1g12(const Ref< IntParamsG12 > &p)
Return the evaluator of two-body integrals with kernel where is a geminal described by the IntParam...
Definition: integral.h:573
sc::Integral::new_cartesian_iter
virtual CartesianIter * new_cartesian_iter(int)=0
Return a CartesianIter object.
sc::TwoBodyIntShape::value
value
Definition: nbint.h:49
sc::Integral::set_basis
virtual void set_basis(const Ref< GaussianBasisSet > &b1, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Set the basis set for each center.
sc::Integral::adjust_storage
void adjust_storage(ptrdiff_t s)
The specific integral classes use this to tell Integral how much memory they are using/freeing.
sc::detail::OneBodyEvalCreator
Definition: integral.h:79
sc::Integral::CartesianOrdering
CartesianOrdering
Describes the ordering of the cartesian functions in a shell.
Definition: integral.h:175
sc::Integral::storage_required_g12
virtual size_t storage_required_g12(const Ref< GaussianBasisSet > &b1, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Returns how much storage will be needed to initialize a two-body integrals evaluator for G12 integral...
sc::Integral::equiv
virtual int equiv(const Ref< Integral > &)
Returns nonzero if this and the given Integral object have the same integral ordering,...
sc::Integral::dipole
virtual Ref< OneBodyInt > dipole(const Ref< IntParamsOrigin > &O=0)=0
Return a OneBodyInt that computes electric dipole moment integrals, i.e.
sc::Integral::overlap_deriv
virtual Ref< OneBodyDerivInt > overlap_deriv()=0
Return a OneBodyDerivInt that computes overlap derivatives.
sc::RedundantCartesianSubIter
Like RedundantCartesianIter, except a, b, and c are fixed to a given value.
Definition: cartiter.h:172
sc::detail::R12m1G12EvalCreator
Definition: integral.h:101
sc::detail::R12EvalCreator
Definition: integral.h:96
sc::Integral::save_data_state
void save_data_state(StateOut &)
Save the base classes (with save_data_state) and the members in the same order that the StateIn CTOR ...
sc::detail::G12T1G12EvalCreator
Definition: integral.h:102
sc::Integral::electron_repulsion2_deriv
virtual Ref< TwoBodyTwoCenterDerivInt > electron_repulsion2_deriv()
Return a TwoBodyTwoCenterInt that computes electron repulsion integrals.
sc::Integral::efield
virtual Ref< OneBodyInt > efield(const Ref< IntParamsOrigin > &O)=0
Return a OneBodyInt that computes the electric field integrals at specified point.
sc::Integral::basis3
const Ref< GaussianBasisSet > & basis3() const
retrieves basis for center 3
Definition: integral.h:265
sc::FeatureNotImplemented
This is thrown when an attempt is made to use a feature that is not yet implemented.
Definition: scexception.h:120
sc::detail::SEvalCreator
Definition: integral.h:69
sc::Integral::new_redundant_cartesian_iter
virtual RedundantCartesianIter * new_redundant_cartesian_iter(int)=0
Return a RedundantCartesianIter object.
sc::Integral::r12_k_g12
Ref< typename TwoBodyIntEvalType< NumCenters >::value > r12_k_g12(const Ref< IntParamsG12 > &p, int k)
Return the evaluator of two-body integrals with kernel where is a geminal described by the IntParam...
Definition: integral.h:542
sc::Integral::petite_list
Ref< PetiteList > petite_list()
Return the PetiteList object.
sc::Integral::set_default_integral
static void set_default_integral(const Ref< Integral > &)
Specifies a new default Integral factory.
sc::SphericalTransformIter
This iterates through the components of a SphericalTransform.
Definition: transform.h:136
sc::Integral::kinetic
virtual Ref< OneBodyInt > kinetic()=0
Return a OneBodyInt that computes the kinetic energy.
sc::StateIn
Definition: statein.h:79
sc::Integral::storage_required_g12nc
virtual size_t storage_required_g12nc(const Ref< GaussianBasisSet > &b1, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Returns how much storage will be needed to initialize a two-body integrals evaluator for G12NC integr...
sc::detail::R120G12EvalCreator
Definition: integral.h:100
sc::detail::G12EvalCreator
Definition: integral.h:97
sc::Integral::point_charge
virtual Ref< OneBodyInt > point_charge(const Ref< PointChargeData > &)=0
Return a OneBodyInt that computes the integrals for interactions with point charges.
sc::Integral::basis2
const Ref< GaussianBasisSet > & basis2() const
retrieves basis for center 2
Definition: integral.h:263
sc::detail::QEvalCreator
Definition: integral.h:74
sc::Integral::p4
virtual Ref< OneBodyInt > p4()=0
Return a OneBodyInt that computes .
sc::Integral::delta_function
Ref< typename TwoBodyIntEvalType< NumCenters >::value > delta_function()
Return the evaluator of two-body integrals with kernel i.e.
Definition: integral.h:592
sc::OneBodyIntEvalType
returns the type of the evaluator for evaluating this set of two-body integrals
Definition: integral.h:60
sc::Integral::get_default_integral
static Integral * get_default_integral()
Returns the default Integral factory.
sc::TwoBodyIntEvalType
returns the type of the evaluator for evaluating this set of two-body integrals
Definition: integral.h:83
sc::Integral::storage_used
size_t storage_used() const
Returns how much storage has been used.
Definition: integral.h:186
sc::Integral::new_redundant_cartesian_sub_iter
virtual RedundantCartesianSubIter * new_redundant_cartesian_sub_iter(int)=0
Return a RedundantCartesianSubIter object.
sc::detail::G12DKHEvalCreator
Definition: integral.h:99
sc::OneBodyInt
OneBodyInt is an abstract base class for objects that compute integrals between two basis functions.
Definition: obint.h:49
sc::Integral::quadrupole
virtual Ref< OneBodyInt > quadrupole(const Ref< IntParamsOrigin > &O=0)=0
Return a OneBodyInt that computes electric quadrupole moment integrals, i.e.
sc::Integral::hcore
virtual Ref< OneBodyInt > hcore()=0
Return a OneBodyInt that computes the core Hamiltonian integrals.
sc::Integral::p_dot_nuclear_p
virtual Ref< OneBodyInt > p_dot_nuclear_p()
Return a OneBodyInt that computes , where is the nuclear potential.
sc::Integral::storage_unused
size_t storage_unused() const
Returns how much storage was not needed.
sc::Integral
The Integral abstract class acts as a factory to provide objects that compute one and two electron in...
Definition: integral.h:111
sc::detail::TwoBodyEvalCreator
Definition: integral.h:104
sc::detail::DDPhiEvalCreator
Definition: integral.h:77
sc::Integral::efield_gradient
virtual Ref< OneBodyInt > efield_gradient(const Ref< IntParamsOrigin > &O)
Return a OneBodyInt that computes the electric field gradient integrals at specified point.
sc::StateOut
Definition: stateout.h:71
sc::Integral::electron_repulsion
virtual DEPRECATED Ref< TwoBodyInt > electron_repulsion()
Return a TwoBodyInt that computes electron repulsion integrals.
sc::TwoBodyThreeCenterInt
This is an abstract base type for classes that compute integrals involving two electrons in three Gau...
Definition: tbint.h:191
sc::SphericalTransform
This is a base class for a container for a sparse Cartesian to solid harmonic basis function transfor...
Definition: transform.h:73
sc::Integral::Integral
Integral(const Ref< GaussianBasisSet > &b1, const Ref< GaussianBasisSet > &b2, const Ref< GaussianBasisSet > &b3, const Ref< GaussianBasisSet > &b4)
Initialize the Integral object given a GaussianBasisSet for each center.
sc::detail::VEvalCreator
Definition: integral.h:71
sc::Integral::storage_required_g12dkh
virtual size_t storage_required_g12dkh(const Ref< GaussianBasisSet > &b1, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Returns how much storage will be needed to initialize a two-body integrals evaluator for G12DKH integ...
sc::Integral::coulomb
Ref< typename TwoBodyIntEvalType< NumCenters >::value > coulomb()
Return the evaluator of two-body integrals with Coulomb kernel: The evaluator will produce a set of ...
Definition: integral.h:474
sc::Integral::electron_repulsion3_deriv
virtual Ref< TwoBodyThreeCenterDerivInt > electron_repulsion3_deriv()
Return a TwoBodyThreeCenterInt that computes electron repulsion integrals.
sc::Integral::electron_repulsion2
virtual DEPRECATED Ref< TwoBodyTwoCenterInt > electron_repulsion2()
Return a TwoBodyTwoCenterInt that computes electron repulsion integrals.
sc::TwoBodyOper::type
type
types of known two-body operators
Definition: operator.h:318
sc::IntParamsG12
Used to pass params to Integral::g12().
Definition: intparams.h:144
sc::Integral::new_spherical_transform_iter
virtual SphericalTransformIter * new_spherical_transform_iter(int l, int inv=0, int subl=-1)=0
Return a SphericalTransformIter object.
sc::Integral::basis1
const Ref< GaussianBasisSet > & basis1() const
retrieves basis for center 1
Definition: integral.h:261
sc::Integral::electron_repulsion_deriv
virtual Ref< TwoBodyDerivInt > electron_repulsion_deriv()
Return a TwoBodyDerivInt that computes electron repulsion derivatives.
sc::Integral::storage_required
virtual size_t storage_required(TwoBodyOper::type opertype, TwoBodyIntShape::value tbinttype, size_t deriv_level=0, const Ref< GaussianBasisSet > &b1=0, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Reports the approximate amount of memory required, in bytes, to create an evaluator for opertype.
sc::Integral::set_storage
virtual void set_storage(size_t i)
Sets the total amount of storage, in bytes, that is available.
sc::Integral::hcore_deriv
virtual Ref< OneBodyDerivInt > hcore_deriv()=0
Return a OneBodyDerivInt that computes core Hamiltonian derivatives.
sc::Integral::nuclear
virtual Ref< OneBodyInt > nuclear()=0
Return a OneBodyInt that computes the nuclear repulsion integrals.
sc::Integral::cartesian_ordering
virtual CartesianOrdering cartesian_ordering() const =0
returns the ordering used by this factory
sc::Integral::shell_rotation
ShellRotation shell_rotation(int am, SymmetryOperation &, int pure=0)
Return the ShellRotation object for a shell of the given angular momentum.
sc::detail::TEvalCreator
Definition: integral.h:70
sc::detail::DeltaFunctionEvalCreator
Definition: integral.h:103
sc::Integral::storage_required_grt
virtual size_t storage_required_grt(const Ref< GaussianBasisSet > &b1, const Ref< GaussianBasisSet > &b2=0, const Ref< GaussianBasisSet > &b3=0, const Ref< GaussianBasisSet > &b4=0)
Returns how much storage will be needed to initialize a two-body integrals evaluator for linear R12 i...
sc::SavableState
Base class for objects that can save/restore state.
Definition: state.h:45
sc::Integral::p_cross_nuclear_p
virtual Ref< OneBodyInt > p_cross_nuclear_p()
Return a OneBodyInt that computes , where is the nuclear potential.
sc::Integral::spherical_transform
virtual const SphericalTransform * spherical_transform(int l, int inv=0, int subl=-1)=0
Return a SphericalTransform object.
sc::detail::ERIEvalCreator
Definition: integral.h:95
sc
Contains all MPQC code up to version 3.
Definition: mpqcin.h:14
sc::Integral::g12
DEPRECATED Ref< typename TwoBodyIntEvalType< NumCenters >::value > g12(const Ref< IntParamsG12 > &p)
Return a TwoBodyInt that computes two-electron integrals specific to explicitly correlated methods wh...
Definition: integral.h:501
sc::Integral::clone
virtual Integral * clone()=0
Clones the given Integral factory. The new factory may need to have set_basis and set_storage to be c...
sc::detail::G12NCEvalCreator
Definition: integral.h:98
sc::detail::MuEvalCreator
Definition: integral.h:73
Generated at Sun Jan 26 2020 23:23:57 for MPQC 3.0.0-alpha using the documentation package Doxygen 1.8.16.