MPQC  3.0.0-alpha
tbint.h
1 //
2 // tbint.h
3 //
4 // Copyright (C) 1996 Limit Point Systems, Inc.
5 //
6 // Author: Edward Seidl <seidl@janed.com>
7 // Maintainer: LPS
8 //
9 // This file is part of the SC Toolkit.
10 //
11 // The SC Toolkit is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU Library General Public License as published by
13 // the Free Software Foundation; either version 2, or (at your option)
14 // any later version.
15 //
16 // The SC Toolkit is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU Library General Public License for more details.
20 //
21 // You should have received a copy of the GNU Library General Public License
22 // along with the SC Toolkit; see the file COPYING.LIB. If not, write to
23 // the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24 //
25 // The U.S. Government is granted a limited license as per AL 91-7.
26 //
27 
28 #ifndef _chemistry_qc_basis_tbint_h
29 #define _chemistry_qc_basis_tbint_h
30 
31 #include <util/ref/ref.h>
32 #include <util/group/message.h>
33 #include <util/container/stdarray.h>
34 #include <chemistry/qc/basis/gaussbas.h>
35 #include <chemistry/qc/basis/dercent.h>
36 #include <chemistry/qc/basis/operator.h>
37 #include <chemistry/qc/basis/obint.h>
38 
39 namespace sc {
40 
41 // //////////////////////////////////////////////////////////////////////////
42 
43 class Integral;
44 
48 struct TwoBodyIntShape {
49  enum value {
51  _11_O_22,
53  _11_O_2,
55  _1_O_2 };
56 };
57 
61 class TwoBodyInt : public RefCount {
62 
63  private:
64  double *log2_to_double_;
65 
66  protected:
67  // this is who created me
68  Integral *integral_;
69 
70  Ref<GaussianBasisSet> bs1_;
71  Ref<GaussianBasisSet> bs2_;
72  Ref<GaussianBasisSet> bs3_;
73  Ref<GaussianBasisSet> bs4_;
74 
75  double *buffer_;
76 
77  int redundant_;
78 
79  TwoBodyInt(Integral *integral,
80  const Ref<GaussianBasisSet>&bs1,
81  const Ref<GaussianBasisSet>&bs2,
82  const Ref<GaussianBasisSet>&bs3,
83  const Ref<GaussianBasisSet>&bs4);
84  public:
85  virtual ~TwoBodyInt();
86 
88  int nbasis() const;
89 
91  int nbasis1() const;
93  int nbasis2() const;
95  int nbasis3() const;
97  int nbasis4() const;
98 
100  int nshell() const;
101 
103  int nshell1() const;
105  int nshell2() const;
107  int nshell3() const;
109  int nshell4() const;
110 
116  Ref<GaussianBasisSet> basis(size_t c = 0) const;
117 
119  Ref<GaussianBasisSet> basis1() const;
121  Ref<GaussianBasisSet> basis2() const;
123  Ref<GaussianBasisSet> basis3() const;
125  Ref<GaussianBasisSet> basis4() const;
126 
130  virtual TwoBodyOperSet::type type() const =0;
132  virtual const Ref<TwoBodyOperSetDescr>& descr() const =0;
133 
138  virtual const double * buffer(TwoBodyOper::type type = TwoBodyOper::eri) const;
139 
143  virtual void compute_shell(int,int,int,int) = 0;
144 
151  std::pair<std::map<TwoBodyOper::type,const double*>,std::array<unsigned long,4> >
152  compute_shell_arrays(int,int,int,int);
153 
157  virtual int log2_shell_bound(int= -1,int= -1,int= -1,int= -1) = 0;
158 
162  double shell_bound(int= -1,int= -1,int= -1,int= -1);
163 
166  virtual int redundant() const { return redundant_; }
168  virtual void set_redundant(int i) { redundant_ = i; }
169 
171  virtual void set_integral_storage(size_t storage);
172 
175  virtual bool cloneable() const;
176 
179  virtual Ref<TwoBodyInt> clone();
180 
182  Integral *integral() const { return integral_; }
183 
184 };
185 
186 // //////////////////////////////////////////////////////////////////////////
187 
191 class TwoBodyThreeCenterInt : public RefCount {
192 
193  private:
194  double *log2_to_double_;
195 
196  protected:
197  // this is who created me
198  Integral *integral_;
199 
200  Ref<GaussianBasisSet> bs1_;
201  Ref<GaussianBasisSet> bs2_;
202  Ref<GaussianBasisSet> bs3_;
203 
204  double *buffer_;
205 
206  int redundant_;
207 
208  TwoBodyThreeCenterInt(Integral *integral,
209  const Ref<GaussianBasisSet>&bs1,
210  const Ref<GaussianBasisSet>&bs2,
211  const Ref<GaussianBasisSet>&bs3);
212  public:
213  virtual ~TwoBodyThreeCenterInt();
214 
216  int nbasis() const;
217 
219  int nbasis1() const;
221  int nbasis2() const;
223  int nbasis3() const;
224 
226  int nshell() const;
227 
229  int nshell1() const;
231  int nshell2() const;
233  int nshell3() const;
234 
240  Ref<GaussianBasisSet> basis(size_t c = 0) const;
241 
243  Ref<GaussianBasisSet> basis1() const;
245  Ref<GaussianBasisSet> basis2() const;
247  Ref<GaussianBasisSet> basis3() const;
248 
252  virtual TwoBodyOperSet::type type() const =0;
254  virtual const Ref<TwoBodyOperSetDescr>& descr() const =0;
255 
260  virtual const double * buffer(TwoBodyOper::type type = TwoBodyOper::eri) const;
261 
265  virtual void compute_shell(int,int,int) = 0;
266 
270  virtual int log2_shell_bound(int= -1,int= -1,int= -1) = 0;
271 
275  double shell_bound(int= -1,int= -1,int= -1);
276 
279  int redundant() const { return redundant_; }
281  void set_redundant(int i) { redundant_ = i; }
282 
284  virtual void set_integral_storage(size_t storage);
285 
288  virtual bool cloneable() const;
289 
292  virtual Ref<TwoBodyThreeCenterInt> clone();
293 
295  Integral *integral() const { return integral_; }
296 
297 };
298 
299 // //////////////////////////////////////////////////////////////////////////
300 
305 class TwoBodyTwoCenterInt : public RefCount {
306 
307  private:
308  double *log2_to_double_;
309 
310  protected:
311  // this is who created me
312  Integral *integral_;
313 
314  Ref<GaussianBasisSet> bs1_;
315  Ref<GaussianBasisSet> bs2_;
316 
317  double *buffer_;
318 
319  int redundant_;
320 
321  TwoBodyTwoCenterInt(Integral *integral,
322  const Ref<GaussianBasisSet>&bs1,
323  const Ref<GaussianBasisSet>&bs2);
324  public:
325  virtual ~TwoBodyTwoCenterInt();
326 
328  int nbasis() const;
329 
331  int nbasis1() const;
333  int nbasis2() const;
334 
336  int nshell() const;
337 
339  int nshell1() const;
341  int nshell2() const;
342 
348  Ref<GaussianBasisSet> basis(size_t c = 0) const;
349 
351  Ref<GaussianBasisSet> basis1() const;
353  Ref<GaussianBasisSet> basis2() const;
354 
358  virtual TwoBodyOperSet::type type() const =0;
360  virtual const Ref<TwoBodyOperSetDescr>& descr() const =0;
361 
366  virtual const double * buffer(TwoBodyOper::type type = TwoBodyOper::eri) const;
367 
371  virtual void compute_shell(int,int) = 0;
372 
376  virtual int log2_shell_bound(int= -1,int= -1) = 0;
377 
381  double shell_bound(int= -1,int= -1);
382 
385  int redundant() const { return redundant_; }
387  void set_redundant(int i) { redundant_ = i; }
388 
390  virtual void set_integral_storage(size_t storage);
391 
394  virtual bool cloneable() const;
395 
398  virtual Ref<TwoBodyTwoCenterInt> clone();
399 
401  Integral *integral() const { return integral_; }
402 
403 };
404 
405 // //////////////////////////////////////////////////////////////////////////
406 
407 class ShellQuartetIter {
408  protected:
409  const double * buf;
410  double scale_;
411 
412  int redund_;
413 
414  int e12;
415  int e34;
416  int e13e24;
417 
418  int index;
419 
420  int istart;
421  int jstart;
422  int kstart;
423  int lstart;
424 
425  int iend;
426  int jend;
427  int kend;
428  int lend;
429 
430  int icur;
431  int jcur;
432  int kcur;
433  int lcur;
434 
435  int i_;
436  int j_;
437  int k_;
438  int l_;
439 
440  public:
441  ShellQuartetIter();
442  virtual ~ShellQuartetIter();
443 
444  virtual void init(const double *,
445  int, int, int, int,
446  int, int, int, int,
447  int, int, int, int,
448  double, int);
449 
450  virtual void start();
451  virtual void next();
452 
453  int ready() const { return icur < iend; }
454 
455  int i() const { return i_; }
456  int j() const { return j_; }
457  int k() const { return k_; }
458  int l() const { return l_; }
459 
460  int nint() const { return iend*jend*kend*lend; }
461 
462  double val() const { return buf[index]*scale_; }
463 };
464 
465 class TwoBodyIntIter {
466  protected:
467  Ref<TwoBodyInt> tbi;
468  ShellQuartetIter sqi;
469 
470  int iend;
471 
472  int icur;
473  int jcur;
474  int kcur;
475  int lcur;
476 
477  public:
478  TwoBodyIntIter();
479  TwoBodyIntIter(const Ref<TwoBodyInt>&);
480 
481  virtual ~TwoBodyIntIter();
482 
483  virtual void start();
484  virtual void next();
485 
486  int ready() const { return (icur < iend); }
487 
488  int ishell() const { return icur; }
489  int jshell() const { return jcur; }
490  int kshell() const { return kcur; }
491  int lshell() const { return lcur; }
492 
493  virtual double scale() const;
494 
495  ShellQuartetIter& current_quartet();
496 };
497 
498 // //////////////////////////////////////////////////////////////////////////
499 
500 class TwoBodyTwoCenterIntIter : public RefCount {
501  protected:
502  Ref<TwoBodyTwoCenterInt> tbi; // help me obi wan
503  TwoBodyOper::type type;
504  ShellPairIter spi;
505 
506  int redund;
507 
508  int istart;
509  int jstart;
510 
511  int iend;
512  int jend;
513 
514  int icur;
515  int jcur;
516 
517  int ij;
518 
519  public:
520  TwoBodyTwoCenterIntIter();
521  TwoBodyTwoCenterIntIter(const Ref<TwoBodyTwoCenterInt>& e,
522  TwoBodyOper::type t = TwoBodyOper::eri);
523  virtual ~TwoBodyTwoCenterIntIter();
524 
525  virtual void start(int ist=0, int jst=0, int ien=0, int jen=0);
526  virtual void next();
527 
528  int ready() const { return (icur < iend); }
529 
530  int ishell() const { return icur; }
531  int jshell() const { return jcur; }
532 
533  int ijshell() const { return ij; }
534 
535  int redundant() const { return redund; }
536  void set_redundant(int i) { redund=i; }
537 
538  virtual double scale() const;
539 
540  Ref<TwoBodyTwoCenterInt> two_body_int() { return tbi; }
541 
542  ShellPairIter& current_pair();
543 
544  virtual bool cloneable() const;
545  virtual Ref<TwoBodyTwoCenterIntIter> clone();
546 };
547 
548 // //////////////////////////////////////////////////////////////////////////
549 
554 class TwoBodyDerivInt : public RefCount {
555 
556  private:
557  double *log2_to_double_;
558 
559  protected:
560  // this is who created me
561  Integral *integral_;
562 
563  Ref<GaussianBasisSet> bs1_;
564  Ref<GaussianBasisSet> bs2_;
565  Ref<GaussianBasisSet> bs3_;
566  Ref<GaussianBasisSet> bs4_;
567 
568  double *buffer_;
569 
570  TwoBodyDerivInt(Integral* integral,
571  const Ref<GaussianBasisSet>&b1,
572  const Ref<GaussianBasisSet>&b2,
573  const Ref<GaussianBasisSet>&b3,
574  const Ref<GaussianBasisSet>&b4);
575  public:
576  virtual ~TwoBodyDerivInt();
577 
579  int nbasis() const;
580 
582  int nbasis1() const;
584  int nbasis2() const;
586  int nbasis3() const;
588  int nbasis4() const;
589 
591  int nshell() const;
592 
594  int nshell1() const;
596  int nshell2() const;
598  int nshell3() const;
600  int nshell4() const;
601 
603  Ref<GaussianBasisSet> basis() const;
604 
606  Ref<GaussianBasisSet> basis1() const;
608  Ref<GaussianBasisSet> basis2() const;
610  Ref<GaussianBasisSet> basis3() const;
612  Ref<GaussianBasisSet> basis4() const;
613 
632  const double * buffer() const;
633 
642  virtual void compute_shell(int sh0, int sh1, int sh2, int sh3,
643  DerivCenters& dercenters) = 0;
644 
647  virtual int log2_shell_bound(int= -1,int= -1,int= -1,int= -1) = 0;
648 
651  double shell_bound(int= -1,int= -1,int= -1,int= -1);
652 
654  Integral *integral() const { return integral_; }
655 
658  virtual bool cloneable() const;
659 
662  virtual Ref<TwoBodyDerivInt> clone();
663 
664 };
665 
666 // //////////////////////////////////////////////////////////////////////////
667 
671 class TwoBodyThreeCenterDerivInt : public RefCount {
672 
673  private:
674  double *log2_to_double_;
675 
676  protected:
677  // this is who created me
678  Integral *integral_;
679 
680  Ref<GaussianBasisSet> bs1_;
681  Ref<GaussianBasisSet> bs2_;
682  Ref<GaussianBasisSet> bs3_;
683 
684  double *buffer_;
685 
686  TwoBodyThreeCenterDerivInt(Integral* integral,
687  const Ref<GaussianBasisSet>&b1,
688  const Ref<GaussianBasisSet>&b2,
689  const Ref<GaussianBasisSet>&b3);
690  public:
691  virtual ~TwoBodyThreeCenterDerivInt();
692 
694  int nbasis() const;
695 
697  int nbasis1() const;
699  int nbasis2() const;
701  int nbasis3() const;
702 
704  int nshell() const;
705 
707  int nshell1() const;
709  int nshell2() const;
711  int nshell3() const;
712 
714  Ref<GaussianBasisSet> basis() const;
715 
717  Ref<GaussianBasisSet> basis1() const;
719  Ref<GaussianBasisSet> basis2() const;
721  Ref<GaussianBasisSet> basis3() const;
722 
726  const double * buffer() const;
727 
730  virtual void compute_shell(int,int,int,DerivCenters&) = 0;
731 
734  virtual int log2_shell_bound(int= -1,int= -1,int= -1) = 0;
735 
738  double shell_bound(int= -1,int= -1,int= -1);
739 
740 };
741 
742 // //////////////////////////////////////////////////////////////////////////
743 
747 class TwoBodyTwoCenterDerivInt : public RefCount {
748 
749  private:
750  double *log2_to_double_;
751 
752  protected:
753  // this is who created me
754  Integral *integral_;
755 
756  Ref<GaussianBasisSet> bs1_;
757  Ref<GaussianBasisSet> bs2_;
758 
759  double *buffer_;
760 
761  TwoBodyTwoCenterDerivInt(Integral* integral,
762  const Ref<GaussianBasisSet>&b1,
763  const Ref<GaussianBasisSet>&b2);
764  public:
765  virtual ~TwoBodyTwoCenterDerivInt();
766 
768  int nbasis() const;
769 
771  int nbasis1() const;
773  int nbasis2() const;
774 
776  int nshell() const;
777 
779  int nshell1() const;
781  int nshell2() const;
782 
784  Ref<GaussianBasisSet> basis() const;
785 
787  Ref<GaussianBasisSet> basis1() const;
789  Ref<GaussianBasisSet> basis2() const;
790 
794  const double * buffer() const;
795 
798  virtual void compute_shell(int,int,DerivCenters&) = 0;
799 
802  virtual int log2_shell_bound(int= -1,int= -1) = 0;
803 
806  double shell_bound(int= -1,int= -1);
807 
808 };
809 
811 
813 class TwoBodyTwoCenterIntOp: public SCElementOp {
814  protected:
815  Ref<TwoBodyTwoCenterIntIter> iter;
816 
817  public:
818  TwoBodyTwoCenterIntOp(const Ref<TwoBodyTwoCenterInt>&, TwoBodyOper::type type = TwoBodyOper::eri);
819  TwoBodyTwoCenterIntOp(const Ref<TwoBodyTwoCenterIntIter>&);
820  virtual ~TwoBodyTwoCenterIntOp();
821 
822  void process(SCMatrixBlockIter&);
823  void process_spec_rect(SCMatrixRectBlock*);
824  void process_spec_ltri(SCMatrixLTriBlock*);
825  void process_spec_rectsub(SCMatrixRectSubBlock*);
826  void process_spec_ltrisub(SCMatrixLTriSubBlock*);
827 
828  bool cloneable() const;
829  Ref<SCElementOp> clone();
830 
831  int has_side_effects();
832 };
833 
834 // //////////////////////////////////////////////////////////////////////////
835 
839 class TwoBodyIntEval : public RefCount {
840 
841  private:
842  double *log2_to_double_;
843 
844  protected:
845  // this is who created me
846  Integral *integral_;
847 
848  std::vector< Ref<GaussianBasisSet> > bs_;
849  double *buffer_;
850 
851  int redundant_;
852 
853  TwoBodyIntEval(Integral *integral,
854  const std::vector< Ref<GaussianBasisSet> >&bs);
855 
856  public:
857  virtual ~TwoBodyIntEval();
858 
860  Ref<GaussianBasisSet> basis(size_t C) const;
861 
865  virtual TwoBodyOperSet::type type() const =0;
867  virtual const Ref<TwoBodyOperSetDescr>& descr() const =0;
868 
873  virtual const double * buffer(TwoBodyOper::type type = TwoBodyOper::eri) const;
874 
878  virtual void compute_shell(int,int,int,int) = 0;
879 
886  std::pair<std::map<TwoBodyOper::type,const double*>,std::array<unsigned long,4> >
887  compute_shell_arrays(int,int,int,int);
888 
892  virtual int log2_shell_bound(int= -1,int= -1,int= -1,int= -1) = 0;
893 
897  double shell_bound(int= -1,int= -1,int= -1,int= -1);
898 
901  virtual int redundant() const { return redundant_; }
903  virtual void set_redundant(int i) { redundant_ = i; }
904 
906  virtual void set_integral_storage(size_t storage);
907 
910  virtual bool cloneable() const;
911 
914  virtual Ref<TwoBodyIntEval> clone();
915 
917  Integral *integral() const { return integral_; }
918 
919 };
920 
921 
922 } // end of namespace sc
923 
924 // //////////////////////////////////////////////////////////////////////////
925 
926 #endif
927 
928 // Local Variables:
929 // mode: c++
930 // c-file-style: "ETS"
931 // End:
sc::TwoBodyTwoCenterIntOp::cloneable
bool cloneable() const
Returns true if this SCElementOp supports the clone() member.
sc::TwoBodyTwoCenterIntOp::process
void process(SCMatrixBlockIter &)
This is the fallback routine to process blocks and is called by process_spec members that are not ove...
sc::TwoBodyTwoCenterDerivInt::basis1
Ref< GaussianBasisSet > basis1() const
Return the basis set on center one.
sc::TwoBodyThreeCenterDerivInt::nshell1
int nshell1() const
Return the number of shells on center one.
sc::TwoBodyTwoCenterInt::nshell1
int nshell1() const
Return the number of shells on center one.
sc::TwoBodyDerivInt::nbasis2
int nbasis2() const
Return the number of basis functions on center two.
sc::TwoBodyThreeCenterInt::redundant
int redundant() const
If redundant is true, then keep redundant integrals in the buffer.
Definition: tbint.h:279
sc::TwoBodyThreeCenterDerivInt::log2_shell_bound
virtual int log2_shell_bound(int=-1, int=-1, int=-1)=0
Return log base 2 of the maximum magnitude of any integral in a shell block.
sc::TwoBodyTwoCenterInt::descr
virtual const Ref< TwoBodyOperSetDescr > & descr() const =0
return the operator set descriptor
sc::TwoBodyInt::nshell2
int nshell2() const
Return the number of shells on center two.
sc::TwoBodyInt
This is an abstract base type for classes that compute integrals involving two electrons and 2 functi...
Definition: tbint.h:61
sc::TwoBodyTwoCenterInt::log2_shell_bound
virtual int log2_shell_bound(int=-1, int=-1)=0
Return log base 2 of the maximum magnitude of any integral in a shell block obtained from compute_she...
sc::TwoBodyTwoCenterIntOp::clone
Ref< SCElementOp > clone()
Returns a clone of this object.
sc::TwoBodyIntEval::clone
virtual Ref< TwoBodyIntEval > clone()
Returns a clone of this.
sc::TwoBodyThreeCenterDerivInt::basis1
Ref< GaussianBasisSet > basis1() const
Return the basis set on center one.
sc::TwoBodyThreeCenterDerivInt::basis
Ref< GaussianBasisSet > basis() const
Return the basis set on center one.
sc::TwoBodyTwoCenterInt
This is an abstract base type for classes that compute integrals involving two electrons in two Gauss...
Definition: tbint.h:305
sc::TwoBodyThreeCenterInt::basis2
Ref< GaussianBasisSet > basis2() const
Return the basis set on center two.
sc::TwoBodyThreeCenterDerivInt::nshell3
int nshell3() const
Return the number of shells on center three.
sc::TwoBodyThreeCenterInt::integral
Integral * integral() const
Return the integral factory that was used to create this object.
Definition: tbint.h:295
sc::TwoBodyInt::nshell
int nshell() const
Return the number of shells on center one.
sc::TwoBodyIntEval::compute_shell_arrays
std::pair< std::map< TwoBodyOper::type, const double * >, std::array< unsigned long, 4 > > compute_shell_arrays(int, int, int, int)
Given four shell indices, supported two body integral types are computed and returned.
sc::TwoBodyInt::basis3
Ref< GaussianBasisSet > basis3() const
Return the basis set on center three.
sc::TwoBodyTwoCenterInt::shell_bound
double shell_bound(int=-1, int=-1)
Return the maximum magnitude (as a double) of any integral in a shell block obtained from compute_she...
sc::TwoBodyTwoCenterDerivInt::log2_shell_bound
virtual int log2_shell_bound(int=-1, int=-1)=0
Return log base 2 of the maximum magnitude of any integral in a shell block.
sc::TwoBodyTwoCenterInt::nshell
int nshell() const
Return the number of shells on center one.
sc::TwoBodyDerivInt::compute_shell
virtual void compute_shell(int sh0, int sh1, int sh2, int sh3, DerivCenters &dercenters)=0
Given for shell indices, this will cause the derivative integral shell set to be computed.
sc::TwoBodyInt::nshell4
int nshell4() const
Return the number of shells on center four.
sc::TwoBodyOperSet::type
type
Definition: operator.h:344
sc::TwoBodyInt::basis4
Ref< GaussianBasisSet > basis4() const
Return the basis set on center four.
sc::SCMatrixLTriBlock
The SCMatrixLTriBlock describes a triangular piece of a matrix.
Definition: block.h:253
sc::Ref
A template class that maintains references counts.
Definition: ref.h:361
sc::TwoBodyInt::shell_bound
double shell_bound(int=-1, int=-1, int=-1, int=-1)
Return the maximum magnitude of any integral in a shell block obtained from compute_shell.
sc::TwoBodyIntEval::integral
Integral * integral() const
Return the integral factory that was used to create this object.
Definition: tbint.h:917
sc::TwoBodyInt::nbasis3
int nbasis3() const
Return the number of basis functions on center three.
sc::TwoBodyIntShape::value
value
Definition: nbint.h:49
sc::TwoBodyDerivInt::nbasis4
int nbasis4() const
Return the number of basis functions on center four.
sc::SCMatrixRectBlock
The SCMatrixRectBlock describes a rectangular piece of a matrix.
Definition: block.h:183
sc::TwoBodyThreeCenterInt::compute_shell
virtual void compute_shell(int, int, int)=0
Given three shell indices, integrals will be computed and placed in the buffer.
sc::TwoBodyDerivInt::nshell4
int nshell4() const
Return the number of shells on center four.
sc::TwoBodyThreeCenterInt::cloneable
virtual bool cloneable() const
Return true if the clone member can be called.
sc::TwoBodyThreeCenterInt::set_integral_storage
virtual void set_integral_storage(size_t storage)
This storage is used to cache computed integrals.
sc::TwoBodyTwoCenterInt::basis2
Ref< GaussianBasisSet > basis2() const
Return the basis set on center two.
sc::TwoBodyThreeCenterInt::nshell
int nshell() const
Return the number of shells on center one.
sc::TwoBodyIntEval::cloneable
virtual bool cloneable() const
Return true if the clone member can be called.
sc::TwoBodyInt::nshell3
int nshell3() const
Return the number of shells on center three.
sc::TwoBodyThreeCenterInt::nbasis2
int nbasis2() const
Return the number of basis functions on center two.
sc::TwoBodyIntIter
Definition: tbint.h:465
sc::TwoBodyTwoCenterDerivInt::nbasis1
int nbasis1() const
Return the number of basis functions on center one.
sc::SCMatrixLTriSubBlock
The SCMatrixLTriSubBlock describes a triangular subblock of a matrix.
Definition: block.h:288
sc::TwoBodyThreeCenterInt::type
virtual TwoBodyOperSet::type type() const =0
Returns the type of the operator set that this object computes.
sc::TwoBodyThreeCenterInt::buffer
virtual const double * buffer(TwoBodyOper::type type=TwoBodyOper::eri) const
The computed shell integrals will be put in the buffer returned by this member.
sc::TwoBodyInt::basis1
Ref< GaussianBasisSet > basis1() const
Return the basis set on center one.
sc::TwoBodyDerivInt::cloneable
virtual bool cloneable() const
Return true if the clone member can be called.
sc::TwoBodyTwoCenterInt::nbasis
int nbasis() const
Return the number of basis functions on center one.
sc::TwoBodyInt::integral
Integral * integral() const
Return the integral factory that was used to create this object.
Definition: tbint.h:182
sc::TwoBodyTwoCenterDerivInt::basis2
Ref< GaussianBasisSet > basis2() const
Return the basis set on center two.
sc::TwoBodyThreeCenterDerivInt::nbasis2
int nbasis2() const
Return the number of basis functions on center two.
sc::TwoBodyTwoCenterInt::basis1
Ref< GaussianBasisSet > basis1() const
Return the basis set on center one.
sc::TwoBodyInt::nshell1
int nshell1() const
Return the number of shells on center one.
sc::TwoBodyThreeCenterDerivInt::nbasis3
int nbasis3() const
Return the number of basis functions on center three.
sc::TwoBodyTwoCenterInt::type
virtual TwoBodyOperSet::type type() const =0
Returns the type of the operator set that this object computes.
sc::TwoBodyInt::compute_shell_arrays
std::pair< std::map< TwoBodyOper::type, const double * >, std::array< unsigned long, 4 > > compute_shell_arrays(int, int, int, int)
Given four shell indices, supported two body integral types are computed and returned.
sc::TwoBodyThreeCenterInt::log2_shell_bound
virtual int log2_shell_bound(int=-1, int=-1, int=-1)=0
Return log base 2 of the maximum magnitude of any integral in a shell block obtained from compute_she...
sc::TwoBodyInt::compute_shell
virtual void compute_shell(int, int, int, int)=0
Given four shell indices, integrals will be computed and placed in the buffer.
sc::TwoBodyDerivInt::basis4
Ref< GaussianBasisSet > basis4() const
Return the basis set on center four.
sc::TwoBodyIntEval::type
virtual TwoBodyOperSet::type type() const =0
Returns the type of the operator set that this object computes.
sc::TwoBodyIntEval::set_redundant
virtual void set_redundant(int i)
See redundant().
Definition: tbint.h:903
sc::TwoBodyTwoCenterDerivInt
This is an abstract base type for classes that compute two centers integrals involving two electrons.
Definition: tbint.h:747
sc::SCElementOp
Objects of class SCElementOp are used to perform operations on the elements of matrices.
Definition: elemop.h:94
sc::TwoBodyTwoCenterIntIter
Definition: nbint.h:237
sc::TwoBodyThreeCenterDerivInt::nbasis1
int nbasis1() const
Return the number of basis functions on center one.
sc::TwoBodyThreeCenterDerivInt::compute_shell
virtual void compute_shell(int, int, int, DerivCenters &)=0
Given for shell indices, this will cause the integral buffer to be filled in.
sc::TwoBodyTwoCenterInt::nbasis2
int nbasis2() const
Return the number of basis functions on center two.
sc::TwoBodyIntEval::basis
Ref< GaussianBasisSet > basis(size_t C) const
Return the basis set on center C.
sc::TwoBodyThreeCenterDerivInt::buffer
const double * buffer() const
The computed shell integrals will be put in the buffer returned by this member.
sc::TwoBodyThreeCenterInt::basis3
Ref< GaussianBasisSet > basis3() const
Return the basis set on center three.
sc::TwoBodyThreeCenterDerivInt::nshell2
int nshell2() const
Return the number of shells on center two.
sc::TwoBodyTwoCenterDerivInt::shell_bound
double shell_bound(int=-1, int=-1)
Return the maximum magnitude of any integral in a shell block.
sc::TwoBodyInt::set_integral_storage
virtual void set_integral_storage(size_t storage)
This storage is used to cache computed integrals.
sc::TwoBodyIntShape::_11_O_2
3-center integral
Definition: tbint.h:53
sc::TwoBodyIntShape::_11_O_22
4-center integral in chemistry convention
Definition: tbint.h:51
sc::TwoBodyTwoCenterInt::set_integral_storage
virtual void set_integral_storage(size_t storage)
This storage is used to cache computed integrals.
sc::TwoBodyInt::redundant
virtual int redundant() const
If redundant is true, then keep redundant integrals in the buffer.
Definition: tbint.h:166
sc::TwoBodyInt::nbasis1
int nbasis1() const
Return the number of basis functions on center one.
sc::TwoBodyInt::nbasis
int nbasis() const
Return the number of basis functions on center one.
sc::TwoBodyDerivInt
This is an abstract base type for classes that compute geometric derivatives of the integrals involvi...
Definition: tbint.h:554
sc::TwoBodyDerivInt::shell_bound
double shell_bound(int=-1, int=-1, int=-1, int=-1)
Return the maximum magnitude of any integral in a shell block.
sc::TwoBodyTwoCenterIntOp::has_side_effects
int has_side_effects()
By default this returns nonzero.
sc::TwoBodyThreeCenterInt::descr
virtual const Ref< TwoBodyOperSetDescr > & descr() const =0
return the operator set descriptor
sc::TwoBodyInt::set_redundant
virtual void set_redundant(int i)
See redundant().
Definition: tbint.h:168
sc::TwoBodyTwoCenterIntOp::process_spec_rect
void process_spec_rect(SCMatrixRectBlock *)
Matrices should call these members when the type of block is known.
sc::TwoBodyDerivInt::clone
virtual Ref< TwoBodyDerivInt > clone()
Returns a clone of this.
sc::TwoBodyDerivInt::basis
Ref< GaussianBasisSet > basis() const
Return the basis set on center one.
sc::TwoBodyDerivInt::buffer
const double * buffer() const
The computed shell-set of integrals will be put in the buffer returned by this member.
sc::TwoBodyDerivInt::integral
Integral * integral() const
Return the integral factory that was used to create this object.
Definition: tbint.h:654
sc::TwoBodyTwoCenterIntOp
The 2-body analog of OneBodyIntOp.
Definition: nbint.h:288
sc::Integral
The Integral abstract class acts as a factory to provide objects that compute one and two electron in...
Definition: integral.h:111
sc::TwoBodyTwoCenterInt::nbasis1
int nbasis1() const
Return the number of basis functions on center one.
sc::TwoBodyTwoCenterInt::buffer
virtual const double * buffer(TwoBodyOper::type type=TwoBodyOper::eri) const
The computed shell integrals will be put in the buffer returned by this member.
sc::TwoBodyThreeCenterDerivInt::basis3
Ref< GaussianBasisSet > basis3() const
Return the basis set on center three.
sc::ShellPairIter
Definition: obint.h:195
sc::TwoBodyTwoCenterDerivInt::buffer
const double * buffer() const
The computed shell integrals will be put in the buffer returned by this member.
sc::TwoBodyThreeCenterDerivInt::shell_bound
double shell_bound(int=-1, int=-1, int=-1)
Return the maximum magnitude of any integral in a shell block.
sc::TwoBodyInt::buffer
virtual const double * buffer(TwoBodyOper::type type=TwoBodyOper::eri) const
The computed shell integrals will be put in the buffer returned by this member.
sc::TwoBodyDerivInt::nshell2
int nshell2() const
Return the number of shells on center two.
sc::TwoBodyDerivInt::log2_shell_bound
virtual int log2_shell_bound(int=-1, int=-1, int=-1, int=-1)=0
Return log base 2 of the maximum magnitude of any integral in a shell block.
sc::TwoBodyDerivInt::nbasis
int nbasis() const
Return the number of basis functions on center one.
sc::TwoBodyOper::eri
two-body Coulomb
Definition: operator.h:319
sc::SCMatrixBlockIter
The SCMatrixBlockIter class is used to described iterates that loop through the elements in a block.
Definition: blkiter.h:46
sc::TwoBodyTwoCenterDerivInt::nshell1
int nshell1() const
Return the number of shells on center one.
sc::TwoBodyThreeCenterDerivInt::basis2
Ref< GaussianBasisSet > basis2() const
Return the basis set on center two.
sc::TwoBodyTwoCenterInt::set_redundant
void set_redundant(int i)
See redundant().
Definition: tbint.h:387
sc::TwoBodyIntEval::descr
virtual const Ref< TwoBodyOperSetDescr > & descr() const =0
return the operator set descriptor
sc::TwoBodyThreeCenterInt
This is an abstract base type for classes that compute integrals involving two electrons in three Gau...
Definition: tbint.h:191
sc::TwoBodyTwoCenterInt::nshell2
int nshell2() const
Return the number of shells on center two.
sc::TwoBodyTwoCenterDerivInt::nshell2
int nshell2() const
Return the number of shells on center two.
sc::TwoBodyIntEval::shell_bound
double shell_bound(int=-1, int=-1, int=-1, int=-1)
Return the maximum magnitude of any integral in a shell block obtained from compute_shell.
sc::TwoBodyThreeCenterDerivInt::nbasis
int nbasis() const
Return the number of basis functions on center one.
sc::TwoBodyInt::log2_shell_bound
virtual int log2_shell_bound(int=-1, int=-1, int=-1, int=-1)=0
Return log base 2 of the maximum magnitude of any integral in a shell block obtained from compute_she...
sc::TwoBodyIntEval::compute_shell
virtual void compute_shell(int, int, int, int)=0
Given four shell indices, integrals will be computed and placed in the buffer.
sc::TwoBodyDerivInt::basis2
Ref< GaussianBasisSet > basis2() const
Return the basis set on center two.
sc::TwoBodyIntEval::redundant
virtual int redundant() const
If redundant is true, then keep redundant integrals in the buffer.
Definition: tbint.h:901
sc::TwoBodyThreeCenterInt::nbasis3
int nbasis3() const
Return the number of basis functions on center three.
sc::TwoBodyDerivInt::basis3
Ref< GaussianBasisSet > basis3() const
Return the basis set on center three.
sc::TwoBodyTwoCenterInt::integral
Integral * integral() const
Return the integral factory that was used to create this object.
Definition: tbint.h:401
sc::TwoBodyTwoCenterInt::compute_shell
virtual void compute_shell(int, int)=0
Given four shell indices, integrals will be computed and placed in the buffer.
sc::TwoBodyTwoCenterInt::redundant
int redundant() const
If redundant is true, then keep redundant integrals in the buffer.
Definition: tbint.h:385
sc::TwoBodyInt::type
virtual TwoBodyOperSet::type type() const =0
Returns the type of the operator set that this object computes.
sc::TwoBodyTwoCenterInt::basis
Ref< GaussianBasisSet > basis(size_t c=0) const
Return the basis set on center c.
sc::TwoBodyOper::type
type
types of known two-body operators
Definition: operator.h:318
sc::TwoBodyIntShape::_1_O_2
2-center integral
Definition: tbint.h:55
sc::TwoBodyDerivInt::nshell
int nshell() const
Return the number of shells on center one.
sc::TwoBodyTwoCenterDerivInt::nshell
int nshell() const
Return the number of shells on center one.
sc::TwoBodyTwoCenterDerivInt::compute_shell
virtual void compute_shell(int, int, DerivCenters &)=0
Given for shell indices, this will cause the integral buffer to be filled in.
sc::TwoBodyDerivInt::nbasis3
int nbasis3() const
Return the number of basis functions on center three.
sc::TwoBodyTwoCenterDerivInt::basis
Ref< GaussianBasisSet > basis() const
Return the basis set on center one.
sc::TwoBodyThreeCenterInt::shell_bound
double shell_bound(int=-1, int=-1, int=-1)
Return the maximum magnitude of any integral in a shell block obtained from compute_shell.
sc::TwoBodyThreeCenterInt::set_redundant
void set_redundant(int i)
See redundant().
Definition: tbint.h:281
sc::TwoBodyDerivInt::nbasis1
int nbasis1() const
Return the number of basis functions on center one.
sc::TwoBodyThreeCenterInt::clone
virtual Ref< TwoBodyThreeCenterInt > clone()
Returns a clone of this.
sc::SCMatrixRectSubBlock
The SCMatrixRectSubBlock describes a rectangular piece of a matrix.
Definition: block.h:219
sc::RefCount
The base class for all reference counted objects.
Definition: ref.h:192
sc::TwoBodyInt::nbasis4
int nbasis4() const
Return the number of basis functions on center four.
sc::TwoBodyThreeCenterInt::nshell2
int nshell2() const
Return the number of shells on center two.
sc::TwoBodyTwoCenterInt::clone
virtual Ref< TwoBodyTwoCenterInt > clone()
Returns a clone of this.
sc::TwoBodyThreeCenterInt::basis
Ref< GaussianBasisSet > basis(size_t c=0) const
Return the basis set on center c.
sc::TwoBodyDerivInt::nshell3
int nshell3() const
Return the number of shells on center three.
sc::TwoBodyInt::cloneable
virtual bool cloneable() const
Return true if the clone member can be called.
sc::TwoBodyThreeCenterInt::nshell1
int nshell1() const
Return the number of shells on center one.
sc::TwoBodyThreeCenterInt::nshell3
int nshell3() const
Return the number of shells on center three.
sc::TwoBodyIntEval
This is an abstract base type for classes that compute integrals involving two electrons and 2 functi...
Definition: tbint.h:839
sc::ShellQuartetIter
Definition: nbint.h:144
sc::TwoBodyIntEval::log2_shell_bound
virtual int log2_shell_bound(int=-1, int=-1, int=-1, int=-1)=0
Return log base 2 of the maximum magnitude of any integral in a shell block obtained from compute_she...
sc::TwoBodyInt::descr
virtual const Ref< TwoBodyOperSetDescr > & descr() const =0
return the operator set descriptor
sc::DerivCenters
DerivCenters keeps track the centers that derivatives are taken with respect to.
Definition: dercent.h:42
sc::TwoBodyThreeCenterDerivInt::nshell
int nshell() const
Return the number of shells on center one.
sc::TwoBodyThreeCenterDerivInt
This is an abstract base type for classes that compute three centers integrals involving two electron...
Definition: tbint.h:671
sc
Contains all MPQC code up to version 3.
Definition: mpqcin.h:14
sc::TwoBodyThreeCenterInt::nbasis
int nbasis() const
Return the number of basis functions on center one.
sc::TwoBodyInt::basis
Ref< GaussianBasisSet > basis(size_t c=0) const
Return the basis set on center c.
sc::TwoBodyThreeCenterInt::basis1
Ref< GaussianBasisSet > basis1() const
Return the basis set on center one.
sc::TwoBodyTwoCenterInt::cloneable
virtual bool cloneable() const
Return true if the clone member can be called.
sc::TwoBodyThreeCenterInt::nbasis1
int nbasis1() const
Return the number of basis functions on center one.
sc::TwoBodyInt::nbasis2
int nbasis2() const
Return the number of basis functions on center two.
sc::TwoBodyIntEval::buffer
virtual const double * buffer(TwoBodyOper::type type=TwoBodyOper::eri) const
The computed shell integrals will be put in the buffer returned by this member.
sc::TwoBodyDerivInt::basis1
Ref< GaussianBasisSet > basis1() const
Return the basis set on center one.
sc::TwoBodyTwoCenterDerivInt::nbasis2
int nbasis2() const
Return the number of basis functions on center two.
sc::TwoBodyTwoCenterDerivInt::nbasis
int nbasis() const
Return the number of basis functions on center one.
sc::TwoBodyInt::clone
virtual Ref< TwoBodyInt > clone()
Returns a clone of this.
sc::TwoBodyDerivInt::nshell1
int nshell1() const
Return the number of shells on center one.
sc::TwoBodyInt::basis2
Ref< GaussianBasisSet > basis2() const
Return the basis set on center two.
sc::TwoBodyIntEval::set_integral_storage
virtual void set_integral_storage(size_t storage)
This storage is used to cache computed integrals.
Generated at Sun Jan 26 2020 23:23:57 for MPQC 3.0.0-alpha using the documentation package Doxygen 1.8.16.