operator.h

//
// operator.h
//
// Copyright (C) 2007 Edward Valeev
//
// Author: Edward Valeev <evaleev@vt.edu>
// Maintainer: EV
//
// 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.
//
 
#include <util/ref/ref.h>
#include <math/distarray4/distarray4.h>
#include <chemistry/qc/basis/intparams.h>
 
#ifndef _chemistry_qc_basis_operator_h
#define _chemistry_qc_basis_operator_h
 
namespace sc {
 
  class OperatorDescr : public RefCount {
  public:
    OperatorDescr() {}
    virtual ~OperatorDescr() {}
 
    virtual unsigned int num_particles() const =0;
    virtual int perm_symm(unsigned int p) const =0;
    virtual int perm_symm(unsigned int i, unsigned int j) const =0;
  };
 
  class OneBodyOperDescr : public OperatorDescr {
  public:
    OneBodyOperDescr(int perm);
 
    unsigned int num_particles() const;
    int perm_symm(unsigned int i) const;
    int perm_symm(unsigned int i, unsigned int j) const;
 
  private:
    int perm_;
  };
 
  class TwoBodyOperDescr : public OperatorDescr {
  public:
    TwoBodyOperDescr(int perm_p1, int perm_p2, int perm_p12);
 
    unsigned int num_particles() const;
    int perm_symm(unsigned int i) const;
    int perm_symm(unsigned int i, unsigned int j) const;
 
  private:
    int perm_p1_;
    int perm_p2_;
    int perm_p12_;
 
  };
 
  // One-Body Operators
 
 
  struct OneBodyOper {
    enum type {
      gamma = -1, 
      T = 0,      
      V = 1,      
      h = 2,      
      J = 3,      
      K = 4,      
      F = 5,      
      hJ = 6,     
      mu_x = 7,   
      mu_y = 8,   
      mu_z = 9,   
      q_xx = 10,   
      q_xy = 11,  
      q_xz = 12,  
      q_yy = 13,  
      q_yz = 14,  
      q_zz = 15,  
      pVp = 16,   
      pxVp_x = 17,
      pxVp_y = 18,
      pxVp_z = 19,
      p4 = 20,      
      Nabla_x = 21,   
      Nabla_y = 22,   
      Nabla_z = 23,   
      iL_x = 24,   
      iL_y = 25,   
      iL_z = 26,    
      phi   = 27,   
      dphi_x = 28,   
      dphi_y = 29,   
      dphi_z = 30,   
      ddphi_xx = 31,   
      ddphi_xy = 32,   
      ddphi_xz = 33,   
      ddphi_yy = 34,   
      ddphi_yz = 35,   
      ddphi_zz = 36,   
      S = 37,          
      invalid = 38
    };
 
    static int max_ntypes;
 
    static Ref<OneBodyOperDescr> descr(OneBodyOper::type t);
 
    static std::string to_string(type t);
    static type to_type(const std::string& key);
  };
 
 
  struct OneBodyOperSet {
    enum type {
      S=0,  
      T=1,  
      V=2,  
      h=3,  
      mu=4, 
      q=5,  
      phi=6,   
      dphi=7,  
      ddphi=8, 
      pVp=9,
      p4=10,  
      invalid=11
    };
 
    static std::string to_string(type t);
    static type to_type(const std::string& key);
 
    static type to_type(OneBodyOper::type oper);
 
  };
 
  template <OneBodyOperSet::type Type> struct OneBodyOperSetProperties;
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::S> {
    static const int size = 1;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::T> {
    static const int size = 1;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::V> {
    static const int size = 1;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::h> {
    static const int size = 1;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::mu> {
    static const int size = 3;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::q> {
    static const int size = 6;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::pVp> {
    static const int size = 1;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::p4> {
    static const int size = 1;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::phi> {
    static const int size = 1;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::dphi> {
    static const int size = 3;
    static OneBodyOper::type value[];
    static std::string key;
  };
  template <> struct OneBodyOperSetProperties<OneBodyOperSet::ddphi> {
    static const int size = 6;
    static OneBodyOper::type value[];
    static std::string key;
  };
 
  class OneBodyOperSetDescr : public RefCount {
    public:
      static Ref<OneBodyOperSetDescr> instance(OneBodyOperSet::type oset);
      int size() const { return size_; }
      OneBodyOper::type opertype(unsigned int o) const;
      unsigned int opertype(OneBodyOper::type o) const;
      std::string key() const { return key_; }
    private:
      OneBodyOperSetDescr(int size,
                          const OneBodyOper::type* value,
                          std::string key) :
                          size_(size), value_(value), key_(key) { }
 
      int size_;
      const OneBodyOper::type* value_;
      std::string key_;
  };
 
  template <OneBodyOperSet::type Type> struct OneBodyIntParamsType;
  template <> struct OneBodyIntParamsType<OneBodyOperSet::T> {
    typedef IntParamsVoid value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::V> {
    typedef IntParamsVoid value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::h> {
    typedef IntParamsVoid value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::mu> {
    typedef IntParamsOrigin value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::q> {
    typedef IntParamsOrigin value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::pVp> {
    typedef IntParamsVoid value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::p4> {
    typedef IntParamsVoid value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::phi> {
    typedef IntParamsOrigin value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::dphi> {
    typedef IntParamsOrigin value;
  };
  template <> struct OneBodyIntParamsType<OneBodyOperSet::ddphi> {
    typedef IntParamsOrigin value;
  };
 
  // Two-Body Operators
 
 
  struct TwoBodyOper {
    enum type {
      eri =0,                  
      r12 =1,                  
      r12t1 =2,                
      r12t2 =3,                
      r12_0_g12 =4,            
      r12_m1_g12 =5,           
      t1g12 =6,                
      t2g12 =7,                
      g12t1g12 =8,             
      g12p4g12_m_g12t1g12t1 =9,
      anti_g12g12 =10,         
      delta =11                
    };
    static int max_ntypes;
    static Ref<TwoBodyOperDescr> descr(TwoBodyOper::type t);
    static std::string to_string(type t);
    static type to_type(const std::string& key);
  };
 
  struct TwoBodyOperSet {
    enum type {
      ERI,       
      R12,       
      G12,       
      G12NC,     
      G12DKH,    
      R12_0_G12, 
      R12_m1_G12,
      G12_T1_G12,
      DeltaFunction 
    };
 
    static std::string to_string(type t);
    static type to_type(const std::string& key);
 
    static type to_type(TwoBodyOper::type oper);
 
  };
 
  template <TwoBodyOperSet::type Type> struct TwoBodyOperSetProperties;
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::ERI> {
    static const int size = 1;
    static TwoBodyOper::type value[];
    static std::string key;
  };
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::R12> {
    static const int size = 4;
    static TwoBodyOper::type value[];
    static std::string key;
  };
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::G12> {
    static const int size = 6;
    static TwoBodyOper::type value[];
    static std::string key;
  };
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::G12NC> {
    static const int size = 5;
    static TwoBodyOper::type value[];
    static std::string key;
  };
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::G12DKH> {
    static const int size = 1;
    static TwoBodyOper::type value[];
    static std::string key;
  };
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::R12_0_G12> {
    static const int size = 1;
    static TwoBodyOper::type value[];
    static std::string key;
  };
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::R12_m1_G12> {
    static const int size = 1;
    static TwoBodyOper::type value[];
    static std::string key;
  };
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::G12_T1_G12> {
    static const int size = 1;
    static TwoBodyOper::type value[];
    static std::string key;
  };
  template <> struct TwoBodyOperSetProperties<TwoBodyOperSet::DeltaFunction> {
    static const int size = 1;
    static TwoBodyOper::type value[];
    static std::string key;
  };
 
 
  class TwoBodyOperSetDescr : public RefCount {
    public:
      static Ref<TwoBodyOperSetDescr> instance(TwoBodyOperSet::type oset);
      int size() const { return size_; }
      TwoBodyOper::type opertype(unsigned int o) const;
      unsigned int opertype(TwoBodyOper::type o) const;
      std::string key() const { return key_; }
    private:
      TwoBodyOperSetDescr(int size,
                          const TwoBodyOper::type* value,
                          const std::string& key);
      int size_;
      const TwoBodyOper::type* value_;
      std::string key_;
  };
 
  template <TwoBodyOperSet::type Type> struct TwoBodyIntParamsType;
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::ERI> {
    typedef IntParamsVoid value;
  };
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::R12> {
    typedef IntParamsVoid value;
  };
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::G12> {
    typedef IntParamsG12 value;
  };
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::G12NC> {
    typedef IntParamsG12 value;
  };
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::G12DKH> {
    typedef IntParamsG12 value;
  };
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::R12_0_G12> {
    typedef IntParamsG12 value;
  };
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::R12_m1_G12> {
    typedef IntParamsG12 value;
  };
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::G12_T1_G12> {
    typedef IntParamsG12 value;
  };
  template <> struct TwoBodyIntParamsType<TwoBodyOperSet::DeltaFunction> {
    typedef IntParamsVoid value;
  };
 
 
}
 
#endif