nbint.h

//
// tbint.h
//
// 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_tbint_h
#define _chemistry_qc_basis_tbint_h
 
#include <util/ref/ref.h>
#include <util/group/message.h>
#include <util/container/stdarray.h>
#include <chemistry/qc/basis/gaussbas.h>
#include <chemistry/qc/basis/dercent.h>
#include <chemistry/qc/basis/operator.h>
#include <chemistry/qc/basis/obint.h>
 
namespace sc {
 
// //////////////////////////////////////////////////////////////////////////
 
class Integral;
 
struct TwoBodyIntShape {
    enum value {
      11_O_22,
      11_O_2,
      1_O_2 };
};
 
class NBodyIntEval : public RefCount {
 
  private:
    double *log2_to_double_;
 
  protected:
    // this is who created me
    Integral *integral_;
 
    std::vector< Ref<GaussianBasisSet> > bs_;
 
    double *buffer_;
 
    int redundant_;
 
    NBodyInt(Integral *integral,
             const std::vector< Ref<GaussianBasisSet> >& bs);
  public:
    virtual ~NBodyInt();
 
    Ref<GaussianBasisSet> basis(size_t center = 0) { return bs_.at(center); }
 
    virtual NBodyOperSet::type type() const =0;
    virtual const Ref<OperSetDescr>& descr() const =0;
 
    virtual const double * buffer(NBodyOper::type type = NBodyOper::coulomb) const;
 
    virtual void compute_shell(int,int,int,int) = 0;
 
    std::pair<std::map<TwoBodyOper::type,const double*>,std::array<unsigned long,4> >
    compute_shell_arrays(int,int,int,int);
 
    virtual int log2_shell_bound(int= -1,int= -1,int= -1,int= -1) = 0;
 
    double shell_bound(int= -1,int= -1,int= -1,int= -1);
 
    virtual int redundant() const { return redundant_; }
    virtual void set_redundant(int i) { redundant_ = i; }
 
    virtual void set_integral_storage(size_t storage);
 
    virtual bool cloneable() const;
 
    virtual Ref<TwoBodyInt> clone();
 
    Integral *integral() const { return integral_; }
 
};
 
 
class ShellQuartetIter {
  protected:
    const double * buf;
    double scale_;
 
    int redund_;
 
    int e12;
    int e34;
    int e13e24;
 
    int index;
 
    int istart;
    int jstart;
    int kstart;
    int lstart;
 
    int iend;
    int jend;
    int kend;
    int lend;
 
    int icur;
    int jcur;
    int kcur;
    int lcur;
 
    int i_;
    int j_;
    int k_;
    int l_;
 
  public:
    ShellQuartetIter();
    virtual ~ShellQuartetIter();
 
    virtual void init(const double *,
                      int, int, int, int,
                      int, int, int, int,
                      int, int, int, int,
                      double, int);
 
    virtual void start();
    virtual void next();
 
    int ready() const { return icur < iend; }
 
    int i() const { return i_; }
    int j() const { return j_; }
    int k() const { return k_; }
    int l() const { return l_; }
 
    int nint() const { return iend*jend*kend*lend; }
 
    double val() const { return buf[index]*scale_; }
};
 
class NBodyIntIter {
  protected:
    Ref<TwoBodyInt> tbi;
    ShellQuartetIter sqi;
 
    int iend;
 
    int icur;
    int jcur;
    int kcur;
    int lcur;
 
  public:
    TwoBodyIntIter();
    TwoBodyIntIter(const Ref<TwoBodyInt>&);
 
    virtual ~TwoBodyIntIter();
 
    virtual void start();
    virtual void next();
 
    int ready() const { return (icur < iend); }
 
    int ishell() const { return icur; }
    int jshell() const { return jcur; }
    int kshell() const { return kcur; }
    int lshell() const { return lcur; }
 
    virtual double scale() const;
 
    ShellQuartetIter& current_quartet();
};
 
// //////////////////////////////////////////////////////////////////////////
 
class TwoBodyTwoCenterIntIter : public RefCount {
  protected:
    Ref<TwoBodyTwoCenterInt> tbi; // help me obi wan
    TwoBodyOper::type type;
    ShellPairIter spi;
 
    int redund;
 
    int istart;
    int jstart;
 
    int iend;
    int jend;
 
    int icur;
    int jcur;
 
    int ij;
 
  public:
    TwoBodyTwoCenterIntIter();
    TwoBodyTwoCenterIntIter(const Ref<TwoBodyTwoCenterInt>& tbinteval,
                            TwoBodyOper::type t = TwoBodyOper::eri);
    virtual ~TwoBodyTwoCenterIntIter();
 
    virtual void start(int ist=0, int jst=0, int ien=0, int jen=0);
    virtual void next();
 
    int ready() const { return (icur < iend); }
 
    int ishell() const { return icur; }
    int jshell() const { return jcur; }
 
    int ijshell() const { return ij; }
 
    int redundant() const { return redund; }
    void set_redundant(int i) { redund=i; }
 
    virtual double scale() const;
 
    Ref<TwoBodyTwoCenterInt> two_body_int() { return tbi; }
 
    ShellPairIter& current_pair();
 
    virtual bool cloneable() const;
    virtual Ref<TwoBodyTwoCenterIntIter> clone();
};
 
 
class TwoBodyTwoCenterIntOp: public SCElementOp {
  protected:
    Ref<TwoBodyTwoCenterIntIter> iter;
 
  public:
    TwoBodyTwoCenterIntOp(const Ref<TwoBodyTwoCenterInt>&);
    TwoBodyTwoCenterIntOp(const Ref<TwoBodyTwoCenterIntIter>&);
    virtual ~TwoBodyTwoCenterIntOp();
 
    void process(SCMatrixBlockIter&);
    void process_spec_rect(SCMatrixRectBlock*);
    void process_spec_ltri(SCMatrixLTriBlock*);
    void process_spec_rectsub(SCMatrixRectSubBlock*);
    void process_spec_ltrisub(SCMatrixLTriSubBlock*);
 
    bool cloneable() const;
    Ref<SCElementOp> clone();
 
    int has_side_effects();
};
 
 
}
 
#endif
 
// Local Variables:
// mode: c++
// c-file-style: "ETS"
// End: