LIBINT  2.1.0-stable
comp_11_tig12_11.h
1 /*
2  * This file is a part of Libint.
3  * Copyright (C) 2004-2014 Edward F. Valeev
4  *
5  * This program is free software: you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation, either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program. If not, see http://www.gnu.org/licenses/.
17  *
18  */
19 
20 #ifndef _libint2_src_bin_libint_cr11tig1211_h_
21 #define _libint2_src_bin_libint_cr11tig1211_h_
22 
23 #include <generic_rr.h>
24 #include <tig12_11_11.h>
25 #include <gaussoper.h>
26 
27 using namespace std;
28 
29 namespace libint2 {
30 
33  template <class BFSet>
34  class CR_11_TiG12_11 : public GenericRecurrenceRelation< CR_11_TiG12_11<BFSet>,
35  BFSet,
36  GenIntegralSet_11_11<BFSet,TiG12,mType> >
37  {
38  public:
39  typedef CR_11_TiG12_11 ThisType;
40  typedef BFSet BasisFunctionType;
43  friend class GenericRecurrenceRelation<ThisType,BFSet,TargetType>;
44  static const unsigned int max_nchildren = 8;
45 
46  using ParentType::Instance;
47 
49  static bool directional() { return false; }
50 
51  private:
52  using ParentType::RecurrenceRelation::expr_;
53  using ParentType::RecurrenceRelation::nflops_;
54  using ParentType::target_;
55  using ParentType::is_simple;
56  template<class RR, class C> friend class ChildFactory;
57 
59  CR_11_TiG12_11(const SafePtr<TargetType>&, unsigned int dir);
60  static std::string descr() { return "CR"; }
61 
62  };
63 
64  template <class F>
65  CR_11_TiG12_11<F>::CR_11_TiG12_11(const SafePtr<TargetType>& Tint,
66  unsigned int dir) :
67  ParentType(Tint,dir)
68  {
69  if (dir != 0)
70  return;
71  using namespace libint2::algebra;
72  using namespace libint2::prefactor;
73  using namespace libint2::braket;
74  // kinetic energy of which electron?
75  const int i = target_->oper()->descr().K();
76  const R12kG12 G0(R12_k_G12_Descr(0));
77  const R12kG12 G2(R12_k_G12_Descr(2));
78 
79  F a(Tint->bra(0,0));
80  F b(Tint->ket(0,0));
81  F c(Tint->bra(1,0));
82  F d(Tint->ket(1,0));
83 
84  if (i == 0) {
85  if (b.contracted() || target_->oper()->descr().contracted())
86  return;
87  }
88  if (i == 1) {
89  if (d.contracted() || target_->oper()->descr().contracted())
90  return;
91  }
92 
93  // [T1,G12]
94  if (i == 0) {
97  for(int xyz=0; xyz<3; ++xyz) {
98  R12k_R12l_G12_Descr descr(IntVec3(),unit_intvec3(xyz));
99  factory.wedge(_pbra(a,c) , Nabla1(_pket(b,d),xyz), EmptySet(), R12kR12lG12(descr));
100  }
101  if (is_simple()) expr_ *= Scalar(2.0) * Scalar("gamma");
102  }
103  // [T2,G12]
104  if (i == 1) {
106  ChildFactory<ThisType,ChildType> factory(this);
107  for(int xyz=0; xyz<3; ++xyz) {
108  R12k_R12l_G12_Descr descr(IntVec3(),unit_intvec3(xyz));
109  factory.wedge(_pbra(a,c) , Nabla2(_pket(b,d),xyz), EmptySet(), R12kR12lG12(descr));
110  }
111  if (is_simple()) expr_ *= Scalar(-2.0) * Scalar("gamma");
112  }
113 
114  {
116  ChildFactory<ThisType,ChildType> factory(this);
117  auto ab_G0_cd = factory.make_child(a,b,c,d,0u,G0);
118  if (is_simple())
119  expr_ += Scalar(3.0) * Scalar("gamma") * ab_G0_cd;
120 
121  auto ab_G2_cd = factory.make_child(a,b,c,d,0u,G2);
122  if (is_simple())
123  expr_ += Scalar(-2.0) * Scalar("gamma") * Scalar("gamma") * ab_G2_cd;
124  }
125 
126  }
127 
128 };
129 
130 #endif
R12_k_G12 is a two-body operator of form r_{12}^k * exp(- * r_{12}), where k is an integer and is a ...
Definition: oper.h:298
const SafePtr< DGVertex > & make_child(const F &A, const F &B, const F &C, const F &D, const AuxIndexType &aux=AuxIndexType(), const OperType &oper=OperType())
make_child
Definition: generic_rr.h:157
Defaults definitions for various parameters assumed by Libint.
Definition: algebra.cc:23
BraketPair< F, PKet > _pket(const F &f1, const F &f2)
Physicists ket.
Definition: braket.h:448
Definition: stdarray.h:18
Definition: prefactors.h:159
LinearCombination< SafePtr< DGVertex >, BraketPair< F, BKType > > Nabla1(const BraketPair< F, BKType > &bkt, int xyz)
Applies Nabla1 to a physicists&#39; braket.
Definition: gaussoper.h:131
GenOper is a single operator described by descriptor Descr.
Definition: oper.h:152
Generic integral over a two-body operator with one bfs for each particle in bra and ket...
Definition: integral_11_11.h:32
Compute relation for 2-e integrals of the Ti_G12 operators.
Definition: comp_11_tig12_11.h:34
void wedge(const LinearCombination< SafePtr< DGVertex >, BraketPair< F, PBra > > &bra_lc, const LinearCombination< SafePtr< DGVertex >, BraketPair< F, PKet > > &ket_lc, const AuxIndexType &aux=AuxIndexType(), const OperType &oper=OperType())
take a wedge product of various (linear combinations of) brakets
Definition: generic_rr.h:191
RRImpl must inherit GenericRecurrenceRelation<RRImpl>
Definition: generic_rr.h:48
QuantumNumbersA<T,N> is a set of N quantum numbers of type T implemented in terms of a C-style array...
Definition: quanta.h:198
Definition: algebra.h:32
these objects help to construct BraketPairs
Definition: braket.h:442
R12k_R12l_G12 is a two-body operator of form ( r_{12x}^kx * r_{12y}^ky * r_{12z}^kz ) * (r_{12x}^lx *...
Definition: oper.h:322
Set of basis functions.
Definition: bfset.h:41
LinearCombination< SafePtr< DGVertex >, BraketPair< F, BKType > > Nabla2(const BraketPair< F, BKType > &bkt, int xyz)
Applies Nabla2 to a physicists&#39; braket.
Definition: gaussoper.h:164
static bool directional()
This relation is not directional.
Definition: comp_11_tig12_11.h:49
BraketPair< F, PBra > _pbra(const F &f1, const F &f2)
Physicists bra.
Definition: braket.h:444
Helps GenericRecurrenceRelation to work around the compiler problem with make_child.
Definition: generic_rr.h:148