1 //
2 // BAGEL - Brilliantly Advanced General Electronic Structure Library
3 // Filename: MRCI_gamma.cc
4 // Copyright (C) 2014 Toru Shiozaki
5 //
6 // Author: Shiozaki group <shiozaki@northwestern.edu>
7 // Maintainer: Shiozaki group
8 //
9 // This file is part of the BAGEL package.
10 //
11 // This program is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation, either version 3 of the License, or
14 // (at your option) any later version.
15 //
16 // This program 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 General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program. If not, see <http://www.gnu.org/licenses/>.
23 //
24
25
26 #include <bagel_config.h>
27 #ifdef COMPILE_SMITH
28 #include <src/smith/mrci/MRCI.h>
29 #include <src/smith/mrci/MRCI_tasks1.h>
30 #include <src/smith/mrci/MRCI_tasks2.h>
31 #include <src/smith/mrci/MRCI_tasks3.h>
32
33 using namespace std;
34 using namespace bagel;
35 using namespace bagel::SMITH;
36 using bagel::SMITH::MRCI::FutureTensor;
37
Gamma0_()38 shared_ptr<FutureTensor> MRCI::MRCI::Gamma0_() {
39 vector<IndexRange> Gamma0_index = {active_, active_, active_, active_};
40 auto Gamma0 = make_shared<Tensor>(Gamma0_index);
41 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
42 auto tensor0 = vector<shared_ptr<Tensor>>{Gamma0, rdm0_, rdm1_, rdm2_};
43 auto task0 = make_shared<Task0>(tensor0, pindex);
44 return make_shared<FutureTensor>(*Gamma0, task0);
45 }
46
Gamma1_()47 shared_ptr<FutureTensor> MRCI::MRCI::Gamma1_() {
48 vector<IndexRange> Gamma1_index = {active_, active_, active_, active_, active_, active_};
49 auto Gamma1 = make_shared<Tensor>(Gamma1_index);
50 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
51 auto tensor1 = vector<shared_ptr<Tensor>>{Gamma1, rdm1_, rdm2_, rdm3_};
52 auto task1 = make_shared<Task1>(tensor1, pindex);
53 return make_shared<FutureTensor>(*Gamma1, task1);
54 }
55
Gamma2_()56 shared_ptr<FutureTensor> MRCI::MRCI::Gamma2_() {
57 vector<IndexRange> Gamma2_index = {active_, active_, active_, active_};
58 auto Gamma2 = make_shared<Tensor>(Gamma2_index);
59 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
60 auto tensor2 = vector<shared_ptr<Tensor>>{Gamma2, rdm0_, rdm1_, rdm2_};
61 auto task2 = make_shared<Task2>(tensor2, pindex);
62 return make_shared<FutureTensor>(*Gamma2, task2);
63 }
64
Gamma80_()65 shared_ptr<FutureTensor> MRCI::MRCI::Gamma80_() {
66 vector<IndexRange> Gamma80_index = {active_, active_, active_, active_, active_, active_};
67 auto Gamma80 = make_shared<Tensor>(Gamma80_index);
68 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
69 auto tensor3 = vector<shared_ptr<Tensor>>{Gamma80, rdm0_, rdm1_, rdm2_, rdm3_};
70 auto task3 = make_shared<Task3>(tensor3, pindex);
71 return make_shared<FutureTensor>(*Gamma80, task3);
72 }
73
Gamma81_()74 shared_ptr<FutureTensor> MRCI::MRCI::Gamma81_() {
75 vector<IndexRange> Gamma81_index = {active_, active_, active_, active_, active_, active_};
76 auto Gamma81 = make_shared<Tensor>(Gamma81_index);
77 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
78 auto tensor4 = vector<shared_ptr<Tensor>>{Gamma81, rdm0_, rdm1_, rdm2_, rdm3_};
79 auto task4 = make_shared<Task4>(tensor4, pindex);
80 return make_shared<FutureTensor>(*Gamma81, task4);
81 }
82
Gamma82_()83 shared_ptr<FutureTensor> MRCI::MRCI::Gamma82_() {
84 vector<IndexRange> Gamma82_index = {active_, active_, active_, active_, active_, active_};
85 auto Gamma82 = make_shared<Tensor>(Gamma82_index);
86 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
87 auto tensor5 = vector<shared_ptr<Tensor>>{Gamma82, rdm0_, rdm1_, rdm2_, rdm3_};
88 auto task5 = make_shared<Task5>(tensor5, pindex);
89 return make_shared<FutureTensor>(*Gamma82, task5);
90 }
91
Gamma85_()92 shared_ptr<FutureTensor> MRCI::MRCI::Gamma85_() {
93 vector<IndexRange> Gamma85_index = {active_, active_, active_, active_, active_, active_, active_, active_};
94 auto Gamma85 = make_shared<Tensor>(Gamma85_index);
95 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
96 auto tensor6 = vector<shared_ptr<Tensor>>{Gamma85, rdm1_, rdm2_, rdm3_, rdm4_};
97 auto task6 = make_shared<Task6>(tensor6, pindex);
98 return make_shared<FutureTensor>(*Gamma85, task6);
99 }
100
Gamma86_()101 shared_ptr<FutureTensor> MRCI::MRCI::Gamma86_() {
102 vector<IndexRange> Gamma86_index = {active_, active_, active_, active_, active_, active_, active_, active_};
103 auto Gamma86 = make_shared<Tensor>(Gamma86_index);
104 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
105 auto tensor7 = vector<shared_ptr<Tensor>>{Gamma86, rdm1_, rdm2_, rdm3_, rdm4_};
106 auto task7 = make_shared<Task7>(tensor7, pindex);
107 return make_shared<FutureTensor>(*Gamma86, task7);
108 }
109
Gamma87_()110 shared_ptr<FutureTensor> MRCI::MRCI::Gamma87_() {
111 vector<IndexRange> Gamma87_index = {active_, active_, active_, active_, active_, active_};
112 auto Gamma87 = make_shared<Tensor>(Gamma87_index);
113 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
114 auto tensor8 = vector<shared_ptr<Tensor>>{Gamma87, rdm1_, rdm2_, rdm3_};
115 auto task8 = make_shared<Task8>(tensor8, pindex);
116 return make_shared<FutureTensor>(*Gamma87, task8);
117 }
118
Gamma88_()119 shared_ptr<FutureTensor> MRCI::MRCI::Gamma88_() {
120 vector<IndexRange> Gamma88_index = {active_, active_, active_, active_, active_, active_};
121 auto Gamma88 = make_shared<Tensor>(Gamma88_index);
122 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
123 auto tensor9 = vector<shared_ptr<Tensor>>{Gamma88, rdm0_, rdm1_, rdm2_, rdm3_};
124 auto task9 = make_shared<Task9>(tensor9, pindex);
125 return make_shared<FutureTensor>(*Gamma88, task9);
126 }
127
Gamma89_()128 shared_ptr<FutureTensor> MRCI::MRCI::Gamma89_() {
129 vector<IndexRange> Gamma89_index = {active_, active_, active_, active_, active_, active_};
130 auto Gamma89 = make_shared<Tensor>(Gamma89_index);
131 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
132 auto tensor10 = vector<shared_ptr<Tensor>>{Gamma89, rdm0_, rdm1_, rdm2_, rdm3_};
133 auto task10 = make_shared<Task10>(tensor10, pindex);
134 return make_shared<FutureTensor>(*Gamma89, task10);
135 }
136
Gamma94_()137 shared_ptr<FutureTensor> MRCI::MRCI::Gamma94_() {
138 vector<IndexRange> Gamma94_index = {active_, active_, active_, active_, active_, active_};
139 auto Gamma94 = make_shared<Tensor>(Gamma94_index);
140 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
141 auto tensor11 = vector<shared_ptr<Tensor>>{Gamma94, rdm1_, rdm2_, rdm3_};
142 auto task11 = make_shared<Task11>(tensor11, pindex);
143 return make_shared<FutureTensor>(*Gamma94, task11);
144 }
145
Gamma3_()146 shared_ptr<FutureTensor> MRCI::MRCI::Gamma3_() {
147 vector<IndexRange> Gamma3_index = {active_, active_, active_, active_, active_, active_};
148 auto Gamma3 = make_shared<Tensor>(Gamma3_index);
149 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
150 auto tensor12 = vector<shared_ptr<Tensor>>{Gamma3, rdm1_, rdm2_, rdm3_};
151 auto task12 = make_shared<Task12>(tensor12, pindex);
152 return make_shared<FutureTensor>(*Gamma3, task12);
153 }
154
Gamma4_()155 shared_ptr<FutureTensor> MRCI::MRCI::Gamma4_() {
156 vector<IndexRange> Gamma4_index = {active_, active_, active_, active_, active_, active_};
157 auto Gamma4 = make_shared<Tensor>(Gamma4_index);
158 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
159 auto tensor13 = vector<shared_ptr<Tensor>>{Gamma4, rdm1_, rdm2_, rdm3_};
160 auto task13 = make_shared<Task13>(tensor13, pindex);
161 return make_shared<FutureTensor>(*Gamma4, task13);
162 }
163
Gamma5_()164 shared_ptr<FutureTensor> MRCI::MRCI::Gamma5_() {
165 vector<IndexRange> Gamma5_index = {active_, active_, active_, active_};
166 auto Gamma5 = make_shared<Tensor>(Gamma5_index);
167 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
168 auto tensor14 = vector<shared_ptr<Tensor>>{Gamma5, rdm1_, rdm2_};
169 auto task14 = make_shared<Task14>(tensor14, pindex);
170 return make_shared<FutureTensor>(*Gamma5, task14);
171 }
172
Gamma7_()173 shared_ptr<FutureTensor> MRCI::MRCI::Gamma7_() {
174 vector<IndexRange> Gamma7_index = {active_, active_, active_, active_, active_, active_};
175 auto Gamma7 = make_shared<Tensor>(Gamma7_index);
176 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
177 auto tensor15 = vector<shared_ptr<Tensor>>{Gamma7, rdm1_, rdm2_, rdm3_};
178 auto task15 = make_shared<Task15>(tensor15, pindex);
179 return make_shared<FutureTensor>(*Gamma7, task15);
180 }
181
Gamma97_()182 shared_ptr<FutureTensor> MRCI::MRCI::Gamma97_() {
183 vector<IndexRange> Gamma97_index = {active_, active_, active_, active_, active_, active_, active_, active_};
184 auto Gamma97 = make_shared<Tensor>(Gamma97_index);
185 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
186 auto tensor16 = vector<shared_ptr<Tensor>>{Gamma97, rdm1_, rdm2_, rdm3_, rdm4_};
187 auto task16 = make_shared<Task16>(tensor16, pindex);
188 return make_shared<FutureTensor>(*Gamma97, task16);
189 }
190
Gamma98_()191 shared_ptr<FutureTensor> MRCI::MRCI::Gamma98_() {
192 vector<IndexRange> Gamma98_index = {active_, active_, active_, active_, active_, active_, active_, active_};
193 auto Gamma98 = make_shared<Tensor>(Gamma98_index);
194 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
195 auto tensor17 = vector<shared_ptr<Tensor>>{Gamma98, rdm1_, rdm2_, rdm3_, rdm4_};
196 auto task17 = make_shared<Task17>(tensor17, pindex);
197 return make_shared<FutureTensor>(*Gamma98, task17);
198 }
199
Gamma100_()200 shared_ptr<FutureTensor> MRCI::MRCI::Gamma100_() {
201 vector<IndexRange> Gamma100_index = {active_, active_, active_, active_, active_, active_, active_, active_};
202 auto Gamma100 = make_shared<Tensor>(Gamma100_index);
203 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
204 auto tensor18 = vector<shared_ptr<Tensor>>{Gamma100, rdm1_, rdm2_, rdm3_, rdm4_};
205 auto task18 = make_shared<Task18>(tensor18, pindex);
206 return make_shared<FutureTensor>(*Gamma100, task18);
207 }
208
Gamma101_()209 shared_ptr<FutureTensor> MRCI::MRCI::Gamma101_() {
210 vector<IndexRange> Gamma101_index = {active_, active_, active_, active_, active_, active_, active_, active_};
211 auto Gamma101 = make_shared<Tensor>(Gamma101_index);
212 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
213 auto tensor19 = vector<shared_ptr<Tensor>>{Gamma101, rdm1_, rdm2_, rdm3_, rdm4_};
214 auto task19 = make_shared<Task19>(tensor19, pindex);
215 return make_shared<FutureTensor>(*Gamma101, task19);
216 }
217
Gamma102_()218 shared_ptr<FutureTensor> MRCI::MRCI::Gamma102_() {
219 vector<IndexRange> Gamma102_index = {active_, active_, active_, active_, active_, active_, active_, active_};
220 auto Gamma102 = make_shared<Tensor>(Gamma102_index);
221 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
222 auto tensor20 = vector<shared_ptr<Tensor>>{Gamma102, rdm1_, rdm2_, rdm3_, rdm4_};
223 auto task20 = make_shared<Task20>(tensor20, pindex);
224 return make_shared<FutureTensor>(*Gamma102, task20);
225 }
226
Gamma104_()227 shared_ptr<FutureTensor> MRCI::MRCI::Gamma104_() {
228 vector<IndexRange> Gamma104_index = {active_, active_, active_, active_, active_, active_};
229 auto Gamma104 = make_shared<Tensor>(Gamma104_index);
230 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
231 auto tensor21 = vector<shared_ptr<Tensor>>{Gamma104, rdm1_, rdm2_, rdm3_};
232 auto task21 = make_shared<Task21>(tensor21, pindex);
233 return make_shared<FutureTensor>(*Gamma104, task21);
234 }
235
Gamma107_()236 shared_ptr<FutureTensor> MRCI::MRCI::Gamma107_() {
237 vector<IndexRange> Gamma107_index = {active_, active_, active_, active_, active_, active_};
238 auto Gamma107 = make_shared<Tensor>(Gamma107_index);
239 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
240 auto tensor22 = vector<shared_ptr<Tensor>>{Gamma107, rdm1_, rdm2_, rdm3_};
241 auto task22 = make_shared<Task22>(tensor22, pindex);
242 return make_shared<FutureTensor>(*Gamma107, task22);
243 }
244
Gamma109_()245 shared_ptr<FutureTensor> MRCI::MRCI::Gamma109_() {
246 vector<IndexRange> Gamma109_index = {active_, active_, active_, active_, active_, active_};
247 auto Gamma109 = make_shared<Tensor>(Gamma109_index);
248 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
249 auto tensor23 = vector<shared_ptr<Tensor>>{Gamma109, rdm1_, rdm2_, rdm3_};
250 auto task23 = make_shared<Task23>(tensor23, pindex);
251 return make_shared<FutureTensor>(*Gamma109, task23);
252 }
253
Gamma114_()254 shared_ptr<FutureTensor> MRCI::MRCI::Gamma114_() {
255 vector<IndexRange> Gamma114_index = {active_, active_, active_, active_, active_, active_, active_, active_};
256 auto Gamma114 = make_shared<Tensor>(Gamma114_index);
257 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
258 auto tensor24 = vector<shared_ptr<Tensor>>{Gamma114, rdm1_, rdm2_, rdm3_, rdm4_};
259 auto task24 = make_shared<Task24>(tensor24, pindex);
260 return make_shared<FutureTensor>(*Gamma114, task24);
261 }
262
Gamma115_()263 shared_ptr<FutureTensor> MRCI::MRCI::Gamma115_() {
264 vector<IndexRange> Gamma115_index = {active_, active_, active_, active_, active_, active_, active_, active_};
265 auto Gamma115 = make_shared<Tensor>(Gamma115_index);
266 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
267 auto tensor25 = vector<shared_ptr<Tensor>>{Gamma115, rdm1_, rdm2_, rdm3_, rdm4_};
268 auto task25 = make_shared<Task25>(tensor25, pindex);
269 return make_shared<FutureTensor>(*Gamma115, task25);
270 }
271
Gamma119_()272 shared_ptr<FutureTensor> MRCI::MRCI::Gamma119_() {
273 vector<IndexRange> Gamma119_index = {active_, active_, active_, active_, active_, active_, active_, active_};
274 auto Gamma119 = make_shared<Tensor>(Gamma119_index);
275 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
276 auto tensor26 = vector<shared_ptr<Tensor>>{Gamma119, rdm1_, rdm2_, rdm3_, rdm4_};
277 auto task26 = make_shared<Task26>(tensor26, pindex);
278 return make_shared<FutureTensor>(*Gamma119, task26);
279 }
280
Gamma122_()281 shared_ptr<FutureTensor> MRCI::MRCI::Gamma122_() {
282 vector<IndexRange> Gamma122_index = {active_, active_, active_, active_, active_, active_, active_, active_};
283 auto Gamma122 = make_shared<Tensor>(Gamma122_index);
284 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
285 auto tensor27 = vector<shared_ptr<Tensor>>{Gamma122, rdm2_, rdm3_, rdm4_};
286 auto task27 = make_shared<Task27>(tensor27, pindex);
287 return make_shared<FutureTensor>(*Gamma122, task27);
288 }
289
Gamma550_()290 shared_ptr<FutureTensor> MRCI::MRCI::Gamma550_() {
291 vector<IndexRange> Gamma550_index = {active_, active_, active_, active_, active_, active_};
292 auto Gamma550 = make_shared<Tensor>(Gamma550_index);
293 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
294 auto tensor28 = vector<shared_ptr<Tensor>>{Gamma550, rdm1_, rdm2_, rdm3_, rdm4_, h1_};
295 auto task28 = make_shared<Task28>(tensor28, pindex);
296 return make_shared<FutureTensor>(*Gamma550, task28);
297 }
298
Gamma551_()299 shared_ptr<FutureTensor> MRCI::MRCI::Gamma551_() {
300 vector<IndexRange> Gamma551_index = {active_, active_, active_, active_, active_, active_};
301 auto Gamma551 = make_shared<Tensor>(Gamma551_index);
302 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
303 auto tensor29 = vector<shared_ptr<Tensor>>{Gamma551, rdm1_, rdm2_, rdm3_, rdm4_, v2_};
304 auto task29 = make_shared<Task29>(tensor29, pindex);
305 return make_shared<FutureTensor>(*Gamma551, task29);
306 }
307
Gamma10_()308 shared_ptr<FutureTensor> MRCI::MRCI::Gamma10_() {
309 vector<IndexRange> Gamma10_index = {active_, active_, active_, active_};
310 auto Gamma10 = make_shared<Tensor>(Gamma10_index);
311 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
312 auto tensor30 = vector<shared_ptr<Tensor>>{Gamma10, rdm1_, rdm2_};
313 auto task30 = make_shared<Task30>(tensor30, pindex);
314 return make_shared<FutureTensor>(*Gamma10, task30);
315 }
316
Gamma12_()317 shared_ptr<FutureTensor> MRCI::MRCI::Gamma12_() {
318 vector<IndexRange> Gamma12_index = {active_, active_};
319 auto Gamma12 = make_shared<Tensor>(Gamma12_index);
320 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
321 auto tensor31 = vector<shared_ptr<Tensor>>{Gamma12, rdm0_, rdm1_};
322 auto task31 = make_shared<Task31>(tensor31, pindex);
323 return make_shared<FutureTensor>(*Gamma12, task31);
324 }
325
Gamma18_()326 shared_ptr<FutureTensor> MRCI::MRCI::Gamma18_() {
327 vector<IndexRange> Gamma18_index = {active_, active_, active_, active_};
328 auto Gamma18 = make_shared<Tensor>(Gamma18_index);
329 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
330 auto tensor32 = vector<shared_ptr<Tensor>>{Gamma18, rdm1_, rdm2_};
331 auto task32 = make_shared<Task32>(tensor32, pindex);
332 return make_shared<FutureTensor>(*Gamma18, task32);
333 }
334
Gamma197_()335 shared_ptr<FutureTensor> MRCI::MRCI::Gamma197_() {
336 vector<IndexRange> Gamma197_index = {active_, active_, active_, active_};
337 auto Gamma197 = make_shared<Tensor>(Gamma197_index);
338 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
339 auto tensor33 = vector<shared_ptr<Tensor>>{Gamma197, rdm0_, rdm1_, rdm2_};
340 auto task33 = make_shared<Task33>(tensor33, pindex);
341 return make_shared<FutureTensor>(*Gamma197, task33);
342 }
343
Gamma126_()344 shared_ptr<FutureTensor> MRCI::MRCI::Gamma126_() {
345 vector<IndexRange> Gamma126_index = {active_, active_, active_, active_, active_, active_};
346 auto Gamma126 = make_shared<Tensor>(Gamma126_index);
347 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
348 auto tensor34 = vector<shared_ptr<Tensor>>{Gamma126, rdm0_, rdm1_, rdm2_, rdm3_};
349 auto task34 = make_shared<Task34>(tensor34, pindex);
350 return make_shared<FutureTensor>(*Gamma126, task34);
351 }
352
Gamma132_()353 shared_ptr<FutureTensor> MRCI::MRCI::Gamma132_() {
354 vector<IndexRange> Gamma132_index = {active_, active_, active_, active_, active_, active_};
355 auto Gamma132 = make_shared<Tensor>(Gamma132_index);
356 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
357 auto tensor35 = vector<shared_ptr<Tensor>>{Gamma132, rdm1_, rdm2_, rdm3_};
358 auto task35 = make_shared<Task35>(tensor35, pindex);
359 return make_shared<FutureTensor>(*Gamma132, task35);
360 }
361
Gamma137_()362 shared_ptr<FutureTensor> MRCI::MRCI::Gamma137_() {
363 vector<IndexRange> Gamma137_index = {active_, active_, active_, active_, active_, active_};
364 auto Gamma137 = make_shared<Tensor>(Gamma137_index);
365 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
366 auto tensor36 = vector<shared_ptr<Tensor>>{Gamma137, rdm1_, rdm2_, rdm3_};
367 auto task36 = make_shared<Task36>(tensor36, pindex);
368 return make_shared<FutureTensor>(*Gamma137, task36);
369 }
370
Gamma155_()371 shared_ptr<FutureTensor> MRCI::MRCI::Gamma155_() {
372 vector<IndexRange> Gamma155_index = {active_, active_, active_, active_};
373 auto Gamma155 = make_shared<Tensor>(Gamma155_index);
374 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
375 auto tensor37 = vector<shared_ptr<Tensor>>{Gamma155, rdm0_, rdm1_, rdm2_};
376 auto task37 = make_shared<Task37>(tensor37, pindex);
377 return make_shared<FutureTensor>(*Gamma155, task37);
378 }
379
Gamma176_()380 shared_ptr<FutureTensor> MRCI::MRCI::Gamma176_() {
381 vector<IndexRange> Gamma176_index = {active_, active_, active_, active_, active_, active_};
382 auto Gamma176 = make_shared<Tensor>(Gamma176_index);
383 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
384 auto tensor38 = vector<shared_ptr<Tensor>>{Gamma176, rdm1_, rdm2_, rdm3_};
385 auto task38 = make_shared<Task38>(tensor38, pindex);
386 return make_shared<FutureTensor>(*Gamma176, task38);
387 }
388
Gamma178_()389 shared_ptr<FutureTensor> MRCI::MRCI::Gamma178_() {
390 vector<IndexRange> Gamma178_index = {active_, active_, active_, active_, active_, active_};
391 auto Gamma178 = make_shared<Tensor>(Gamma178_index);
392 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
393 auto tensor39 = vector<shared_ptr<Tensor>>{Gamma178, rdm1_, rdm2_, rdm3_};
394 auto task39 = make_shared<Task39>(tensor39, pindex);
395 return make_shared<FutureTensor>(*Gamma178, task39);
396 }
397
Gamma179_()398 shared_ptr<FutureTensor> MRCI::MRCI::Gamma179_() {
399 vector<IndexRange> Gamma179_index = {active_, active_, active_, active_, active_, active_};
400 auto Gamma179 = make_shared<Tensor>(Gamma179_index);
401 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
402 auto tensor40 = vector<shared_ptr<Tensor>>{Gamma179, rdm1_, rdm2_, rdm3_};
403 auto task40 = make_shared<Task40>(tensor40, pindex);
404 return make_shared<FutureTensor>(*Gamma179, task40);
405 }
406
Gamma196_()407 shared_ptr<FutureTensor> MRCI::MRCI::Gamma196_() {
408 vector<IndexRange> Gamma196_index = {active_, active_, active_, active_, active_, active_};
409 auto Gamma196 = make_shared<Tensor>(Gamma196_index);
410 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
411 auto tensor41 = vector<shared_ptr<Tensor>>{Gamma196, rdm2_, rdm3_};
412 auto task41 = make_shared<Task41>(tensor41, pindex);
413 return make_shared<FutureTensor>(*Gamma196, task41);
414 }
415
Gamma552_()416 shared_ptr<FutureTensor> MRCI::MRCI::Gamma552_() {
417 vector<IndexRange> Gamma552_index = {active_, active_};
418 auto Gamma552 = make_shared<Tensor>(Gamma552_index);
419 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
420 auto tensor42 = vector<shared_ptr<Tensor>>{Gamma552, rdm0_, rdm1_, rdm2_, h1_};
421 auto task42 = make_shared<Task42>(tensor42, pindex);
422 return make_shared<FutureTensor>(*Gamma552, task42);
423 }
424
Gamma554_()425 shared_ptr<FutureTensor> MRCI::MRCI::Gamma554_() {
426 vector<IndexRange> Gamma554_index = {active_, active_};
427 auto Gamma554 = make_shared<Tensor>(Gamma554_index);
428 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
429 auto tensor43 = vector<shared_ptr<Tensor>>{Gamma554, rdm0_, rdm1_, rdm2_, rdm3_, v2_};
430 auto task43 = make_shared<Task43>(tensor43, pindex);
431 return make_shared<FutureTensor>(*Gamma554, task43);
432 }
433
Gamma24_()434 shared_ptr<FutureTensor> MRCI::MRCI::Gamma24_() {
435 vector<IndexRange> Gamma24_index = {active_, active_, active_, active_, active_, active_};
436 auto Gamma24 = make_shared<Tensor>(Gamma24_index);
437 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
438 auto tensor44 = vector<shared_ptr<Tensor>>{Gamma24, rdm1_, rdm2_, rdm3_};
439 auto task44 = make_shared<Task44>(tensor44, pindex);
440 return make_shared<FutureTensor>(*Gamma24, task44);
441 }
442
Gamma25_()443 shared_ptr<FutureTensor> MRCI::MRCI::Gamma25_() {
444 vector<IndexRange> Gamma25_index = {active_, active_, active_, active_};
445 auto Gamma25 = make_shared<Tensor>(Gamma25_index);
446 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
447 auto tensor45 = vector<shared_ptr<Tensor>>{Gamma25, rdm1_, rdm2_};
448 auto task45 = make_shared<Task45>(tensor45, pindex);
449 return make_shared<FutureTensor>(*Gamma25, task45);
450 }
451
Gamma27_()452 shared_ptr<FutureTensor> MRCI::MRCI::Gamma27_() {
453 vector<IndexRange> Gamma27_index = {active_, active_, active_, active_};
454 auto Gamma27 = make_shared<Tensor>(Gamma27_index);
455 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
456 auto tensor46 = vector<shared_ptr<Tensor>>{Gamma27, rdm1_, rdm2_};
457 auto task46 = make_shared<Task46>(tensor46, pindex);
458 return make_shared<FutureTensor>(*Gamma27, task46);
459 }
460
Gamma29_()461 shared_ptr<FutureTensor> MRCI::MRCI::Gamma29_() {
462 vector<IndexRange> Gamma29_index = {active_, active_, active_, active_};
463 auto Gamma29 = make_shared<Tensor>(Gamma29_index);
464 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
465 auto tensor47 = vector<shared_ptr<Tensor>>{Gamma29, rdm1_, rdm2_};
466 auto task47 = make_shared<Task47>(tensor47, pindex);
467 return make_shared<FutureTensor>(*Gamma29, task47);
468 }
469
Gamma31_()470 shared_ptr<FutureTensor> MRCI::MRCI::Gamma31_() {
471 vector<IndexRange> Gamma31_index = {active_, active_, active_, active_, active_, active_};
472 auto Gamma31 = make_shared<Tensor>(Gamma31_index);
473 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
474 auto tensor48 = vector<shared_ptr<Tensor>>{Gamma31, rdm2_, rdm3_};
475 auto task48 = make_shared<Task48>(tensor48, pindex);
476 return make_shared<FutureTensor>(*Gamma31, task48);
477 }
478
Gamma32_()479 shared_ptr<FutureTensor> MRCI::MRCI::Gamma32_() {
480 vector<IndexRange> Gamma32_index = {active_, active_};
481 auto Gamma32 = make_shared<Tensor>(Gamma32_index);
482 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
483 auto tensor49 = vector<shared_ptr<Tensor>>{Gamma32, rdm1_};
484 auto task49 = make_shared<Task49>(tensor49, pindex);
485 return make_shared<FutureTensor>(*Gamma32, task49);
486 }
487
Gamma215_()488 shared_ptr<FutureTensor> MRCI::MRCI::Gamma215_() {
489 vector<IndexRange> Gamma215_index = {active_, active_, active_, active_, active_, active_};
490 auto Gamma215 = make_shared<Tensor>(Gamma215_index);
491 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
492 auto tensor50 = vector<shared_ptr<Tensor>>{Gamma215, rdm1_, rdm2_, rdm3_};
493 auto task50 = make_shared<Task50>(tensor50, pindex);
494 return make_shared<FutureTensor>(*Gamma215, task50);
495 }
496
Gamma216_()497 shared_ptr<FutureTensor> MRCI::MRCI::Gamma216_() {
498 vector<IndexRange> Gamma216_index = {active_, active_, active_, active_, active_, active_, active_, active_};
499 auto Gamma216 = make_shared<Tensor>(Gamma216_index);
500 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
501 auto tensor51 = vector<shared_ptr<Tensor>>{Gamma216, rdm1_, rdm2_, rdm3_, rdm4_};
502 auto task51 = make_shared<Task51>(tensor51, pindex);
503 return make_shared<FutureTensor>(*Gamma216, task51);
504 }
505
Gamma217_()506 shared_ptr<FutureTensor> MRCI::MRCI::Gamma217_() {
507 vector<IndexRange> Gamma217_index = {active_, active_, active_, active_, active_, active_, active_, active_};
508 auto Gamma217 = make_shared<Tensor>(Gamma217_index);
509 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
510 auto tensor52 = vector<shared_ptr<Tensor>>{Gamma217, rdm1_, rdm2_, rdm3_, rdm4_};
511 auto task52 = make_shared<Task52>(tensor52, pindex);
512 return make_shared<FutureTensor>(*Gamma217, task52);
513 }
514
Gamma220_()515 shared_ptr<FutureTensor> MRCI::MRCI::Gamma220_() {
516 vector<IndexRange> Gamma220_index = {active_, active_, active_, active_, active_, active_};
517 auto Gamma220 = make_shared<Tensor>(Gamma220_index);
518 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
519 auto tensor53 = vector<shared_ptr<Tensor>>{Gamma220, rdm1_, rdm2_, rdm3_};
520 auto task53 = make_shared<Task53>(tensor53, pindex);
521 return make_shared<FutureTensor>(*Gamma220, task53);
522 }
523
Gamma222_()524 shared_ptr<FutureTensor> MRCI::MRCI::Gamma222_() {
525 vector<IndexRange> Gamma222_index = {active_, active_, active_, active_, active_, active_};
526 auto Gamma222 = make_shared<Tensor>(Gamma222_index);
527 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
528 auto tensor54 = vector<shared_ptr<Tensor>>{Gamma222, rdm1_, rdm2_, rdm3_};
529 auto task54 = make_shared<Task54>(tensor54, pindex);
530 return make_shared<FutureTensor>(*Gamma222, task54);
531 }
532
Gamma221_()533 shared_ptr<FutureTensor> MRCI::MRCI::Gamma221_() {
534 vector<IndexRange> Gamma221_index = {active_, active_, active_, active_, active_, active_};
535 auto Gamma221 = make_shared<Tensor>(Gamma221_index);
536 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
537 auto tensor55 = vector<shared_ptr<Tensor>>{Gamma221, rdm1_, rdm2_, rdm3_};
538 auto task55 = make_shared<Task55>(tensor55, pindex);
539 return make_shared<FutureTensor>(*Gamma221, task55);
540 }
541
Gamma230_()542 shared_ptr<FutureTensor> MRCI::MRCI::Gamma230_() {
543 vector<IndexRange> Gamma230_index = {active_, active_, active_, active_, active_, active_};
544 auto Gamma230 = make_shared<Tensor>(Gamma230_index);
545 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
546 auto tensor56 = vector<shared_ptr<Tensor>>{Gamma230, rdm1_, rdm2_, rdm3_};
547 auto task56 = make_shared<Task56>(tensor56, pindex);
548 return make_shared<FutureTensor>(*Gamma230, task56);
549 }
550
Gamma232_()551 shared_ptr<FutureTensor> MRCI::MRCI::Gamma232_() {
552 vector<IndexRange> Gamma232_index = {active_, active_, active_, active_, active_, active_};
553 auto Gamma232 = make_shared<Tensor>(Gamma232_index);
554 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
555 auto tensor57 = vector<shared_ptr<Tensor>>{Gamma232, rdm1_, rdm2_, rdm3_};
556 auto task57 = make_shared<Task57>(tensor57, pindex);
557 return make_shared<FutureTensor>(*Gamma232, task57);
558 }
559
Gamma234_()560 shared_ptr<FutureTensor> MRCI::MRCI::Gamma234_() {
561 vector<IndexRange> Gamma234_index = {active_, active_, active_, active_, active_, active_};
562 auto Gamma234 = make_shared<Tensor>(Gamma234_index);
563 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
564 auto tensor58 = vector<shared_ptr<Tensor>>{Gamma234, rdm1_, rdm2_, rdm3_};
565 auto task58 = make_shared<Task58>(tensor58, pindex);
566 return make_shared<FutureTensor>(*Gamma234, task58);
567 }
568
Gamma233_()569 shared_ptr<FutureTensor> MRCI::MRCI::Gamma233_() {
570 vector<IndexRange> Gamma233_index = {active_, active_, active_, active_, active_, active_};
571 auto Gamma233 = make_shared<Tensor>(Gamma233_index);
572 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
573 auto tensor59 = vector<shared_ptr<Tensor>>{Gamma233, rdm1_, rdm2_, rdm3_};
574 auto task59 = make_shared<Task59>(tensor59, pindex);
575 return make_shared<FutureTensor>(*Gamma233, task59);
576 }
577
Gamma235_()578 shared_ptr<FutureTensor> MRCI::MRCI::Gamma235_() {
579 vector<IndexRange> Gamma235_index = {active_, active_, active_, active_, active_, active_};
580 auto Gamma235 = make_shared<Tensor>(Gamma235_index);
581 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
582 auto tensor60 = vector<shared_ptr<Tensor>>{Gamma235, rdm1_, rdm2_, rdm3_};
583 auto task60 = make_shared<Task60>(tensor60, pindex);
584 return make_shared<FutureTensor>(*Gamma235, task60);
585 }
586
Gamma240_()587 shared_ptr<FutureTensor> MRCI::MRCI::Gamma240_() {
588 vector<IndexRange> Gamma240_index = {active_, active_, active_, active_, active_, active_};
589 auto Gamma240 = make_shared<Tensor>(Gamma240_index);
590 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
591 auto tensor61 = vector<shared_ptr<Tensor>>{Gamma240, rdm1_, rdm2_, rdm3_};
592 auto task61 = make_shared<Task61>(tensor61, pindex);
593 return make_shared<FutureTensor>(*Gamma240, task61);
594 }
595
Gamma244_()596 shared_ptr<FutureTensor> MRCI::MRCI::Gamma244_() {
597 vector<IndexRange> Gamma244_index = {active_, active_, active_, active_, active_, active_};
598 auto Gamma244 = make_shared<Tensor>(Gamma244_index);
599 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
600 auto tensor62 = vector<shared_ptr<Tensor>>{Gamma244, rdm1_, rdm2_, rdm3_};
601 auto task62 = make_shared<Task62>(tensor62, pindex);
602 return make_shared<FutureTensor>(*Gamma244, task62);
603 }
604
Gamma250_()605 shared_ptr<FutureTensor> MRCI::MRCI::Gamma250_() {
606 vector<IndexRange> Gamma250_index = {active_, active_, active_, active_, active_, active_, active_, active_};
607 auto Gamma250 = make_shared<Tensor>(Gamma250_index);
608 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
609 auto tensor63 = vector<shared_ptr<Tensor>>{Gamma250, rdm2_, rdm3_, rdm4_};
610 auto task63 = make_shared<Task63>(tensor63, pindex);
611 return make_shared<FutureTensor>(*Gamma250, task63);
612 }
613
Gamma251_()614 shared_ptr<FutureTensor> MRCI::MRCI::Gamma251_() {
615 vector<IndexRange> Gamma251_index = {active_, active_, active_, active_, active_, active_, active_, active_};
616 auto Gamma251 = make_shared<Tensor>(Gamma251_index);
617 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
618 auto tensor64 = vector<shared_ptr<Tensor>>{Gamma251, rdm2_, rdm3_, rdm4_};
619 auto task64 = make_shared<Task64>(tensor64, pindex);
620 return make_shared<FutureTensor>(*Gamma251, task64);
621 }
622
Gamma252_()623 shared_ptr<FutureTensor> MRCI::MRCI::Gamma252_() {
624 vector<IndexRange> Gamma252_index = {active_, active_, active_, active_, active_, active_};
625 auto Gamma252 = make_shared<Tensor>(Gamma252_index);
626 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
627 auto tensor65 = vector<shared_ptr<Tensor>>{Gamma252, rdm2_, rdm3_};
628 auto task65 = make_shared<Task65>(tensor65, pindex);
629 return make_shared<FutureTensor>(*Gamma252, task65);
630 }
631
Gamma276_()632 shared_ptr<FutureTensor> MRCI::MRCI::Gamma276_() {
633 vector<IndexRange> Gamma276_index = {active_, active_, active_, active_, active_, active_};
634 auto Gamma276 = make_shared<Tensor>(Gamma276_index);
635 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
636 auto tensor66 = vector<shared_ptr<Tensor>>{Gamma276, rdm2_, rdm3_};
637 auto task66 = make_shared<Task66>(tensor66, pindex);
638 return make_shared<FutureTensor>(*Gamma276, task66);
639 }
640
Gamma568_()641 shared_ptr<FutureTensor> MRCI::MRCI::Gamma568_() {
642 vector<IndexRange> Gamma568_index = {active_, active_, active_, active_};
643 auto Gamma568 = make_shared<Tensor>(Gamma568_index);
644 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
645 auto tensor67 = vector<shared_ptr<Tensor>>{Gamma568, rdm1_, rdm2_, rdm3_, h1_};
646 auto task67 = make_shared<Task67>(tensor67, pindex);
647 return make_shared<FutureTensor>(*Gamma568, task67);
648 }
649
Gamma569_()650 shared_ptr<FutureTensor> MRCI::MRCI::Gamma569_() {
651 vector<IndexRange> Gamma569_index = {active_, active_, active_, active_};
652 auto Gamma569 = make_shared<Tensor>(Gamma569_index);
653 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
654 auto tensor68 = vector<shared_ptr<Tensor>>{Gamma569, rdm1_, rdm2_, rdm3_, h1_};
655 auto task68 = make_shared<Task68>(tensor68, pindex);
656 return make_shared<FutureTensor>(*Gamma569, task68);
657 }
658
Gamma572_()659 shared_ptr<FutureTensor> MRCI::MRCI::Gamma572_() {
660 vector<IndexRange> Gamma572_index = {active_, active_, active_, active_};
661 auto Gamma572 = make_shared<Tensor>(Gamma572_index);
662 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
663 auto tensor69 = vector<shared_ptr<Tensor>>{Gamma572, rdm1_, rdm2_, rdm3_, rdm4_, v2_};
664 auto task69 = make_shared<Task69>(tensor69, pindex);
665 return make_shared<FutureTensor>(*Gamma572, task69);
666 }
667
Gamma573_()668 shared_ptr<FutureTensor> MRCI::MRCI::Gamma573_() {
669 vector<IndexRange> Gamma573_index = {active_, active_, active_, active_};
670 auto Gamma573 = make_shared<Tensor>(Gamma573_index);
671 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
672 auto tensor70 = vector<shared_ptr<Tensor>>{Gamma573, rdm1_, rdm2_, rdm3_, rdm4_, v2_};
673 auto task70 = make_shared<Task70>(tensor70, pindex);
674 return make_shared<FutureTensor>(*Gamma573, task70);
675 }
676
Gamma278_()677 shared_ptr<FutureTensor> MRCI::MRCI::Gamma278_() {
678 vector<IndexRange> Gamma278_index = {active_, active_, active_, active_, active_, active_, active_, active_};
679 auto Gamma278 = make_shared<Tensor>(Gamma278_index);
680 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
681 auto tensor71 = vector<shared_ptr<Tensor>>{Gamma278, rdm1_, rdm2_, rdm3_, rdm4_};
682 auto task71 = make_shared<Task71>(tensor71, pindex);
683 return make_shared<FutureTensor>(*Gamma278, task71);
684 }
685
Gamma296_()686 shared_ptr<FutureTensor> MRCI::MRCI::Gamma296_() {
687 vector<IndexRange> Gamma296_index = {active_, active_, active_, active_, active_, active_};
688 auto Gamma296 = make_shared<Tensor>(Gamma296_index);
689 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
690 auto tensor72 = vector<shared_ptr<Tensor>>{Gamma296, rdm1_, rdm2_, rdm3_};
691 auto task72 = make_shared<Task72>(tensor72, pindex);
692 return make_shared<FutureTensor>(*Gamma296, task72);
693 }
694
Gamma312_()695 shared_ptr<FutureTensor> MRCI::MRCI::Gamma312_() {
696 vector<IndexRange> Gamma312_index = {active_, active_, active_, active_, active_, active_, active_, active_};
697 auto Gamma312 = make_shared<Tensor>(Gamma312_index);
698 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
699 auto tensor73 = vector<shared_ptr<Tensor>>{Gamma312, rdm2_, rdm3_, rdm4_};
700 auto task73 = make_shared<Task73>(tensor73, pindex);
701 return make_shared<FutureTensor>(*Gamma312, task73);
702 }
703
Gamma313_()704 shared_ptr<FutureTensor> MRCI::MRCI::Gamma313_() {
705 vector<IndexRange> Gamma313_index = {active_, active_, active_, active_, active_, active_, active_, active_};
706 auto Gamma313 = make_shared<Tensor>(Gamma313_index);
707 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
708 auto tensor74 = vector<shared_ptr<Tensor>>{Gamma313, rdm2_, rdm3_, rdm4_};
709 auto task74 = make_shared<Task74>(tensor74, pindex);
710 return make_shared<FutureTensor>(*Gamma313, task74);
711 }
712
Gamma338_()713 shared_ptr<FutureTensor> MRCI::MRCI::Gamma338_() {
714 vector<IndexRange> Gamma338_index = {active_, active_, active_, active_, active_, active_};
715 auto Gamma338 = make_shared<Tensor>(Gamma338_index);
716 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
717 auto tensor75 = vector<shared_ptr<Tensor>>{Gamma338, rdm2_, rdm3_};
718 auto task75 = make_shared<Task75>(tensor75, pindex);
719 return make_shared<FutureTensor>(*Gamma338, task75);
720 }
721
Gamma48_()722 shared_ptr<FutureTensor> MRCI::MRCI::Gamma48_() {
723 vector<IndexRange> Gamma48_index = {active_, active_, active_, active_, active_, active_};
724 auto Gamma48 = make_shared<Tensor>(Gamma48_index);
725 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
726 auto tensor76 = vector<shared_ptr<Tensor>>{Gamma48, rdm2_, rdm3_};
727 auto task76 = make_shared<Task76>(tensor76, pindex);
728 return make_shared<FutureTensor>(*Gamma48, task76);
729 }
730
Gamma49_()731 shared_ptr<FutureTensor> MRCI::MRCI::Gamma49_() {
732 vector<IndexRange> Gamma49_index = {active_, active_, active_, active_, active_, active_};
733 auto Gamma49 = make_shared<Tensor>(Gamma49_index);
734 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
735 auto tensor77 = vector<shared_ptr<Tensor>>{Gamma49, rdm2_, rdm3_};
736 auto task77 = make_shared<Task77>(tensor77, pindex);
737 return make_shared<FutureTensor>(*Gamma49, task77);
738 }
739
Gamma50_()740 shared_ptr<FutureTensor> MRCI::MRCI::Gamma50_() {
741 vector<IndexRange> Gamma50_index = {active_, active_, active_, active_, active_, active_};
742 auto Gamma50 = make_shared<Tensor>(Gamma50_index);
743 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
744 auto tensor78 = vector<shared_ptr<Tensor>>{Gamma50, rdm2_, rdm3_};
745 auto task78 = make_shared<Task78>(tensor78, pindex);
746 return make_shared<FutureTensor>(*Gamma50, task78);
747 }
748
Gamma51_()749 shared_ptr<FutureTensor> MRCI::MRCI::Gamma51_() {
750 vector<IndexRange> Gamma51_index = {active_, active_, active_, active_};
751 auto Gamma51 = make_shared<Tensor>(Gamma51_index);
752 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
753 auto tensor79 = vector<shared_ptr<Tensor>>{Gamma51, rdm2_};
754 auto task79 = make_shared<Task79>(tensor79, pindex);
755 return make_shared<FutureTensor>(*Gamma51, task79);
756 }
757
Gamma339_()758 shared_ptr<FutureTensor> MRCI::MRCI::Gamma339_() {
759 vector<IndexRange> Gamma339_index = {active_, active_, active_, active_, active_, active_, active_, active_};
760 auto Gamma339 = make_shared<Tensor>(Gamma339_index);
761 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
762 auto tensor80 = vector<shared_ptr<Tensor>>{Gamma339, rdm2_, rdm3_, rdm4_};
763 auto task80 = make_shared<Task80>(tensor80, pindex);
764 return make_shared<FutureTensor>(*Gamma339, task80);
765 }
766
Gamma340_()767 shared_ptr<FutureTensor> MRCI::MRCI::Gamma340_() {
768 vector<IndexRange> Gamma340_index = {active_, active_, active_, active_, active_, active_};
769 auto Gamma340 = make_shared<Tensor>(Gamma340_index);
770 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
771 auto tensor81 = vector<shared_ptr<Tensor>>{Gamma340, rdm2_, rdm3_};
772 auto task81 = make_shared<Task81>(tensor81, pindex);
773 return make_shared<FutureTensor>(*Gamma340, task81);
774 }
775
Gamma341_()776 shared_ptr<FutureTensor> MRCI::MRCI::Gamma341_() {
777 vector<IndexRange> Gamma341_index = {active_, active_, active_, active_, active_, active_, active_, active_};
778 auto Gamma341 = make_shared<Tensor>(Gamma341_index);
779 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
780 auto tensor82 = vector<shared_ptr<Tensor>>{Gamma341, rdm2_, rdm3_, rdm4_};
781 auto task82 = make_shared<Task82>(tensor82, pindex);
782 return make_shared<FutureTensor>(*Gamma341, task82);
783 }
784
Gamma342_()785 shared_ptr<FutureTensor> MRCI::MRCI::Gamma342_() {
786 vector<IndexRange> Gamma342_index = {active_, active_, active_, active_, active_, active_, active_, active_};
787 auto Gamma342 = make_shared<Tensor>(Gamma342_index);
788 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
789 auto tensor83 = vector<shared_ptr<Tensor>>{Gamma342, rdm2_, rdm3_, rdm4_};
790 auto task83 = make_shared<Task83>(tensor83, pindex);
791 return make_shared<FutureTensor>(*Gamma342, task83);
792 }
793
Gamma345_()794 shared_ptr<FutureTensor> MRCI::MRCI::Gamma345_() {
795 vector<IndexRange> Gamma345_index = {active_, active_, active_, active_, active_, active_, active_, active_};
796 auto Gamma345 = make_shared<Tensor>(Gamma345_index);
797 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
798 auto tensor84 = vector<shared_ptr<Tensor>>{Gamma345, rdm2_, rdm3_, rdm4_};
799 auto task84 = make_shared<Task84>(tensor84, pindex);
800 return make_shared<FutureTensor>(*Gamma345, task84);
801 }
802
Gamma346_()803 shared_ptr<FutureTensor> MRCI::MRCI::Gamma346_() {
804 vector<IndexRange> Gamma346_index = {active_, active_, active_, active_, active_, active_, active_, active_};
805 auto Gamma346 = make_shared<Tensor>(Gamma346_index);
806 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
807 auto tensor85 = vector<shared_ptr<Tensor>>{Gamma346, rdm2_, rdm3_, rdm4_};
808 auto task85 = make_shared<Task85>(tensor85, pindex);
809 return make_shared<FutureTensor>(*Gamma346, task85);
810 }
811
Gamma349_()812 shared_ptr<FutureTensor> MRCI::MRCI::Gamma349_() {
813 vector<IndexRange> Gamma349_index = {active_, active_, active_, active_, active_, active_, active_, active_};
814 auto Gamma349 = make_shared<Tensor>(Gamma349_index);
815 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
816 auto tensor86 = vector<shared_ptr<Tensor>>{Gamma349, rdm2_, rdm3_, rdm4_};
817 auto task86 = make_shared<Task86>(tensor86, pindex);
818 return make_shared<FutureTensor>(*Gamma349, task86);
819 }
820
Gamma350_()821 shared_ptr<FutureTensor> MRCI::MRCI::Gamma350_() {
822 vector<IndexRange> Gamma350_index = {active_, active_, active_, active_, active_, active_, active_, active_};
823 auto Gamma350 = make_shared<Tensor>(Gamma350_index);
824 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
825 auto tensor87 = vector<shared_ptr<Tensor>>{Gamma350, rdm2_, rdm3_, rdm4_};
826 auto task87 = make_shared<Task87>(tensor87, pindex);
827 return make_shared<FutureTensor>(*Gamma350, task87);
828 }
829
Gamma351_()830 shared_ptr<FutureTensor> MRCI::MRCI::Gamma351_() {
831 vector<IndexRange> Gamma351_index = {active_, active_, active_, active_, active_, active_, active_, active_};
832 auto Gamma351 = make_shared<Tensor>(Gamma351_index);
833 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
834 auto tensor88 = vector<shared_ptr<Tensor>>{Gamma351, rdm2_, rdm3_, rdm4_};
835 auto task88 = make_shared<Task88>(tensor88, pindex);
836 return make_shared<FutureTensor>(*Gamma351, task88);
837 }
838
Gamma359_()839 shared_ptr<FutureTensor> MRCI::MRCI::Gamma359_() {
840 vector<IndexRange> Gamma359_index = {active_, active_, active_, active_, active_, active_};
841 auto Gamma359 = make_shared<Tensor>(Gamma359_index);
842 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
843 auto tensor89 = vector<shared_ptr<Tensor>>{Gamma359, rdm2_, rdm3_};
844 auto task89 = make_shared<Task89>(tensor89, pindex);
845 return make_shared<FutureTensor>(*Gamma359, task89);
846 }
847
Gamma366_()848 shared_ptr<FutureTensor> MRCI::MRCI::Gamma366_() {
849 vector<IndexRange> Gamma366_index = {active_, active_, active_, active_, active_, active_, active_, active_};
850 auto Gamma366 = make_shared<Tensor>(Gamma366_index);
851 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
852 auto tensor90 = vector<shared_ptr<Tensor>>{Gamma366, rdm3_, rdm4_};
853 auto task90 = make_shared<Task90>(tensor90, pindex);
854 return make_shared<FutureTensor>(*Gamma366, task90);
855 }
856
Gamma556_()857 shared_ptr<FutureTensor> MRCI::MRCI::Gamma556_() {
858 vector<IndexRange> Gamma556_index = {active_, active_, active_, active_, active_, active_};
859 auto Gamma556 = make_shared<Tensor>(Gamma556_index);
860 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
861 auto tensor91 = vector<shared_ptr<Tensor>>{Gamma556, rdm2_, rdm3_, rdm4_, h1_};
862 auto task91 = make_shared<Task91>(tensor91, pindex);
863 return make_shared<FutureTensor>(*Gamma556, task91);
864 }
865
Gamma557_()866 shared_ptr<FutureTensor> MRCI::MRCI::Gamma557_() {
867 vector<IndexRange> Gamma557_index = {active_, active_, active_, active_, active_, active_};
868 auto Gamma557 = make_shared<Tensor>(Gamma557_index);
869 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
870 auto tensor92 = vector<shared_ptr<Tensor>>{Gamma557, rdm2_, rdm3_, rdm4_, v2_};
871 auto task92 = make_shared<Task92>(tensor92, pindex);
872 return make_shared<FutureTensor>(*Gamma557, task92);
873 }
874
Gamma471_()875 shared_ptr<FutureTensor> MRCI::MRCI::Gamma471_() {
876 vector<IndexRange> Gamma471_index = {active_, active_, active_, active_, active_, active_};
877 auto Gamma471 = make_shared<Tensor>(Gamma471_index);
878 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
879 auto tensor93 = vector<shared_ptr<Tensor>>{Gamma471, rdm2_, rdm3_};
880 auto task93 = make_shared<Task93>(tensor93, pindex);
881 return make_shared<FutureTensor>(*Gamma471, task93);
882 }
883
Gamma503_()884 shared_ptr<FutureTensor> MRCI::MRCI::Gamma503_() {
885 vector<IndexRange> Gamma503_index = {active_, active_, active_, active_};
886 auto Gamma503 = make_shared<Tensor>(Gamma503_index);
887 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
888 auto tensor94 = vector<shared_ptr<Tensor>>{Gamma503, rdm2_};
889 auto task94 = make_shared<Task94>(tensor94, pindex);
890 return make_shared<FutureTensor>(*Gamma503, task94);
891 }
892
Gamma526_()893 shared_ptr<FutureTensor> MRCI::MRCI::Gamma526_() {
894 vector<IndexRange> Gamma526_index = {active_, active_, active_, active_, active_, active_};
895 auto Gamma526 = make_shared<Tensor>(Gamma526_index);
896 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
897 auto tensor95 = vector<shared_ptr<Tensor>>{Gamma526, rdm3_};
898 auto task95 = make_shared<Task95>(tensor95, pindex);
899 return make_shared<FutureTensor>(*Gamma526, task95);
900 }
901
Gamma562_()902 shared_ptr<FutureTensor> MRCI::MRCI::Gamma562_() {
903 vector<IndexRange> Gamma562_index = {active_, active_};
904 auto Gamma562 = make_shared<Tensor>(Gamma562_index);
905 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
906 auto tensor96 = vector<shared_ptr<Tensor>>{Gamma562, rdm1_, rdm2_, h1_};
907 auto task96 = make_shared<Task96>(tensor96, pindex);
908 return make_shared<FutureTensor>(*Gamma562, task96);
909 }
910
Gamma564_()911 shared_ptr<FutureTensor> MRCI::MRCI::Gamma564_() {
912 vector<IndexRange> Gamma564_index = {active_, active_};
913 auto Gamma564 = make_shared<Tensor>(Gamma564_index);
914 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
915 auto tensor97 = vector<shared_ptr<Tensor>>{Gamma564, rdm1_, rdm2_, rdm3_, v2_};
916 auto task97 = make_shared<Task97>(tensor97, pindex);
917 return make_shared<FutureTensor>(*Gamma564, task97);
918 }
919
Gamma531_()920 shared_ptr<FutureTensor> MRCI::MRCI::Gamma531_() {
921 vector<IndexRange> Gamma531_index = {active_, active_, active_, active_, active_, active_};
922 auto Gamma531 = make_shared<Tensor>(Gamma531_index);
923 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
924 auto tensor98 = vector<shared_ptr<Tensor>>{Gamma531, rdm2_, rdm3_};
925 auto task98 = make_shared<Task98>(tensor98, pindex);
926 return make_shared<FutureTensor>(*Gamma531, task98);
927 }
928
Gamma532_()929 shared_ptr<FutureTensor> MRCI::MRCI::Gamma532_() {
930 vector<IndexRange> Gamma532_index = {active_, active_, active_, active_, active_, active_};
931 auto Gamma532 = make_shared<Tensor>(Gamma532_index);
932 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
933 auto tensor99 = vector<shared_ptr<Tensor>>{Gamma532, rdm2_, rdm3_};
934 auto task99 = make_shared<Task99>(tensor99, pindex);
935 return make_shared<FutureTensor>(*Gamma532, task99);
936 }
937
Gamma533_()938 shared_ptr<FutureTensor> MRCI::MRCI::Gamma533_() {
939 vector<IndexRange> Gamma533_index = {active_, active_, active_, active_, active_, active_, active_, active_};
940 auto Gamma533 = make_shared<Tensor>(Gamma533_index);
941 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
942 auto tensor100 = vector<shared_ptr<Tensor>>{Gamma533, rdm3_, rdm4_};
943 auto task100 = make_shared<Task100>(tensor100, pindex);
944 return make_shared<FutureTensor>(*Gamma533, task100);
945 }
946
Gamma545_()947 shared_ptr<FutureTensor> MRCI::MRCI::Gamma545_() {
948 vector<IndexRange> Gamma545_index = {active_, active_, active_, active_, active_, active_};
949 auto Gamma545 = make_shared<Tensor>(Gamma545_index);
950 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
951 auto tensor101 = vector<shared_ptr<Tensor>>{Gamma545, rdm3_};
952 auto task101 = make_shared<Task101>(tensor101, pindex);
953 return make_shared<FutureTensor>(*Gamma545, task101);
954 }
955
Gamma548_()956 shared_ptr<FutureTensor> MRCI::MRCI::Gamma548_() {
957 vector<IndexRange> Gamma548_index = {active_, active_, active_, active_};
958 auto Gamma548 = make_shared<Tensor>(Gamma548_index);
959 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
960 auto tensor102 = vector<shared_ptr<Tensor>>{Gamma548, rdm0_, rdm1_, rdm2_, rdm3_, h1_};
961 auto task102 = make_shared<Task102>(tensor102, pindex);
962 return make_shared<FutureTensor>(*Gamma548, task102);
963 }
964
Gamma549_()965 shared_ptr<FutureTensor> MRCI::MRCI::Gamma549_() {
966 vector<IndexRange> Gamma549_index = {active_, active_, active_, active_};
967 auto Gamma549 = make_shared<Tensor>(Gamma549_index);
968 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
969 auto tensor103 = vector<shared_ptr<Tensor>>{Gamma549, rdm0_, rdm1_, rdm2_, rdm3_, rdm4_, v2_};
970 auto task103 = make_shared<Task103>(tensor103, pindex);
971 return make_shared<FutureTensor>(*Gamma549, task103);
972 }
973
Gamma558_()974 shared_ptr<FutureTensor> MRCI::MRCI::Gamma558_() {
975 vector<IndexRange> Gamma558_index;
976 auto Gamma558 = make_shared<Tensor>(Gamma558_index);
977 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
978 auto tensor104 = vector<shared_ptr<Tensor>>{Gamma558, rdm1_, h1_};
979 auto task104 = make_shared<Task104>(tensor104, pindex);
980 return make_shared<FutureTensor>(*Gamma558, task104);
981 }
982
Gamma560_()983 shared_ptr<FutureTensor> MRCI::MRCI::Gamma560_() {
984 vector<IndexRange> Gamma560_index;
985 auto Gamma560 = make_shared<Tensor>(Gamma560_index);
986 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
987 auto tensor105 = vector<shared_ptr<Tensor>>{Gamma560, rdm1_, rdm2_, v2_};
988 auto task105 = make_shared<Task105>(tensor105, pindex);
989 return make_shared<FutureTensor>(*Gamma560, task105);
990 }
991
Gamma566_()992 shared_ptr<FutureTensor> MRCI::MRCI::Gamma566_() {
993 vector<IndexRange> Gamma566_index = {active_, active_, active_, active_};
994 auto Gamma566 = make_shared<Tensor>(Gamma566_index);
995 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
996 auto tensor106 = vector<shared_ptr<Tensor>>{Gamma566, rdm2_, rdm3_, h1_};
997 auto task106 = make_shared<Task106>(tensor106, pindex);
998 return make_shared<FutureTensor>(*Gamma566, task106);
999 }
1000
Gamma567_()1001 shared_ptr<FutureTensor> MRCI::MRCI::Gamma567_() {
1002 vector<IndexRange> Gamma567_index = {active_, active_, active_, active_};
1003 auto Gamma567 = make_shared<Tensor>(Gamma567_index);
1004 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
1005 auto tensor107 = vector<shared_ptr<Tensor>>{Gamma567, rdm2_, rdm3_, rdm4_, v2_};
1006 auto task107 = make_shared<Task107>(tensor107, pindex);
1007 return make_shared<FutureTensor>(*Gamma567, task107);
1008 }
1009
1010 #endif
1011