1 //
2 // BAGEL - Brilliantly Advanced General Electronic Structure Library
3 // Filename: RelMRCI_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/relmrci/RelMRCI.h>
29 #include <src/smith/relmrci/RelMRCI_tasks1.h>
30 #include <src/smith/relmrci/RelMRCI_tasks2.h>
31
32 using namespace std;
33 using namespace bagel;
34 using namespace bagel::SMITH;
35 using bagel::SMITH::RelMRCI::FutureTensor;
36
Gamma0_()37 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma0_() {
38 vector<IndexRange> Gamma0_index = {active_, active_, active_, active_};
39 auto Gamma0 = make_shared<Tensor>(Gamma0_index);
40 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
41 auto tensor0 = vector<shared_ptr<Tensor>>{Gamma0, rdm0_, rdm1_, rdm2_};
42 auto task0 = make_shared<Task0>(tensor0, pindex);
43 return make_shared<FutureTensor>(*Gamma0, task0);
44 }
45
Gamma1_()46 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma1_() {
47 vector<IndexRange> Gamma1_index = {active_, active_, active_, active_, active_, active_};
48 auto Gamma1 = make_shared<Tensor>(Gamma1_index);
49 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
50 auto tensor1 = vector<shared_ptr<Tensor>>{Gamma1, rdm1_, rdm2_, rdm3_};
51 auto task1 = make_shared<Task1>(tensor1, pindex);
52 return make_shared<FutureTensor>(*Gamma1, task1);
53 }
54
Gamma2_()55 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma2_() {
56 vector<IndexRange> Gamma2_index = {active_, active_, active_, active_};
57 auto Gamma2 = make_shared<Tensor>(Gamma2_index);
58 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
59 auto tensor2 = vector<shared_ptr<Tensor>>{Gamma2, rdm0_, rdm1_, rdm2_};
60 auto task2 = make_shared<Task2>(tensor2, pindex);
61 return make_shared<FutureTensor>(*Gamma2, task2);
62 }
63
Gamma58_()64 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma58_() {
65 vector<IndexRange> Gamma58_index = {active_, active_, active_, active_, active_, active_};
66 auto Gamma58 = make_shared<Tensor>(Gamma58_index);
67 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
68 auto tensor3 = vector<shared_ptr<Tensor>>{Gamma58, rdm0_, rdm1_, rdm2_, rdm3_};
69 auto task3 = make_shared<Task3>(tensor3, pindex);
70 return make_shared<FutureTensor>(*Gamma58, task3);
71 }
72
Gamma59_()73 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma59_() {
74 vector<IndexRange> Gamma59_index = {active_, active_, active_, active_, active_, active_};
75 auto Gamma59 = make_shared<Tensor>(Gamma59_index);
76 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
77 auto tensor4 = vector<shared_ptr<Tensor>>{Gamma59, rdm0_, rdm1_, rdm2_, rdm3_};
78 auto task4 = make_shared<Task4>(tensor4, pindex);
79 return make_shared<FutureTensor>(*Gamma59, task4);
80 }
81
Gamma60_()82 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma60_() {
83 vector<IndexRange> Gamma60_index = {active_, active_, active_, active_, active_, active_};
84 auto Gamma60 = make_shared<Tensor>(Gamma60_index);
85 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
86 auto tensor5 = vector<shared_ptr<Tensor>>{Gamma60, rdm0_, rdm1_, rdm2_, rdm3_};
87 auto task5 = make_shared<Task5>(tensor5, pindex);
88 return make_shared<FutureTensor>(*Gamma60, task5);
89 }
90
Gamma63_()91 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma63_() {
92 vector<IndexRange> Gamma63_index = {active_, active_, active_, active_, active_, active_, active_, active_};
93 auto Gamma63 = make_shared<Tensor>(Gamma63_index);
94 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
95 auto tensor6 = vector<shared_ptr<Tensor>>{Gamma63, rdm1_, rdm2_, rdm3_, rdm4_};
96 auto task6 = make_shared<Task6>(tensor6, pindex);
97 return make_shared<FutureTensor>(*Gamma63, task6);
98 }
99
Gamma64_()100 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma64_() {
101 vector<IndexRange> Gamma64_index = {active_, active_, active_, active_, active_, active_, active_, active_};
102 auto Gamma64 = make_shared<Tensor>(Gamma64_index);
103 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
104 auto tensor7 = vector<shared_ptr<Tensor>>{Gamma64, rdm1_, rdm2_, rdm3_, rdm4_};
105 auto task7 = make_shared<Task7>(tensor7, pindex);
106 return make_shared<FutureTensor>(*Gamma64, task7);
107 }
108
Gamma65_()109 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma65_() {
110 vector<IndexRange> Gamma65_index = {active_, active_, active_, active_, active_, active_};
111 auto Gamma65 = make_shared<Tensor>(Gamma65_index);
112 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
113 auto tensor8 = vector<shared_ptr<Tensor>>{Gamma65, rdm1_, rdm2_, rdm3_};
114 auto task8 = make_shared<Task8>(tensor8, pindex);
115 return make_shared<FutureTensor>(*Gamma65, task8);
116 }
117
Gamma66_()118 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma66_() {
119 vector<IndexRange> Gamma66_index = {active_, active_, active_, active_, active_, active_};
120 auto Gamma66 = make_shared<Tensor>(Gamma66_index);
121 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
122 auto tensor9 = vector<shared_ptr<Tensor>>{Gamma66, rdm0_, rdm1_, rdm2_, rdm3_};
123 auto task9 = make_shared<Task9>(tensor9, pindex);
124 return make_shared<FutureTensor>(*Gamma66, task9);
125 }
126
Gamma67_()127 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma67_() {
128 vector<IndexRange> Gamma67_index = {active_, active_, active_, active_, active_, active_};
129 auto Gamma67 = make_shared<Tensor>(Gamma67_index);
130 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
131 auto tensor10 = vector<shared_ptr<Tensor>>{Gamma67, rdm0_, rdm1_, rdm2_, rdm3_};
132 auto task10 = make_shared<Task10>(tensor10, pindex);
133 return make_shared<FutureTensor>(*Gamma67, task10);
134 }
135
Gamma3_()136 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma3_() {
137 vector<IndexRange> Gamma3_index = {active_, active_, active_, active_, active_, active_};
138 auto Gamma3 = make_shared<Tensor>(Gamma3_index);
139 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
140 auto tensor11 = vector<shared_ptr<Tensor>>{Gamma3, rdm1_, rdm2_, rdm3_};
141 auto task11 = make_shared<Task11>(tensor11, pindex);
142 return make_shared<FutureTensor>(*Gamma3, task11);
143 }
144
Gamma4_()145 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma4_() {
146 vector<IndexRange> Gamma4_index = {active_, active_, active_, active_, active_, active_};
147 auto Gamma4 = make_shared<Tensor>(Gamma4_index);
148 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
149 auto tensor12 = vector<shared_ptr<Tensor>>{Gamma4, rdm1_, rdm2_, rdm3_};
150 auto task12 = make_shared<Task12>(tensor12, pindex);
151 return make_shared<FutureTensor>(*Gamma4, task12);
152 }
153
Gamma5_()154 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma5_() {
155 vector<IndexRange> Gamma5_index = {active_, active_, active_, active_};
156 auto Gamma5 = make_shared<Tensor>(Gamma5_index);
157 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
158 auto tensor13 = vector<shared_ptr<Tensor>>{Gamma5, rdm1_, rdm2_};
159 auto task13 = make_shared<Task13>(tensor13, pindex);
160 return make_shared<FutureTensor>(*Gamma5, task13);
161 }
162
Gamma74_()163 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma74_() {
164 vector<IndexRange> Gamma74_index = {active_, active_, active_, active_, active_, active_, active_, active_};
165 auto Gamma74 = make_shared<Tensor>(Gamma74_index);
166 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
167 auto tensor14 = vector<shared_ptr<Tensor>>{Gamma74, rdm1_, rdm2_, rdm3_, rdm4_};
168 auto task14 = make_shared<Task14>(tensor14, pindex);
169 return make_shared<FutureTensor>(*Gamma74, task14);
170 }
171
Gamma75_()172 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma75_() {
173 vector<IndexRange> Gamma75_index = {active_, active_, active_, active_, active_, active_, active_, active_};
174 auto Gamma75 = make_shared<Tensor>(Gamma75_index);
175 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
176 auto tensor15 = vector<shared_ptr<Tensor>>{Gamma75, rdm1_, rdm2_, rdm3_, rdm4_};
177 auto task15 = make_shared<Task15>(tensor15, pindex);
178 return make_shared<FutureTensor>(*Gamma75, task15);
179 }
180
Gamma77_()181 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma77_() {
182 vector<IndexRange> Gamma77_index = {active_, active_, active_, active_, active_, active_, active_, active_};
183 auto Gamma77 = make_shared<Tensor>(Gamma77_index);
184 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
185 auto tensor16 = vector<shared_ptr<Tensor>>{Gamma77, rdm1_, rdm2_, rdm3_, rdm4_};
186 auto task16 = make_shared<Task16>(tensor16, pindex);
187 return make_shared<FutureTensor>(*Gamma77, task16);
188 }
189
Gamma78_()190 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma78_() {
191 vector<IndexRange> Gamma78_index = {active_, active_, active_, active_, active_, active_, active_, active_};
192 auto Gamma78 = make_shared<Tensor>(Gamma78_index);
193 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
194 auto tensor17 = vector<shared_ptr<Tensor>>{Gamma78, rdm1_, rdm2_, rdm3_, rdm4_};
195 auto task17 = make_shared<Task17>(tensor17, pindex);
196 return make_shared<FutureTensor>(*Gamma78, task17);
197 }
198
Gamma79_()199 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma79_() {
200 vector<IndexRange> Gamma79_index = {active_, active_, active_, active_, active_, active_, active_, active_};
201 auto Gamma79 = make_shared<Tensor>(Gamma79_index);
202 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
203 auto tensor18 = vector<shared_ptr<Tensor>>{Gamma79, rdm1_, rdm2_, rdm3_, rdm4_};
204 auto task18 = make_shared<Task18>(tensor18, pindex);
205 return make_shared<FutureTensor>(*Gamma79, task18);
206 }
207
Gamma81_()208 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma81_() {
209 vector<IndexRange> Gamma81_index = {active_, active_, active_, active_, active_, active_};
210 auto Gamma81 = make_shared<Tensor>(Gamma81_index);
211 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
212 auto tensor19 = vector<shared_ptr<Tensor>>{Gamma81, rdm1_, rdm2_, rdm3_};
213 auto task19 = make_shared<Task19>(tensor19, pindex);
214 return make_shared<FutureTensor>(*Gamma81, task19);
215 }
216
Gamma84_()217 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma84_() {
218 vector<IndexRange> Gamma84_index = {active_, active_, active_, active_, active_, active_};
219 auto Gamma84 = make_shared<Tensor>(Gamma84_index);
220 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
221 auto tensor20 = vector<shared_ptr<Tensor>>{Gamma84, rdm1_, rdm2_, rdm3_};
222 auto task20 = make_shared<Task20>(tensor20, pindex);
223 return make_shared<FutureTensor>(*Gamma84, task20);
224 }
225
Gamma86_()226 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma86_() {
227 vector<IndexRange> Gamma86_index = {active_, active_, active_, active_, active_, active_};
228 auto Gamma86 = make_shared<Tensor>(Gamma86_index);
229 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
230 auto tensor21 = vector<shared_ptr<Tensor>>{Gamma86, rdm1_, rdm2_, rdm3_};
231 auto task21 = make_shared<Task21>(tensor21, pindex);
232 return make_shared<FutureTensor>(*Gamma86, task21);
233 }
234
Gamma92_()235 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma92_() {
236 vector<IndexRange> Gamma92_index = {active_, active_, active_, active_, active_, active_, active_, active_};
237 auto Gamma92 = make_shared<Tensor>(Gamma92_index);
238 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
239 auto tensor22 = vector<shared_ptr<Tensor>>{Gamma92, rdm1_, rdm2_, rdm3_, rdm4_};
240 auto task22 = make_shared<Task22>(tensor22, pindex);
241 return make_shared<FutureTensor>(*Gamma92, task22);
242 }
243
Gamma95_()244 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma95_() {
245 vector<IndexRange> Gamma95_index = {active_, active_, active_, active_, active_, active_, active_, active_};
246 auto Gamma95 = make_shared<Tensor>(Gamma95_index);
247 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
248 auto tensor23 = vector<shared_ptr<Tensor>>{Gamma95, rdm2_, rdm3_, rdm4_};
249 auto task23 = make_shared<Task23>(tensor23, pindex);
250 return make_shared<FutureTensor>(*Gamma95, task23);
251 }
252
Gamma98_()253 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma98_() {
254 vector<IndexRange> Gamma98_index = {active_, active_, active_, active_, active_, active_};
255 auto Gamma98 = make_shared<Tensor>(Gamma98_index);
256 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
257 auto tensor24 = vector<shared_ptr<Tensor>>{Gamma98, rdm1_, rdm2_, rdm3_};
258 auto task24 = make_shared<Task24>(tensor24, pindex);
259 return make_shared<FutureTensor>(*Gamma98, task24);
260 }
261
Gamma414_()262 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma414_() {
263 vector<IndexRange> Gamma414_index = {active_, active_, active_, active_, active_, active_};
264 auto Gamma414 = make_shared<Tensor>(Gamma414_index);
265 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
266 auto tensor25 = vector<shared_ptr<Tensor>>{Gamma414, rdm1_, rdm2_, rdm3_, rdm4_, h1_};
267 auto task25 = make_shared<Task25>(tensor25, pindex);
268 return make_shared<FutureTensor>(*Gamma414, task25);
269 }
270
Gamma415_()271 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma415_() {
272 vector<IndexRange> Gamma415_index = {active_, active_, active_, active_, active_, active_};
273 auto Gamma415 = make_shared<Tensor>(Gamma415_index);
274 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
275 auto tensor26 = vector<shared_ptr<Tensor>>{Gamma415, rdm1_, rdm2_, rdm3_, rdm4_, v2_};
276 auto task26 = make_shared<Task26>(tensor26, pindex);
277 return make_shared<FutureTensor>(*Gamma415, task26);
278 }
279
Gamma9_()280 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma9_() {
281 vector<IndexRange> Gamma9_index = {active_, active_, active_, active_};
282 auto Gamma9 = make_shared<Tensor>(Gamma9_index);
283 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
284 auto tensor27 = vector<shared_ptr<Tensor>>{Gamma9, rdm1_, rdm2_};
285 auto task27 = make_shared<Task27>(tensor27, pindex);
286 return make_shared<FutureTensor>(*Gamma9, task27);
287 }
288
Gamma11_()289 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma11_() {
290 vector<IndexRange> Gamma11_index = {active_, active_};
291 auto Gamma11 = make_shared<Tensor>(Gamma11_index);
292 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
293 auto tensor28 = vector<shared_ptr<Tensor>>{Gamma11, rdm0_, rdm1_};
294 auto task28 = make_shared<Task28>(tensor28, pindex);
295 return make_shared<FutureTensor>(*Gamma11, task28);
296 }
297
Gamma160_()298 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma160_() {
299 vector<IndexRange> Gamma160_index = {active_, active_, active_, active_};
300 auto Gamma160 = make_shared<Tensor>(Gamma160_index);
301 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
302 auto tensor29 = vector<shared_ptr<Tensor>>{Gamma160, rdm0_, rdm1_, rdm2_};
303 auto task29 = make_shared<Task29>(tensor29, pindex);
304 return make_shared<FutureTensor>(*Gamma160, task29);
305 }
306
Gamma99_()307 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma99_() {
308 vector<IndexRange> Gamma99_index = {active_, active_, active_, active_, active_, active_};
309 auto Gamma99 = make_shared<Tensor>(Gamma99_index);
310 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
311 auto tensor30 = vector<shared_ptr<Tensor>>{Gamma99, rdm0_, rdm1_, rdm2_, rdm3_};
312 auto task30 = make_shared<Task30>(tensor30, pindex);
313 return make_shared<FutureTensor>(*Gamma99, task30);
314 }
315
Gamma105_()316 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma105_() {
317 vector<IndexRange> Gamma105_index = {active_, active_, active_, active_, active_, active_};
318 auto Gamma105 = make_shared<Tensor>(Gamma105_index);
319 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
320 auto tensor31 = vector<shared_ptr<Tensor>>{Gamma105, rdm1_, rdm2_, rdm3_};
321 auto task31 = make_shared<Task31>(tensor31, pindex);
322 return make_shared<FutureTensor>(*Gamma105, task31);
323 }
324
Gamma110_()325 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma110_() {
326 vector<IndexRange> Gamma110_index = {active_, active_, active_, active_, active_, active_};
327 auto Gamma110 = make_shared<Tensor>(Gamma110_index);
328 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
329 auto tensor32 = vector<shared_ptr<Tensor>>{Gamma110, rdm1_, rdm2_, rdm3_};
330 auto task32 = make_shared<Task32>(tensor32, pindex);
331 return make_shared<FutureTensor>(*Gamma110, task32);
332 }
333
Gamma128_()334 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma128_() {
335 vector<IndexRange> Gamma128_index = {active_, active_, active_, active_};
336 auto Gamma128 = make_shared<Tensor>(Gamma128_index);
337 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
338 auto tensor33 = vector<shared_ptr<Tensor>>{Gamma128, rdm0_, rdm1_, rdm2_};
339 auto task33 = make_shared<Task33>(tensor33, pindex);
340 return make_shared<FutureTensor>(*Gamma128, task33);
341 }
342
Gamma151_()343 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma151_() {
344 vector<IndexRange> Gamma151_index = {active_, active_, active_, active_, active_, active_};
345 auto Gamma151 = make_shared<Tensor>(Gamma151_index);
346 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
347 auto tensor34 = vector<shared_ptr<Tensor>>{Gamma151, rdm1_, rdm2_, rdm3_};
348 auto task34 = make_shared<Task34>(tensor34, pindex);
349 return make_shared<FutureTensor>(*Gamma151, task34);
350 }
351
Gamma159_()352 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma159_() {
353 vector<IndexRange> Gamma159_index = {active_, active_, active_, active_, active_, active_};
354 auto Gamma159 = make_shared<Tensor>(Gamma159_index);
355 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
356 auto tensor35 = vector<shared_ptr<Tensor>>{Gamma159, rdm2_, rdm3_};
357 auto task35 = make_shared<Task35>(tensor35, pindex);
358 return make_shared<FutureTensor>(*Gamma159, task35);
359 }
360
Gamma174_()361 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma174_() {
362 vector<IndexRange> Gamma174_index = {active_, active_, active_, active_};
363 auto Gamma174 = make_shared<Tensor>(Gamma174_index);
364 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
365 auto tensor36 = vector<shared_ptr<Tensor>>{Gamma174, rdm1_, rdm2_};
366 auto task36 = make_shared<Task36>(tensor36, pindex);
367 return make_shared<FutureTensor>(*Gamma174, task36);
368 }
369
Gamma416_()370 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma416_() {
371 vector<IndexRange> Gamma416_index = {active_, active_};
372 auto Gamma416 = make_shared<Tensor>(Gamma416_index);
373 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
374 auto tensor37 = vector<shared_ptr<Tensor>>{Gamma416, rdm0_, rdm1_, rdm2_, h1_};
375 auto task37 = make_shared<Task37>(tensor37, pindex);
376 return make_shared<FutureTensor>(*Gamma416, task37);
377 }
378
Gamma418_()379 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma418_() {
380 vector<IndexRange> Gamma418_index = {active_, active_};
381 auto Gamma418 = make_shared<Tensor>(Gamma418_index);
382 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
383 auto tensor38 = vector<shared_ptr<Tensor>>{Gamma418, rdm0_, rdm1_, rdm2_, rdm3_, v2_};
384 auto task38 = make_shared<Task38>(tensor38, pindex);
385 return make_shared<FutureTensor>(*Gamma418, task38);
386 }
387
Gamma24_()388 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma24_() {
389 vector<IndexRange> Gamma24_index = {active_, active_, active_, active_};
390 auto Gamma24 = make_shared<Tensor>(Gamma24_index);
391 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
392 auto tensor39 = vector<shared_ptr<Tensor>>{Gamma24, rdm1_, rdm2_};
393 auto task39 = make_shared<Task39>(tensor39, pindex);
394 return make_shared<FutureTensor>(*Gamma24, task39);
395 }
396
Gamma26_()397 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma26_() {
398 vector<IndexRange> Gamma26_index = {active_, active_, active_, active_, active_, active_};
399 auto Gamma26 = make_shared<Tensor>(Gamma26_index);
400 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
401 auto tensor40 = vector<shared_ptr<Tensor>>{Gamma26, rdm2_, rdm3_};
402 auto task40 = make_shared<Task40>(tensor40, pindex);
403 return make_shared<FutureTensor>(*Gamma26, task40);
404 }
405
Gamma27_()406 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma27_() {
407 vector<IndexRange> Gamma27_index = {active_, active_};
408 auto Gamma27 = make_shared<Tensor>(Gamma27_index);
409 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
410 auto tensor41 = vector<shared_ptr<Tensor>>{Gamma27, rdm1_};
411 auto task41 = make_shared<Task41>(tensor41, pindex);
412 return make_shared<FutureTensor>(*Gamma27, task41);
413 }
414
Gamma179_()415 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma179_() {
416 vector<IndexRange> Gamma179_index = {active_, active_, active_, active_, active_, active_, active_, active_};
417 auto Gamma179 = make_shared<Tensor>(Gamma179_index);
418 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
419 auto tensor42 = vector<shared_ptr<Tensor>>{Gamma179, rdm1_, rdm2_, rdm3_, rdm4_};
420 auto task42 = make_shared<Task42>(tensor42, pindex);
421 return make_shared<FutureTensor>(*Gamma179, task42);
422 }
423
Gamma183_()424 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma183_() {
425 vector<IndexRange> Gamma183_index = {active_, active_, active_, active_, active_, active_};
426 auto Gamma183 = make_shared<Tensor>(Gamma183_index);
427 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
428 auto tensor43 = vector<shared_ptr<Tensor>>{Gamma183, rdm1_, rdm2_, rdm3_};
429 auto task43 = make_shared<Task43>(tensor43, pindex);
430 return make_shared<FutureTensor>(*Gamma183, task43);
431 }
432
Gamma193_()433 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma193_() {
434 vector<IndexRange> Gamma193_index = {active_, active_, active_, active_, active_, active_};
435 auto Gamma193 = make_shared<Tensor>(Gamma193_index);
436 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
437 auto tensor44 = vector<shared_ptr<Tensor>>{Gamma193, rdm1_, rdm2_, rdm3_};
438 auto task44 = make_shared<Task44>(tensor44, pindex);
439 return make_shared<FutureTensor>(*Gamma193, task44);
440 }
441
Gamma203_()442 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma203_() {
443 vector<IndexRange> Gamma203_index = {active_, active_, active_, active_, active_, active_, active_, active_};
444 auto Gamma203 = make_shared<Tensor>(Gamma203_index);
445 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
446 auto tensor45 = vector<shared_ptr<Tensor>>{Gamma203, rdm2_, rdm3_, rdm4_};
447 auto task45 = make_shared<Task45>(tensor45, pindex);
448 return make_shared<FutureTensor>(*Gamma203, task45);
449 }
450
Gamma204_()451 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma204_() {
452 vector<IndexRange> Gamma204_index = {active_, active_, active_, active_, active_, active_, active_, active_};
453 auto Gamma204 = make_shared<Tensor>(Gamma204_index);
454 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
455 auto tensor46 = vector<shared_ptr<Tensor>>{Gamma204, rdm2_, rdm3_, rdm4_};
456 auto task46 = make_shared<Task46>(tensor46, pindex);
457 return make_shared<FutureTensor>(*Gamma204, task46);
458 }
459
Gamma229_()460 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma229_() {
461 vector<IndexRange> Gamma229_index = {active_, active_, active_, active_, active_, active_};
462 auto Gamma229 = make_shared<Tensor>(Gamma229_index);
463 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
464 auto tensor47 = vector<shared_ptr<Tensor>>{Gamma229, rdm2_, rdm3_};
465 auto task47 = make_shared<Task47>(tensor47, pindex);
466 return make_shared<FutureTensor>(*Gamma229, task47);
467 }
468
Gamma420_()469 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma420_() {
470 vector<IndexRange> Gamma420_index = {active_, active_, active_, active_};
471 auto Gamma420 = make_shared<Tensor>(Gamma420_index);
472 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
473 auto tensor48 = vector<shared_ptr<Tensor>>{Gamma420, rdm1_, rdm2_, rdm3_, h1_};
474 auto task48 = make_shared<Task48>(tensor48, pindex);
475 return make_shared<FutureTensor>(*Gamma420, task48);
476 }
477
Gamma421_()478 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma421_() {
479 vector<IndexRange> Gamma421_index = {active_, active_, active_, active_};
480 auto Gamma421 = make_shared<Tensor>(Gamma421_index);
481 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
482 auto tensor49 = vector<shared_ptr<Tensor>>{Gamma421, rdm1_, rdm2_, rdm3_, rdm4_, v2_};
483 auto task49 = make_shared<Task49>(tensor49, pindex);
484 return make_shared<FutureTensor>(*Gamma421, task49);
485 }
486
Gamma31_()487 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma31_() {
488 vector<IndexRange> Gamma31_index = {active_, active_, active_, active_, active_, active_};
489 auto Gamma31 = make_shared<Tensor>(Gamma31_index);
490 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
491 auto tensor50 = vector<shared_ptr<Tensor>>{Gamma31, rdm2_, rdm3_};
492 auto task50 = make_shared<Task50>(tensor50, pindex);
493 return make_shared<FutureTensor>(*Gamma31, task50);
494 }
495
Gamma32_()496 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma32_() {
497 vector<IndexRange> Gamma32_index = {active_, active_, active_, active_, active_, active_};
498 auto Gamma32 = make_shared<Tensor>(Gamma32_index);
499 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
500 auto tensor51 = vector<shared_ptr<Tensor>>{Gamma32, rdm2_, rdm3_};
501 auto task51 = make_shared<Task51>(tensor51, pindex);
502 return make_shared<FutureTensor>(*Gamma32, task51);
503 }
504
Gamma33_()505 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma33_() {
506 vector<IndexRange> Gamma33_index = {active_, active_, active_, active_};
507 auto Gamma33 = make_shared<Tensor>(Gamma33_index);
508 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
509 auto tensor52 = vector<shared_ptr<Tensor>>{Gamma33, rdm2_};
510 auto task52 = make_shared<Task52>(tensor52, pindex);
511 return make_shared<FutureTensor>(*Gamma33, task52);
512 }
513
Gamma230_()514 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma230_() {
515 vector<IndexRange> Gamma230_index = {active_, active_, active_, active_, active_, active_, active_, active_};
516 auto Gamma230 = make_shared<Tensor>(Gamma230_index);
517 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
518 auto tensor53 = vector<shared_ptr<Tensor>>{Gamma230, rdm2_, rdm3_, rdm4_};
519 auto task53 = make_shared<Task53>(tensor53, pindex);
520 return make_shared<FutureTensor>(*Gamma230, task53);
521 }
522
Gamma231_()523 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma231_() {
524 vector<IndexRange> Gamma231_index = {active_, active_, active_, active_, active_, active_};
525 auto Gamma231 = make_shared<Tensor>(Gamma231_index);
526 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
527 auto tensor54 = vector<shared_ptr<Tensor>>{Gamma231, rdm2_, rdm3_};
528 auto task54 = make_shared<Task54>(tensor54, pindex);
529 return make_shared<FutureTensor>(*Gamma231, task54);
530 }
531
Gamma232_()532 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma232_() {
533 vector<IndexRange> Gamma232_index = {active_, active_, active_, active_, active_, active_, active_, active_};
534 auto Gamma232 = make_shared<Tensor>(Gamma232_index);
535 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
536 auto tensor55 = vector<shared_ptr<Tensor>>{Gamma232, rdm2_, rdm3_, rdm4_};
537 auto task55 = make_shared<Task55>(tensor55, pindex);
538 return make_shared<FutureTensor>(*Gamma232, task55);
539 }
540
Gamma233_()541 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma233_() {
542 vector<IndexRange> Gamma233_index = {active_, active_, active_, active_, active_, active_, active_, active_};
543 auto Gamma233 = make_shared<Tensor>(Gamma233_index);
544 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
545 auto tensor56 = vector<shared_ptr<Tensor>>{Gamma233, rdm2_, rdm3_, rdm4_};
546 auto task56 = make_shared<Task56>(tensor56, pindex);
547 return make_shared<FutureTensor>(*Gamma233, task56);
548 }
549
Gamma236_()550 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma236_() {
551 vector<IndexRange> Gamma236_index = {active_, active_, active_, active_, active_, active_, active_, active_};
552 auto Gamma236 = make_shared<Tensor>(Gamma236_index);
553 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
554 auto tensor57 = vector<shared_ptr<Tensor>>{Gamma236, rdm2_, rdm3_, rdm4_};
555 auto task57 = make_shared<Task57>(tensor57, pindex);
556 return make_shared<FutureTensor>(*Gamma236, task57);
557 }
558
Gamma237_()559 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma237_() {
560 vector<IndexRange> Gamma237_index = {active_, active_, active_, active_, active_, active_, active_, active_};
561 auto Gamma237 = make_shared<Tensor>(Gamma237_index);
562 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
563 auto tensor58 = vector<shared_ptr<Tensor>>{Gamma237, rdm2_, rdm3_, rdm4_};
564 auto task58 = make_shared<Task58>(tensor58, pindex);
565 return make_shared<FutureTensor>(*Gamma237, task58);
566 }
567
Gamma238_()568 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma238_() {
569 vector<IndexRange> Gamma238_index = {active_, active_, active_, active_, active_, active_, active_, active_};
570 auto Gamma238 = make_shared<Tensor>(Gamma238_index);
571 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
572 auto tensor59 = vector<shared_ptr<Tensor>>{Gamma238, rdm2_, rdm3_, rdm4_};
573 auto task59 = make_shared<Task59>(tensor59, pindex);
574 return make_shared<FutureTensor>(*Gamma238, task59);
575 }
576
Gamma245_()577 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma245_() {
578 vector<IndexRange> Gamma245_index = {active_, active_, active_, active_, active_, active_};
579 auto Gamma245 = make_shared<Tensor>(Gamma245_index);
580 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
581 auto tensor60 = vector<shared_ptr<Tensor>>{Gamma245, rdm2_, rdm3_};
582 auto task60 = make_shared<Task60>(tensor60, pindex);
583 return make_shared<FutureTensor>(*Gamma245, task60);
584 }
585
Gamma246_()586 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma246_() {
587 vector<IndexRange> Gamma246_index = {active_, active_, active_, active_, active_, active_};
588 auto Gamma246 = make_shared<Tensor>(Gamma246_index);
589 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
590 auto tensor61 = vector<shared_ptr<Tensor>>{Gamma246, rdm2_, rdm3_};
591 auto task61 = make_shared<Task61>(tensor61, pindex);
592 return make_shared<FutureTensor>(*Gamma246, task61);
593 }
594
Gamma253_()595 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma253_() {
596 vector<IndexRange> Gamma253_index = {active_, active_, active_, active_, active_, active_, active_, active_};
597 auto Gamma253 = make_shared<Tensor>(Gamma253_index);
598 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
599 auto tensor62 = vector<shared_ptr<Tensor>>{Gamma253, rdm3_, rdm4_};
600 auto task62 = make_shared<Task62>(tensor62, pindex);
601 return make_shared<FutureTensor>(*Gamma253, task62);
602 }
603
Gamma422_()604 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma422_() {
605 vector<IndexRange> Gamma422_index = {active_, active_, active_, active_, active_, active_};
606 auto Gamma422 = make_shared<Tensor>(Gamma422_index);
607 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
608 auto tensor63 = vector<shared_ptr<Tensor>>{Gamma422, rdm2_, rdm3_, rdm4_, h1_};
609 auto task63 = make_shared<Task63>(tensor63, pindex);
610 return make_shared<FutureTensor>(*Gamma422, task63);
611 }
612
Gamma423_()613 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma423_() {
614 vector<IndexRange> Gamma423_index = {active_, active_, active_, active_, active_, active_};
615 auto Gamma423 = make_shared<Tensor>(Gamma423_index);
616 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
617 auto tensor64 = vector<shared_ptr<Tensor>>{Gamma423, rdm2_, rdm3_, rdm4_, v2_};
618 auto task64 = make_shared<Task64>(tensor64, pindex);
619 return make_shared<FutureTensor>(*Gamma423, task64);
620 }
621
Gamma317_()622 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma317_() {
623 vector<IndexRange> Gamma317_index = {active_, active_, active_, active_, active_, active_};
624 auto Gamma317 = make_shared<Tensor>(Gamma317_index);
625 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
626 auto tensor65 = vector<shared_ptr<Tensor>>{Gamma317, rdm1_, rdm2_, rdm3_};
627 auto task65 = make_shared<Task65>(tensor65, pindex);
628 return make_shared<FutureTensor>(*Gamma317, task65);
629 }
630
Gamma318_()631 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma318_() {
632 vector<IndexRange> Gamma318_index = {active_, active_, active_, active_};
633 auto Gamma318 = make_shared<Tensor>(Gamma318_index);
634 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
635 auto tensor66 = vector<shared_ptr<Tensor>>{Gamma318, rdm1_, rdm2_};
636 auto task66 = make_shared<Task66>(tensor66, pindex);
637 return make_shared<FutureTensor>(*Gamma318, task66);
638 }
639
Gamma335_()640 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma335_() {
641 vector<IndexRange> Gamma335_index = {active_, active_, active_, active_, active_, active_};
642 auto Gamma335 = make_shared<Tensor>(Gamma335_index);
643 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
644 auto tensor67 = vector<shared_ptr<Tensor>>{Gamma335, rdm2_, rdm3_};
645 auto task67 = make_shared<Task67>(tensor67, pindex);
646 return make_shared<FutureTensor>(*Gamma335, task67);
647 }
648
Gamma336_()649 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma336_() {
650 vector<IndexRange> Gamma336_index = {active_, active_, active_, active_, active_, active_};
651 auto Gamma336 = make_shared<Tensor>(Gamma336_index);
652 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
653 auto tensor68 = vector<shared_ptr<Tensor>>{Gamma336, rdm2_, rdm3_};
654 auto task68 = make_shared<Task68>(tensor68, pindex);
655 return make_shared<FutureTensor>(*Gamma336, task68);
656 }
657
Gamma368_()658 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma368_() {
659 vector<IndexRange> Gamma368_index = {active_, active_, active_, active_};
660 auto Gamma368 = make_shared<Tensor>(Gamma368_index);
661 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
662 auto tensor69 = vector<shared_ptr<Tensor>>{Gamma368, rdm2_};
663 auto task69 = make_shared<Task69>(tensor69, pindex);
664 return make_shared<FutureTensor>(*Gamma368, task69);
665 }
666
Gamma363_()667 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma363_() {
668 vector<IndexRange> Gamma363_index = {active_, active_, active_, active_};
669 auto Gamma363 = make_shared<Tensor>(Gamma363_index);
670 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
671 auto tensor70 = vector<shared_ptr<Tensor>>{Gamma363, rdm1_, rdm2_};
672 auto task70 = make_shared<Task70>(tensor70, pindex);
673 return make_shared<FutureTensor>(*Gamma363, task70);
674 }
675
Gamma391_()676 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma391_() {
677 vector<IndexRange> Gamma391_index = {active_, active_, active_, active_, active_, active_};
678 auto Gamma391 = make_shared<Tensor>(Gamma391_index);
679 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
680 auto tensor71 = vector<shared_ptr<Tensor>>{Gamma391, rdm3_};
681 auto task71 = make_shared<Task71>(tensor71, pindex);
682 return make_shared<FutureTensor>(*Gamma391, task71);
683 }
684
Gamma428_()685 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma428_() {
686 vector<IndexRange> Gamma428_index = {active_, active_};
687 auto Gamma428 = make_shared<Tensor>(Gamma428_index);
688 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
689 auto tensor72 = vector<shared_ptr<Tensor>>{Gamma428, rdm1_, rdm2_, h1_};
690 auto task72 = make_shared<Task72>(tensor72, pindex);
691 return make_shared<FutureTensor>(*Gamma428, task72);
692 }
693
Gamma430_()694 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma430_() {
695 vector<IndexRange> Gamma430_index = {active_, active_};
696 auto Gamma430 = make_shared<Tensor>(Gamma430_index);
697 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
698 auto tensor73 = vector<shared_ptr<Tensor>>{Gamma430, rdm1_, rdm2_, rdm3_, v2_};
699 auto task73 = make_shared<Task73>(tensor73, pindex);
700 return make_shared<FutureTensor>(*Gamma430, task73);
701 }
702
Gamma396_()703 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma396_() {
704 vector<IndexRange> Gamma396_index = {active_, active_, active_, active_, active_, active_};
705 auto Gamma396 = make_shared<Tensor>(Gamma396_index);
706 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
707 auto tensor74 = vector<shared_ptr<Tensor>>{Gamma396, rdm2_, rdm3_};
708 auto task74 = make_shared<Task74>(tensor74, pindex);
709 return make_shared<FutureTensor>(*Gamma396, task74);
710 }
711
Gamma397_()712 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma397_() {
713 vector<IndexRange> Gamma397_index = {active_, active_, active_, active_, active_, active_, active_, active_};
714 auto Gamma397 = make_shared<Tensor>(Gamma397_index);
715 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
716 auto tensor75 = vector<shared_ptr<Tensor>>{Gamma397, rdm3_, rdm4_};
717 auto task75 = make_shared<Task75>(tensor75, pindex);
718 return make_shared<FutureTensor>(*Gamma397, task75);
719 }
720
Gamma409_()721 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma409_() {
722 vector<IndexRange> Gamma409_index = {active_, active_, active_, active_, active_, active_};
723 auto Gamma409 = make_shared<Tensor>(Gamma409_index);
724 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
725 auto tensor76 = vector<shared_ptr<Tensor>>{Gamma409, rdm3_};
726 auto task76 = make_shared<Task76>(tensor76, pindex);
727 return make_shared<FutureTensor>(*Gamma409, task76);
728 }
729
Gamma412_()730 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma412_() {
731 vector<IndexRange> Gamma412_index = {active_, active_, active_, active_};
732 auto Gamma412 = make_shared<Tensor>(Gamma412_index);
733 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
734 auto tensor77 = vector<shared_ptr<Tensor>>{Gamma412, rdm0_, rdm1_, rdm2_, rdm3_, h1_};
735 auto task77 = make_shared<Task77>(tensor77, pindex);
736 return make_shared<FutureTensor>(*Gamma412, task77);
737 }
738
Gamma413_()739 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma413_() {
740 vector<IndexRange> Gamma413_index = {active_, active_, active_, active_};
741 auto Gamma413 = make_shared<Tensor>(Gamma413_index);
742 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
743 auto tensor78 = vector<shared_ptr<Tensor>>{Gamma413, rdm0_, rdm1_, rdm2_, rdm3_, rdm4_, v2_};
744 auto task78 = make_shared<Task78>(tensor78, pindex);
745 return make_shared<FutureTensor>(*Gamma413, task78);
746 }
747
Gamma424_()748 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma424_() {
749 vector<IndexRange> Gamma424_index;
750 auto Gamma424 = make_shared<Tensor>(Gamma424_index);
751 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
752 auto tensor79 = vector<shared_ptr<Tensor>>{Gamma424, rdm1_, h1_};
753 auto task79 = make_shared<Task79>(tensor79, pindex);
754 return make_shared<FutureTensor>(*Gamma424, task79);
755 }
756
Gamma426_()757 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma426_() {
758 vector<IndexRange> Gamma426_index;
759 auto Gamma426 = make_shared<Tensor>(Gamma426_index);
760 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
761 auto tensor80 = vector<shared_ptr<Tensor>>{Gamma426, rdm1_, rdm2_, v2_};
762 auto task80 = make_shared<Task80>(tensor80, pindex);
763 return make_shared<FutureTensor>(*Gamma426, task80);
764 }
765
Gamma432_()766 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma432_() {
767 vector<IndexRange> Gamma432_index = {active_, active_, active_, active_};
768 auto Gamma432 = make_shared<Tensor>(Gamma432_index);
769 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
770 auto tensor81 = vector<shared_ptr<Tensor>>{Gamma432, rdm2_, rdm3_, h1_};
771 auto task81 = make_shared<Task81>(tensor81, pindex);
772 return make_shared<FutureTensor>(*Gamma432, task81);
773 }
774
Gamma433_()775 shared_ptr<FutureTensor> RelMRCI::RelMRCI::Gamma433_() {
776 vector<IndexRange> Gamma433_index = {active_, active_, active_, active_};
777 auto Gamma433 = make_shared<Tensor>(Gamma433_index);
778 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
779 auto tensor82 = vector<shared_ptr<Tensor>>{Gamma433, rdm2_, rdm3_, rdm4_, v2_};
780 auto task82 = make_shared<Task82>(tensor82, pindex);
781 return make_shared<FutureTensor>(*Gamma433, task82);
782 }
783
784 #endif
785