quanta.h

/*
 *  Copyright (C) 2004-2021 Edward F. Valeev
 *
 *  This file is part of Libint.
 *
 *  Libint 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 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.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef _libint2_src_bin_libint_quanta_h_
#define _libint2_src_bin_libint_quanta_h_
 
#include <cassert>
#include <vector>
#include <smart_ptr.h>
#include <global_macros.h>
#include <iter.h>
 
namespace libint2 {
 
  class QuantumSet : public ConstructablePolymorphically,
                     public Hashable<LIBINT2_UINT_LEAST64,ComputeKey> {
  public:
    typedef DummyIterator iter_type;
    static const LIBINT2_UINT_LEAST64 max_quantum_number = 100;
 
    virtual ~QuantumSet() {}
    virtual std::string label() const =0;
 
    virtual unsigned int num_quanta() const =0;
    virtual void inc(unsigned int i) =0;
    virtual void dec(unsigned int i) =0;
  };
 
  template<typename T, unsigned int N> class QuantumNumbers : public QuantumSet {
 
    std::vector<T> qn_;
 
  public:
    typedef QuantumSet parent_type;
    typedef QuantumNumbers iter_type;
 
    QuantumNumbers(const std::vector<T>& qn);
    QuantumNumbers(const SafePtr<QuantumNumbers>&);
    QuantumNumbers(const SafePtr<QuantumSet>&);
    QuantumNumbers(const SafePtr<ConstructablePolymorphically>&);
    QuantumNumbers(const ConstructablePolymorphically&);
    ~QuantumNumbers();
 
    bool operator==(const QuantumNumbers&) const;
    std::string label() const override;
 
    void inc(unsigned int i) override { ++qn_.at(i); }
    void dec(unsigned int i) override {
#if CHECK_SAFETY
      if (qn_.at(i) == T(0))
        throw std::runtime_error("QuantumNumbers::dec -- quantum number already zero");
#endif
      --qn_.at(i);
    }
 
    const T elem(unsigned int i) const {
      return qn_.at(i);
    }
 
    unsigned int num_quanta() const {
      return qn_.size();
    }
 
    LIBINT2_UINT_LEAST64 key() const override {
      LIBINT2_UINT_LEAST64 key = 0;
      LIBINT2_UINT_LEAST64 pfac = 1;
      const int maxi = ((int)num_quanta()) - 1;
      for(int i=maxi; i>=0; i--) {
        key += pfac*qn_[i];
        pfac *= QuantumSet::max_quantum_number;
      }
      assert(key < this->max_key());
      return key;
    }
 
    LIBINT2_UINT_LEAST64 max_key() const {
      LIBINT2_UINT_LEAST64 max_key = 1;
      const int maxi = ((int)num_quanta()) - 1;
      for(int i=maxi; i>=0; i--) {
        max_key *= QuantumSet::max_quantum_number;
      }
      return max_key;
    }
 
  };
 
  template<typename T, unsigned int N>
    QuantumNumbers<T,N>::QuantumNumbers(const std::vector<T>& qn) :
    qn_(qn)
    {
    }
 
  template<typename T, unsigned int N>
    QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<QuantumNumbers>& sptr) :
    qn_(sptr->qn_)
    {
    }
 
  template<typename T, unsigned int N>
    QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<QuantumSet>& sptr)
    {
      const SafePtr< QuantumNumbers<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbers,QuantumSet>(sptr);
#if CHECK_SAFETY
      if (sptr_cast == 0)
        throw std::runtime_error("QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<QuantumSet>& sptr) -- type of sptr is incompatible with QuantumNumbers");
#endif
 
      qn_ = sptr_cast->qn_;
    }
 
  template<typename T, unsigned int N>
    QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<ConstructablePolymorphically>& sptr)
    {
      const SafePtr< QuantumNumbers<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbers,ConstructablePolymorphically>(sptr);
#if CHECK_SAFETY
      if (sptr_cast == 0)
        throw std::runtime_error("QuantumNumbers<T,N>::QuantumNumbers(const SafePtr<ConstructablePolymorphically>& sptr) -- type of sptr is incompatible with QuantumNumbers");
#endif
 
      qn_ = sptr_cast->qn_;
    }
 
  template<typename T, unsigned int N>
    QuantumNumbers<T,N>::QuantumNumbers(const ConstructablePolymorphically& sptr)
    {
      const QuantumNumbers<T,N>& sptr_cast = dynamic_cast<const QuantumNumbers&>(sptr);
      qn_ = sptr_cast.qn_;
    }
 
  template<typename T, unsigned int N>
    QuantumNumbers<T,N>::~QuantumNumbers()
    {
    }
 
  template<typename T, unsigned int N>
  bool
    QuantumNumbers<T,N>::operator==(const QuantumNumbers& a) const
    {
      return qn_ == a.qn_;
    }
 
  template<typename T, unsigned int N>
    std::string
    QuantumNumbers<T,N>::label() const
    {
      std::ostringstream oss;
      oss << "{";
      if (qn_.size() > 0)
        oss << qn_[0];
      for(int i=1; i<qn_.size(); i++)
        oss << "," << qn_[i];
      oss << "}";
      return oss.str();
    }
 
  //typedef QuantumNumbers<unsigned int,0> NullQuantumSet;
 
 
  template<typename T, unsigned int N> class QuantumNumbersA : public QuantumSet {
 
    T qn_[N];
 
  public:
    typedef QuantumSet parent_type;
    typedef QuantumNumbersA iter_type;
 
    // Set all quanta to val
    QuantumNumbersA(const T& val);
    QuantumNumbersA(const T* qn);
    QuantumNumbersA(const std::vector<T>& qn);
    QuantumNumbersA(const SafePtr<QuantumNumbersA>&);
    QuantumNumbersA(const SafePtr<QuantumSet>&);
    QuantumNumbersA(const SafePtr<ConstructablePolymorphically>&);
    ~QuantumNumbersA();
 
    bool operator==(const QuantumNumbersA&) const;
    std::string label() const override;
 
    void inc(unsigned int i) override { ++qn_[i]; }
    void dec(unsigned int i) override {
#if CHECK_SAFETY
      if (qn_[i] == T(0))
        throw std::runtime_error("QuantumNumbersA::dec -- quantum number already zero");
#endif
      --qn_[i];
    }
 
    const T elem(unsigned int i) const {
      return qn_[i];
    }
 
    void set_elem(unsigned int i, const T& value) {
      qn_[i] = value;
    }
 
    unsigned int num_quanta() const override {
      return N;
    }
 
    LIBINT2_UINT_LEAST64 key() const override {
      LIBINT2_UINT_LEAST64 key = 0;
      LIBINT2_UINT_LEAST64 pfac = 1;
      const int maxi = ((int)num_quanta()) - 1;
      for(int i=maxi; i>=0; i--) {
        key += pfac*qn_[i];
        pfac *= QuantumSet::max_quantum_number;
      }
      assert(key < this->max_key());
      return key;
    }
 
    LIBINT2_UINT_LEAST64 max_key() const {
      LIBINT2_UINT_LEAST64 max_key = 1;
      const int maxi = ((int)num_quanta()) - 1;
      for(int i=maxi; i>=0; i--) {
        max_key *= QuantumSet::max_quantum_number;
      }
      return max_key;
    }
 
  };
 
  template<typename T, unsigned int N>
    QuantumNumbersA<T,N>::QuantumNumbersA(const T& val)
    {
      for(unsigned int i=0; i<N; i++)
        qn_[i] = val;
    }
 
  template<typename T, unsigned int N>
    QuantumNumbersA<T,N>::QuantumNumbersA(const T* qn)
    {
      for(int i=0; i<N; i++)
        qn_[i] = qn[i];
    }
 
  template<typename T, unsigned int N>
    QuantumNumbersA<T,N>::QuantumNumbersA(const std::vector<T>& qn)
    {
      for(int i=0; i<N; i++)
        qn_[i] = qn[i];
    }
 
  template<typename T, unsigned int N>
    QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<QuantumNumbersA>& sptr)
    {
      T* qn = sptr->qn_;
      for(unsigned int i=0; i<N; i++)
        qn_[i] = qn[i];
    }
 
  template<typename T, unsigned int N>
    QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<QuantumSet>& sptr)
    {
      const SafePtr< QuantumNumbersA<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbersA,QuantumSet>(sptr);
#if CHECK_SAFETY
      if (sptr_cast == 0)
        throw std::runtime_error("QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<QuantumSet>& sptr) -- type of sptr is incompatible with QuantumNumbersA");
#endif
 
      T* qn = sptr_cast->qn_;
      for(int i=0; i<N; i++)
        qn_[i] = qn[i];
    }
 
  template<typename T, unsigned int N>
    QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<ConstructablePolymorphically>& sptr)
    {
      const SafePtr< QuantumNumbersA<T,N> > sptr_cast = dynamic_pointer_cast<QuantumNumbersA,ConstructablePolymorphically>(sptr);
#if CHECK_SAFETY
      if (sptr_cast == 0)
        throw std::runtime_error("QuantumNumbersA<T,N>::QuantumNumbersA(const SafePtr<ConstructablePolymorphically>& sptr) -- type of sptr is incompatible with QuantumNumbersA");
#endif
      T* qn = sptr_cast->qn_;
      for(int i=0; i<N; i++)
        qn_[i] = qn[i];
    }
 
  template<typename T, unsigned int N>
    QuantumNumbersA<T,N>::~QuantumNumbersA()
    {
    }
 
  template<typename T, unsigned int N>
  bool
    QuantumNumbersA<T,N>::operator==(const QuantumNumbersA& a) const
    {
      const T* qn0 = qn_;
      const T* qn1 = a.qn_;
      for(int i=0; i<N; i++, ++qn0, ++qn1)
        if (*qn0 != *qn1)
          return false;
 
      return true;
    }
 
  template<typename T, unsigned int N>
    std::string
    QuantumNumbersA<T,N>::label() const
    {
      std::ostringstream oss;
      oss << "{";
      if (N > 0)
        oss << qn_[0];
      for(unsigned int i=1; i<N; i++)
        oss << "," << qn_[i];
      oss << "}";
      return oss.str();
    }
 
  template<typename T> class QuantumNumbersA<T,0> : public QuantumSet {
 
  public:
    typedef QuantumSet parent_type;
    typedef QuantumNumbersA iter_type;
 
    QuantumNumbersA() {}
    QuantumNumbersA(const T* qn) {}
    QuantumNumbersA(const std::vector<T>& qn) {}
    QuantumNumbersA(const SafePtr<QuantumNumbersA>&) {}
    QuantumNumbersA(const SafePtr<QuantumSet>&) {}
    QuantumNumbersA(const SafePtr<ConstructablePolymorphically>&) {}
    ~QuantumNumbersA() {}
 
    bool operator==(const QuantumNumbersA&) const { return true; }
    std::string label() const override { return "{}"; }
 
    void inc(unsigned int i) override { throw std::runtime_error("QuantumNumbersA<T,0>::inc -- no quantum numbers to increment"); }
    void dec(unsigned int i) override {
      throw std::runtime_error("QuantumNumbersA<T,0>::inc -- no quantum numbers to decrement");
    }
    const T elem(unsigned int i) const { throw std::runtime_error("QuantumNumbersA<T,0>::inc -- no quantum numbers to return"); }
    unsigned int num_quanta() const override { return 0; }
 
    LIBINT2_UINT_LEAST64 key() const override { return 0; }
 
    LIBINT2_UINT_LEAST64 max_key() const { return 1; }
 
  };
 
  template <typename T, unsigned int N>
    struct DefaultQuantumNumbers {
      typedef QuantumNumbersA<T,N> Result;
    };
  typedef DefaultQuantumNumbers<int,0>::Result EmptySet;
  typedef DefaultQuantumNumbers<unsigned int,1>::Result mType;
 
};
 
#endif