integral.h

//
// integral.h --- definition of the Integral class
//
// Copyright (C) 1996 Limit Point Systems, Inc.
//
// Author: Edward Seidl <seidl@janed.com>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef _chemistry_qc_basis_integral_h
#define _chemistry_qc_basis_integral_h
 
#include <stddef.h>
 
#include <util/state/state.h>
#include <util/group/message.h>
#include <chemistry/qc/basis/basis.h>
#include <chemistry/qc/basis/obint.h>
#include <chemistry/qc/basis/tbint.h>
#include <chemistry/qc/basis/intparams.h>
#include <chemistry/qc/basis/operator.h>
 
#define INTEGRALTHROWDEFAULT { throw ProgrammingError("not implemented in this particular factory", __FILE__, __LINE__); }
 
namespace sc {
 
class SymmetryOperation;
class RefSymmSCMatrix;
class ShellRotation;
class CartesianIter;
class RedundantCartesianIter;
class RedundantCartesianSubIter;
class SphericalTransformIter;
class SphericalTransform;
class PointBag_double;
class PetiteList;
 
 
template <int NumCenters> struct OneBodyIntEvalType;
template <> struct OneBodyIntEvalType<2> {
  typedef OneBodyInt value;
};
template <> struct OneBodyIntEvalType<1> {
  typedef OneBodyOneCenterInt value;
};
// forward declarations of auxiliary type functions
namespace detail {
  template <int NumCenters> struct SEvalCreator;
  template <int NumCenters> struct TEvalCreator;
  template <int NumCenters> struct VEvalCreator;
  template <int NumCenters> struct HCoreEvalCreator;
  template <int NumCenters> struct MuEvalCreator;
  template <int NumCenters> struct QEvalCreator;
  template <int NumCenters> struct PhiEvalCreator;
  template <int NumCenters> struct DPhiEvalCreator;
  template <int NumCenters> struct DDPhiEvalCreator;
  template <int NumCenters> struct P4EvalCreator;
  template <int NumCenters, OneBodyOperSet::type Type> struct OneBodyEvalCreator;
};
 
template <int NumCenters> struct TwoBodyIntEvalType;
template <> struct TwoBodyIntEvalType<4> {
  typedef TwoBodyInt value;
};
template <> struct TwoBodyIntEvalType<3> {
  typedef TwoBodyThreeCenterInt value;
};
template <> struct TwoBodyIntEvalType<2> {
  typedef TwoBodyTwoCenterInt value;
};
// forward declarations of auxiliary type functions
namespace detail {
  template <int NumCenters> struct ERIEvalCreator;
  template <int NumCenters> struct R12EvalCreator;
  template <int NumCenters> struct G12EvalCreator;
  template <int NumCenters> struct G12NCEvalCreator;
  template <int NumCenters> struct G12DKHEvalCreator;
  template <int NumCenters> struct R120G12EvalCreator;
  template <int NumCenters> struct R12m1G12EvalCreator;
  template <int NumCenters> struct G12T1G12EvalCreator;
  template <int NumCenters> struct DeltaFunctionEvalCreator;
  template <int NumCenters, TwoBodyOperSet::type Type> struct TwoBodyEvalCreator;
};
 
 
class Integral : public SavableState {
  protected:
    Integral(const Ref<GaussianBasisSet> &b1,
             const Ref<GaussianBasisSet> &b2,
             const Ref<GaussianBasisSet> &b3,
             const Ref<GaussianBasisSet> &b4);
    Ref<GaussianBasisSet> bs1_;
    Ref<GaussianBasisSet> bs2_;
    Ref<GaussianBasisSet> bs3_;
    Ref<GaussianBasisSet> bs4_;
 
    typedef enum {
    MPQCSolidHarmonicsOrdering,
    CCASolidHarmonicsOrdering
    } SolidHarmonicsOrdering;
    SolidHarmonicsOrdering sharmorder_;
 
    // the maximum number of bytes that should be used for
    // storing intermediates
    size_t storage_;
    size_t storage_used_;
    // in absence of atomic<> weapons use this to protect storage_ and storage_used_
    Ref<ThreadLock> tlock_;
 
    Ref<MessageGrp> grp_;
 
  private:
    static const SolidHarmonicsOrdering default_sharmorder_ = CCASolidHarmonicsOrdering;
 
  public:
    Integral(StateIn&);
    Integral(const Ref<KeyVal>&);
 
    virtual ~Integral();
 
    void save_data_state(StateOut&);
 
    static Integral* initial_integral(int &argc, char **argv);
    static void set_default_integral(const Ref<Integral>&);
    static Integral* get_default_integral();
    virtual Integral* clone() =0;
 
    virtual int equiv(const Ref<Integral> &);
    typedef enum {
    IntV3CartesianOrdering,
    CCACartesianOrdering,
    GAMESSCartesianOrdering,
    } CartesianOrdering;
    virtual CartesianOrdering cartesian_ordering() const =0;
 
    virtual void set_storage(size_t i);
    size_t storage_used() const { return storage_used_; }
    size_t storage_unused() const;
 
    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);
 
    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);
    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);
    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);
    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);
    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);
    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);
 
    void adjust_storage(ptrdiff_t s);
 
    Ref<PetiteList> petite_list();
    Ref<PetiteList> petite_list(const Ref<GaussianBasisSet>&);
    ShellRotation shell_rotation(int am, SymmetryOperation&, int pure=0);
 
    const Ref<GaussianBasisSet>& basis1() const { return bs1_; }
    const Ref<GaussianBasisSet>& basis2() const { return bs2_; }
    const Ref<GaussianBasisSet>& basis3() const { return bs3_; }
    const Ref<GaussianBasisSet>& basis4() const { return bs4_; }
    virtual void set_basis(const Ref<GaussianBasisSet> &b1,
                           const Ref<GaussianBasisSet> &b2 = 0,
                           const Ref<GaussianBasisSet> &b3 = 0,
                           const Ref<GaussianBasisSet> &b4 = 0);
 
    Ref<MessageGrp> messagegrp() { return grp_; }
 
    // /////////////////////////////////////////////////////////////////////
    // the following must be defined in the specific integral package
 
    virtual CartesianIter * new_cartesian_iter(int) =0;
    virtual RedundantCartesianIter * new_redundant_cartesian_iter(int) =0;
    virtual RedundantCartesianSubIter*
                                 new_redundant_cartesian_sub_iter(int) =0;
    virtual SphericalTransformIter *
                  new_spherical_transform_iter(int l,
                                               int inv=0, int subl=-1) =0;
    virtual const SphericalTransform *
                  spherical_transform(int l,
                                      int inv=0, int subl=-1) =0;
 
    virtual Ref<OneBodyInt> overlap() =0;
 
    virtual Ref<OneBodyInt> kinetic() =0;
 
    virtual Ref<OneBodyInt> point_charge(const Ref<PointChargeData>&) =0;
 
    virtual Ref<OneBodyOneCenterInt> point_charge1(const Ref<PointChargeData>&);
 
    virtual Ref<OneBodyInt> nuclear() = 0;
 
    virtual Ref<OneBodyInt> p_dot_nuclear_p();
 
    virtual Ref<OneBodyInt> p_cross_nuclear_p();
 
    virtual Ref<OneBodyInt> p4() =0;
 
    virtual Ref<OneBodyInt> hcore() = 0;
 
    virtual Ref<OneBodyInt> efield(const Ref<IntParamsOrigin>& O) =0;
 
    virtual Ref<OneBodyInt> efield_dot_vector(const Ref<EfieldDotVectorData>&) =0;
 
    virtual Ref<OneBodyInt> efield_gradient(const Ref<IntParamsOrigin>& O);
 
    virtual Ref<OneBodyInt> dipole(const Ref<IntParamsOrigin>& O = 0) =0;
 
    virtual Ref<OneBodyInt> quadrupole(const Ref<IntParamsOrigin>& O  = 0) =0;
 
    virtual Ref<OneBodyDerivInt> overlap_deriv() =0;
 
    virtual Ref<OneBodyDerivInt> kinetic_deriv() =0;
 
    virtual Ref<OneBodyDerivInt> nuclear_deriv() =0;
 
    virtual Ref<OneBodyDerivInt> hcore_deriv() =0;
 
    DEPRECATED virtual Ref<TwoBodyThreeCenterInt> electron_repulsion3();
 
    virtual Ref<TwoBodyThreeCenterDerivInt> electron_repulsion3_deriv();
 
    DEPRECATED virtual Ref<TwoBodyTwoCenterInt> electron_repulsion2();
 
    virtual Ref<TwoBodyTwoCenterDerivInt> electron_repulsion2_deriv();
 
    DEPRECATED virtual Ref<TwoBodyInt> electron_repulsion();
 
    virtual Ref<TwoBodyDerivInt> electron_repulsion_deriv();
 
    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);
 
    template <int NumCenters>
    Ref< typename TwoBodyIntEvalType<NumCenters>::value > coulomb() {
      typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::ERI>::value EvalCreator;
      return EvalCreator::eval(this,new IntParamsVoid);
    }
 
    template <int NumCenters>
    DEPRECATED Ref< typename TwoBodyIntEvalType<NumCenters>::value > grt() {
      typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12>::value EvalCreator;
      return EvalCreator::eval(this,new IntParamsVoid);
    }
    template <int NumCenters>
    DEPRECATED Ref< typename TwoBodyIntEvalType<NumCenters>::value > g12(const Ref<IntParamsG12>& p) {
      typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12>::value EvalCreator;
      return EvalCreator::eval(this,p);
    }
    template <int NumCenters>
    DEPRECATED Ref< typename TwoBodyIntEvalType<NumCenters>::value > g12nc(const Ref<IntParamsG12>& p) {
      typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12NC>::value EvalCreator;
      return EvalCreator::eval(this,p);
    }
    template <int NumCenters>
    Ref< typename TwoBodyIntEvalType<NumCenters>::value > g12dkh(const Ref<IntParamsG12>& p) {
      typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12DKH>::value EvalCreator;
      return EvalCreator::eval(this,p);
    }
 
    template <int NumCenters>
    Ref< typename TwoBodyIntEvalType<NumCenters>::value > r12_k_g12(const Ref<IntParamsG12>& p, int k) {
      if (k == 0) {
        typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12_0_G12>::value EvalCreator;
        return EvalCreator::eval(this,p);
      }
      if (k == -1) {
        typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12_m1_G12>::value EvalCreator;
        return EvalCreator::eval(this,p);
      }
      std::ostringstream oss;
      oss << "Integral::r12_k_g12 can only be computed for k=-1 and 0 but k = " << k;
      throw FeatureNotImplemented(oss.str().c_str(),
                                  __FILE__, __LINE__);
    }
 
    template <int NumCenters>
    Ref< typename TwoBodyIntEvalType<NumCenters>::value > g12t1g12(const Ref<IntParamsG12>& p) {
      typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12_T1_G12>::value EvalCreator;
      return EvalCreator::eval(this,p);
    }
 
    template <int NumCenters>
    Ref< typename TwoBodyIntEvalType<NumCenters>::value > delta_function() {
      typedef typename detail::TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::DeltaFunction>::value EvalCreator;
      return EvalCreator::eval(this, new IntParamsVoid);
    }
 
  private:
    template <int NumCenters> friend struct sc::detail::ERIEvalCreator;
    template <int NumCenters> friend struct sc::detail::R12EvalCreator;
    template <int NumCenters> friend struct sc::detail::G12EvalCreator;
    template <int NumCenters> friend struct sc::detail::G12NCEvalCreator;
    template <int NumCenters> friend struct sc::detail::G12DKHEvalCreator;
    template <int NumCenters> friend struct sc::detail::R120G12EvalCreator;
    template <int NumCenters> friend struct sc::detail::R12m1G12EvalCreator;
    template <int NumCenters> friend struct sc::detail::G12T1G12EvalCreator;
    template <int NumCenters> friend struct sc::detail::DeltaFunctionEvalCreator;
 
    virtual Ref<TwoBodyInt> grt_4() INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyThreeCenterInt> grt_3() INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyTwoCenterInt> grt_2() INTEGRALTHROWDEFAULT;
 
    virtual Ref<TwoBodyInt> g12_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyThreeCenterInt> g12_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyTwoCenterInt> g12_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
 
    virtual Ref<TwoBodyInt> g12nc_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyThreeCenterInt> g12nc_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyTwoCenterInt> g12nc_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
 
    virtual Ref<TwoBodyInt> g12dkh_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyThreeCenterInt> g12dkh_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyTwoCenterInt> g12dkh_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
 
    virtual Ref<TwoBodyInt> r120g12_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyThreeCenterInt> r120g12_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyTwoCenterInt> r120g12_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
 
    virtual Ref<TwoBodyInt> r12m1g12_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyThreeCenterInt> r12m1g12_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyTwoCenterInt> r12m1g12_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
 
    virtual Ref<TwoBodyInt> g12t1g12_4(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyThreeCenterInt> g12t1g12_3(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyTwoCenterInt> g12t1g12_2(const Ref<IntParamsG12>&) INTEGRALTHROWDEFAULT;
 
    virtual Ref<TwoBodyInt> delta_function_4() INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyThreeCenterInt> delta_function_3() INTEGRALTHROWDEFAULT;
    virtual Ref<TwoBodyTwoCenterInt> delta_function_2() INTEGRALTHROWDEFAULT;
 
};
 
// auxiliary type functions
namespace detail {
 
  template <> struct ERIEvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->electron_repulsion();
    }
  };
  template <> struct ERIEvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->electron_repulsion3();
    }
  };
  template <> struct ERIEvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->electron_repulsion2();
    }
  };
 
  template <> struct R12EvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->grt_4();
    }
  };
  template <> struct R12EvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->grt_3();
    }
  };
  template <> struct R12EvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->grt_2();
    }
  };
 
  template <> struct G12EvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12_4(params);
    }
  };
  template <> struct G12EvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12_3(params);
    }
  };
  template <> struct G12EvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12_2(params);
    }
  };
 
  template <> struct G12NCEvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12nc_4(params);
    }
  };
  template <> struct G12NCEvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12nc_3(params);
    }
  };
  template <> struct G12NCEvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12nc_2(params);
    }
  };
 
  template <> struct G12DKHEvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12dkh_4(params);
    }
  };
  template <> struct G12DKHEvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12dkh_3(params);
    }
  };
  template <> struct G12DKHEvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12dkh_2(params);
    }
  };
 
  template <> struct R120G12EvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->r120g12_4(params);
    }
  };
  template <> struct R120G12EvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->r120g12_3(params);
    }
  };
  template <> struct R120G12EvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->r120g12_2(params);
    }
  };
 
  template <> struct R12m1G12EvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->r12m1g12_4(params);
    }
  };
  template <> struct R12m1G12EvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->r12m1g12_3(params);
    }
  };
  template <> struct R12m1G12EvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->r12m1g12_2(params);
    }
  };
 
  template <> struct G12T1G12EvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12t1g12_4(params);
    }
  };
  template <> struct G12T1G12EvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12t1g12_3(params);
    }
  };
  template <> struct G12T1G12EvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsG12>& params) {
      return factory->g12t1g12_2(params);
    }
  };
 
  template <> struct DeltaFunctionEvalCreator<4> {
    static Ref< TwoBodyIntEvalType<4>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->delta_function_4();
    }
  };
  template <> struct DeltaFunctionEvalCreator<3> {
    static Ref< TwoBodyIntEvalType<3>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->delta_function_3();
    }
  };
  template <> struct DeltaFunctionEvalCreator<2> {
    static Ref< TwoBodyIntEvalType<2>::value >
    eval(Integral* factory, const Ref<IntParamsVoid>& params) {
      return factory->delta_function_2();
    }
  };
 
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::ERI> {
    typedef ERIEvalCreator<NumCenters> value;
  };
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12> {
    typedef R12EvalCreator<NumCenters> value;
  };
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12> {
    typedef G12EvalCreator<NumCenters> value;
  };
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12NC> {
    typedef G12NCEvalCreator<NumCenters> value;
  };
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12DKH> {
    typedef G12DKHEvalCreator<NumCenters> value;
  };
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12_0_G12> {
    typedef R120G12EvalCreator<NumCenters> value;
  };
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::R12_m1_G12> {
    typedef R12m1G12EvalCreator<NumCenters> value;
  };
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::G12_T1_G12> {
    typedef G12T1G12EvalCreator<NumCenters> value;
  };
  template <int NumCenters> struct TwoBodyEvalCreator<NumCenters,TwoBodyOperSet::DeltaFunction> {
    typedef DeltaFunctionEvalCreator<NumCenters> value;
  };
 
};
 
// end of addtogroup ChemistryBasisIntegral
 
}
 
#endif
 
// Local Variables:
// mode: c++
// c-file-style: "ETS"
// End: