prefactors.h

/*
 *  Copyright (C) 2004-2024 Edward F. Valeev
 *
 *  This file is part of Libint compiler.
 *
 *  Libint compiler is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Libint compiler 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Libint compiler.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef _libint2_src_bin_libint_prefactors_h_
#define _libint2_src_bin_libint_prefactors_h_
 
#include <bfset.h>
#include <entity.h>
#include <singl_stack.h>
#include <smart_ptr.h>
 
#include <cstring>
 
#define CTIMEENTITIES_SINGLETONS 1
 
namespace libint2 {
 
class Prefactors {
 public:
  Prefactors();
  ~Prefactors();
 
  typedef RTimeEntity<double> rdouble;
  typedef CTimeEntity<double> cdouble;
 
  static const unsigned int NMAX = 200;
  static const unsigned int np = 2;
  static const unsigned int nfunc_per_part = 1;
 
  std::shared_ptr<rdouble> vX_Y[np];
  std::shared_ptr<rdouble> X_Y[np][3];
 
  std::shared_ptr<rdouble> vY_X[np];
  std::shared_ptr<rdouble> Y_X[np][3];
 
  std::shared_ptr<rdouble> vXY_X[np][2];
  std::shared_ptr<rdouble> XY_X[np][2][3];
  std::shared_ptr<rdouble> vW_XY[np];
  std::shared_ptr<rdouble> W_XY[np][3];
 
  std::shared_ptr<rdouble> zeta[np][2];
  std::shared_ptr<rdouble> zeta2[np][2];
 
  std::shared_ptr<rdouble> alpha12[np];
  std::shared_ptr<rdouble> rho;
  std::shared_ptr<rdouble> one_o_2alpha12[np];
  std::shared_ptr<rdouble> rho_o_alpha12[np];
  std::shared_ptr<rdouble> one_o_2alphasum;
 
  std::shared_ptr<rdouble> TwoPRepITR_vpfac0[np];
  std::shared_ptr<rdouble> TwoPRepITR_pfac0[np][3];
  std::shared_ptr<rdouble> TwoPRepITR_pfac1[np];
 
  std::shared_ptr<rdouble> R12kG12VRR_vpfac0[np];
  std::shared_ptr<rdouble> R12kG12VRR_pfac0[np][3];
  std::shared_ptr<rdouble> R12kG12VRR_pfac1[np];
  std::shared_ptr<rdouble> R12kG12VRR_pfac2;
  std::shared_ptr<rdouble> R12kG12VRR_pfac3[np];
  std::shared_ptr<rdouble> R12kG12VRR_vpfac4[np];
  std::shared_ptr<rdouble> R12kG12VRR_pfac4[np][3];
 
  std::shared_ptr<rdouble> Overlap00_1d[3];
 
#if CTIMEENTITIES_SINGLETONS
  std::shared_ptr<cdouble> N_i[NMAX];
 
  std::shared_ptr<cdouble> Cdouble(double a);
#endif
 
 private:
};
 
extern Prefactors prefactors;
 
namespace prefactor {
 
template <typename T>
struct RTimeSingletons {
  typedef SingletonStack<RTimeEntity<T>, typename RTimeEntity<T>::key_type>
      ManagerType;
  static std::shared_ptr<ManagerType>& Manager() {
    if (manager_ == 0) {
      manager_ =
          std::shared_ptr<ManagerType>(new ManagerType(&RTimeEntity<T>::key));
    }
    return manager_;
  }
  static std::shared_ptr<ManagerType> manager_;
};
template <typename T>
std::shared_ptr<typename RTimeSingletons<T>::ManagerType>
    RTimeSingletons<T>::manager_;
 
#if CTIMEENTITIES_SINGLETONS
template <typename T>
struct CTimeSingletons {
  typedef SingletonStack<CTimeEntity<T>, T> ManagerType;
  static std::shared_ptr<ManagerType>& Manager() {
    if (manager_ == 0) {
      manager_ =
          std::shared_ptr<ManagerType>(new ManagerType(&CTimeEntity<T>::value));
    }
    return manager_;
  }
  static std::shared_ptr<ManagerType> manager_;
};
template <typename T>
std::shared_ptr<typename CTimeSingletons<T>::ManagerType>
    CTimeSingletons<T>::manager_;
#endif
 
template <typename T,
          typename = typename std::enable_if<std::is_integral<T>::value>::type>
std::shared_ptr<CTimeEntity<double> > Scalar(T a) {
  typedef CTimeEntity<double> return_type;
  std::shared_ptr<return_type> tmp(new return_type(a));
#if CTIMEENTITIES_SINGLETONS
  typedef CTimeSingletons<double> singletons_type;
  typedef typename singletons_type::ManagerType ManagerType;
  const typename ManagerType::value_type& result =
      singletons_type::Manager()->find(tmp);
  return result.second;
#else
  return tmp;
#endif
}
inline std::shared_ptr<CTimeEntity<double> > Scalar(double a) {
  typedef CTimeEntity<double> return_type;
  std::shared_ptr<return_type> tmp(new return_type(a));
#if CTIMEENTITIES_SINGLETONS
  typedef CTimeSingletons<double> singletons_type;
  typedef typename singletons_type::ManagerType ManagerType;
  const typename ManagerType::value_type& result =
      singletons_type::Manager()->find(tmp);
  return result.second;
#else
  return tmp;
#endif
}
//    inline std::shared_ptr< RTimeEntity<double> > Scalar(const char* id) {
//      typedef double T;
//      typedef RTimeEntity<T> return_type;
//      typedef RTimeSingletons<T> singletons_type;
//      typedef singletons_type::ManagerType ManagerType;
//      std::shared_ptr<return_type> tmp(new return_type(id));
//      const ManagerType::value_type& result =
//      singletons_type::Manager()->find(tmp); return result.second;
//    }
inline std::shared_ptr<RTimeEntity<double> > Scalar(const std::string& id) {
  typedef double T;
  typedef RTimeEntity<T> return_type;
  typedef RTimeSingletons<T> singletons_type;
  typedef singletons_type::ManagerType ManagerType;
  std::shared_ptr<return_type> tmp(new return_type(id));
  const ManagerType::value_type& result = singletons_type::Manager()->find(tmp);
  return result.second;
}
 
template <class T>
class RTimeVector3 {
 public:
  RTimeVector3(const char* id) : id_(id) {}
  RTimeVector3(const std::string& id) : id_(id) {}
  std::shared_ptr<RTimeEntity<T> > operator[](unsigned int xyz) {
    return Scalar(id_ + "_" + dirchar[xyz]);
  }
 
 private:
  static const char* dirchar;
  std::string id_;
};
template <class T>
const char* RTimeVector3<T>::dirchar(strdup("xyz"));
 
template <class T>
class CTimeVector3 {
 public:
  CTimeVector3(const T* val) {
    for (int xyz = 0; xyz < 3; ++xyz) val_[xyz] = val[xyz];
  }
  std::shared_ptr<CTimeEntity<T> > operator[](unsigned int xyz) {
    return Scalar(val_[xyz]);
  }
 
 private:
  T val_[3];
};
 
#if 0  // these do not get resolved correctly by icpc 12 on OS X
    template <class T = double> RTimeVector3<T> Vector(const char* id)
    {
      return RTimeVector3<T>(id);
    }
    template <class T = double> RTimeVector3<T> Vector(const std::string& id)
    {
      return RTimeVector3<T>(id);
    }
    template <class T = double> CTimeVector3<T> Vector(const T* a)
    {
      return CTimeVector3<T>(a);
    }
#endif
inline RTimeVector3<double> Vector(const char* id) {
  return RTimeVector3<double>(id);
}
inline CTimeVector3<double> Vector(const CGF& bf) {
  double qn[3];
  for (unsigned int xyz = 0; xyz < 3; ++xyz) qn[xyz] = bf.qn(xyz);
  return CTimeVector3<double>(qn);
}
inline CTimeVector3<double> Vector(const OriginDerivative<3u>& dd) {
  double d[3];
  for (unsigned int xyz = 0; xyz < 3; ++xyz) d[xyz] = dd.d(xyz);
  return CTimeVector3<double>(d);
}
 
}  // namespace prefactor
};  // namespace libint2
 
#endif