MPQC  3.0.0-alpha
sr_r12intermediates.h
1 //
2 // singlereference_r12_intermediates.h
3 //
4 // Copyright (C) 2013 Edward Valeev
5 //
6 // Author: Edward Valeev <evaleev@vt.edu>
7 // Maintainer: EV
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 #ifdef __GNUG__
29 #pragma implementation
30 #endif
31 
32 #ifndef _mpqc_src_lib_chemistry_qc_mbptr12_srr12intermediates_h
33 #define _mpqc_src_lib_chemistry_qc_mbptr12_srr12intermediates_h
34 
35 #if defined(MPQC_NEW_FEATURES)
36 # include <tiledarray.h>
37 #else
38 # error "sr_r12intermediates.h requires MPQC3 runtime, but it is not available"
39 #endif
40 
41 #include <chemistry/qc/wfn/rdm.h>
42 #include <chemistry/qc/mbptr12/r12wfnworld.h>
43 #include <../bin/mpqc/mpqcinit.h>
44 
45 namespace TA = TiledArray;
46 
47 namespace sc {
48 
50  template <typename T>
51  class DA4_Tile {
52  private:
53  TA::Array<T, 4, DA4_Tile>* owner_;
54  std::array<std::size_t, 4> index_;
55  Ref<DistArray4> darray4_;
56  int te_type_;
57 
58  public:
59  typedef T value_type;
60  typedef TA::Tensor<T> eval_type;
61  typedef typename eval_type::range_type range_type;
62 
63  DA4_Tile() { }
64 
65  DA4_Tile(TA::Array<T, 4, DA4_Tile>* owner,
66  const std::array<std::size_t, 4>& index,
67  const Ref<DistArray4>& darray4,
68  int te_type) :
69  owner_(owner), index_(index), darray4_(darray4), te_type_(te_type)
70  { }
71 
72  operator TA::Tensor<T> () const;
73 
74  range_type range() const {
75  return owner_->trange().make_tile_range(index_);
76  }
77 
80  template <typename Archive>
81  void serialize(Archive& ar) {
82  MPQC_ASSERT(false);
83  }
84 
85  };
86 
88  template <typename T>
89  class DA4_Tile34 {
90  private:
91  TA::Array<TA::Tensor<T>, 2, DA4_Tile34 >* owner_;
92  std::array<std::size_t, 2> index_;
93  Ref<DistArray4> darray4_;
94  int te_type_;
95 
96  public:
97  typedef T value_type;
98  typedef TA::Tensor<TA::Tensor<T> > eval_type;
99  typedef typename eval_type::range_type range_type;
100  typedef T numeric_type;
101 
102  DA4_Tile34() { }
103 
104  DA4_Tile34(TA::Array<TA::Tensor<T>, 2, DA4_Tile34 >* owner,
105  const std::array<std::size_t, 2>& index,
106  const Ref<DistArray4>& darray4,
107  int te_type) :
108  owner_(owner), index_(index), darray4_(darray4), te_type_(te_type)
109  { }
110 
112  operator TA::Tensor<TA::Tensor<T> > () const;
113 
116  template <typename Archive>
117  void serialize(Archive& ar) {
118  MPQC_ASSERT(false);
119  }
120 
121  };
122 
124  template <typename T, unsigned int DIM, typename ElementGenerator>
125  class LazyTensor {
126  private:
127  TA::Array<T, DIM, LazyTensor>* owner_;
128  std::array<std::size_t, DIM> index_;
129  ElementGenerator* element_generator_;
130 
131  public:
132  typedef T value_type;
133  typedef TA::Tensor<T> eval_type;
134  typedef typename eval_type::range_type range_type;
135 
136  LazyTensor() { }
137 
138  LazyTensor(const LazyTensor& other) :
139  owner_(other.owner_), index_(other.index_), element_generator_(other.element_generator_)
140  {}
141 
142  LazyTensor& operator=(const LazyTensor& other) {
143  owner_ = other.owner_;
144  index_ = other.index_;
145  element_generator_ = other.element_generator_;
146  return *this;
147  }
148 
149  LazyTensor(TA::Array<T, DIM, LazyTensor>* owner,
150  const std::array<std::size_t, DIM>& index,
151  ElementGenerator* gen) :
152  owner_(owner), index_(index), element_generator_(gen)
153  { }
154 
155  operator TA::Tensor<T> () const {
156 
157  eval_type tile(owner_->trange().make_tile_range(index_));
158 
159  auto* ptr = tile.data();
160  for(auto i = tile.range().begin();
161  i!=tile.range().end();
162  ++i, ++ptr) {
163 
164  *ptr = (*element_generator_)(*i);
165 
166  }
167 
168  return tile;
169  }
170 
173  template <typename Archive>
174  void serialize(Archive& ar) {
175  MPQC_ASSERT(false);
176  }
177 
178  };
179 
180  namespace expressions {
181  template <typename ArgType, bool Transpose> struct trace_tensor2_op;
182  template <typename ArgType, bool Transpose> struct diag_tensor2_op;
183 
185  template <typename T>
186  struct TGeminalGenerator {
188  TGeminalGenerator(unsigned int spin = 0) : s_(spin) {
189  MPQC_ASSERT(s_ == 0 || s_ == 1);
190  }
191 
192  template <typename Index> T operator()(const Index& i) {
193  if (s_ == 0) {
194  if (i[0] == i[1] && i[0] == i[2] && i[0] == i[3]) // iiii
195  return 1.0/2.0;
196  else if (i[0] == i[2] && i[1] == i[3]) // ijij
197  return 3.0/8.0;
198  else if (i[0] == i[3] && i[1] == i[2]) // ijji
199  return 1.0/8.0;
200  }
201  if (s_ == 1) {
202  if ((i[0] == i[2] && i[1] == i[3]) || (i[0] == i[3] && i[1] == i[2])) // ijij
203  return 1.0/4.0;
204  }
205  return 0.0;
206  }
207 
208  private:
209  unsigned int s_;
210  };
211 
212  };
213 
214 
217  template <typename T>
218  class SingleReference_R12Intermediates {
219  public:
220 
222  typedef TA::Array<T, 4 > TArray4; // Tile = Tensor<T>
224  typedef TA::Array<T, 4, DA4_Tile<T> > TArray4d; // Tile = DA4_Tile<T>
226  typedef TA::Array<T, 2> TArray2; // Tile = Tensor<T>
228  typedef TA::Array<T, 2, DA4_Tile<T> > TArray2d; // Tile = DA4_Tile<T>
230  //typedef TA::Array<T, 2, LazyTensor<T, 2, ElementGenerator> > TArray2d; // Tile = LazyTensor<T, 2, ElementGenerator>
232  typedef TA::Array<TA::Tensor<T>, 2> TArray22; // Tile = Tensor<Tensor<T>>
234  typedef TA::Array<TA::Tensor<T>, 2, DA4_Tile34<T> > TArray22d; // Tile = Tensor<Tensor<T>>
235 
237  typedef TA::Array<T, 4, LazyTensor<T, 4, expressions::TGeminalGenerator<T> > > TArray4Tg;
238 
245  SingleReference_R12Intermediates(madness::World& world,
246  const Ref<R12WavefunctionWorld>& r12world) :
247  world_(world),
248  r12world_(r12world)
249  {
250  }
251  ~SingleReference_R12Intermediates() {
252  r12world_ = 0;
253  }
254 
255  const Ref<R12WavefunctionWorld>& r12world() const {
256  return r12world_;
257  }
258 
262  std::pair<TArray2,TArray2> V_diag();
263 
267  std::pair<TArray2,TArray2> X_diag();
268 
272  std::pair<TArray2,TArray2> B_diag();
273 
278  void gf2_r12(int orbital);
279 
283  TArray2 rdm1();
284 
285  // compute multipole
286  void compute_multipole();
287  TArray2 XaiAddToXam(const TA::Array<double, 2 >& Xam,
288  const TA::Array<double, 2 >& Xai);
289  // compute B^P_Q which is summed over k
290  TArray2 BPk_Qk(const char* p, const char* q,
291  const double C_0, const double C_1);
292  TArray4 Bpr_qs(const char* p, const char* q);
293 
294  // compute V^Pq_Rs = 1/2 \bar{R}^Pq_AlphaBeta \bar{g}^AlphaBeta_Rs
295  // P and R are in alpha or beta space
296  TArray4 VPq_Rs(const char* p, const char* q,
297  const char* r, const char* s,
298  const double C_0, const double C_1);
299  // V^Rk_Sk which is summed over k
300  TArray2 VRk_Sk(const char* r, const char* s,
301  const double C_0, const double C_1);
302 
303  // compute Xam contribution from CABS Singles
304  TArray2 Xam_CabsSingles(const TArray2& TmA, const TArray2& Tma);
305 
306  // compute Xam contribution from MP2
307  TArray2 Xam_mp2(const TArray4& T2_ijab,
308  const TArray2& Dij, const TArray2& Dab);
309 
310  // compute Xam contribution from MP2 F12 coulping part
311  TArray2 Xam_Cmp2f12(const double C_0, const double C_1,
312  const TArray4& T2_ijab, const TArray4& A_ijab,
313  const TArray2& Dij, const TArray2& Dab,
314  const TArray2& RT_apb);
315 
316  // compute F12 density from X and B terms
317  void compute_Df12_XB(const double C_0, const double C_1,
318  TArray2& D_f12_ij, TArray2& D_f12_ab,
319  TArray2& D_f12_apbp, TArray2& D_f12_apb);
320  // compute X and B density contribution to Xam
321  TArray2 Xam_Df12_XB(const double C_0, const double C_1,
322  const TArray2& Df12_ij, const TArray2& Df12_ab,
323  const TArray2& Df12_apbp, const TArray2& Df12_apb);
324 
325  // compute Xam contribution from F12 V part
326  TArray2 Xam_V(const double C_0, const double C_1);
327  // compute Xam contribution from F12 X part
328  TArray2 Xam_X(const double C_0, const double C_1);
329  // compute Xam contribution from F12 B part
330  TArray2 Xam_B(const double C_0, const double C_1);
331 
332  // compute Xii' contribution from F12 part for frozen-core systems
333  TArray2 Xiip_VBX(const double C_0, const double C_1);
334  // compute Xii' contribution from CCSD F12 coupling
335  // for frozen-core systems
336  TArray2 Xiip_CVT(const double C_0, const double C_1,
337  const TArray2& T1, const TArray4& T2);
338 
339  // Xam contribution of CT2 part resulted from CCSD F12 coupling
340  TArray2 Xam_CT2_ccsd(const double C_0, const double C_1,
341  const TArray4& T2, const TArray2& RT2_aPb);
342  // Xam contribution of VT(T1&T2) part resulted from CCSD F12 coupling
343  TArray2 Xam_VT_ccsd(const double C_0, const double C_1,
344  const TArray2& T1, const TArray4& T2);
345 
346  // compute T1 & T2 amplitudes of CC2
347  void compute_T_cc2(TArray2& T1, TArray4& T2);
348 
349  // compute Lambda_1 & Lambda_2 amplitudes of CC2
350  // using formula from Schaefer III, JCP 87, 5361 (1987)
351  void compute_lambda_cc2(const TArray2& t1, const TArray4& t2,
352  TArray2& L1, TArray4& L2);
353 
354  // use formula from Gauss and Stanton, JCP, 103 (1995)
355  void compute_lambda_cc2_2(const TArray2& t1, const TArray4& t2,
356  TArray2& L1, TArray4& L2);
357 
358  // CCSD (Gauss and Stanton formula)
359  // compute Delta_ai = 1 / (- <a|F|a> + <i|F|i>)
360  // & Delta_ijab = 1 / (- <a|F|a> - <b|F|b> + <i|F|i> + <j|F|j>)
361  void compute_Delta_cc(const TA::TiledRange& TR_ai,
362  const TA::TiledRange& TR_abij,
363  TArray2& D_ai, TArray4& D_abij);
364  // compute intermediates needed for T and lambda amplitudes
365  void compute_intermediates_TFW_ccsd(
366  const TArray2& t1, const TArray4& t2,
367  const TArray4d& g_abij, const TArray4d& g_aikl,
368  const TArray4d& g_aibj, const TArray4d& g_aijb,
369  const TArray4d& g_abci,
370  const TArray4d& g_ijkl, const TArray4d& g_abcd,
371  TArray2& TFkc, TArray2& TFac, TArray2& TFki,
372  TArray4& TW_KbCj_ab,TArray4& TW_KbcJ_ba,
373  TArray4& TW_AbCd_ab, TArray4& TW_KlIj_ab);
374  void compute_intermediates_CW_ccsd(
375  const TArray2& t1, const TArray4& t2,
376  TArray2& CFkc, TArray2& CFac, TArray2& CFki,
377  TArray4& CW_KbEj_ab, TArray4& CW_KbeJ_ba,
378  TArray4& CW_AbCd_ab, TArray4& CW_AbCi_ab,
379  TArray4& CW_KlIj_ab, TArray4& CW_KbIj_ab,
380  TArray4& CW_KlIc_ab, TArray4& CW_KliC_ab,
381  TArray4& CW_AkCd_ab);
382  // compute CCSD T amplitudes
383  void compute_T_ccsd(TArray2& t1, TArray4& t2, const std::string method);
384  // compute CCSD lambda amplitudes
385  void compute_lambda_ccsd(const TArray2& t1, const TArray4& t2,
386  TArray2& L1, TArray4& L2,
387  const std::string method);
388 
389  // compute CC2 one-electron density from amplitudes
390  void compute_cc2_1rdm_amp(const TArray2& T1_cc2, const TArray4& T2_cc2,
391  const TArray2& L1_cc2, const TArray4& L2_cc2,
392  TArray2& Dij_cc2, TArray2& Dab_cc2,
393  TArray2& Dia_cc2, TArray2& Dai_cc2);
394 
395  // cpmute Gamma intermediates needed for CCSD Xam
396  void compute_Gamma_ijab_ccsd(const TArray2& T1, const TArray4& T2,
397  const TArray4& tau_ab,
398  const TArray2& L1, const TArray4& L2,
399  TArray4& Gamma_IjAb_ab);
400  void compute_ccsd_1rdm_amp(const TArray2& T1, const TArray4& T2,
401  const TArray2& L1, const TArray4& L2,
402  TArray2& Dij, TArray2& Dab,
403  TArray2& Dia, TArray2& Dai);
404 
405  void compute_Gamma2_ccsd(const TArray2& T1, const TArray4& T2,
406  const TArray2& L1, const TArray4& L2,
407  const TArray4& tau_aa, const TArray4& tau_ab,
408  TArray4& Gamma_IjKa_ab,
409  TArray4& Gamma_AbCi_ab,
410  TArray4& Gamma_iBjA_ab, TArray4& Gamma_iBJa_ba,
411  TArray4& Gamma_AbCd_ab, TArray4& Gamma_IjKl_ab,
412  TArray4& Gamma_IjAb_ab);
413 
414  // compute CCSD Xam (JCP, 103, 3561 (1995))
415  void compute_Xam_ccsd(const TArray2& T1, const TArray4& T2,
416  const TArray2& L1, const TArray4& L2,
417  TArray2& Xam_tot, TArray2& Xiip);
418 
419  // compute multipole using F12b method
420  void compute_multipole_F12b_coupling();
421  // compute V^PQ_RS = 1/2 R^PQ_A'B' g^A'B'_RS
422  // P, Q, R, and S in same spin space (or for close-shell)
423  TArray4 VPQ_RS(const char* p, const char* q,
424  const char* r, const char* s);
425  TArray2 Xam_CT2L2_f12b(const double C_0, const double C_1,
426  const TArray4& T2, const TArray2& RT2_aPb,
427  const TArray4& L2, const TArray2& RL2_aPb);
428  TArray2 Xam_VTL_f12b(const double C_0, const double C_1,
429  const TArray2& T1, const TArray4& T2,
430  const TArray2& L1, const TArray4& L2);
431 
432  TArray2 Xam_VT1T1_f12b(const double C_0, const double C_1,
433  const TArray2& T1);
434  // test function
435  TArray2 Xam_VT1T1_f12b_test(const double C_0, const double C_1,
436  const TArray4& tauT1_ab);
437 
438  TArray2 Xam_VL2T1_f12b(const double C_0, const double C_1,
439  const TArray2& T1, const TArray4& L2);
440  // test function
441  TArray2 Xam_VL2T1_f12b_test(const double C_0, const double C_1,
442  const TArray2& T1, const TArray4& L2);
443 
444  TArray2 Xam_VL2T1T1_f12b(const double C_0, const double C_1,
445  const TArray2& T1, const TArray4& L2);
446  // test function
447  TArray2 Xam_VL2T1T1_f12b_test(const double C_0, const double C_1,
448  const TArray2& T1, const TArray4& L2);
449 
450  // frozen-core contribution: Xii' from CT2, VT2, and VT1 in F12b
451  TArray2 Xiip_CVT_f12b(const double C_0, const double C_1,
452  const TArray2& T1, const TArray4& T2,
453  const TArray2& L1, const TArray4& L2);
454  // frozen-core contribution: Xii' from VT1T1 in F12b
455  TArray2 Xiip_VT1T1_f12b(const double C_0, const double C_1,
456  const TArray2& T1, const TArray4& T2,
457  const TArray4& L2);
458 
462  TArray4 rdm2();
463 
468  TArray4 V_spinfree(bool symmetrize_p1_p2 = false);
469 
474  TArray4 X_spinfree(bool symmetrize_p1_p2 = false);
475 
480  TArray4 B_spinfree(bool symmetrize_p1_p2 = false);
481 
486  void set_T1(const RefSCMatrix& t1) { t1_ = t1; }
491  void set_T1_cabs(const RefSCMatrix& t1_cabs) { t1_cabs_ = t1_cabs; }
496  void set_L1(const RefSCMatrix& l1) { l1_ = l1; }
501  void set_T2(const Ref<DistArray4> (&t2)[NSpinCases2]) { std::copy(t2, t2+NSpinCases2, t2_); }
506  void set_L2(const Ref<DistArray4> (&l2)[NSpinCases2]) { std::copy(l2, l2+NSpinCases2, l2_); }
511  void set_rdm2(const Ref<SpinFreeRDM<Two> >& rdm2) { rdm2_ = rdm2; }
512 
514  TArray4d& ijxy(const std::string& key);
516  TArray22d& ij_xy(const std::string& key);
518  TArray2& xy(const std::string& key);
519 
522  TArray2& sieve(const TArray2& input, const std::string& output_annotation);
523 
549  TA::expressions::TsrExpr<const TArray4d, true> _4(const std::string& key);
550 
573  TA::expressions::TsrExpr<const TArray2, true> _2(const std::string& key);
574 
575  //TA::expressions::TensorExpression<TA::Tensor< TA::Tensor<T> > > _22(const std::string& key);
576 
578  TA::expressions::TsrExpr<const TArray4Tg, true> _Tg(const std::string& key);
579 
580  private:
581  madness::World& world_;
582  Ref<R12WavefunctionWorld> r12world_;
583 
584  // extra data
585  RefSCMatrix t1_;
586  RefSCMatrix t1_cabs_;
587  RefSCMatrix l1_; // lambda1
588  Ref<DistArray4> t2_[NSpinCases2];
589  Ref<DistArray4> l2_[NSpinCases2]; // lambda2
590  Ref<SpinFreeRDM<Two> > rdm2_;
591 
592  // utilities
593 
594  // deprecated
596  std::shared_ptr<TArray22> ab_O_cd(const std::string& key,
597  const int te_type);
598 
599  std::map<std::string, std::shared_ptr<TArray22> > tarray22_registry_;
600  std::map<std::string, std::shared_ptr<TArray4d> > tarray4_registry_;
601  std::map<std::string, std::shared_ptr<TArray2> > tarray2_registry_;
602  std::map<std::string, std::shared_ptr<TArray22d> > tarray22d_registry_;
603  std::map<std::string, std::shared_ptr<TArray4Tg> > tarray4tg_registry_;
604 
605  // helps to create TArray4Tg
606  static expressions::TGeminalGenerator<T> tg_s0_gen;
607  static expressions::TGeminalGenerator<T> tg_s1_gen;
608 
609  // deprecated
610  TArray22& _(const std::string& key);
611 
621  std::string to_space(const std::string& index);
622 
641  static std::string to_space_(std::string index);
642 
646  std::vector<size_t> space_hashmarks(std::string space_label) const;
647 
648  template <size_t NDIM>
649  TA::TiledRange
650  make_trange(const std::array<std::string, NDIM>& spaces) const;
651 
656  RefSCMatrix rdm1(const Ref<OrbitalSpace>& row,
657  const Ref<OrbitalSpace>& col) const;
658 
659  typedef enum {
660  ij=0, ji=1
661  } ij_type;
663  template <typename Array22>
664  TA::expressions::TsrExpr<const Array22, true> take(const Array22& ij_o_pq,
665  ij_type IJ) {
666  //typedef typename Array22::value_type value_type;
667  typedef TA::Tensor<TA::Tensor<T> > value_type;
668  if (IJ == ij) {
669  sc::expressions::diag_tensor2_op<value_type,false> diag_op;
670  return make_unary_tensor(ij_o_pq("i,j"),
671  diag_op);
672  }
673  // else: IJ == ji
674  sc::expressions::diag_tensor2_op<value_type,true> diag_op;
675  return make_unary_tensor(ij_o_pq("i,j"),
676  diag_op);
677  }
678 
680  template <typename Array22>
681  TA::expressions::TsrExpr<const TArray2, true> dotket(const Array22& ij_o1_pq,
682  const Array22& ij_o2_pq,
683  bool transpose_o2_ket = false) {
684  //typedef typename Array22::value_type value_type;
685  typedef TA::Tensor<TA::Tensor<T> > value_type;
686  if (transpose_o2_ket == false) {
687  sc::expressions::trace_tensor2_op<value_type,false> trace_op;
688  return make_binary_tensor(ij_o1_pq("i,j"), ij_o2_pq("i,j"),
689  trace_op);
690  }
691  // else: transpose_o2_ket = true
692  sc::expressions::trace_tensor2_op<value_type,false> trace_op;
693  return make_binary_tensor(ij_o1_pq("i,j"), ij_o2_pq("j,i"),
694  trace_op);
695  }
696 
697  };
698 
699 }; // end of namespace sc
700 
701 #include <chemistry/qc/mbptr12/sr_r12intermediates_util.h>
702 #include <chemistry/qc/mbptr12/sr_r12intermediates_VXB_diag.h>
703 
704 #endif // end of header guard
705 
706 
707 // Local Variables:
708 // mode: c++
709 // c-file-style: "CLJ-CONDENSED"
710 // End:
sc::expressions::TGeminalGenerator
makes a geminal T tensor
Definition: sr_r12intermediates.h:186
sc::DA4_Tile34::serialize
void serialize(Archive &ar)
Definition: sr_r12intermediates.h:117
sc::SingleReference_R12Intermediates::ijxy
TArray4d & ijxy(const std::string &key)
Definition: sr_r12intermediates_util.h:164
sc::SingleReference_R12Intermediates::set_L2
void set_L2(const Ref< DistArray4 >(&l2)[NSpinCases2])
provides Lambda2 amplitudes
Definition: sr_r12intermediates.h:506
sc::SingleReference_R12Intermediates::xy
TArray2 & xy(const std::string &key)
Definition: sr_r12intermediates_util.h:437
sc::SingleReference_R12Intermediates::TArray22
TA::Array< TA::Tensor< T >, 2 > TArray22
2-index tensor with lazy tiles
Definition: sr_r12intermediates.h:232
sc::SingleReference_R12Intermediates::V_diag
std::pair< TArray2, TArray2 > V_diag()
computes diagonal (spin-restricted, for now) V intermediate
Definition: sr_r12intermediates_VXB_diag.h:433
sc::LazyTensor::serialize
void serialize(Archive &ar)
Definition: sr_r12intermediates.h:174
sc::SingleReference_R12Intermediates::compute_multipole
void compute_multipole()
Definition: sr_r12intermediates_VXB_diag.h:4163
mpqc::range
Definition: range.hpp:23
sc::SingleReference_R12Intermediates::X_diag
std::pair< TArray2, TArray2 > X_diag()
computes diagonal (spin-restricted, for now) X intermediate
Definition: sr_r12intermediates_VXB_diag.h:453
sc::RefSCMatrix
The RefSCMatrix class is a smart pointer to an SCMatrix specialization.
Definition: matrix.h:135
sc::Ref
A template class that maintains references counts.
Definition: ref.h:361
sc::SingleReference_R12Intermediates::gf2_r12
void gf2_r12(int orbital)
Computes second-order Green's function IPs and EAs \parame orbital the index of the orbital,...
Definition: sr_r12intermediates_VXB_diag.h:513
sc::SingleReference_R12Intermediates::TArray4d
TA::Array< T, 4, DA4_Tile< T > > TArray4d
4-index tensor with lazy tiles
Definition: sr_r12intermediates.h:224
sc::SingleReference_R12Intermediates::_4
TA::expressions::TsrExpr< const TArray4d, true > _4(const std::string &key)
Given a descriptive key, creates a rank-4 Array of integrals, or other related quantities The syntax ...
Definition: sr_r12intermediates_util.h:579
sc::SingleReference_R12Intermediates::set_T2
void set_T2(const Ref< DistArray4 >(&t2)[NSpinCases2])
provides T2 amplitudes
Definition: sr_r12intermediates.h:501
sc::SingleReference_R12Intermediates::compute_multipole_F12b_coupling
void compute_multipole_F12b_coupling()
Definition: sr_r12intermediates_VXB_diag.h:6242
sc::SingleReference_R12Intermediates::TArray2
TA::Array< T, 2 > TArray2
standard 2-index tensor
Definition: sr_r12intermediates.h:226
sc::SingleReference_R12Intermediates::set_rdm2
void set_rdm2(const Ref< SpinFreeRDM< Two > > &rdm2)
provides (spin-free) RDM2
Definition: sr_r12intermediates.h:511
sc::SingleReference_R12Intermediates::rdm2
TArray4 rdm2()
returns the 2-particle density matrix
sc::SingleReference_R12Intermediates::B_diag
std::pair< TArray2, TArray2 > B_diag()
computes diagonal (spin-restricted, for now) B intermediate
Definition: sr_r12intermediates_VXB_diag.h:473
sc::SingleReference_R12Intermediates::set_T1
void set_T1(const RefSCMatrix &t1)
provides T1 amplitude tensor
Definition: sr_r12intermediates.h:486
sc::SingleReference_R12Intermediates
SingleReference_R12Intermediates computes R12/F12 intermediates using MPQC3 runtime.
Definition: sr_r12intermediates.h:218
sc::SingleReference_R12Intermediates::TArray2d
TA::Array< T, 2, DA4_Tile< T > > TArray2d
2-index tensor with lazy tiles
Definition: sr_r12intermediates.h:228
sc::SingleReference_R12Intermediates::SingleReference_R12Intermediates
SingleReference_R12Intermediates(madness::World &world, const Ref< R12WavefunctionWorld > &r12world)
Constructs an SingleReference_R12Intermediates object.
Definition: sr_r12intermediates.h:245
sc::DA4_Tile::serialize
void serialize(Archive &ar)
Definition: sr_r12intermediates.h:81
sc::SpinFreeRDM< Two >
sc::LazyTensor
Tile of a DIM-order tensor that's "evaluated" when needed by calling ElementGenerator({i0,...
Definition: sr_r12intermediates.h:125
sc::other
SpinCase1 other(SpinCase1 S)
given 1-spin return the other 1-spin
sc::expressions::trace_tensor2_op
Definition: sr_r12intermediates.h:181
sc::SingleReference_R12Intermediates::_2
TA::expressions::TsrExpr< const TArray2, true > _2(const std::string &key)
Given a descriptive key, creates a rank-2 Array of integrals, or other related quantities The syntax ...
Definition: sr_r12intermediates_util.h:597
sc::SingleReference_R12Intermediates::set_T1_cabs
void set_T1_cabs(const RefSCMatrix &t1_cabs)
provides T1 CABS amplitude tensor
Definition: sr_r12intermediates.h:491
sc::SingleReference_R12Intermediates::ij_xy
TArray22d & ij_xy(const std::string &key)
Definition: sr_r12intermediates_util.h:345
sc::SingleReference_R12Intermediates::TArray4
TA::Array< T, 4 > TArray4
standard 4-index tensor
Definition: sr_r12intermediates.h:222
sc::SingleReference_R12Intermediates::TArray4Tg
TA::Array< T, 4, LazyTensor< T, 4, expressions::TGeminalGenerator< T > > > TArray4Tg
geminal T tensor
Definition: sr_r12intermediates.h:237
sc::SingleReference_R12Intermediates::TArray22d
TA::Array< TA::Tensor< T >, 2, DA4_Tile34< T > > TArray22d
2-index tensor of lazy 2-index tensors
Definition: sr_r12intermediates.h:234
sc::SingleReference_R12Intermediates::set_L1
void set_L1(const RefSCMatrix &l1)
provides Lambda1 amplitude tensor
Definition: sr_r12intermediates.h:496
sc::SingleReference_R12Intermediates::B_spinfree
TArray4 B_spinfree(bool symmetrize_p1_p2=false)
computes spin-free B intermediate
Definition: sr_r12intermediates_VXB_diag.h:7256
sc::SingleReference_R12Intermediates::X_spinfree
TArray4 X_spinfree(bool symmetrize_p1_p2=false)
computes spin-free X intermediate
Definition: sr_r12intermediates_VXB_diag.h:7242
sc::SingleReference_R12Intermediates::sieve
TArray2 & sieve(const TArray2 &input, const std::string &output_annotation)
sieves x|o1|y -> x'|o1|y' does not throw only if each tile of the result depends only on 1 tile of th...
sc::expressions::TGeminalGenerator::TGeminalGenerator
TGeminalGenerator(unsigned int spin=0)
Definition: sr_r12intermediates.h:188
sc::SingleReference_R12Intermediates::_Tg
TA::expressions::TsrExpr< const TArray4Tg, true > _Tg(const std::string &key)
like _4, produces geminal T tensor
Definition: sr_r12intermediates_util.h:620
sc::expressions::diag_tensor2_op
Definition: sr_r12intermediates.h:182
sc::DA4_Tile34
Tile of a <34> slice of <1234> that's "evaluated" when needed by reading from DistArray4 holding pqrs...
Definition: sr_r12intermediates.h:89
sc
Contains all MPQC code up to version 3.
Definition: mpqcin.h:14
sc::DA4_Tile
Tile of a 4-index tensor that's "evaluated" when needed by reading from DistArray4.
Definition: sr_r12intermediates.h:51
sc::SingleReference_R12Intermediates::V_spinfree
TArray4 V_spinfree(bool symmetrize_p1_p2=false)
computes spin-free V intermediate
Definition: sr_r12intermediates_VXB_diag.h:7228
sc::SingleReference_R12Intermediates::rdm1
TArray2 rdm1()
returns the 1-particle reduced density matrix
Definition: sr_r12intermediates_VXB_diag.h:6783
Generated at Sun Jan 26 2020 23:23:59 for MPQC 3.0.0-alpha using the documentation package Doxygen 1.8.16.