1 //
2 // BAGEL - Brilliantly Advanced General Electronic Structure Library
3 // Filename: MRCI_normqq.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/mrci/MRCI.h>
30 #include <src/smith/mrci/MRCI_tasks20.h>
31
32 using namespace std;
33 using namespace bagel;
34 using namespace bagel::SMITH;
35
make_normq(const bool reset,const bool diagonal)36 shared_ptr<Queue> MRCI::MRCI::make_normq(const bool reset, const bool diagonal) {
37
38 array<shared_ptr<const IndexRange>,3> pindex = {{rclosed_, ractive_, rvirt_}};
39 auto normq = make_shared<Queue>();
40 auto tensor967 = vector<shared_ptr<Tensor>>{n};
41 auto task967 = make_shared<Task967>(tensor967, reset);
42 normq->add_task(task967);
43
44 vector<IndexRange> I1774_index = {active_, active_, closed_, closed_};
45 auto I1774 = make_shared<Tensor>(I1774_index);
46 auto tensor968 = vector<shared_ptr<Tensor>>{n, I1774};
47 auto task968 = make_shared<Task968>(tensor968, pindex);
48 task968->add_dep(task967);
49 normq->add_task(task968);
50
51 auto tensor969 = vector<shared_ptr<Tensor>>{I1774, t2, Gamma0_()};
52 auto task969 = make_shared<Task969>(tensor969, pindex);
53 task968->add_dep(task969);
54 task969->add_dep(task967);
55 normq->add_task(task969);
56
57 vector<IndexRange> I1776_index = {active_, active_, active_, closed_};
58 auto I1776 = make_shared<Tensor>(I1776_index);
59 auto tensor970 = vector<shared_ptr<Tensor>>{n, I1776};
60 auto task970 = make_shared<Task970>(tensor970, pindex);
61 task970->add_dep(task967);
62 normq->add_task(task970);
63
64 auto tensor971 = vector<shared_ptr<Tensor>>{I1776, t2, Gamma4_()};
65 auto task971 = make_shared<Task971>(tensor971, pindex);
66 task970->add_dep(task971);
67 task971->add_dep(task967);
68 normq->add_task(task971);
69
70 vector<IndexRange> I1778_index = {active_, closed_, virt_, closed_};
71 auto I1778 = make_shared<Tensor>(I1778_index);
72 auto tensor972 = vector<shared_ptr<Tensor>>{n, I1778};
73 auto task972 = make_shared<Task972>(tensor972, pindex);
74 task972->add_dep(task967);
75 normq->add_task(task972);
76
77 auto tensor973 = vector<shared_ptr<Tensor>>{I1778, t2, Gamma12_()};
78 auto task973 = make_shared<Task973>(tensor973, pindex);
79 task972->add_dep(task973);
80 task973->add_dep(task967);
81 normq->add_task(task973);
82
83 auto tensor974 = vector<shared_ptr<Tensor>>{I1778, t2, Gamma12_()};
84 auto task974 = make_shared<Task974>(tensor974, pindex);
85 task972->add_dep(task974);
86 task974->add_dep(task967);
87 normq->add_task(task974);
88
89 vector<IndexRange> I1782_index = {active_, active_, virt_, closed_};
90 auto I1782 = make_shared<Tensor>(I1782_index);
91 auto tensor975 = vector<shared_ptr<Tensor>>{n, I1782};
92 auto task975 = make_shared<Task975>(tensor975, pindex);
93 task975->add_dep(task967);
94 normq->add_task(task975);
95
96 auto tensor976 = vector<shared_ptr<Tensor>>{I1782, t2, Gamma27_()};
97 auto task976 = make_shared<Task976>(tensor976, pindex);
98 task975->add_dep(task976);
99 task976->add_dep(task967);
100 normq->add_task(task976);
101
102 auto tensor977 = vector<shared_ptr<Tensor>>{I1782, t2, Gamma29_()};
103 auto task977 = make_shared<Task977>(tensor977, pindex);
104 task975->add_dep(task977);
105 task977->add_dep(task967);
106 normq->add_task(task977);
107
108 vector<IndexRange> I1786_index = {active_, active_, virt_, closed_};
109 auto I1786 = make_shared<Tensor>(I1786_index);
110 auto tensor978 = vector<shared_ptr<Tensor>>{n, I1786};
111 auto task978 = make_shared<Task978>(tensor978, pindex);
112 task978->add_dep(task967);
113 normq->add_task(task978);
114
115 auto tensor979 = vector<shared_ptr<Tensor>>{I1786, t2, Gamma29_()};
116 auto task979 = make_shared<Task979>(tensor979, pindex);
117 task978->add_dep(task979);
118 task979->add_dep(task967);
119 normq->add_task(task979);
120
121 auto tensor980 = vector<shared_ptr<Tensor>>{I1786, t2, Gamma29_()};
122 auto task980 = make_shared<Task980>(tensor980, pindex);
123 task978->add_dep(task980);
124 task980->add_dep(task967);
125 normq->add_task(task980);
126
127 vector<IndexRange> I1790_index = {active_, active_, active_, virt_};
128 auto I1790 = make_shared<Tensor>(I1790_index);
129 auto tensor981 = vector<shared_ptr<Tensor>>{n, I1790};
130 auto task981 = make_shared<Task981>(tensor981, pindex);
131 task981->add_dep(task967);
132 normq->add_task(task981);
133
134 auto tensor982 = vector<shared_ptr<Tensor>>{I1790, t2, Gamma50_()};
135 auto task982 = make_shared<Task982>(tensor982, pindex);
136 task981->add_dep(task982);
137 task982->add_dep(task967);
138 normq->add_task(task982);
139
140 shared_ptr<Tensor> I1792;
141 if (diagonal) {
142 vector<IndexRange> I1792_index = {closed_, virt_, closed_, virt_};
143 I1792 = make_shared<Tensor>(I1792_index);
144 }
145 shared_ptr<Task983> task983;
146 if (diagonal) {
147 auto tensor983 = vector<shared_ptr<Tensor>>{n, I1792};
148 task983 = make_shared<Task983>(tensor983, pindex);
149 task983->add_dep(task967);
150 normq->add_task(task983);
151 }
152
153 shared_ptr<Task984> task984;
154 if (diagonal) {
155 auto tensor984 = vector<shared_ptr<Tensor>>{I1792, t2};
156 task984 = make_shared<Task984>(tensor984, pindex);
157 task983->add_dep(task984);
158 task984->add_dep(task967);
159 normq->add_task(task984);
160 }
161
162 vector<IndexRange> I1794_index = {active_, virt_, closed_, virt_};
163 auto I1794 = make_shared<Tensor>(I1794_index);
164 auto tensor985 = vector<shared_ptr<Tensor>>{n, I1794};
165 auto task985 = make_shared<Task985>(tensor985, pindex);
166 task985->add_dep(task967);
167 normq->add_task(task985);
168
169 auto tensor986 = vector<shared_ptr<Tensor>>{I1794, t2, Gamma32_()};
170 auto task986 = make_shared<Task986>(tensor986, pindex);
171 task985->add_dep(task986);
172 task986->add_dep(task967);
173 normq->add_task(task986);
174
175 auto tensor987 = vector<shared_ptr<Tensor>>{I1794, Gamma32_(), t2};
176 auto task987 = make_shared<Task987>(tensor987, pindex);
177 task985->add_dep(task987);
178 task987->add_dep(task967);
179 normq->add_task(task987);
180
181 vector<IndexRange> I1798_index = {active_, active_, virt_, virt_};
182 auto I1798 = make_shared<Tensor>(I1798_index);
183 auto tensor988 = vector<shared_ptr<Tensor>>{n, I1798};
184 auto task988 = make_shared<Task988>(tensor988, pindex);
185 task988->add_dep(task967);
186 normq->add_task(task988);
187
188 auto tensor989 = vector<shared_ptr<Tensor>>{I1798, t2, Gamma51_()};
189 auto task989 = make_shared<Task989>(tensor989, pindex);
190 task988->add_dep(task989);
191 task989->add_dep(task967);
192 normq->add_task(task989);
193
194 return normq;
195 }
196
197
198 #endif
199