1 //
2 // BAGEL - Brilliantly Advanced General Electronic Structure Library
3 // Filename: RelCASA_residualqq.cc
4 // Copyright (C) 2014 Toru Shiozaki
5 //
6 // Author: Toru Shiozaki <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 #include <bagel_config.h>
26 #ifdef COMPILE_SMITH
27
28
29 #include <src/smith/relcasa/RelCASA.h>
30 #include <src/smith/relcasa/RelCASA_tasks.h>
31
32 using namespace std;
33 using namespace bagel;
34 using namespace bagel::SMITH;
35
make_residualq(const bool reset,const bool diagonal)36 shared_ptr<Queue> RelCASA::RelCASA::make_residualq(const bool reset, const bool diagonal) {
37
38 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
39 auto residualq = make_shared<Queue>();
40 auto tensor40 = vector<shared_ptr<Tensor>>{r};
41 auto task40 = make_shared<Task40>(tensor40, reset);
42 residualq->add_task(task40);
43
44 vector<IndexRange> I0_index = {closed_, active_, active_, closed_};
45 auto I0 = make_shared<Tensor>(I0_index);
46 auto tensor41 = vector<shared_ptr<Tensor>>{r, I0};
47 auto task41 = make_shared<Task41>(tensor41, pindex);
48 task41->add_dep(task40);
49 residualq->add_task(task41);
50
51 vector<IndexRange> I1_index = {closed_, closed_, active_, active_};
52 auto I1 = make_shared<Tensor>(I1_index);
53 auto tensor42 = vector<shared_ptr<Tensor>>{I0, f1_, I1};
54 auto task42 = make_shared<Task42>(tensor42, pindex);
55 task41->add_dep(task42);
56 task42->add_dep(task40);
57 residualq->add_task(task42);
58
59 auto tensor43 = vector<shared_ptr<Tensor>>{I1, Gamma0_(), t2};
60 auto task43 = make_shared<Task43>(tensor43, pindex);
61 task42->add_dep(task43);
62 task43->add_dep(task40);
63 residualq->add_task(task43);
64
65 vector<IndexRange> I4_index = {closed_, active_, active_, active_};
66 auto I4 = make_shared<Tensor>(I4_index);
67 auto tensor44 = vector<shared_ptr<Tensor>>{I0, f1_, I4};
68 auto task44 = make_shared<Task44>(tensor44, pindex);
69 task41->add_dep(task44);
70 task44->add_dep(task40);
71 residualq->add_task(task44);
72
73 auto tensor45 = vector<shared_ptr<Tensor>>{I4, Gamma1_(), t2};
74 auto task45 = make_shared<Task45>(tensor45, pindex);
75 task44->add_dep(task45);
76 task45->add_dep(task40);
77 residualq->add_task(task45);
78
79 vector<IndexRange> I7_index = {closed_, closed_, active_, active_};
80 auto I7 = make_shared<Tensor>(I7_index);
81 auto tensor46 = vector<shared_ptr<Tensor>>{I0, Gamma2_(), I7};
82 auto task46 = make_shared<Task46>(tensor46, pindex);
83 task41->add_dep(task46);
84 task46->add_dep(task40);
85 residualq->add_task(task46);
86
87 auto tensor47 = vector<shared_ptr<Tensor>>{I7, f1_, t2};
88 auto task47 = make_shared<Task47>(tensor47, pindex);
89 task46->add_dep(task47);
90 task47->add_dep(task40);
91 residualq->add_task(task47);
92
93 vector<IndexRange> I9_index = {active_, active_, active_, closed_};
94 auto I9 = make_shared<Tensor>(I9_index);
95 auto tensor48 = vector<shared_ptr<Tensor>>{r, I9};
96 auto task48 = make_shared<Task48>(tensor48, pindex);
97 task48->add_dep(task40);
98 residualq->add_task(task48);
99
100 vector<IndexRange> I10_index = {closed_, active_, active_, active_};
101 auto I10 = make_shared<Tensor>(I10_index);
102 auto tensor49 = vector<shared_ptr<Tensor>>{I9, f1_, I10};
103 auto task49 = make_shared<Task49>(tensor49, pindex);
104 task48->add_dep(task49);
105 task49->add_dep(task40);
106 residualq->add_task(task49);
107
108 auto tensor50 = vector<shared_ptr<Tensor>>{I10, Gamma3_(), t2};
109 auto task50 = make_shared<Task50>(tensor50, pindex);
110 task49->add_dep(task50);
111 task50->add_dep(task40);
112 residualq->add_task(task50);
113
114 vector<IndexRange> I13_index = {closed_, active_, active_, active_};
115 auto I13 = make_shared<Tensor>(I13_index);
116 auto tensor51 = vector<shared_ptr<Tensor>>{I9, Gamma4_(), I13};
117 auto task51 = make_shared<Task51>(tensor51, pindex);
118 task48->add_dep(task51);
119 task51->add_dep(task40);
120 residualq->add_task(task51);
121
122 auto tensor52 = vector<shared_ptr<Tensor>>{I13, f1_, t2};
123 auto task52 = make_shared<Task52>(tensor52, pindex);
124 task51->add_dep(task52);
125 task52->add_dep(task40);
126 residualq->add_task(task52);
127
128 vector<IndexRange> I16_index = {closed_, active_};
129 auto I16 = make_shared<Tensor>(I16_index);
130 auto tensor53 = vector<shared_ptr<Tensor>>{I9, Gamma5_(), I16};
131 auto task53 = make_shared<Task53>(tensor53, pindex);
132 task48->add_dep(task53);
133 task53->add_dep(task40);
134 residualq->add_task(task53);
135
136 vector<IndexRange> I17_index = {closed_, virt_, closed_, active_};
137 auto I17 = make_shared<Tensor>(I17_index);
138 auto tensor54 = vector<shared_ptr<Tensor>>{I16, f1_, I17};
139 auto task54 = make_shared<Task54>(tensor54, pindex);
140 task53->add_dep(task54);
141 task54->add_dep(task40);
142 residualq->add_task(task54);
143
144 auto tensor55 = vector<shared_ptr<Tensor>>{I17, t2};
145 auto task55 = make_shared<Task55>(tensor55, pindex);
146 task54->add_dep(task55);
147 task55->add_dep(task40);
148 residualq->add_task(task55);
149
150 vector<IndexRange> I22_index = {active_, closed_, active_, active_};
151 auto I22 = make_shared<Tensor>(I22_index);
152 auto tensor56 = vector<shared_ptr<Tensor>>{I9, Gamma7_(), I22};
153 auto task56 = make_shared<Task56>(tensor56, pindex);
154 task48->add_dep(task56);
155 task56->add_dep(task40);
156 residualq->add_task(task56);
157
158 auto tensor57 = vector<shared_ptr<Tensor>>{I22, f1_, t2};
159 auto task57 = make_shared<Task57>(tensor57, pindex);
160 task56->add_dep(task57);
161 task57->add_dep(task40);
162 residualq->add_task(task57);
163
164 vector<IndexRange> I25_index = {closed_, active_, active_, active_};
165 auto I25 = make_shared<Tensor>(I25_index);
166 auto tensor58 = vector<shared_ptr<Tensor>>{I9, Gamma3_(), I25};
167 auto task58 = make_shared<Task58>(tensor58, pindex);
168 task48->add_dep(task58);
169 task58->add_dep(task40);
170 residualq->add_task(task58);
171
172 auto tensor59 = vector<shared_ptr<Tensor>>{I25, t2};
173 auto task59 = make_shared<Task59>(tensor59, pindex, this->e0_);
174 task58->add_dep(task59);
175 task59->add_dep(task40);
176 residualq->add_task(task59);
177
178 auto tensor60 = vector<shared_ptr<Tensor>>{I25, f1_, t2};
179 auto task60 = make_shared<Task60>(tensor60, pindex);
180 task58->add_dep(task60);
181 task60->add_dep(task40);
182 residualq->add_task(task60);
183
184 auto tensor61 = vector<shared_ptr<Tensor>>{I9, Gamma94_(), t2};
185 auto task61 = make_shared<Task61>(tensor61, pindex);
186 task48->add_dep(task61);
187 task61->add_dep(task40);
188 residualq->add_task(task61);
189
190 auto tensor62 = vector<shared_ptr<Tensor>>{I9, Gamma95_(), t2};
191 auto task62 = make_shared<Task62>(tensor62, pindex);
192 task48->add_dep(task62);
193 task62->add_dep(task40);
194 residualq->add_task(task62);
195
196 vector<IndexRange> I27_index = {virt_, closed_, active_, closed_};
197 auto I27 = make_shared<Tensor>(I27_index);
198 auto tensor63 = vector<shared_ptr<Tensor>>{r, I27};
199 auto task63 = make_shared<Task63>(tensor63, pindex);
200 task63->add_dep(task40);
201 residualq->add_task(task63);
202
203 vector<IndexRange> I28_index = {closed_, virt_, closed_, active_};
204 auto I28 = make_shared<Tensor>(I28_index);
205 auto tensor64 = vector<shared_ptr<Tensor>>{I27, f1_, I28};
206 auto task64 = make_shared<Task64>(tensor64, pindex);
207 task63->add_dep(task64);
208 task64->add_dep(task40);
209 residualq->add_task(task64);
210
211 vector<IndexRange> I29_index = {closed_, virt_, closed_, active_};
212 auto I29 = make_shared<Tensor>(I29_index);
213 auto tensor65 = vector<shared_ptr<Tensor>>{I28, Gamma9_(), I29};
214 auto task65 = make_shared<Task65>(tensor65, pindex);
215 task64->add_dep(task65);
216 task65->add_dep(task40);
217 residualq->add_task(task65);
218
219 auto tensor66 = vector<shared_ptr<Tensor>>{I29, t2};
220 auto task66 = make_shared<Task66>(tensor66, pindex);
221 task65->add_dep(task66);
222 task66->add_dep(task40);
223 residualq->add_task(task66);
224
225 vector<IndexRange> I34_index = {closed_, virt_, closed_, active_};
226 auto I34 = make_shared<Tensor>(I34_index);
227 auto tensor67 = vector<shared_ptr<Tensor>>{I27, f1_, I34};
228 auto task67 = make_shared<Task67>(tensor67, pindex);
229 task63->add_dep(task67);
230 task67->add_dep(task40);
231 residualq->add_task(task67);
232
233 vector<IndexRange> I35_index = {closed_, virt_, closed_, active_};
234 auto I35 = make_shared<Tensor>(I35_index);
235 auto tensor68 = vector<shared_ptr<Tensor>>{I34, Gamma9_(), I35};
236 auto task68 = make_shared<Task68>(tensor68, pindex);
237 task67->add_dep(task68);
238 task68->add_dep(task40);
239 residualq->add_task(task68);
240
241 auto tensor69 = vector<shared_ptr<Tensor>>{I35, t2};
242 auto task69 = make_shared<Task69>(tensor69, pindex);
243 task68->add_dep(task69);
244 task69->add_dep(task40);
245 residualq->add_task(task69);
246
247 vector<IndexRange> I40_index = {virt_, closed_, active_, active_};
248 auto I40 = make_shared<Tensor>(I40_index);
249 auto tensor70 = vector<shared_ptr<Tensor>>{I27, f1_, I40};
250 auto task70 = make_shared<Task70>(tensor70, pindex);
251 task63->add_dep(task70);
252 task70->add_dep(task40);
253 residualq->add_task(task70);
254
255 auto tensor71 = vector<shared_ptr<Tensor>>{I40, Gamma13_(), t2};
256 auto task71 = make_shared<Task71>(tensor71, pindex);
257 task70->add_dep(task71);
258 task71->add_dep(task40);
259 residualq->add_task(task71);
260
261 auto tensor72 = vector<shared_ptr<Tensor>>{I40, Gamma15_(), t2};
262 auto task72 = make_shared<Task72>(tensor72, pindex);
263 task70->add_dep(task72);
264 task72->add_dep(task40);
265 residualq->add_task(task72);
266
267 vector<IndexRange> I43_index = {virt_, closed_, active_, active_};
268 auto I43 = make_shared<Tensor>(I43_index);
269 auto tensor73 = vector<shared_ptr<Tensor>>{I27, f1_, I43};
270 auto task73 = make_shared<Task73>(tensor73, pindex);
271 task63->add_dep(task73);
272 task73->add_dep(task40);
273 residualq->add_task(task73);
274
275 vector<IndexRange> I44_index = {active_, virt_, closed_, active_};
276 auto I44 = make_shared<Tensor>(I44_index);
277 auto tensor74 = vector<shared_ptr<Tensor>>{I43, Gamma15_(), I44};
278 auto task74 = make_shared<Task74>(tensor74, pindex);
279 task73->add_dep(task74);
280 task74->add_dep(task40);
281 residualq->add_task(task74);
282
283 auto tensor75 = vector<shared_ptr<Tensor>>{I44, t2};
284 auto task75 = make_shared<Task75>(tensor75, pindex);
285 task74->add_dep(task75);
286 task75->add_dep(task40);
287 residualq->add_task(task75);
288
289 vector<IndexRange> I52_index = {closed_, active_};
290 auto I52 = make_shared<Tensor>(I52_index);
291 auto tensor76 = vector<shared_ptr<Tensor>>{I27, f1_, I52};
292 auto task76 = make_shared<Task76>(tensor76, pindex);
293 task63->add_dep(task76);
294 task76->add_dep(task40);
295 residualq->add_task(task76);
296
297 auto tensor77 = vector<shared_ptr<Tensor>>{I52, Gamma15_(), t2};
298 auto task77 = make_shared<Task77>(tensor77, pindex);
299 task76->add_dep(task77);
300 task77->add_dep(task40);
301 residualq->add_task(task77);
302
303 vector<IndexRange> I55_index = {closed_, active_};
304 auto I55 = make_shared<Tensor>(I55_index);
305 auto tensor78 = vector<shared_ptr<Tensor>>{I27, f1_, I55};
306 auto task78 = make_shared<Task78>(tensor78, pindex);
307 task63->add_dep(task78);
308 task78->add_dep(task40);
309 residualq->add_task(task78);
310
311 auto tensor79 = vector<shared_ptr<Tensor>>{I55, Gamma15_(), t2};
312 auto task79 = make_shared<Task79>(tensor79, pindex);
313 task78->add_dep(task79);
314 task79->add_dep(task40);
315 residualq->add_task(task79);
316
317 vector<IndexRange> I58_index = {virt_, active_};
318 auto I58 = make_shared<Tensor>(I58_index);
319 auto tensor80 = vector<shared_ptr<Tensor>>{I27, t2, I58};
320 auto task80 = make_shared<Task80>(tensor80, pindex);
321 task63->add_dep(task80);
322 task80->add_dep(task40);
323 residualq->add_task(task80);
324
325 auto tensor81 = vector<shared_ptr<Tensor>>{I58, Gamma9_(), f1_};
326 auto task81 = make_shared<Task81>(tensor81, pindex);
327 task80->add_dep(task81);
328 task81->add_dep(task40);
329 residualq->add_task(task81);
330
331 vector<IndexRange> I61_index = {virt_, active_};
332 auto I61 = make_shared<Tensor>(I61_index);
333 auto tensor82 = vector<shared_ptr<Tensor>>{I27, t2, I61};
334 auto task82 = make_shared<Task82>(tensor82, pindex);
335 task63->add_dep(task82);
336 task82->add_dep(task40);
337 residualq->add_task(task82);
338
339 auto tensor83 = vector<shared_ptr<Tensor>>{I61, Gamma9_(), f1_};
340 auto task83 = make_shared<Task83>(tensor83, pindex);
341 task82->add_dep(task83);
342 task83->add_dep(task40);
343 residualq->add_task(task83);
344
345 vector<IndexRange> I64_index = {closed_, closed_, active_, active_};
346 auto I64 = make_shared<Tensor>(I64_index);
347 auto tensor84 = vector<shared_ptr<Tensor>>{I27, f1_, I64};
348 auto task84 = make_shared<Task84>(tensor84, pindex);
349 task63->add_dep(task84);
350 task84->add_dep(task40);
351 residualq->add_task(task84);
352
353 auto tensor85 = vector<shared_ptr<Tensor>>{I64, Gamma2_(), t2};
354 auto task85 = make_shared<Task85>(tensor85, pindex);
355 task84->add_dep(task85);
356 task85->add_dep(task40);
357 residualq->add_task(task85);
358
359 vector<IndexRange> I67_index = {closed_, virt_, closed_, active_};
360 auto I67 = make_shared<Tensor>(I67_index);
361 auto tensor86 = vector<shared_ptr<Tensor>>{I27, f1_, I67};
362 auto task86 = make_shared<Task86>(tensor86, pindex);
363 task63->add_dep(task86);
364 task86->add_dep(task40);
365 residualq->add_task(task86);
366
367 vector<IndexRange> I68_index = {closed_, virt_, closed_, active_};
368 auto I68 = make_shared<Tensor>(I68_index);
369 auto tensor87 = vector<shared_ptr<Tensor>>{I67, Gamma9_(), I68};
370 auto task87 = make_shared<Task87>(tensor87, pindex);
371 task86->add_dep(task87);
372 task87->add_dep(task40);
373 residualq->add_task(task87);
374
375 auto tensor88 = vector<shared_ptr<Tensor>>{I68, t2};
376 auto task88 = make_shared<Task88>(tensor88, pindex);
377 task87->add_dep(task88);
378 task88->add_dep(task40);
379 residualq->add_task(task88);
380
381 vector<IndexRange> I253_index = {closed_, virt_, closed_, active_};
382 auto I253 = make_shared<Tensor>(I253_index);
383 auto tensor89 = vector<shared_ptr<Tensor>>{I27, Gamma9_(), I253};
384 auto task89 = make_shared<Task89>(tensor89, pindex);
385 task63->add_dep(task89);
386 task89->add_dep(task40);
387 residualq->add_task(task89);
388
389 auto tensor90 = vector<shared_ptr<Tensor>>{I253, t2};
390 auto task90 = make_shared<Task90>(tensor90, pindex, this->e0_);
391 task89->add_dep(task90);
392 task90->add_dep(task40);
393 residualq->add_task(task90);
394
395 vector<IndexRange> I283_index = {closed_, virt_, closed_, active_};
396 auto I283 = make_shared<Tensor>(I283_index);
397 auto tensor91 = vector<shared_ptr<Tensor>>{I27, Gamma96_(), I283};
398 auto task91 = make_shared<Task91>(tensor91, pindex);
399 task63->add_dep(task91);
400 task91->add_dep(task40);
401 residualq->add_task(task91);
402
403 auto tensor92 = vector<shared_ptr<Tensor>>{I283, t2};
404 auto task92 = make_shared<Task92>(tensor92, pindex);
405 task91->add_dep(task92);
406 task92->add_dep(task40);
407 residualq->add_task(task92);
408
409 vector<IndexRange> I287_index = {closed_, virt_, closed_, active_};
410 auto I287 = make_shared<Tensor>(I287_index);
411 auto tensor93 = vector<shared_ptr<Tensor>>{I27, Gamma98_(), I287};
412 auto task93 = make_shared<Task93>(tensor93, pindex);
413 task63->add_dep(task93);
414 task93->add_dep(task40);
415 residualq->add_task(task93);
416
417 auto tensor94 = vector<shared_ptr<Tensor>>{I287, t2};
418 auto task94 = make_shared<Task94>(tensor94, pindex);
419 task93->add_dep(task94);
420 task94->add_dep(task40);
421 residualq->add_task(task94);
422
423 vector<IndexRange> I72_index = {virt_, active_, active_, closed_};
424 auto I72 = make_shared<Tensor>(I72_index);
425 auto tensor95 = vector<shared_ptr<Tensor>>{r, I72};
426 auto task95 = make_shared<Task95>(tensor95, pindex);
427 task95->add_dep(task40);
428 residualq->add_task(task95);
429
430 vector<IndexRange> I73_index = {virt_, closed_, active_, active_};
431 auto I73 = make_shared<Tensor>(I73_index);
432 auto tensor96 = vector<shared_ptr<Tensor>>{I72, f1_, I73};
433 auto task96 = make_shared<Task96>(tensor96, pindex);
434 task95->add_dep(task96);
435 task96->add_dep(task40);
436 residualq->add_task(task96);
437
438 auto tensor97 = vector<shared_ptr<Tensor>>{I73, Gamma24_(), t2};
439 auto task97 = make_shared<Task97>(tensor97, pindex);
440 task96->add_dep(task97);
441 task97->add_dep(task40);
442 residualq->add_task(task97);
443
444 auto tensor98 = vector<shared_ptr<Tensor>>{I73, Gamma25_(), t2};
445 auto task98 = make_shared<Task98>(tensor98, pindex);
446 task96->add_dep(task98);
447 task98->add_dep(task40);
448 residualq->add_task(task98);
449
450 vector<IndexRange> I79_index = {virt_, closed_, active_, active_};
451 auto I79 = make_shared<Tensor>(I79_index);
452 auto tensor99 = vector<shared_ptr<Tensor>>{I72, Gamma26_(), I79};
453 auto task99 = make_shared<Task99>(tensor99, pindex);
454 task95->add_dep(task99);
455 task99->add_dep(task40);
456 residualq->add_task(task99);
457
458 auto tensor100 = vector<shared_ptr<Tensor>>{I79, f1_, t2};
459 auto task100 = make_shared<Task100>(tensor100, pindex);
460 task99->add_dep(task100);
461 task100->add_dep(task40);
462 residualq->add_task(task100);
463
464 vector<IndexRange> I82_index = {closed_, virt_, active_, active_};
465 auto I82 = make_shared<Tensor>(I82_index);
466 auto tensor101 = vector<shared_ptr<Tensor>>{I72, Gamma5_(), I82};
467 auto task101 = make_shared<Task101>(tensor101, pindex);
468 task95->add_dep(task101);
469 task101->add_dep(task40);
470 residualq->add_task(task101);
471
472 auto tensor102 = vector<shared_ptr<Tensor>>{I82, f1_, t2};
473 auto task102 = make_shared<Task102>(tensor102, pindex);
474 task101->add_dep(task102);
475 task102->add_dep(task40);
476 residualq->add_task(task102);
477
478 vector<IndexRange> I85_index = {virt_, active_, active_, active_};
479 auto I85 = make_shared<Tensor>(I85_index);
480 auto tensor103 = vector<shared_ptr<Tensor>>{I72, f1_, I85};
481 auto task103 = make_shared<Task103>(tensor103, pindex);
482 task95->add_dep(task103);
483 task103->add_dep(task40);
484 residualq->add_task(task103);
485
486 auto tensor104 = vector<shared_ptr<Tensor>>{I85, Gamma28_(), t2};
487 auto task104 = make_shared<Task104>(tensor104, pindex);
488 task103->add_dep(task104);
489 task104->add_dep(task40);
490 residualq->add_task(task104);
491
492 vector<IndexRange> I88_index = {closed_, virt_};
493 auto I88 = make_shared<Tensor>(I88_index);
494 auto tensor105 = vector<shared_ptr<Tensor>>{I72, Gamma29_(), I88};
495 auto task105 = make_shared<Task105>(tensor105, pindex);
496 task95->add_dep(task105);
497 task105->add_dep(task40);
498 residualq->add_task(task105);
499
500 vector<IndexRange> I89_index = {closed_, virt_, closed_, virt_};
501 auto I89 = make_shared<Tensor>(I89_index);
502 auto tensor106 = vector<shared_ptr<Tensor>>{I88, f1_, I89};
503 auto task106 = make_shared<Task106>(tensor106, pindex);
504 task105->add_dep(task106);
505 task106->add_dep(task40);
506 residualq->add_task(task106);
507
508 auto tensor107 = vector<shared_ptr<Tensor>>{I89, t2};
509 auto task107 = make_shared<Task107>(tensor107, pindex);
510 task106->add_dep(task107);
511 task107->add_dep(task40);
512 residualq->add_task(task107);
513
514 vector<IndexRange> I94_index = {active_, closed_, virt_, active_};
515 auto I94 = make_shared<Tensor>(I94_index);
516 auto tensor108 = vector<shared_ptr<Tensor>>{I72, Gamma25_(), I94};
517 auto task108 = make_shared<Task108>(tensor108, pindex);
518 task95->add_dep(task108);
519 task108->add_dep(task40);
520 residualq->add_task(task108);
521
522 auto tensor109 = vector<shared_ptr<Tensor>>{I94, t2};
523 auto task109 = make_shared<Task109>(tensor109, pindex, this->e0_);
524 task108->add_dep(task109);
525 task109->add_dep(task40);
526 residualq->add_task(task109);
527
528 auto tensor110 = vector<shared_ptr<Tensor>>{I94, f1_, t2};
529 auto task110 = make_shared<Task110>(tensor110, pindex);
530 task108->add_dep(task110);
531 task110->add_dep(task40);
532 residualq->add_task(task110);
533
534 vector<IndexRange> I97_index = {active_, virt_, closed_, active_};
535 auto I97 = make_shared<Tensor>(I97_index);
536 auto tensor111 = vector<shared_ptr<Tensor>>{I72, Gamma24_(), I97};
537 auto task111 = make_shared<Task111>(tensor111, pindex);
538 task95->add_dep(task111);
539 task111->add_dep(task40);
540 residualq->add_task(task111);
541
542 auto tensor112 = vector<shared_ptr<Tensor>>{I97, t2};
543 auto task112 = make_shared<Task112>(tensor112, pindex, this->e0_);
544 task111->add_dep(task112);
545 task112->add_dep(task40);
546 residualq->add_task(task112);
547
548 auto tensor113 = vector<shared_ptr<Tensor>>{I97, f1_, t2};
549 auto task113 = make_shared<Task113>(tensor113, pindex);
550 task111->add_dep(task113);
551 task113->add_dep(task40);
552 residualq->add_task(task113);
553
554 vector<IndexRange> I100_index = {closed_, active_, active_, active_};
555 auto I100 = make_shared<Tensor>(I100_index);
556 auto tensor114 = vector<shared_ptr<Tensor>>{I72, f1_, I100};
557 auto task114 = make_shared<Task114>(tensor114, pindex);
558 task95->add_dep(task114);
559 task114->add_dep(task40);
560 residualq->add_task(task114);
561
562 auto tensor115 = vector<shared_ptr<Tensor>>{I100, Gamma33_(), t2};
563 auto task115 = make_shared<Task115>(tensor115, pindex);
564 task114->add_dep(task115);
565 task115->add_dep(task40);
566 residualq->add_task(task115);
567
568 vector<IndexRange> I103_index = {virt_, closed_, active_, active_};
569 auto I103 = make_shared<Tensor>(I103_index);
570 auto tensor116 = vector<shared_ptr<Tensor>>{I72, f1_, I103};
571 auto task116 = make_shared<Task116>(tensor116, pindex);
572 task95->add_dep(task116);
573 task116->add_dep(task40);
574 residualq->add_task(task116);
575
576 auto tensor117 = vector<shared_ptr<Tensor>>{I103, Gamma24_(), t2};
577 auto task117 = make_shared<Task117>(tensor117, pindex);
578 task116->add_dep(task117);
579 task117->add_dep(task40);
580 residualq->add_task(task117);
581
582 auto tensor118 = vector<shared_ptr<Tensor>>{I103, Gamma25_(), t2};
583 auto task118 = make_shared<Task118>(tensor118, pindex);
584 task116->add_dep(task118);
585 task118->add_dep(task40);
586 residualq->add_task(task118);
587
588 auto tensor119 = vector<shared_ptr<Tensor>>{I72, Gamma112_(), t2};
589 auto task119 = make_shared<Task119>(tensor119, pindex);
590 task95->add_dep(task119);
591 task119->add_dep(task40);
592 residualq->add_task(task119);
593
594 auto tensor120 = vector<shared_ptr<Tensor>>{I72, Gamma113_(), t2};
595 auto task120 = make_shared<Task120>(tensor120, pindex);
596 task95->add_dep(task120);
597 task120->add_dep(task40);
598 residualq->add_task(task120);
599
600 auto tensor121 = vector<shared_ptr<Tensor>>{I72, Gamma116_(), t2};
601 auto task121 = make_shared<Task121>(tensor121, pindex);
602 task95->add_dep(task121);
603 task121->add_dep(task40);
604 residualq->add_task(task121);
605
606 auto tensor122 = vector<shared_ptr<Tensor>>{I72, Gamma117_(), t2};
607 auto task122 = make_shared<Task122>(tensor122, pindex);
608 task95->add_dep(task122);
609 task122->add_dep(task40);
610 residualq->add_task(task122);
611
612 vector<IndexRange> I108_index = {virt_, active_, active_, closed_};
613 auto I108 = make_shared<Tensor>(I108_index);
614 auto tensor123 = vector<shared_ptr<Tensor>>{r, I108};
615 auto task123 = make_shared<Task123>(tensor123, pindex);
616 task123->add_dep(task40);
617 residualq->add_task(task123);
618
619 vector<IndexRange> I109_index = {virt_, closed_, active_, active_};
620 auto I109 = make_shared<Tensor>(I109_index);
621 auto tensor124 = vector<shared_ptr<Tensor>>{I108, f1_, I109};
622 auto task124 = make_shared<Task124>(tensor124, pindex);
623 task123->add_dep(task124);
624 task124->add_dep(task40);
625 residualq->add_task(task124);
626
627 vector<IndexRange> I110_index = {active_, virt_, closed_, active_};
628 auto I110 = make_shared<Tensor>(I110_index);
629 auto tensor125 = vector<shared_ptr<Tensor>>{I109, Gamma25_(), I110};
630 auto task125 = make_shared<Task125>(tensor125, pindex);
631 task124->add_dep(task125);
632 task125->add_dep(task40);
633 residualq->add_task(task125);
634
635 auto tensor126 = vector<shared_ptr<Tensor>>{I110, t2};
636 auto task126 = make_shared<Task126>(tensor126, pindex);
637 task125->add_dep(task126);
638 task126->add_dep(task40);
639 residualq->add_task(task126);
640
641 vector<IndexRange> I115_index = {virt_, closed_, active_, active_};
642 auto I115 = make_shared<Tensor>(I115_index);
643 auto tensor127 = vector<shared_ptr<Tensor>>{I108, Gamma5_(), I115};
644 auto task127 = make_shared<Task127>(tensor127, pindex);
645 task123->add_dep(task127);
646 task127->add_dep(task40);
647 residualq->add_task(task127);
648
649 vector<IndexRange> I116_index = {closed_, virt_, closed_, active_};
650 auto I116 = make_shared<Tensor>(I116_index);
651 auto tensor128 = vector<shared_ptr<Tensor>>{I115, f1_, I116};
652 auto task128 = make_shared<Task128>(tensor128, pindex);
653 task127->add_dep(task128);
654 task128->add_dep(task40);
655 residualq->add_task(task128);
656
657 auto tensor129 = vector<shared_ptr<Tensor>>{I116, t2};
658 auto task129 = make_shared<Task129>(tensor129, pindex);
659 task128->add_dep(task129);
660 task129->add_dep(task40);
661 residualq->add_task(task129);
662
663 vector<IndexRange> I121_index = {virt_, active_, active_, active_};
664 auto I121 = make_shared<Tensor>(I121_index);
665 auto tensor130 = vector<shared_ptr<Tensor>>{I108, f1_, I121};
666 auto task130 = make_shared<Task130>(tensor130, pindex);
667 task123->add_dep(task130);
668 task130->add_dep(task40);
669 residualq->add_task(task130);
670
671 auto tensor131 = vector<shared_ptr<Tensor>>{I121, Gamma40_(), t2};
672 auto task131 = make_shared<Task131>(tensor131, pindex);
673 task130->add_dep(task131);
674 task131->add_dep(task40);
675 residualq->add_task(task131);
676
677 vector<IndexRange> I124_index = {closed_, virt_};
678 auto I124 = make_shared<Tensor>(I124_index);
679 auto tensor132 = vector<shared_ptr<Tensor>>{I108, Gamma29_(), I124};
680 auto task132 = make_shared<Task132>(tensor132, pindex);
681 task123->add_dep(task132);
682 task132->add_dep(task40);
683 residualq->add_task(task132);
684
685 vector<IndexRange> I125_index = {closed_, virt_, closed_, virt_};
686 auto I125 = make_shared<Tensor>(I125_index);
687 auto tensor133 = vector<shared_ptr<Tensor>>{I124, f1_, I125};
688 auto task133 = make_shared<Task133>(tensor133, pindex);
689 task132->add_dep(task133);
690 task133->add_dep(task40);
691 residualq->add_task(task133);
692
693 auto tensor134 = vector<shared_ptr<Tensor>>{I125, t2};
694 auto task134 = make_shared<Task134>(tensor134, pindex);
695 task133->add_dep(task134);
696 task134->add_dep(task40);
697 residualq->add_task(task134);
698
699 vector<IndexRange> I130_index = {active_, closed_, virt_, active_};
700 auto I130 = make_shared<Tensor>(I130_index);
701 auto tensor135 = vector<shared_ptr<Tensor>>{I108, Gamma25_(), I130};
702 auto task135 = make_shared<Task135>(tensor135, pindex);
703 task123->add_dep(task135);
704 task135->add_dep(task40);
705 residualq->add_task(task135);
706
707 auto tensor136 = vector<shared_ptr<Tensor>>{I130, t2};
708 auto task136 = make_shared<Task136>(tensor136, pindex, this->e0_);
709 task135->add_dep(task136);
710 task136->add_dep(task40);
711 residualq->add_task(task136);
712
713 vector<IndexRange> I131_index = {active_, virt_, closed_, virt_};
714 auto I131 = make_shared<Tensor>(I131_index);
715 auto tensor137 = vector<shared_ptr<Tensor>>{I130, f1_, I131};
716 auto task137 = make_shared<Task137>(tensor137, pindex);
717 task135->add_dep(task137);
718 task137->add_dep(task40);
719 residualq->add_task(task137);
720
721 auto tensor138 = vector<shared_ptr<Tensor>>{I131, t2};
722 auto task138 = make_shared<Task138>(tensor138, pindex);
723 task137->add_dep(task138);
724 task138->add_dep(task40);
725 residualq->add_task(task138);
726
727 vector<IndexRange> I136_index = {closed_, active_, active_, active_};
728 auto I136 = make_shared<Tensor>(I136_index);
729 auto tensor139 = vector<shared_ptr<Tensor>>{I108, f1_, I136};
730 auto task139 = make_shared<Task139>(tensor139, pindex);
731 task123->add_dep(task139);
732 task139->add_dep(task40);
733 residualq->add_task(task139);
734
735 auto tensor140 = vector<shared_ptr<Tensor>>{I136, Gamma3_(), t2};
736 auto task140 = make_shared<Task140>(tensor140, pindex);
737 task139->add_dep(task140);
738 task140->add_dep(task40);
739 residualq->add_task(task140);
740
741 vector<IndexRange> I139_index = {virt_, closed_, active_, active_};
742 auto I139 = make_shared<Tensor>(I139_index);
743 auto tensor141 = vector<shared_ptr<Tensor>>{I108, f1_, I139};
744 auto task141 = make_shared<Task141>(tensor141, pindex);
745 task123->add_dep(task141);
746 task141->add_dep(task40);
747 residualq->add_task(task141);
748
749 vector<IndexRange> I140_index = {active_, virt_, closed_, active_};
750 auto I140 = make_shared<Tensor>(I140_index);
751 auto tensor142 = vector<shared_ptr<Tensor>>{I139, Gamma25_(), I140};
752 auto task142 = make_shared<Task142>(tensor142, pindex);
753 task141->add_dep(task142);
754 task142->add_dep(task40);
755 residualq->add_task(task142);
756
757 auto tensor143 = vector<shared_ptr<Tensor>>{I140, t2};
758 auto task143 = make_shared<Task143>(tensor143, pindex);
759 task142->add_dep(task143);
760 task143->add_dep(task40);
761 residualq->add_task(task143);
762
763 vector<IndexRange> I319_index = {active_, virt_, closed_, active_};
764 auto I319 = make_shared<Tensor>(I319_index);
765 auto tensor144 = vector<shared_ptr<Tensor>>{I108, Gamma113_(), I319};
766 auto task144 = make_shared<Task144>(tensor144, pindex);
767 task123->add_dep(task144);
768 task144->add_dep(task40);
769 residualq->add_task(task144);
770
771 auto tensor145 = vector<shared_ptr<Tensor>>{I319, t2};
772 auto task145 = make_shared<Task145>(tensor145, pindex);
773 task144->add_dep(task145);
774 task145->add_dep(task40);
775 residualq->add_task(task145);
776
777 vector<IndexRange> I327_index = {active_, virt_, closed_, active_};
778 auto I327 = make_shared<Tensor>(I327_index);
779 auto tensor146 = vector<shared_ptr<Tensor>>{I108, Gamma117_(), I327};
780 auto task146 = make_shared<Task146>(tensor146, pindex);
781 task123->add_dep(task146);
782 task146->add_dep(task40);
783 residualq->add_task(task146);
784
785 auto tensor147 = vector<shared_ptr<Tensor>>{I327, t2};
786 auto task147 = make_shared<Task147>(tensor147, pindex);
787 task146->add_dep(task147);
788 task147->add_dep(task40);
789 residualq->add_task(task147);
790
791 vector<IndexRange> I144_index = {virt_, active_, active_, active_};
792 auto I144 = make_shared<Tensor>(I144_index);
793 auto tensor148 = vector<shared_ptr<Tensor>>{r, I144};
794 auto task148 = make_shared<Task148>(tensor148, pindex);
795 task148->add_dep(task40);
796 residualq->add_task(task148);
797
798 vector<IndexRange> I145_index = {active_, virt_, active_, active_};
799 auto I145 = make_shared<Tensor>(I145_index);
800 auto tensor149 = vector<shared_ptr<Tensor>>{I144, Gamma48_(), I145};
801 auto task149 = make_shared<Task149>(tensor149, pindex);
802 task148->add_dep(task149);
803 task149->add_dep(task40);
804 residualq->add_task(task149);
805
806 auto tensor150 = vector<shared_ptr<Tensor>>{I145, f1_, t2};
807 auto task150 = make_shared<Task150>(tensor150, pindex);
808 task149->add_dep(task150);
809 task150->add_dep(task40);
810 residualq->add_task(task150);
811
812 vector<IndexRange> I148_index = {virt_, active_, active_, active_};
813 auto I148 = make_shared<Tensor>(I148_index);
814 auto tensor151 = vector<shared_ptr<Tensor>>{I144, Gamma49_(), I148};
815 auto task151 = make_shared<Task151>(tensor151, pindex);
816 task148->add_dep(task151);
817 task151->add_dep(task40);
818 residualq->add_task(task151);
819
820 auto tensor152 = vector<shared_ptr<Tensor>>{I148, f1_, t2};
821 auto task152 = make_shared<Task152>(tensor152, pindex);
822 task151->add_dep(task152);
823 task152->add_dep(task40);
824 residualq->add_task(task152);
825
826 vector<IndexRange> I151_index = {active_, virt_};
827 auto I151 = make_shared<Tensor>(I151_index);
828 auto tensor153 = vector<shared_ptr<Tensor>>{I144, Gamma50_(), I151};
829 auto task153 = make_shared<Task153>(tensor153, pindex);
830 task148->add_dep(task153);
831 task153->add_dep(task40);
832 residualq->add_task(task153);
833
834 vector<IndexRange> I152_index = {active_, virt_, closed_, virt_};
835 auto I152 = make_shared<Tensor>(I152_index);
836 auto tensor154 = vector<shared_ptr<Tensor>>{I151, f1_, I152};
837 auto task154 = make_shared<Task154>(tensor154, pindex);
838 task153->add_dep(task154);
839 task154->add_dep(task40);
840 residualq->add_task(task154);
841
842 auto tensor155 = vector<shared_ptr<Tensor>>{I152, t2};
843 auto task155 = make_shared<Task155>(tensor155, pindex);
844 task154->add_dep(task155);
845 task155->add_dep(task40);
846 residualq->add_task(task155);
847
848 vector<IndexRange> I157_index = {active_, virt_, active_, active_};
849 auto I157 = make_shared<Tensor>(I157_index);
850 auto tensor156 = vector<shared_ptr<Tensor>>{I144, Gamma52_(), I157};
851 auto task156 = make_shared<Task156>(tensor156, pindex);
852 task148->add_dep(task156);
853 task156->add_dep(task40);
854 residualq->add_task(task156);
855
856 auto tensor157 = vector<shared_ptr<Tensor>>{I157, t2};
857 auto task157 = make_shared<Task157>(tensor157, pindex, this->e0_);
858 task156->add_dep(task157);
859 task157->add_dep(task40);
860 residualq->add_task(task157);
861
862 auto tensor158 = vector<shared_ptr<Tensor>>{I157, f1_, t2};
863 auto task158 = make_shared<Task158>(tensor158, pindex);
864 task156->add_dep(task158);
865 task158->add_dep(task40);
866 residualq->add_task(task158);
867
868 vector<IndexRange> I160_index = {virt_, active_, active_, active_};
869 auto I160 = make_shared<Tensor>(I160_index);
870 auto tensor159 = vector<shared_ptr<Tensor>>{I144, f1_, I160};
871 auto task159 = make_shared<Task159>(tensor159, pindex);
872 task148->add_dep(task159);
873 task159->add_dep(task40);
874 residualq->add_task(task159);
875
876 auto tensor160 = vector<shared_ptr<Tensor>>{I160, Gamma52_(), t2};
877 auto task160 = make_shared<Task160>(tensor160, pindex);
878 task159->add_dep(task160);
879 task160->add_dep(task40);
880 residualq->add_task(task160);
881
882 auto tensor161 = vector<shared_ptr<Tensor>>{I144, Gamma100_(), t2};
883 auto task161 = make_shared<Task161>(tensor161, pindex);
884 task148->add_dep(task161);
885 task161->add_dep(task40);
886 residualq->add_task(task161);
887
888 auto tensor162 = vector<shared_ptr<Tensor>>{I144, Gamma101_(), t2};
889 auto task162 = make_shared<Task162>(tensor162, pindex);
890 task148->add_dep(task162);
891 task162->add_dep(task40);
892 residualq->add_task(task162);
893
894 vector<IndexRange> I162_index = {closed_, virt_, virt_, closed_};
895 auto I162 = make_shared<Tensor>(I162_index);
896 auto tensor163 = vector<shared_ptr<Tensor>>{r, I162};
897 auto task163 = make_shared<Task163>(tensor163, pindex);
898 task163->add_dep(task40);
899 residualq->add_task(task163);
900
901 shared_ptr<Tensor> I163;
902 if (diagonal) {
903 vector<IndexRange> I163_index = {closed_, virt_, closed_, virt_};
904 I163 = make_shared<Tensor>(I163_index);
905 }
906 shared_ptr<Task164> task164;
907 if (diagonal) {
908 auto tensor164 = vector<shared_ptr<Tensor>>{I162, f1_, I163};
909 task164 = make_shared<Task164>(tensor164, pindex);
910 task163->add_dep(task164);
911 task164->add_dep(task40);
912 residualq->add_task(task164);
913 }
914
915 shared_ptr<Task165> task165;
916 if (diagonal) {
917 auto tensor165 = vector<shared_ptr<Tensor>>{I163, t2};
918 task165 = make_shared<Task165>(tensor165, pindex);
919 task164->add_dep(task165);
920 task165->add_dep(task40);
921 residualq->add_task(task165);
922 }
923
924 vector<IndexRange> I167_index = {closed_, active_};
925 auto I167 = make_shared<Tensor>(I167_index);
926 auto tensor166 = vector<shared_ptr<Tensor>>{I162, t2, I167};
927 auto task166 = make_shared<Task166>(tensor166, pindex);
928 task163->add_dep(task166);
929 task166->add_dep(task40);
930 residualq->add_task(task166);
931
932 auto tensor167 = vector<shared_ptr<Tensor>>{I167, Gamma29_(), f1_};
933 auto task167 = make_shared<Task167>(tensor167, pindex);
934 task166->add_dep(task167);
935 task167->add_dep(task40);
936 residualq->add_task(task167);
937
938 vector<IndexRange> I170_index = {closed_, active_};
939 auto I170 = make_shared<Tensor>(I170_index);
940 auto tensor168 = vector<shared_ptr<Tensor>>{I162, t2, I170};
941 auto task168 = make_shared<Task168>(tensor168, pindex);
942 task163->add_dep(task168);
943 task168->add_dep(task40);
944 residualq->add_task(task168);
945
946 auto tensor169 = vector<shared_ptr<Tensor>>{I170, Gamma29_(), f1_};
947 auto task169 = make_shared<Task169>(tensor169, pindex);
948 task168->add_dep(task169);
949 task169->add_dep(task40);
950 residualq->add_task(task169);
951
952 vector<IndexRange> I173_index = {virt_, closed_};
953 auto I173 = make_shared<Tensor>(I173_index);
954 auto tensor170 = vector<shared_ptr<Tensor>>{I162, f1_, I173};
955 auto task170 = make_shared<Task170>(tensor170, pindex);
956 task163->add_dep(task170);
957 task170->add_dep(task40);
958 residualq->add_task(task170);
959
960 vector<IndexRange> I174_index = {active_, virt_, closed_, active_};
961 auto I174 = make_shared<Tensor>(I174_index);
962 auto tensor171 = vector<shared_ptr<Tensor>>{I173, Gamma29_(), I174};
963 auto task171 = make_shared<Task171>(tensor171, pindex);
964 task170->add_dep(task171);
965 task171->add_dep(task40);
966 residualq->add_task(task171);
967
968 auto tensor172 = vector<shared_ptr<Tensor>>{I174, t2};
969 auto task172 = make_shared<Task172>(tensor172, pindex);
970 task171->add_dep(task172);
971 task172->add_dep(task40);
972 residualq->add_task(task172);
973
974 vector<IndexRange> I176_index = {virt_, closed_};
975 auto I176 = make_shared<Tensor>(I176_index);
976 auto tensor173 = vector<shared_ptr<Tensor>>{I162, f1_, I176};
977 auto task173 = make_shared<Task173>(tensor173, pindex);
978 task163->add_dep(task173);
979 task173->add_dep(task40);
980 residualq->add_task(task173);
981
982 vector<IndexRange> I177_index = {active_, virt_, closed_, active_};
983 auto I177 = make_shared<Tensor>(I177_index);
984 auto tensor174 = vector<shared_ptr<Tensor>>{I176, Gamma29_(), I177};
985 auto task174 = make_shared<Task174>(tensor174, pindex);
986 task173->add_dep(task174);
987 task174->add_dep(task40);
988 residualq->add_task(task174);
989
990 auto tensor175 = vector<shared_ptr<Tensor>>{I177, t2};
991 auto task175 = make_shared<Task175>(tensor175, pindex);
992 task174->add_dep(task175);
993 task175->add_dep(task40);
994 residualq->add_task(task175);
995
996 vector<IndexRange> I185_index = {virt_, active_};
997 auto I185 = make_shared<Tensor>(I185_index);
998 auto tensor176 = vector<shared_ptr<Tensor>>{I162, t2, I185};
999 auto task176 = make_shared<Task176>(tensor176, pindex);
1000 task163->add_dep(task176);
1001 task176->add_dep(task40);
1002 residualq->add_task(task176);
1003
1004 auto tensor177 = vector<shared_ptr<Tensor>>{I185, Gamma9_(), f1_};
1005 auto task177 = make_shared<Task177>(tensor177, pindex);
1006 task176->add_dep(task177);
1007 task177->add_dep(task40);
1008 residualq->add_task(task177);
1009
1010 vector<IndexRange> I188_index = {virt_, active_};
1011 auto I188 = make_shared<Tensor>(I188_index);
1012 auto tensor178 = vector<shared_ptr<Tensor>>{I162, t2, I188};
1013 auto task178 = make_shared<Task178>(tensor178, pindex);
1014 task163->add_dep(task178);
1015 task178->add_dep(task40);
1016 residualq->add_task(task178);
1017
1018 auto tensor179 = vector<shared_ptr<Tensor>>{I188, Gamma9_(), f1_};
1019 auto task179 = make_shared<Task179>(tensor179, pindex);
1020 task178->add_dep(task179);
1021 task179->add_dep(task40);
1022 residualq->add_task(task179);
1023
1024 shared_ptr<Tensor> I191;
1025 if (diagonal) {
1026 vector<IndexRange> I191_index = {closed_, virt_, closed_, virt_};
1027 I191 = make_shared<Tensor>(I191_index);
1028 }
1029 shared_ptr<Task180> task180;
1030 if (diagonal) {
1031 auto tensor180 = vector<shared_ptr<Tensor>>{I162, f1_, I191};
1032 task180 = make_shared<Task180>(tensor180, pindex);
1033 task163->add_dep(task180);
1034 task180->add_dep(task40);
1035 residualq->add_task(task180);
1036 }
1037
1038 shared_ptr<Task181> task181;
1039 if (diagonal) {
1040 auto tensor181 = vector<shared_ptr<Tensor>>{I191, t2};
1041 task181 = make_shared<Task181>(tensor181, pindex);
1042 task180->add_dep(task181);
1043 task181->add_dep(task40);
1044 residualq->add_task(task181);
1045 }
1046
1047 vector<IndexRange> I194_index = {virt_, virt_, active_, closed_};
1048 auto I194 = make_shared<Tensor>(I194_index);
1049 auto tensor182 = vector<shared_ptr<Tensor>>{r, I194};
1050 auto task182 = make_shared<Task182>(tensor182, pindex);
1051 task182->add_dep(task40);
1052 residualq->add_task(task182);
1053
1054 vector<IndexRange> I195_index = {virt_, closed_, virt_, active_};
1055 auto I195 = make_shared<Tensor>(I195_index);
1056 auto tensor183 = vector<shared_ptr<Tensor>>{I194, f1_, I195};
1057 auto task183 = make_shared<Task183>(tensor183, pindex);
1058 task182->add_dep(task183);
1059 task183->add_dep(task40);
1060 residualq->add_task(task183);
1061
1062 vector<IndexRange> I196_index = {active_, virt_, closed_, virt_};
1063 auto I196 = make_shared<Tensor>(I196_index);
1064 auto tensor184 = vector<shared_ptr<Tensor>>{I195, Gamma29_(), I196};
1065 auto task184 = make_shared<Task184>(tensor184, pindex);
1066 task183->add_dep(task184);
1067 task184->add_dep(task40);
1068 residualq->add_task(task184);
1069
1070 auto tensor185 = vector<shared_ptr<Tensor>>{I196, t2};
1071 auto task185 = make_shared<Task185>(tensor185, pindex);
1072 task184->add_dep(task185);
1073 task185->add_dep(task40);
1074 residualq->add_task(task185);
1075
1076 vector<IndexRange> I201_index = {closed_, active_};
1077 auto I201 = make_shared<Tensor>(I201_index);
1078 auto tensor186 = vector<shared_ptr<Tensor>>{I194, t2, I201};
1079 auto task186 = make_shared<Task186>(tensor186, pindex);
1080 task182->add_dep(task186);
1081 task186->add_dep(task40);
1082 residualq->add_task(task186);
1083
1084 auto tensor187 = vector<shared_ptr<Tensor>>{I201, Gamma29_(), f1_};
1085 auto task187 = make_shared<Task187>(tensor187, pindex);
1086 task186->add_dep(task187);
1087 task187->add_dep(task40);
1088 residualq->add_task(task187);
1089
1090 vector<IndexRange> I204_index = {closed_, active_};
1091 auto I204 = make_shared<Tensor>(I204_index);
1092 auto tensor188 = vector<shared_ptr<Tensor>>{I194, t2, I204};
1093 auto task188 = make_shared<Task188>(tensor188, pindex);
1094 task182->add_dep(task188);
1095 task188->add_dep(task40);
1096 residualq->add_task(task188);
1097
1098 auto tensor189 = vector<shared_ptr<Tensor>>{I204, Gamma29_(), f1_};
1099 auto task189 = make_shared<Task189>(tensor189, pindex);
1100 task188->add_dep(task189);
1101 task189->add_dep(task40);
1102 residualq->add_task(task189);
1103
1104 vector<IndexRange> I207_index = {virt_, virt_, active_, active_};
1105 auto I207 = make_shared<Tensor>(I207_index);
1106 auto tensor190 = vector<shared_ptr<Tensor>>{I194, f1_, I207};
1107 auto task190 = make_shared<Task190>(tensor190, pindex);
1108 task182->add_dep(task190);
1109 task190->add_dep(task40);
1110 residualq->add_task(task190);
1111
1112 auto tensor191 = vector<shared_ptr<Tensor>>{I207, Gamma50_(), t2};
1113 auto task191 = make_shared<Task191>(tensor191, pindex);
1114 task190->add_dep(task191);
1115 task191->add_dep(task40);
1116 residualq->add_task(task191);
1117
1118 vector<IndexRange> I210_index = {virt_, active_};
1119 auto I210 = make_shared<Tensor>(I210_index);
1120 auto tensor192 = vector<shared_ptr<Tensor>>{I194, f1_, I210};
1121 auto task192 = make_shared<Task192>(tensor192, pindex);
1122 task182->add_dep(task192);
1123 task192->add_dep(task40);
1124 residualq->add_task(task192);
1125
1126 auto tensor193 = vector<shared_ptr<Tensor>>{I210, Gamma50_(), t2};
1127 auto task193 = make_shared<Task193>(tensor193, pindex);
1128 task192->add_dep(task193);
1129 task193->add_dep(task40);
1130 residualq->add_task(task193);
1131
1132 vector<IndexRange> I213_index = {virt_, active_};
1133 auto I213 = make_shared<Tensor>(I213_index);
1134 auto tensor194 = vector<shared_ptr<Tensor>>{I194, f1_, I213};
1135 auto task194 = make_shared<Task194>(tensor194, pindex);
1136 task182->add_dep(task194);
1137 task194->add_dep(task40);
1138 residualq->add_task(task194);
1139
1140 auto tensor195 = vector<shared_ptr<Tensor>>{I213, Gamma50_(), t2};
1141 auto task195 = make_shared<Task195>(tensor195, pindex);
1142 task194->add_dep(task195);
1143 task195->add_dep(task40);
1144 residualq->add_task(task195);
1145
1146 vector<IndexRange> I216_index = {virt_, closed_, active_, active_};
1147 auto I216 = make_shared<Tensor>(I216_index);
1148 auto tensor196 = vector<shared_ptr<Tensor>>{I194, f1_, I216};
1149 auto task196 = make_shared<Task196>(tensor196, pindex);
1150 task182->add_dep(task196);
1151 task196->add_dep(task40);
1152 residualq->add_task(task196);
1153
1154 vector<IndexRange> I217_index = {active_, virt_, closed_, active_};
1155 auto I217 = make_shared<Tensor>(I217_index);
1156 auto tensor197 = vector<shared_ptr<Tensor>>{I216, Gamma25_(), I217};
1157 auto task197 = make_shared<Task197>(tensor197, pindex);
1158 task196->add_dep(task197);
1159 task197->add_dep(task40);
1160 residualq->add_task(task197);
1161
1162 auto tensor198 = vector<shared_ptr<Tensor>>{I217, t2};
1163 auto task198 = make_shared<Task198>(tensor198, pindex);
1164 task197->add_dep(task198);
1165 task198->add_dep(task40);
1166 residualq->add_task(task198);
1167
1168 vector<IndexRange> I219_index = {virt_, closed_, active_, active_};
1169 auto I219 = make_shared<Tensor>(I219_index);
1170 auto tensor199 = vector<shared_ptr<Tensor>>{I194, f1_, I219};
1171 auto task199 = make_shared<Task199>(tensor199, pindex);
1172 task182->add_dep(task199);
1173 task199->add_dep(task40);
1174 residualq->add_task(task199);
1175
1176 auto tensor200 = vector<shared_ptr<Tensor>>{I219, Gamma24_(), t2};
1177 auto task200 = make_shared<Task200>(tensor200, pindex);
1178 task199->add_dep(task200);
1179 task200->add_dep(task40);
1180 residualq->add_task(task200);
1181
1182 auto tensor201 = vector<shared_ptr<Tensor>>{I219, Gamma25_(), t2};
1183 auto task201 = make_shared<Task201>(tensor201, pindex);
1184 task199->add_dep(task201);
1185 task201->add_dep(task40);
1186 residualq->add_task(task201);
1187
1188 vector<IndexRange> I228_index = {virt_, closed_, virt_, active_};
1189 auto I228 = make_shared<Tensor>(I228_index);
1190 auto tensor202 = vector<shared_ptr<Tensor>>{I194, f1_, I228};
1191 auto task202 = make_shared<Task202>(tensor202, pindex);
1192 task182->add_dep(task202);
1193 task202->add_dep(task40);
1194 residualq->add_task(task202);
1195
1196 vector<IndexRange> I229_index = {active_, virt_, closed_, virt_};
1197 auto I229 = make_shared<Tensor>(I229_index);
1198 auto tensor203 = vector<shared_ptr<Tensor>>{I228, Gamma29_(), I229};
1199 auto task203 = make_shared<Task203>(tensor203, pindex);
1200 task202->add_dep(task203);
1201 task203->add_dep(task40);
1202 residualq->add_task(task203);
1203
1204 auto tensor204 = vector<shared_ptr<Tensor>>{I229, t2};
1205 auto task204 = make_shared<Task204>(tensor204, pindex);
1206 task203->add_dep(task204);
1207 task204->add_dep(task40);
1208 residualq->add_task(task204);
1209
1210 vector<IndexRange> I234_index = {virt_, closed_, virt_, active_};
1211 auto I234 = make_shared<Tensor>(I234_index);
1212 auto tensor205 = vector<shared_ptr<Tensor>>{I194, f1_, I234};
1213 auto task205 = make_shared<Task205>(tensor205, pindex);
1214 task182->add_dep(task205);
1215 task205->add_dep(task40);
1216 residualq->add_task(task205);
1217
1218 vector<IndexRange> I235_index = {active_, virt_, closed_, virt_};
1219 auto I235 = make_shared<Tensor>(I235_index);
1220 auto tensor206 = vector<shared_ptr<Tensor>>{I234, Gamma29_(), I235};
1221 auto task206 = make_shared<Task206>(tensor206, pindex);
1222 task205->add_dep(task206);
1223 task206->add_dep(task40);
1224 residualq->add_task(task206);
1225
1226 auto tensor207 = vector<shared_ptr<Tensor>>{I235, t2};
1227 auto task207 = make_shared<Task207>(tensor207, pindex);
1228 task206->add_dep(task207);
1229 task207->add_dep(task40);
1230 residualq->add_task(task207);
1231
1232 vector<IndexRange> I269_index = {active_, virt_, closed_, virt_};
1233 auto I269 = make_shared<Tensor>(I269_index);
1234 auto tensor208 = vector<shared_ptr<Tensor>>{I194, Gamma29_(), I269};
1235 auto task208 = make_shared<Task208>(tensor208, pindex);
1236 task182->add_dep(task208);
1237 task208->add_dep(task40);
1238 residualq->add_task(task208);
1239
1240 auto tensor209 = vector<shared_ptr<Tensor>>{I269, t2};
1241 auto task209 = make_shared<Task209>(tensor209, pindex, this->e0_);
1242 task208->add_dep(task209);
1243 task209->add_dep(task40);
1244 residualq->add_task(task209);
1245
1246 vector<IndexRange> I303_index = {active_, virt_, closed_, virt_};
1247 auto I303 = make_shared<Tensor>(I303_index);
1248 auto tensor210 = vector<shared_ptr<Tensor>>{I194, Gamma106_(), I303};
1249 auto task210 = make_shared<Task210>(tensor210, pindex);
1250 task182->add_dep(task210);
1251 task210->add_dep(task40);
1252 residualq->add_task(task210);
1253
1254 auto tensor211 = vector<shared_ptr<Tensor>>{I303, t2};
1255 auto task211 = make_shared<Task211>(tensor211, pindex);
1256 task210->add_dep(task211);
1257 task211->add_dep(task40);
1258 residualq->add_task(task211);
1259
1260 vector<IndexRange> I307_index = {active_, virt_, closed_, virt_};
1261 auto I307 = make_shared<Tensor>(I307_index);
1262 auto tensor212 = vector<shared_ptr<Tensor>>{I194, Gamma108_(), I307};
1263 auto task212 = make_shared<Task212>(tensor212, pindex);
1264 task182->add_dep(task212);
1265 task212->add_dep(task40);
1266 residualq->add_task(task212);
1267
1268 auto tensor213 = vector<shared_ptr<Tensor>>{I307, t2};
1269 auto task213 = make_shared<Task213>(tensor213, pindex);
1270 task212->add_dep(task213);
1271 task213->add_dep(task40);
1272 residualq->add_task(task213);
1273
1274 vector<IndexRange> I239_index = {virt_, virt_, active_, active_};
1275 auto I239 = make_shared<Tensor>(I239_index);
1276 auto tensor214 = vector<shared_ptr<Tensor>>{r, I239};
1277 auto task214 = make_shared<Task214>(tensor214, pindex);
1278 task214->add_dep(task40);
1279 residualq->add_task(task214);
1280
1281 vector<IndexRange> I240_index = {active_, virt_, virt_, active_};
1282 auto I240 = make_shared<Tensor>(I240_index);
1283 auto tensor215 = vector<shared_ptr<Tensor>>{I239, Gamma50_(), I240};
1284 auto task215 = make_shared<Task215>(tensor215, pindex);
1285 task214->add_dep(task215);
1286 task215->add_dep(task40);
1287 residualq->add_task(task215);
1288
1289 auto tensor216 = vector<shared_ptr<Tensor>>{I240, f1_, t2};
1290 auto task216 = make_shared<Task216>(tensor216, pindex);
1291 task215->add_dep(task216);
1292 task216->add_dep(task40);
1293 residualq->add_task(task216);
1294
1295 vector<IndexRange> I243_index = {virt_, active_, active_, active_};
1296 auto I243 = make_shared<Tensor>(I243_index);
1297 auto tensor217 = vector<shared_ptr<Tensor>>{I239, f1_, I243};
1298 auto task217 = make_shared<Task217>(tensor217, pindex);
1299 task214->add_dep(task217);
1300 task217->add_dep(task40);
1301 residualq->add_task(task217);
1302
1303 auto tensor218 = vector<shared_ptr<Tensor>>{I243, Gamma52_(), t2};
1304 auto task218 = make_shared<Task218>(tensor218, pindex);
1305 task217->add_dep(task218);
1306 task218->add_dep(task40);
1307 residualq->add_task(task218);
1308
1309 vector<IndexRange> I246_index = {virt_, virt_, active_, active_};
1310 auto I246 = make_shared<Tensor>(I246_index);
1311 auto tensor219 = vector<shared_ptr<Tensor>>{I239, f1_, I246};
1312 auto task219 = make_shared<Task219>(tensor219, pindex);
1313 task214->add_dep(task219);
1314 task219->add_dep(task40);
1315 residualq->add_task(task219);
1316
1317 auto tensor220 = vector<shared_ptr<Tensor>>{I246, Gamma50_(), t2};
1318 auto task220 = make_shared<Task220>(tensor220, pindex);
1319 task219->add_dep(task220);
1320 task220->add_dep(task40);
1321 residualq->add_task(task220);
1322
1323 vector<IndexRange> I248_index = {closed_, closed_, active_, active_};
1324 auto I248 = make_shared<Tensor>(I248_index);
1325 auto tensor221 = vector<shared_ptr<Tensor>>{r, I248};
1326 auto task221 = make_shared<Task221>(tensor221, pindex);
1327 task221->add_dep(task40);
1328 residualq->add_task(task221);
1329
1330 auto tensor222 = vector<shared_ptr<Tensor>>{I248, Gamma0_(), t2};
1331 auto task222 = make_shared<Task222>(tensor222, pindex, this->e0_);
1332 task221->add_dep(task222);
1333 task222->add_dep(task40);
1334 residualq->add_task(task222);
1335
1336 auto tensor223 = vector<shared_ptr<Tensor>>{I248, Gamma92_(), t2};
1337 auto task223 = make_shared<Task223>(tensor223, pindex);
1338 task221->add_dep(task223);
1339 task223->add_dep(task40);
1340 residualq->add_task(task223);
1341
1342 auto tensor224 = vector<shared_ptr<Tensor>>{I248, Gamma93_(), t2};
1343 auto task224 = make_shared<Task224>(tensor224, pindex);
1344 task221->add_dep(task224);
1345 task224->add_dep(task40);
1346 residualq->add_task(task224);
1347
1348 vector<IndexRange> I266_index = {closed_, virt_, closed_, virt_};
1349 auto I266 = make_shared<Tensor>(I266_index);
1350 auto tensor225 = vector<shared_ptr<Tensor>>{r, I266};
1351 auto task225 = make_shared<Task225>(tensor225, pindex);
1352 task225->add_dep(task40);
1353 residualq->add_task(task225);
1354
1355 shared_ptr<Task226> task226;
1356 if (diagonal) {
1357 auto tensor226 = vector<shared_ptr<Tensor>>{I266, t2};
1358 task226 = make_shared<Task226>(tensor226, pindex, this->e0_);
1359 task225->add_dep(task226);
1360 task226->add_dep(task40);
1361 residualq->add_task(task226);
1362 }
1363
1364 vector<IndexRange> I295_index = {closed_, virt_, closed_, virt_};
1365 auto I295 = make_shared<Tensor>(I295_index);
1366 auto tensor227 = vector<shared_ptr<Tensor>>{I266, Gamma102_(), I295};
1367 auto task227 = make_shared<Task227>(tensor227, pindex);
1368 task225->add_dep(task227);
1369 task227->add_dep(task40);
1370 residualq->add_task(task227);
1371
1372 auto tensor228 = vector<shared_ptr<Tensor>>{I295, t2};
1373 auto task228 = make_shared<Task228>(tensor228, pindex);
1374 task227->add_dep(task228);
1375 task228->add_dep(task40);
1376 residualq->add_task(task228);
1377
1378 vector<IndexRange> I299_index = {closed_, virt_, closed_, virt_};
1379 auto I299 = make_shared<Tensor>(I299_index);
1380 auto tensor229 = vector<shared_ptr<Tensor>>{I266, Gamma104_(), I299};
1381 auto task229 = make_shared<Task229>(tensor229, pindex);
1382 task225->add_dep(task229);
1383 task229->add_dep(task40);
1384 residualq->add_task(task229);
1385
1386 auto tensor230 = vector<shared_ptr<Tensor>>{I299, t2};
1387 auto task230 = make_shared<Task230>(tensor230, pindex);
1388 task229->add_dep(task230);
1389 task230->add_dep(task40);
1390 residualq->add_task(task230);
1391
1392 vector<IndexRange> I272_index = {virt_, virt_, active_, active_};
1393 auto I272 = make_shared<Tensor>(I272_index);
1394 auto tensor231 = vector<shared_ptr<Tensor>>{r, I272};
1395 auto task231 = make_shared<Task231>(tensor231, pindex);
1396 task231->add_dep(task40);
1397 residualq->add_task(task231);
1398
1399 auto tensor232 = vector<shared_ptr<Tensor>>{I272, Gamma50_(), t2};
1400 auto task232 = make_shared<Task232>(tensor232, pindex, this->e0_);
1401 task231->add_dep(task232);
1402 task232->add_dep(task40);
1403 residualq->add_task(task232);
1404
1405 auto tensor233 = vector<shared_ptr<Tensor>>{I272, Gamma110_(), t2};
1406 auto task233 = make_shared<Task233>(tensor233, pindex);
1407 task231->add_dep(task233);
1408 task233->add_dep(task40);
1409 residualq->add_task(task233);
1410
1411 auto tensor234 = vector<shared_ptr<Tensor>>{I272, Gamma111_(), t2};
1412 auto task234 = make_shared<Task234>(tensor234, pindex);
1413 task231->add_dep(task234);
1414 task234->add_dep(task40);
1415 residualq->add_task(task234);
1416
1417 return residualq;
1418 }
1419
1420
1421 #endif
1422