1 //
2 // BAGEL - Brilliantly Advanced General Electronic Structure Library
3 // Filename: RelMRCI_residualq5.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/relmrci/RelMRCI.h>
30 #include <src/smith/relmrci/RelMRCI_tasks11.h>
31 #include <src/smith/relmrci/RelMRCI_tasks12.h>
32 #include <src/smith/relmrci/RelMRCI_tasks13.h>
33 #include <src/smith/relmrci/RelMRCI_tasks14.h>
34
35 using namespace std;
36 using namespace bagel;
37 using namespace bagel::SMITH;
38
make_residualq5(shared_ptr<Queue> residualq,shared_ptr<Task> task83,const bool diagonal)39 void RelMRCI::RelMRCI::make_residualq5(shared_ptr<Queue> residualq, shared_ptr<Task> task83, const bool diagonal) {
40 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
41
42 vector<IndexRange> I134_index = {closed_, virt_, active_, virt_};
43 auto I134 = make_shared<Tensor>(I134_index);
44 auto tensor535 = vector<shared_ptr<Tensor>>{r, I134};
45 auto task535 = make_shared<Task535>(tensor535, pindex);
46 task535->add_dep(task83);
47 residualq->add_task(task535);
48
49 vector<IndexRange> I135_index = {closed_, virt_, active_, active_};
50 auto I135 = make_shared<Tensor>(I135_index);
51 auto tensor536 = vector<shared_ptr<Tensor>>{I134, h1_, I135};
52 auto task536 = make_shared<Task536>(tensor536, pindex);
53 task535->add_dep(task536);
54 task536->add_dep(task83);
55 residualq->add_task(task536);
56
57 auto tensor537 = vector<shared_ptr<Tensor>>{I135, Gamma24_(), t2};
58 auto task537 = make_shared<Task537>(tensor537, pindex);
59 task536->add_dep(task537);
60 task537->add_dep(task83);
61 residualq->add_task(task537);
62
63 vector<IndexRange> I138_index = {closed_, virt_, active_, active_};
64 auto I138 = make_shared<Tensor>(I138_index);
65 auto tensor538 = vector<shared_ptr<Tensor>>{I134, h1_, I138};
66 auto task538 = make_shared<Task538>(tensor538, pindex);
67 task535->add_dep(task538);
68 task538->add_dep(task83);
69 residualq->add_task(task538);
70
71 auto tensor539 = vector<shared_ptr<Tensor>>{I138, Gamma24_(), t2};
72 auto task539 = make_shared<Task539>(tensor539, pindex);
73 task538->add_dep(task539);
74 task539->add_dep(task83);
75 residualq->add_task(task539);
76
77 vector<IndexRange> I141_index = {virt_, active_};
78 auto I141 = make_shared<Tensor>(I141_index);
79 auto tensor540 = vector<shared_ptr<Tensor>>{I134, h1_, I141};
80 auto task540 = make_shared<Task540>(tensor540, pindex);
81 task535->add_dep(task540);
82 task540->add_dep(task83);
83 residualq->add_task(task540);
84
85 auto tensor541 = vector<shared_ptr<Tensor>>{I141, Gamma33_(), t2};
86 auto task541 = make_shared<Task541>(tensor541, pindex);
87 task540->add_dep(task541);
88 task541->add_dep(task83);
89 residualq->add_task(task541);
90
91 vector<IndexRange> I144_index = {virt_, active_};
92 auto I144 = make_shared<Tensor>(I144_index);
93 auto tensor542 = vector<shared_ptr<Tensor>>{I134, h1_, I144};
94 auto task542 = make_shared<Task542>(tensor542, pindex);
95 task535->add_dep(task542);
96 task542->add_dep(task83);
97 residualq->add_task(task542);
98
99 auto tensor543 = vector<shared_ptr<Tensor>>{I144, Gamma33_(), t2};
100 auto task543 = make_shared<Task543>(tensor543, pindex);
101 task542->add_dep(task543);
102 task543->add_dep(task83);
103 residualq->add_task(task543);
104
105 vector<IndexRange> I147_index = {closed_, active_};
106 auto I147 = make_shared<Tensor>(I147_index);
107 auto tensor544 = vector<shared_ptr<Tensor>>{I134, t2, I147};
108 auto task544 = make_shared<Task544>(tensor544, pindex);
109 task535->add_dep(task544);
110 task544->add_dep(task83);
111 residualq->add_task(task544);
112
113 auto tensor545 = vector<shared_ptr<Tensor>>{I147, Gamma27_(), h1_};
114 auto task545 = make_shared<Task545>(tensor545, pindex);
115 task544->add_dep(task545);
116 task545->add_dep(task83);
117 residualq->add_task(task545);
118
119 auto tensor546 = vector<shared_ptr<Tensor>>{I147, Gamma33_(), v2_};
120 auto task546 = make_shared<Task546>(tensor546, pindex);
121 task544->add_dep(task546);
122 task546->add_dep(task83);
123 residualq->add_task(task546);
124
125 auto tensor547 = vector<shared_ptr<Tensor>>{I147, Gamma24_(), v2_};
126 auto task547 = make_shared<Task547>(tensor547, pindex);
127 task544->add_dep(task547);
128 task547->add_dep(task83);
129 residualq->add_task(task547);
130
131 vector<IndexRange> I150_index = {closed_, active_};
132 auto I150 = make_shared<Tensor>(I150_index);
133 auto tensor548 = vector<shared_ptr<Tensor>>{I134, t2, I150};
134 auto task548 = make_shared<Task548>(tensor548, pindex);
135 task535->add_dep(task548);
136 task548->add_dep(task83);
137 residualq->add_task(task548);
138
139 auto tensor549 = vector<shared_ptr<Tensor>>{I150, Gamma27_(), h1_};
140 auto task549 = make_shared<Task549>(tensor549, pindex);
141 task548->add_dep(task549);
142 task549->add_dep(task83);
143 residualq->add_task(task549);
144
145 auto tensor550 = vector<shared_ptr<Tensor>>{I150, Gamma33_(), v2_};
146 auto task550 = make_shared<Task550>(tensor550, pindex);
147 task548->add_dep(task550);
148 task550->add_dep(task83);
149 residualq->add_task(task550);
150
151 auto tensor551 = vector<shared_ptr<Tensor>>{I150, Gamma24_(), v2_};
152 auto task551 = make_shared<Task551>(tensor551, pindex);
153 task548->add_dep(task551);
154 task551->add_dep(task83);
155 residualq->add_task(task551);
156
157 vector<IndexRange> I153_index = {closed_, active_, virt_, virt_};
158 auto I153 = make_shared<Tensor>(I153_index);
159 auto tensor552 = vector<shared_ptr<Tensor>>{I134, Gamma27_(), I153};
160 auto task552 = make_shared<Task552>(tensor552, pindex);
161 task535->add_dep(task552);
162 task552->add_dep(task83);
163 residualq->add_task(task552);
164
165 auto tensor553 = vector<shared_ptr<Tensor>>{I153, t2, h1_};
166 auto task553 = make_shared<Task553>(tensor553, pindex);
167 task552->add_dep(task553);
168 task553->add_dep(task83);
169 residualq->add_task(task553);
170
171 auto tensor554 = vector<shared_ptr<Tensor>>{I153, t2, h1_};
172 auto task554 = make_shared<Task554>(tensor554, pindex);
173 task552->add_dep(task554);
174 task554->add_dep(task83);
175 residualq->add_task(task554);
176
177 auto tensor555 = vector<shared_ptr<Tensor>>{I153, t2, h1_};
178 auto task555 = make_shared<Task555>(tensor555, pindex);
179 task552->add_dep(task555);
180 task555->add_dep(task83);
181 residualq->add_task(task555);
182
183 auto tensor556 = vector<shared_ptr<Tensor>>{I153, t2, h1_};
184 auto task556 = make_shared<Task556>(tensor556, pindex);
185 task552->add_dep(task556);
186 task556->add_dep(task83);
187 residualq->add_task(task556);
188
189 auto tensor557 = vector<shared_ptr<Tensor>>{I153, t2, h1_};
190 auto task557 = make_shared<Task557>(tensor557, pindex);
191 task552->add_dep(task557);
192 task557->add_dep(task83);
193 residualq->add_task(task557);
194
195 auto tensor558 = vector<shared_ptr<Tensor>>{I153, t2, h1_};
196 auto task558 = make_shared<Task558>(tensor558, pindex);
197 task552->add_dep(task558);
198 task558->add_dep(task83);
199 residualq->add_task(task558);
200
201 auto tensor559 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
202 auto task559 = make_shared<Task559>(tensor559, pindex);
203 task552->add_dep(task559);
204 task559->add_dep(task83);
205 residualq->add_task(task559);
206
207 auto tensor560 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
208 auto task560 = make_shared<Task560>(tensor560, pindex);
209 task552->add_dep(task560);
210 task560->add_dep(task83);
211 residualq->add_task(task560);
212
213 auto tensor561 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
214 auto task561 = make_shared<Task561>(tensor561, pindex);
215 task552->add_dep(task561);
216 task561->add_dep(task83);
217 residualq->add_task(task561);
218
219 auto tensor562 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
220 auto task562 = make_shared<Task562>(tensor562, pindex);
221 task552->add_dep(task562);
222 task562->add_dep(task83);
223 residualq->add_task(task562);
224
225 auto tensor563 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
226 auto task563 = make_shared<Task563>(tensor563, pindex);
227 task552->add_dep(task563);
228 task563->add_dep(task83);
229 residualq->add_task(task563);
230
231 auto tensor564 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
232 auto task564 = make_shared<Task564>(tensor564, pindex);
233 task552->add_dep(task564);
234 task564->add_dep(task83);
235 residualq->add_task(task564);
236
237 auto tensor565 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
238 auto task565 = make_shared<Task565>(tensor565, pindex);
239 task552->add_dep(task565);
240 task565->add_dep(task83);
241 residualq->add_task(task565);
242
243 auto tensor566 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
244 auto task566 = make_shared<Task566>(tensor566, pindex);
245 task552->add_dep(task566);
246 task566->add_dep(task83);
247 residualq->add_task(task566);
248
249 auto tensor567 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
250 auto task567 = make_shared<Task567>(tensor567, pindex);
251 task552->add_dep(task567);
252 task567->add_dep(task83);
253 residualq->add_task(task567);
254
255 auto tensor568 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
256 auto task568 = make_shared<Task568>(tensor568, pindex);
257 task552->add_dep(task568);
258 task568->add_dep(task83);
259 residualq->add_task(task568);
260
261 auto tensor569 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
262 auto task569 = make_shared<Task569>(tensor569, pindex);
263 task552->add_dep(task569);
264 task569->add_dep(task83);
265 residualq->add_task(task569);
266
267 auto tensor570 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
268 auto task570 = make_shared<Task570>(tensor570, pindex);
269 task552->add_dep(task570);
270 task570->add_dep(task83);
271 residualq->add_task(task570);
272
273 auto tensor571 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
274 auto task571 = make_shared<Task571>(tensor571, pindex);
275 task552->add_dep(task571);
276 task571->add_dep(task83);
277 residualq->add_task(task571);
278
279 auto tensor572 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
280 auto task572 = make_shared<Task572>(tensor572, pindex);
281 task552->add_dep(task572);
282 task572->add_dep(task83);
283 residualq->add_task(task572);
284
285 auto tensor573 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
286 auto task573 = make_shared<Task573>(tensor573, pindex);
287 task552->add_dep(task573);
288 task573->add_dep(task83);
289 residualq->add_task(task573);
290
291 auto tensor574 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
292 auto task574 = make_shared<Task574>(tensor574, pindex);
293 task552->add_dep(task574);
294 task574->add_dep(task83);
295 residualq->add_task(task574);
296
297 auto tensor575 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
298 auto task575 = make_shared<Task575>(tensor575, pindex);
299 task552->add_dep(task575);
300 task575->add_dep(task83);
301 residualq->add_task(task575);
302
303 auto tensor576 = vector<shared_ptr<Tensor>>{I153, t2, v2_};
304 auto task576 = make_shared<Task576>(tensor576, pindex);
305 task552->add_dep(task576);
306 task576->add_dep(task83);
307 residualq->add_task(task576);
308
309 vector<IndexRange> I171_index = {virt_, virt_, active_, active_};
310 auto I171 = make_shared<Tensor>(I171_index);
311 auto tensor577 = vector<shared_ptr<Tensor>>{I134, h1_, I171};
312 auto task577 = make_shared<Task577>(tensor577, pindex);
313 task535->add_dep(task577);
314 task577->add_dep(task83);
315 residualq->add_task(task577);
316
317 auto tensor578 = vector<shared_ptr<Tensor>>{I171, Gamma33_(), t2};
318 auto task578 = make_shared<Task578>(tensor578, pindex);
319 task577->add_dep(task578);
320 task578->add_dep(task83);
321 residualq->add_task(task578);
322
323 vector<IndexRange> I980_index = {closed_, active_, active_, active_};
324 auto I980 = make_shared<Tensor>(I980_index);
325 auto tensor579 = vector<shared_ptr<Tensor>>{I134, v2_, I980};
326 auto task579 = make_shared<Task579>(tensor579, pindex);
327 task535->add_dep(task579);
328 task579->add_dep(task83);
329 residualq->add_task(task579);
330
331 auto tensor580 = vector<shared_ptr<Tensor>>{I980, Gamma317_(), t2};
332 auto task580 = make_shared<Task580>(tensor580, pindex);
333 task579->add_dep(task580);
334 task580->add_dep(task83);
335 residualq->add_task(task580);
336
337 vector<IndexRange> I983_index = {virt_, closed_, active_, active_};
338 auto I983 = make_shared<Tensor>(I983_index);
339 auto tensor581 = vector<shared_ptr<Tensor>>{I134, t2, I983};
340 auto task581 = make_shared<Task581>(tensor581, pindex);
341 task535->add_dep(task581);
342 task581->add_dep(task83);
343 residualq->add_task(task581);
344
345 auto tensor582 = vector<shared_ptr<Tensor>>{I983, Gamma318_(), v2_};
346 auto task582 = make_shared<Task582>(tensor582, pindex);
347 task581->add_dep(task582);
348 task582->add_dep(task83);
349 residualq->add_task(task582);
350
351 vector<IndexRange> I986_index = {virt_, closed_, active_, active_};
352 auto I986 = make_shared<Tensor>(I986_index);
353 auto tensor583 = vector<shared_ptr<Tensor>>{I134, t2, I986};
354 auto task583 = make_shared<Task583>(tensor583, pindex);
355 task535->add_dep(task583);
356 task583->add_dep(task83);
357 residualq->add_task(task583);
358
359 auto tensor584 = vector<shared_ptr<Tensor>>{I986, Gamma5_(), v2_};
360 auto task584 = make_shared<Task584>(tensor584, pindex);
361 task583->add_dep(task584);
362 task584->add_dep(task83);
363 residualq->add_task(task584);
364
365 vector<IndexRange> I989_index = {virt_, closed_, active_, active_};
366 auto I989 = make_shared<Tensor>(I989_index);
367 auto tensor585 = vector<shared_ptr<Tensor>>{I134, t2, I989};
368 auto task585 = make_shared<Task585>(tensor585, pindex);
369 task535->add_dep(task585);
370 task585->add_dep(task83);
371 residualq->add_task(task585);
372
373 auto tensor586 = vector<shared_ptr<Tensor>>{I989, Gamma318_(), v2_};
374 auto task586 = make_shared<Task586>(tensor586, pindex);
375 task585->add_dep(task586);
376 task586->add_dep(task83);
377 residualq->add_task(task586);
378
379 vector<IndexRange> I992_index = {virt_, closed_, active_, active_};
380 auto I992 = make_shared<Tensor>(I992_index);
381 auto tensor587 = vector<shared_ptr<Tensor>>{I134, t2, I992};
382 auto task587 = make_shared<Task587>(tensor587, pindex);
383 task535->add_dep(task587);
384 task587->add_dep(task83);
385 residualq->add_task(task587);
386
387 auto tensor588 = vector<shared_ptr<Tensor>>{I992, Gamma318_(), v2_};
388 auto task588 = make_shared<Task588>(tensor588, pindex);
389 task587->add_dep(task588);
390 task588->add_dep(task83);
391 residualq->add_task(task588);
392
393 vector<IndexRange> I995_index = {virt_, active_, active_, active_};
394 auto I995 = make_shared<Tensor>(I995_index);
395 auto tensor589 = vector<shared_ptr<Tensor>>{I134, t2, I995};
396 auto task589 = make_shared<Task589>(tensor589, pindex);
397 task535->add_dep(task589);
398 task589->add_dep(task83);
399 residualq->add_task(task589);
400
401 auto tensor590 = vector<shared_ptr<Tensor>>{I995, Gamma31_(), v2_};
402 auto task590 = make_shared<Task590>(tensor590, pindex);
403 task589->add_dep(task590);
404 task590->add_dep(task83);
405 residualq->add_task(task590);
406
407 auto tensor591 = vector<shared_ptr<Tensor>>{I995, Gamma193_(), v2_};
408 auto task591 = make_shared<Task591>(tensor591, pindex);
409 task589->add_dep(task591);
410 task591->add_dep(task83);
411 residualq->add_task(task591);
412
413 vector<IndexRange> I998_index = {virt_, active_, active_, active_};
414 auto I998 = make_shared<Tensor>(I998_index);
415 auto tensor592 = vector<shared_ptr<Tensor>>{I134, t2, I998};
416 auto task592 = make_shared<Task592>(tensor592, pindex);
417 task535->add_dep(task592);
418 task592->add_dep(task83);
419 residualq->add_task(task592);
420
421 auto tensor593 = vector<shared_ptr<Tensor>>{I998, Gamma31_(), v2_};
422 auto task593 = make_shared<Task593>(tensor593, pindex);
423 task592->add_dep(task593);
424 task593->add_dep(task83);
425 residualq->add_task(task593);
426
427 auto tensor594 = vector<shared_ptr<Tensor>>{I998, Gamma193_(), v2_};
428 auto task594 = make_shared<Task594>(tensor594, pindex);
429 task592->add_dep(task594);
430 task594->add_dep(task83);
431 residualq->add_task(task594);
432
433 vector<IndexRange> I1007_index = {closed_, virt_, active_, active_};
434 auto I1007 = make_shared<Tensor>(I1007_index);
435 auto tensor595 = vector<shared_ptr<Tensor>>{I134, v2_, I1007};
436 auto task595 = make_shared<Task595>(tensor595, pindex);
437 task535->add_dep(task595);
438 task595->add_dep(task83);
439 residualq->add_task(task595);
440
441 auto tensor596 = vector<shared_ptr<Tensor>>{I1007, Gamma24_(), t2};
442 auto task596 = make_shared<Task596>(tensor596, pindex);
443 task595->add_dep(task596);
444 task596->add_dep(task83);
445 residualq->add_task(task596);
446
447 vector<IndexRange> I1010_index = {closed_, virt_, active_, active_};
448 auto I1010 = make_shared<Tensor>(I1010_index);
449 auto tensor597 = vector<shared_ptr<Tensor>>{I134, v2_, I1010};
450 auto task597 = make_shared<Task597>(tensor597, pindex);
451 task535->add_dep(task597);
452 task597->add_dep(task83);
453 residualq->add_task(task597);
454
455 auto tensor598 = vector<shared_ptr<Tensor>>{I1010, Gamma24_(), t2};
456 auto task598 = make_shared<Task598>(tensor598, pindex);
457 task597->add_dep(task598);
458 task598->add_dep(task83);
459 residualq->add_task(task598);
460
461 vector<IndexRange> I1013_index = {closed_, virt_, active_, active_};
462 auto I1013 = make_shared<Tensor>(I1013_index);
463 auto tensor599 = vector<shared_ptr<Tensor>>{I134, v2_, I1013};
464 auto task599 = make_shared<Task599>(tensor599, pindex);
465 task535->add_dep(task599);
466 task599->add_dep(task83);
467 residualq->add_task(task599);
468
469 auto tensor600 = vector<shared_ptr<Tensor>>{I1013, Gamma24_(), t2};
470 auto task600 = make_shared<Task600>(tensor600, pindex);
471 task599->add_dep(task600);
472 task600->add_dep(task83);
473 residualq->add_task(task600);
474
475 vector<IndexRange> I1016_index = {closed_, virt_, active_, active_};
476 auto I1016 = make_shared<Tensor>(I1016_index);
477 auto tensor601 = vector<shared_ptr<Tensor>>{I134, v2_, I1016};
478 auto task601 = make_shared<Task601>(tensor601, pindex);
479 task535->add_dep(task601);
480 task601->add_dep(task83);
481 residualq->add_task(task601);
482
483 auto tensor602 = vector<shared_ptr<Tensor>>{I1016, Gamma24_(), t2};
484 auto task602 = make_shared<Task602>(tensor602, pindex);
485 task601->add_dep(task602);
486 task602->add_dep(task83);
487 residualq->add_task(task602);
488
489 vector<IndexRange> I1019_index = {closed_, virt_, active_, active_};
490 auto I1019 = make_shared<Tensor>(I1019_index);
491 auto tensor603 = vector<shared_ptr<Tensor>>{I134, v2_, I1019};
492 auto task603 = make_shared<Task603>(tensor603, pindex);
493 task535->add_dep(task603);
494 task603->add_dep(task83);
495 residualq->add_task(task603);
496
497 auto tensor604 = vector<shared_ptr<Tensor>>{I1019, Gamma24_(), t2};
498 auto task604 = make_shared<Task604>(tensor604, pindex);
499 task603->add_dep(task604);
500 task604->add_dep(task83);
501 residualq->add_task(task604);
502
503 vector<IndexRange> I1022_index = {closed_, virt_, active_, active_};
504 auto I1022 = make_shared<Tensor>(I1022_index);
505 auto tensor605 = vector<shared_ptr<Tensor>>{I134, v2_, I1022};
506 auto task605 = make_shared<Task605>(tensor605, pindex);
507 task535->add_dep(task605);
508 task605->add_dep(task83);
509 residualq->add_task(task605);
510
511 auto tensor606 = vector<shared_ptr<Tensor>>{I1022, Gamma24_(), t2};
512 auto task606 = make_shared<Task606>(tensor606, pindex);
513 task605->add_dep(task606);
514 task606->add_dep(task83);
515 residualq->add_task(task606);
516
517 vector<IndexRange> I1025_index = {virt_, active_, active_, active_};
518 auto I1025 = make_shared<Tensor>(I1025_index);
519 auto tensor607 = vector<shared_ptr<Tensor>>{I134, v2_, I1025};
520 auto task607 = make_shared<Task607>(tensor607, pindex);
521 task535->add_dep(task607);
522 task607->add_dep(task83);
523 residualq->add_task(task607);
524
525 auto tensor608 = vector<shared_ptr<Tensor>>{I1025, Gamma32_(), t2};
526 auto task608 = make_shared<Task608>(tensor608, pindex);
527 task607->add_dep(task608);
528 task608->add_dep(task83);
529 residualq->add_task(task608);
530
531 vector<IndexRange> I1028_index = {virt_, active_, active_, active_};
532 auto I1028 = make_shared<Tensor>(I1028_index);
533 auto tensor609 = vector<shared_ptr<Tensor>>{I134, v2_, I1028};
534 auto task609 = make_shared<Task609>(tensor609, pindex);
535 task535->add_dep(task609);
536 task609->add_dep(task83);
537 residualq->add_task(task609);
538
539 auto tensor610 = vector<shared_ptr<Tensor>>{I1028, Gamma32_(), t2};
540 auto task610 = make_shared<Task610>(tensor610, pindex);
541 task609->add_dep(task610);
542 task610->add_dep(task83);
543 residualq->add_task(task610);
544
545 vector<IndexRange> I1031_index = {virt_, active_, active_, active_};
546 auto I1031 = make_shared<Tensor>(I1031_index);
547 auto tensor611 = vector<shared_ptr<Tensor>>{I134, v2_, I1031};
548 auto task611 = make_shared<Task611>(tensor611, pindex);
549 task535->add_dep(task611);
550 task611->add_dep(task83);
551 residualq->add_task(task611);
552
553 auto tensor612 = vector<shared_ptr<Tensor>>{I1031, Gamma26_(), t2};
554 auto task612 = make_shared<Task612>(tensor612, pindex);
555 task611->add_dep(task612);
556 task612->add_dep(task83);
557 residualq->add_task(task612);
558
559 vector<IndexRange> I1034_index = {virt_, active_, active_, active_};
560 auto I1034 = make_shared<Tensor>(I1034_index);
561 auto tensor613 = vector<shared_ptr<Tensor>>{I134, v2_, I1034};
562 auto task613 = make_shared<Task613>(tensor613, pindex);
563 task535->add_dep(task613);
564 task613->add_dep(task83);
565 residualq->add_task(task613);
566
567 auto tensor614 = vector<shared_ptr<Tensor>>{I1034, Gamma335_(), t2};
568 auto task614 = make_shared<Task614>(tensor614, pindex);
569 task613->add_dep(task614);
570 task614->add_dep(task83);
571 residualq->add_task(task614);
572
573 vector<IndexRange> I1037_index = {virt_, active_, active_, active_};
574 auto I1037 = make_shared<Tensor>(I1037_index);
575 auto tensor615 = vector<shared_ptr<Tensor>>{I134, v2_, I1037};
576 auto task615 = make_shared<Task615>(tensor615, pindex);
577 task535->add_dep(task615);
578 task615->add_dep(task83);
579 residualq->add_task(task615);
580
581 auto tensor616 = vector<shared_ptr<Tensor>>{I1037, Gamma336_(), t2};
582 auto task616 = make_shared<Task616>(tensor616, pindex);
583 task615->add_dep(task616);
584 task616->add_dep(task83);
585 residualq->add_task(task616);
586
587 vector<IndexRange> I1040_index = {virt_, active_, active_, active_};
588 auto I1040 = make_shared<Tensor>(I1040_index);
589 auto tensor617 = vector<shared_ptr<Tensor>>{I134, v2_, I1040};
590 auto task617 = make_shared<Task617>(tensor617, pindex);
591 task535->add_dep(task617);
592 task617->add_dep(task83);
593 residualq->add_task(task617);
594
595 auto tensor618 = vector<shared_ptr<Tensor>>{I1040, Gamma32_(), t2};
596 auto task618 = make_shared<Task618>(tensor618, pindex);
597 task617->add_dep(task618);
598 task618->add_dep(task83);
599 residualq->add_task(task618);
600
601 vector<IndexRange> I1043_index = {virt_, active_, active_, active_};
602 auto I1043 = make_shared<Tensor>(I1043_index);
603 auto tensor619 = vector<shared_ptr<Tensor>>{I134, v2_, I1043};
604 auto task619 = make_shared<Task619>(tensor619, pindex);
605 task535->add_dep(task619);
606 task619->add_dep(task83);
607 residualq->add_task(task619);
608
609 auto tensor620 = vector<shared_ptr<Tensor>>{I1043, Gamma32_(), t2};
610 auto task620 = make_shared<Task620>(tensor620, pindex);
611 task619->add_dep(task620);
612 task620->add_dep(task83);
613 residualq->add_task(task620);
614
615 vector<IndexRange> I1046_index = {virt_, active_, active_, active_};
616 auto I1046 = make_shared<Tensor>(I1046_index);
617 auto tensor621 = vector<shared_ptr<Tensor>>{I134, v2_, I1046};
618 auto task621 = make_shared<Task621>(tensor621, pindex);
619 task535->add_dep(task621);
620 task621->add_dep(task83);
621 residualq->add_task(task621);
622
623 auto tensor622 = vector<shared_ptr<Tensor>>{I1046, Gamma32_(), t2};
624 auto task622 = make_shared<Task622>(tensor622, pindex);
625 task621->add_dep(task622);
626 task622->add_dep(task83);
627 residualq->add_task(task622);
628
629 vector<IndexRange> I1049_index = {virt_, active_};
630 auto I1049 = make_shared<Tensor>(I1049_index);
631 auto tensor623 = vector<shared_ptr<Tensor>>{I134, v2_, I1049};
632 auto task623 = make_shared<Task623>(tensor623, pindex);
633 task535->add_dep(task623);
634 task623->add_dep(task83);
635 residualq->add_task(task623);
636
637 auto tensor624 = vector<shared_ptr<Tensor>>{I1049, Gamma33_(), t2};
638 auto task624 = make_shared<Task624>(tensor624, pindex);
639 task623->add_dep(task624);
640 task624->add_dep(task83);
641 residualq->add_task(task624);
642
643 vector<IndexRange> I1052_index = {virt_, active_};
644 auto I1052 = make_shared<Tensor>(I1052_index);
645 auto tensor625 = vector<shared_ptr<Tensor>>{I134, v2_, I1052};
646 auto task625 = make_shared<Task625>(tensor625, pindex);
647 task535->add_dep(task625);
648 task625->add_dep(task83);
649 residualq->add_task(task625);
650
651 auto tensor626 = vector<shared_ptr<Tensor>>{I1052, Gamma33_(), t2};
652 auto task626 = make_shared<Task626>(tensor626, pindex);
653 task625->add_dep(task626);
654 task626->add_dep(task83);
655 residualq->add_task(task626);
656
657 vector<IndexRange> I1067_index = {closed_, closed_, closed_, active_};
658 auto I1067 = make_shared<Tensor>(I1067_index);
659 auto tensor627 = vector<shared_ptr<Tensor>>{I134, t2, I1067};
660 auto task627 = make_shared<Task627>(tensor627, pindex);
661 task535->add_dep(task627);
662 task627->add_dep(task83);
663 residualq->add_task(task627);
664
665 auto tensor628 = vector<shared_ptr<Tensor>>{I1067, Gamma27_(), v2_};
666 auto task628 = make_shared<Task628>(tensor628, pindex);
667 task627->add_dep(task628);
668 task628->add_dep(task83);
669 residualq->add_task(task628);
670
671 vector<IndexRange> I1070_index = {closed_, closed_, closed_, active_};
672 auto I1070 = make_shared<Tensor>(I1070_index);
673 auto tensor629 = vector<shared_ptr<Tensor>>{I134, t2, I1070};
674 auto task629 = make_shared<Task629>(tensor629, pindex);
675 task535->add_dep(task629);
676 task629->add_dep(task83);
677 residualq->add_task(task629);
678
679 auto tensor630 = vector<shared_ptr<Tensor>>{I1070, Gamma27_(), v2_};
680 auto task630 = make_shared<Task630>(tensor630, pindex);
681 task629->add_dep(task630);
682 task630->add_dep(task83);
683 residualq->add_task(task630);
684
685 vector<IndexRange> I1097_index = {closed_, closed_, active_, active_};
686 auto I1097 = make_shared<Tensor>(I1097_index);
687 auto tensor631 = vector<shared_ptr<Tensor>>{I134, t2, I1097};
688 auto task631 = make_shared<Task631>(tensor631, pindex);
689 task535->add_dep(task631);
690 task631->add_dep(task83);
691 residualq->add_task(task631);
692
693 vector<IndexRange> I1098_index = {closed_, closed_, active_, active_};
694 auto I1098 = make_shared<Tensor>(I1098_index);
695 auto tensor632 = vector<shared_ptr<Tensor>>{I1097, Gamma33_(), I1098};
696 auto task632 = make_shared<Task632>(tensor632, pindex);
697 task631->add_dep(task632);
698 task632->add_dep(task83);
699 residualq->add_task(task632);
700
701 auto tensor633 = vector<shared_ptr<Tensor>>{I1098, v2_};
702 auto task633 = make_shared<Task633>(tensor633, pindex);
703 task632->add_dep(task633);
704 task633->add_dep(task83);
705 residualq->add_task(task633);
706
707 auto tensor634 = vector<shared_ptr<Tensor>>{I1097, Gamma24_(), v2_};
708 auto task634 = make_shared<Task634>(tensor634, pindex);
709 task631->add_dep(task634);
710 task634->add_dep(task83);
711 residualq->add_task(task634);
712
713 auto tensor635 = vector<shared_ptr<Tensor>>{I1097, Gamma368_(), v2_};
714 auto task635 = make_shared<Task635>(tensor635, pindex);
715 task631->add_dep(task635);
716 task635->add_dep(task83);
717 residualq->add_task(task635);
718
719 vector<IndexRange> I1100_index = {closed_, closed_, active_, active_};
720 auto I1100 = make_shared<Tensor>(I1100_index);
721 auto tensor636 = vector<shared_ptr<Tensor>>{I134, t2, I1100};
722 auto task636 = make_shared<Task636>(tensor636, pindex);
723 task535->add_dep(task636);
724 task636->add_dep(task83);
725 residualq->add_task(task636);
726
727 vector<IndexRange> I1101_index = {closed_, closed_, active_, active_};
728 auto I1101 = make_shared<Tensor>(I1101_index);
729 auto tensor637 = vector<shared_ptr<Tensor>>{I1100, Gamma33_(), I1101};
730 auto task637 = make_shared<Task637>(tensor637, pindex);
731 task636->add_dep(task637);
732 task637->add_dep(task83);
733 residualq->add_task(task637);
734
735 auto tensor638 = vector<shared_ptr<Tensor>>{I1101, v2_};
736 auto task638 = make_shared<Task638>(tensor638, pindex);
737 task637->add_dep(task638);
738 task638->add_dep(task83);
739 residualq->add_task(task638);
740
741 auto tensor639 = vector<shared_ptr<Tensor>>{I1100, Gamma363_(), v2_};
742 auto task639 = make_shared<Task639>(tensor639, pindex);
743 task636->add_dep(task639);
744 task639->add_dep(task83);
745 residualq->add_task(task639);
746
747 vector<IndexRange> I1103_index = {virt_, virt_, active_, active_};
748 auto I1103 = make_shared<Tensor>(I1103_index);
749 auto tensor640 = vector<shared_ptr<Tensor>>{I134, t2, I1103};
750 auto task640 = make_shared<Task640>(tensor640, pindex);
751 task535->add_dep(task640);
752 task640->add_dep(task83);
753 residualq->add_task(task640);
754
755 vector<IndexRange> I1104_index = {virt_, virt_, active_, active_};
756 auto I1104 = make_shared<Tensor>(I1104_index);
757 auto tensor641 = vector<shared_ptr<Tensor>>{I1103, Gamma33_(), I1104};
758 auto task641 = make_shared<Task641>(tensor641, pindex);
759 task640->add_dep(task641);
760 task641->add_dep(task83);
761 residualq->add_task(task641);
762
763 auto tensor642 = vector<shared_ptr<Tensor>>{I1104, v2_};
764 auto task642 = make_shared<Task642>(tensor642, pindex);
765 task641->add_dep(task642);
766 task642->add_dep(task83);
767 residualq->add_task(task642);
768
769 auto tensor643 = vector<shared_ptr<Tensor>>{I1103, Gamma24_(), v2_};
770 auto task643 = make_shared<Task643>(tensor643, pindex);
771 task640->add_dep(task643);
772 task643->add_dep(task83);
773 residualq->add_task(task643);
774
775 auto tensor644 = vector<shared_ptr<Tensor>>{I1103, Gamma368_(), v2_};
776 auto task644 = make_shared<Task644>(tensor644, pindex);
777 task640->add_dep(task644);
778 task644->add_dep(task83);
779 residualq->add_task(task644);
780
781 vector<IndexRange> I1106_index = {virt_, virt_, active_, active_};
782 auto I1106 = make_shared<Tensor>(I1106_index);
783 auto tensor645 = vector<shared_ptr<Tensor>>{I134, t2, I1106};
784 auto task645 = make_shared<Task645>(tensor645, pindex);
785 task535->add_dep(task645);
786 task645->add_dep(task83);
787 residualq->add_task(task645);
788
789 vector<IndexRange> I1107_index = {virt_, virt_, active_, active_};
790 auto I1107 = make_shared<Tensor>(I1107_index);
791 auto tensor646 = vector<shared_ptr<Tensor>>{I1106, Gamma33_(), I1107};
792 auto task646 = make_shared<Task646>(tensor646, pindex);
793 task645->add_dep(task646);
794 task646->add_dep(task83);
795 residualq->add_task(task646);
796
797 auto tensor647 = vector<shared_ptr<Tensor>>{I1107, v2_};
798 auto task647 = make_shared<Task647>(tensor647, pindex);
799 task646->add_dep(task647);
800 task647->add_dep(task83);
801 residualq->add_task(task647);
802
803 auto tensor648 = vector<shared_ptr<Tensor>>{I1106, Gamma24_(), v2_};
804 auto task648 = make_shared<Task648>(tensor648, pindex);
805 task645->add_dep(task648);
806 task648->add_dep(task83);
807 residualq->add_task(task648);
808
809 auto tensor649 = vector<shared_ptr<Tensor>>{I1106, Gamma368_(), v2_};
810 auto task649 = make_shared<Task649>(tensor649, pindex);
811 task645->add_dep(task649);
812 task649->add_dep(task83);
813 residualq->add_task(task649);
814
815 vector<IndexRange> I1109_index = {virt_, virt_, active_, active_};
816 auto I1109 = make_shared<Tensor>(I1109_index);
817 auto tensor650 = vector<shared_ptr<Tensor>>{I134, t2, I1109};
818 auto task650 = make_shared<Task650>(tensor650, pindex);
819 task535->add_dep(task650);
820 task650->add_dep(task83);
821 residualq->add_task(task650);
822
823 vector<IndexRange> I1110_index = {virt_, virt_, active_, active_};
824 auto I1110 = make_shared<Tensor>(I1110_index);
825 auto tensor651 = vector<shared_ptr<Tensor>>{I1109, Gamma33_(), I1110};
826 auto task651 = make_shared<Task651>(tensor651, pindex);
827 task650->add_dep(task651);
828 task651->add_dep(task83);
829 residualq->add_task(task651);
830
831 auto tensor652 = vector<shared_ptr<Tensor>>{I1110, v2_};
832 auto task652 = make_shared<Task652>(tensor652, pindex);
833 task651->add_dep(task652);
834 task652->add_dep(task83);
835 residualq->add_task(task652);
836
837 auto tensor653 = vector<shared_ptr<Tensor>>{I1109, Gamma24_(), v2_};
838 auto task653 = make_shared<Task653>(tensor653, pindex);
839 task650->add_dep(task653);
840 task653->add_dep(task83);
841 residualq->add_task(task653);
842
843 auto tensor654 = vector<shared_ptr<Tensor>>{I1109, Gamma368_(), v2_};
844 auto task654 = make_shared<Task654>(tensor654, pindex);
845 task650->add_dep(task654);
846 task654->add_dep(task83);
847 residualq->add_task(task654);
848
849 vector<IndexRange> I1112_index = {virt_, virt_, active_, active_};
850 auto I1112 = make_shared<Tensor>(I1112_index);
851 auto tensor655 = vector<shared_ptr<Tensor>>{I134, t2, I1112};
852 auto task655 = make_shared<Task655>(tensor655, pindex);
853 task535->add_dep(task655);
854 task655->add_dep(task83);
855 residualq->add_task(task655);
856
857 vector<IndexRange> I1113_index = {virt_, virt_, active_, active_};
858 auto I1113 = make_shared<Tensor>(I1113_index);
859 auto tensor656 = vector<shared_ptr<Tensor>>{I1112, Gamma33_(), I1113};
860 auto task656 = make_shared<Task656>(tensor656, pindex);
861 task655->add_dep(task656);
862 task656->add_dep(task83);
863 residualq->add_task(task656);
864
865 auto tensor657 = vector<shared_ptr<Tensor>>{I1113, v2_};
866 auto task657 = make_shared<Task657>(tensor657, pindex);
867 task656->add_dep(task657);
868 task657->add_dep(task83);
869 residualq->add_task(task657);
870
871 auto tensor658 = vector<shared_ptr<Tensor>>{I1112, Gamma363_(), v2_};
872 auto task658 = make_shared<Task658>(tensor658, pindex);
873 task655->add_dep(task658);
874 task658->add_dep(task83);
875 residualq->add_task(task658);
876
877 auto tensor659 = vector<shared_ptr<Tensor>>{I1112, v2_, Gamma33_()};
878 auto task659 = make_shared<Task659>(tensor659, pindex);
879 task655->add_dep(task659);
880 task659->add_dep(task83);
881 residualq->add_task(task659);
882
883 vector<IndexRange> I1199_index = {closed_, active_, active_, active_};
884 auto I1199 = make_shared<Tensor>(I1199_index);
885 auto tensor660 = vector<shared_ptr<Tensor>>{I134, t2, I1199};
886 auto task660 = make_shared<Task660>(tensor660, pindex);
887 task535->add_dep(task660);
888 task660->add_dep(task83);
889 residualq->add_task(task660);
890
891 auto tensor661 = vector<shared_ptr<Tensor>>{I1199, Gamma32_(), v2_};
892 auto task661 = make_shared<Task661>(tensor661, pindex);
893 task660->add_dep(task661);
894 task661->add_dep(task83);
895 residualq->add_task(task661);
896
897 auto tensor662 = vector<shared_ptr<Tensor>>{I1199, Gamma391_(), v2_};
898 auto task662 = make_shared<Task662>(tensor662, pindex);
899 task660->add_dep(task662);
900 task662->add_dep(task83);
901 residualq->add_task(task662);
902
903 vector<IndexRange> I1205_index = {virt_, virt_, active_, active_};
904 auto I1205 = make_shared<Tensor>(I1205_index);
905 auto tensor663 = vector<shared_ptr<Tensor>>{I134, v2_, I1205};
906 auto task663 = make_shared<Task663>(tensor663, pindex);
907 task535->add_dep(task663);
908 task663->add_dep(task83);
909 residualq->add_task(task663);
910
911 auto tensor664 = vector<shared_ptr<Tensor>>{I1205, Gamma33_(), t2};
912 auto task664 = make_shared<Task664>(tensor664, pindex);
913 task663->add_dep(task664);
914 task664->add_dep(task83);
915 residualq->add_task(task664);
916
917 vector<IndexRange> I1208_index = {virt_, virt_, active_, active_};
918 auto I1208 = make_shared<Tensor>(I1208_index);
919 auto tensor665 = vector<shared_ptr<Tensor>>{I134, v2_, I1208};
920 auto task665 = make_shared<Task665>(tensor665, pindex);
921 task535->add_dep(task665);
922 task665->add_dep(task83);
923 residualq->add_task(task665);
924
925 auto tensor666 = vector<shared_ptr<Tensor>>{I1208, Gamma33_(), t2};
926 auto task666 = make_shared<Task666>(tensor666, pindex);
927 task665->add_dep(task666);
928 task666->add_dep(task83);
929 residualq->add_task(task666);
930
931 vector<IndexRange> I1211_index = {virt_, virt_, active_, active_};
932 auto I1211 = make_shared<Tensor>(I1211_index);
933 auto tensor667 = vector<shared_ptr<Tensor>>{I134, v2_, I1211};
934 auto task667 = make_shared<Task667>(tensor667, pindex);
935 task535->add_dep(task667);
936 task667->add_dep(task83);
937 residualq->add_task(task667);
938
939 auto tensor668 = vector<shared_ptr<Tensor>>{I1211, Gamma368_(), t2};
940 auto task668 = make_shared<Task668>(tensor668, pindex);
941 task667->add_dep(task668);
942 task668->add_dep(task83);
943 residualq->add_task(task668);
944
945 vector<IndexRange> I1214_index = {virt_, virt_, active_, active_};
946 auto I1214 = make_shared<Tensor>(I1214_index);
947 auto tensor669 = vector<shared_ptr<Tensor>>{I134, v2_, I1214};
948 auto task669 = make_shared<Task669>(tensor669, pindex);
949 task535->add_dep(task669);
950 task669->add_dep(task83);
951 residualq->add_task(task669);
952
953 auto tensor670 = vector<shared_ptr<Tensor>>{I1214, Gamma33_(), t2};
954 auto task670 = make_shared<Task670>(tensor670, pindex);
955 task669->add_dep(task670);
956 task670->add_dep(task83);
957 residualq->add_task(task670);
958
959 vector<IndexRange> I1297_index = {active_, virt_, closed_, virt_};
960 auto I1297 = make_shared<Tensor>(I1297_index);
961 auto tensor671 = vector<shared_ptr<Tensor>>{I134, Gamma428_(), I1297};
962 auto task671 = make_shared<Task671>(tensor671, pindex);
963 task535->add_dep(task671);
964 task671->add_dep(task83);
965 residualq->add_task(task671);
966
967 auto tensor672 = vector<shared_ptr<Tensor>>{I1297, t2};
968 auto task672 = make_shared<Task672>(tensor672, pindex);
969 task671->add_dep(task672);
970 task672->add_dep(task83);
971 residualq->add_task(task672);
972
973 vector<IndexRange> I1301_index = {active_, virt_, closed_, virt_};
974 auto I1301 = make_shared<Tensor>(I1301_index);
975 auto tensor673 = vector<shared_ptr<Tensor>>{I134, Gamma430_(), I1301};
976 auto task673 = make_shared<Task673>(tensor673, pindex);
977 task535->add_dep(task673);
978 task673->add_dep(task83);
979 residualq->add_task(task673);
980
981 auto tensor674 = vector<shared_ptr<Tensor>>{I1301, t2};
982 auto task674 = make_shared<Task674>(tensor674, pindex);
983 task673->add_dep(task674);
984 task674->add_dep(task83);
985 residualq->add_task(task674);
986 }
987
988 #endif
989