← Back to branch summary

~ubuntu-branches/ubuntu/vivid/psicode/vivid

« back to all changes in this revision

Viewing changes to src/bin/detcas/indpairs.cc

  • Committer: Bazaar Package Importer
  • Author(s): Michael Banck
  • Date: 2008-06-07 16:49:57 UTC
  • mfrom: (2.1.2 hardy)
  • Revision ID: james.westby@ubuntu.com-20080607164957-8pifvb133yjlkagn
Tags: 3.3.0-3
http://bugs.debian.org/464867
* debian/rules (DEB_MAKE_CHECK_TARGET): Do not abort test suite on
  failures.
* debian/rules (DEB_CONFIGURE_EXTRA_FLAGS): Set ${bindir} to /usr/lib/psi.
* debian/rules (install/psi3): Move psi3 file to /usr/bin.
* debian/patches/07_464867_move_executables.dpatch: New patch, add
  /usr/lib/psi to the $PATH, so that the moved executables are found.
  (closes: #464867)
* debian/patches/00list: Adjusted.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/bin/detcas/indpairs.cc
36
36
 
37
37
// Regular constructor
38
38
IndepPairs::IndepPairs(int nirr, int num_ras, int **ras_opi, int ***ras_orbs,
39
 
                       int **fzc_orbs, int **fzv_orbs, int *frozen_docc, 
40
 
                       int *frozen_uocc, int *ci2relpitz, int fciflag) 
 
39
  int *fzc, int **fzc_orbs, int *cor, int **cor_orbs,
 
40
  int *vir, int **vir_orbs, int *fzv, int **fzv_orbs,
 
41
  int *ci2relpitz, int ignore_ras_ras, int ignore_fz) 
41
42
{
42
43
 
43
 
  set(nirr, num_ras, ras_opi, ras_orbs, fzc_orbs, fzv_orbs, 
44
 
      frozen_docc, frozen_uocc, ci2relpitz, fciflag);
 
44
  set(nirr, num_ras, ras_opi, ras_orbs, fzc, fzc_orbs, cor, cor_orbs,
 
45
      vir, vir_orbs, fzv, fzv_orbs, ci2relpitz, ignore_ras_ras, ignore_fz);
45
46
 
46
47
}
47
48
 
 
49
/*!
 
50
** set()
 
51
**
 
52
** This function sets the independent pairs info
 
53
**
 
54
** \param nirr           = number of irreps in point group
 
55
** \param num_ras        = number of RAS spaces
 
56
** \param ras_opi        = number of orbitals per irrep per RAS space
 
57
** \param ras_orbs       = ras_orbs[ras][irr][cnt] gives an orbital number
 
58
** \param fzc            = number of frozen core orbs per irrep
 
59
** \param fzc_orbs       = fzc_orbs[irr][cnt] gives an orbital number
 
60
** \param cor            = number of restricted core orbs per irrep
 
61
** \param cor_orbs       = cor_orbs[irr][cnt] gives an orbital number
 
62
** \param vir            = number of restricted virtual orbitals per irrep
 
63
** \param vir_orbs       = vir_orbs[irr][cnt] gives an orbital number
 
64
** \param fzv            = number of frozen virtual orbitals per irrep 
 
65
** \param fzv_orbs       = fzv_orbs[irr][cnt] gives an orbital number
 
66
** \param ci2relpitz     = maps CI orbitals to relative Pitzer indices
 
67
** \param ignore_ras_ras = ignore RAS/RAS independent pairs
 
68
** \param ignore_fz      = ignore FZC and FZV from all independent pairs
 
69
** 
 
70
*/
 
71
 
48
72
void IndepPairs::set(int nirr, int num_ras, int **ras_opi, int ***ras_orbs,
49
 
                    int **fzc_orbs, int **fzv_orbs, int *frozen_docc, 
50
 
                    int *frozen_uocc, int *ci2relpitz, int fciflag) 
 
73
                     int *fzc, int **fzc_orbs,
 
74
                     int *cor, int **cor_orbs,
 
75
                     int *vir, int **vir_orbs,
 
76
                     int *fzv, int **fzv_orbs,
 
77
                     int *ci2relpitz, int ignore_ras_ras, int ignore_fz) 
51
78
{
52
79
  int count, ir_count, *ir_cnt;
53
80
  int rasi, rasj, irrep;
60
87
 
61
88
  for (irrep=0; irrep<nirreps; irrep++) ir_npairs[irrep] = 0;
62
89
 
 
90
  if (!ignore_fz) {
 
91
    // FZC / COR
 
92
    for (irrep=0; irrep<nirreps; irrep++)
 
93
      ir_npairs[irrep] += fzc[irrep] * cor[irrep];
 
94
 
 
95
    // FZC / RAS
 
96
    for (rasj=0; rasj<num_ras; rasj++)
 
97
      for (irrep=0; irrep<nirreps; irrep++) 
 
98
        ir_npairs[irrep] += ras_opi[rasj][irrep] * fzc[irrep];
 
99
 
 
100
    // FZC / VIR
 
101
    for (irrep=0; irrep<nirreps; irrep++)
 
102
      ir_npairs[irrep] += fzc[irrep] * vir[irrep];
 
103
 
 
104
    // FZC / FZV
 
105
    for (irrep=0; irrep<nirreps; irrep++)
 
106
      ir_npairs[irrep] += fzc[irrep] * fzv[irrep];
 
107
 
 
108
  }
 
109
 
 
110
  // COR / RAS
63
111
  for (rasj=0; rasj<num_ras; rasj++)
64
112
    for (irrep=0; irrep<nirreps; irrep++) 
65
 
      ir_npairs[irrep] += ras_opi[rasj][irrep] * frozen_docc[irrep];
66
 
 
67
 
  if (!fciflag) {
 
113
      ir_npairs[irrep] += ras_opi[rasj][irrep] * cor[irrep];
 
114
 
 
115
  // COR / VIR
 
116
  for (irrep=0; irrep<nirreps; irrep++)
 
117
    ir_npairs[irrep] += cor[irrep] * vir[irrep];
 
118
 
 
119
  // RAS / RAS
 
120
  if (!ignore_ras_ras) {
68
121
    for (rasj=0; rasj<num_ras; rasj++)
69
122
      for (rasi=rasj+1; rasi<num_ras; rasi++)
70
123
        for (irrep=0; irrep<nirreps; irrep++)
71
124
          ir_npairs[irrep] += ras_opi[rasi][irrep] * ras_opi[rasj][irrep];
72
125
  }
73
126
 
 
127
  // VIR / RAS
74
128
  for (rasj=0; rasj<num_ras; rasj++)
75
129
    for (irrep=0; irrep<nirreps; irrep++)
76
 
      ir_npairs[irrep] += ras_opi[rasj][irrep] * frozen_uocc[irrep];
77
 
 
78
 
  for (irrep=0; irrep<nirreps; irrep++)
79
 
    ir_npairs[irrep] += frozen_docc[irrep] * frozen_uocc[irrep];
 
130
      ir_npairs[irrep] += ras_opi[rasj][irrep] * vir[irrep];
 
131
 
 
132
  if (!ignore_fz) {
 
133
    // FZV / COR
 
134
    for (irrep=0; irrep<nirreps; irrep++)
 
135
      ir_npairs[irrep] += fzv[irrep] * cor[irrep];
 
136
    
 
137
    // FZV / RAS
 
138
    for (rasj=0; rasj<num_ras; rasj++)
 
139
      for (irrep=0; irrep<nirreps; irrep++)
 
140
        ir_npairs[irrep] += ras_opi[rasj][irrep] * fzv[irrep];
 
141
 
 
142
    // FZV / VIR
 
143
    for (irrep=0; irrep<nirreps; irrep++)
 
144
      ir_npairs[irrep] += fzv[irrep] * vir[irrep];
 
145
  }
80
146
 
81
147
  npairs = 0;
82
148
  for (irrep=0; irrep<nirreps; irrep++) 
85
151
  if (npairs==0)  {
86
152
    printf("(IndepPairs): Constructor called but no pairs!!\n");
87
153
    fprintf(stderr, "(IndepPairs): Constructor called but no pairs!!\n");
88
 
  }
89
 
 
90
 
  else {
91
 
    p = new int[npairs];
92
 
    q = new int[npairs];
93
 
    map_pair_ir  = new int[npairs];
94
 
    map_pair_rel = new int[npairs]; 
95
 
 
96
 
    ir_p = new int*[nirreps];
97
 
    ir_q = new int*[nirreps];
98
 
    ir_p_rel = new int*[nirreps];
99
 
    ir_q_rel = new int*[nirreps];
100
 
    ir_map_pair = new int*[nirreps];
101
 
 
102
 
    for (irrep=0; irrep<nirreps; irrep++) {
103
 
      i = ir_npairs[irrep];
104
 
      if (!i) continue;
105
 
      ir_p[irrep] = new int[i];
106
 
      ir_q[irrep] = new int[i];
107
 
      ir_p_rel[irrep] = new int[i];
108
 
      ir_q_rel[irrep] = new int[i];
109
 
      ir_map_pair[irrep] = new int[i];
110
 
    }
111
 
 
112
 
    ir_cnt = new int[nirreps];
113
 
    for (irrep=0; irrep<nirreps; irrep++) ir_cnt[irrep] = 0; 
114
 
    count = 0;
115
 
 
116
 
    // Now put everything in the proper arrays
117
 
 
118
 
    // Independent pairs for fzc with rasj 
119
 
    for (rasj=0; rasj<num_ras; rasj++) {
120
 
      for (irrep=0; irrep<nirreps; irrep++) {
121
 
        ir_count = ir_cnt[irrep];
122
 
        for (i=0; i<ras_opi[rasj][irrep]; i++) {
123
 
          for (j=0; j<frozen_docc[irrep]; j++) {
124
 
            p[count] = ras_orbs[rasj][irrep][i];
125
 
            q[count] = fzc_orbs[irrep][j];
126
 
            map_pair_ir[count] = irrep;
127
 
            map_pair_rel[count] = ir_count;
128
 
            ir_p[irrep][ir_count] = p[count];
129
 
            ir_q[irrep][ir_count] = q[count];
130
 
            ir_p_rel[irrep][ir_count] = ci2relpitz[p[count]];
131
 
            ir_q_rel[irrep][ir_count] = ci2relpitz[q[count]];
132
 
            ir_map_pair[irrep][ir_count] = count;
133
 
            count++;
134
 
            ir_count++;
135
 
          }
136
 
        }
137
 
      ir_cnt[irrep] = ir_count;
138
 
      }
139
 
    }
140
 
 
141
 
 
142
 
    // Independent pairs for rasi with rasj 
143
 
    if (!fciflag) {
144
 
      for (rasj=0; rasj<num_ras; rasj++) {
145
 
        for (rasi=rasj+1; rasi<num_ras; rasi++) {
146
 
          for (irrep=0; irrep<nirreps; irrep++) {
147
 
            ir_count = ir_cnt[irrep];
148
 
            for (j=0; j<ras_opi[rasj][irrep]; j++) {
149
 
              for (i=0; i<ras_opi[rasi][irrep]; i++) {
150
 
                p[count] = ras_orbs[rasi][irrep][i];
151
 
                q[count] = ras_orbs[rasj][irrep][j];
152
 
                map_pair_ir[count] = irrep;
153
 
                map_pair_rel[count] = ir_count;
154
 
                ir_p[irrep][ir_count] = p[count];
155
 
                ir_q[irrep][ir_count] = q[count];
156
 
                ir_p_rel[irrep][ir_count] = ci2relpitz[p[count]];
157
 
                ir_q_rel[irrep][ir_count] = ci2relpitz[q[count]];
158
 
                ir_map_pair[irrep][ir_count] = count;
159
 
                count++;
160
 
                ir_count++;
161
 
              }
162
 
            }
163
 
          ir_cnt[irrep] = ir_count;
164
 
          }
165
 
        }
166
 
      }
167
 
    }
168
 
 
169
 
    // Independent pairs for fzv with rasj 
170
 
    for (rasj=0; rasj<num_ras; rasj++) {
171
 
      for (irrep=0; irrep<nirreps; irrep++) {
172
 
        ir_count = ir_cnt[irrep];
173
 
        for (j=0; j<ras_opi[rasj][irrep]; j++) {
174
 
          for (i=0; i<frozen_uocc[irrep]; i++) {
175
 
            p[count] = fzv_orbs[irrep][i];
176
 
            q[count] = ras_orbs[rasj][irrep][j];
177
 
            map_pair_ir[count] = irrep;
178
 
            map_pair_rel[count] = ir_count;
179
 
            ir_p[irrep][ir_count] = p[count];
180
 
            ir_q[irrep][ir_count] = q[count];
181
 
            ir_p_rel[irrep][ir_count] = ci2relpitz[p[count]];
182
 
            ir_q_rel[irrep][ir_count] = ci2relpitz[q[count]];
183
 
            ir_map_pair[irrep][ir_count] = count;
184
 
            count++;
185
 
            ir_count++;
186
 
          }
187
 
        }
188
 
        ir_cnt[irrep] = ir_count;
189
 
      }
190
 
    }
191
 
 
192
 
    // Independent pairs for fzc with fzv 
193
 
    for (irrep=0; irrep<nirreps; irrep++) {
194
 
      ir_count = ir_cnt[irrep];
195
 
      for (i=0; i<frozen_uocc[irrep]; i++) {
196
 
        for (j=0; j<frozen_docc[irrep]; j++) {
197
 
          p[count] = fzv_orbs[irrep][i];
198
 
          q[count] = fzc_orbs[irrep][j];
199
 
          map_pair_ir[count] = irrep;
200
 
          map_pair_rel[count] = ir_count;
201
 
          ir_p[irrep][ir_count] = p[count];
202
 
          ir_q[irrep][ir_count] = q[count];
203
 
          ir_p_rel[irrep][ir_count] = ci2relpitz[p[count]];
204
 
          ir_q_rel[irrep][ir_count] = ci2relpitz[q[count]];
205
 
          ir_map_pair[irrep][ir_count] = count;
206
 
          count++;
207
 
          ir_count++;
208
 
        }
209
 
      }
210
 
      ir_cnt[irrep] = ir_count;
211
 
    }
212
 
 
213
 
    // check things
214
 
    if (count != npairs) {
215
 
      printf("(IndepPairs::set): mismatch in counted pairs!\n");
216
 
      fprintf(stderr, "(IndepPairs::set): mismatch in counted pairs!\n");
217
 
    }
218
 
 
219
 
  } 
220
 
 
221
 
}
222
 
 
 
154
    return;
 
155
  }
 
156
 
 
157
  // Start making the pairs --- first, allocate the arrays
 
158
  p = new int[npairs];
 
159
  q = new int[npairs];
 
160
  map_pair_ir  = new int[npairs];
 
161
  map_pair_rel = new int[npairs]; 
 
162
 
 
163
  ir_p = new int*[nirreps];
 
164
  ir_q = new int*[nirreps];
 
165
  ir_p_rel = new int*[nirreps];
 
166
  ir_q_rel = new int*[nirreps];
 
167
  ir_map_pair = new int*[nirreps];
 
168
 
 
169
  for (irrep=0; irrep<nirreps; irrep++) {
 
170
    i = ir_npairs[irrep];
 
171
    if (!i) continue;
 
172
    ir_p[irrep] = new int[i];
 
173
    ir_q[irrep] = new int[i];
 
174
    ir_p_rel[irrep] = new int[i];
 
175
    ir_q_rel[irrep] = new int[i];
 
176
    ir_map_pair[irrep] = new int[i];
 
177
  }
 
178
 
 
179
  ir_cnt = new int[nirreps];
 
180
  for (irrep=0; irrep<nirreps; irrep++) ir_cnt[irrep] = 0; 
 
181
  count = 0;
 
182
 
 
183
  // Now put everything in the proper arrays
 
184
 
 
185
  if (!ignore_fz) {
 
186
 
 
187
    // FZC / COR
 
188
    set_part(count, ir_cnt, cor, fzc, cor_orbs, fzc_orbs, ci2relpitz);
 
189
 
 
190
    // FZC / RAS
 
191
    for (rasj=0; rasj<num_ras; rasj++) {
 
192
      set_part(count, ir_cnt, ras_opi[rasj], fzc, ras_orbs[rasj], fzc_orbs,
 
193
               ci2relpitz); 
 
194
    }
 
195
 
 
196
    // FZC / VIR
 
197
    set_part(count, ir_cnt, vir, fzc, vir_orbs, fzc_orbs, ci2relpitz);
 
198
 
 
199
    // FZC / FZV
 
200
    set_part(count, ir_cnt, fzv, fzc, fzv_orbs, fzc_orbs, ci2relpitz);
 
201
 
 
202
  }
 
203
 
 
204
  // COR / RAS
 
205
  for (rasj=0; rasj<num_ras; rasj++) {
 
206
    set_part(count, ir_cnt, ras_opi[rasj], cor, ras_orbs[rasj], cor_orbs,
 
207
             ci2relpitz); 
 
208
  }
 
209
 
 
210
  // COR / VIR
 
211
  set_part(count, ir_cnt, vir, cor, vir_orbs, cor_orbs, ci2relpitz); 
 
212
 
 
213
  // COR / FZV
 
214
  if (!ignore_fz)
 
215
    set_part(count, ir_cnt, fzv, cor, fzv_orbs, cor_orbs, ci2relpitz);
 
216
 
 
217
  // RAS / RAS
 
218
  if (!ignore_ras_ras) {
 
219
    for (rasj=0; rasj<num_ras; rasj++) {
 
220
      for (rasi=rasj+1; rasi<num_ras; rasi++) {
 
221
        set_part(count, ir_cnt, ras_opi[rasi], ras_opi[rasj],
 
222
          ras_orbs[rasi], ras_orbs[rasj], ci2relpitz);
 
223
      }
 
224
    }
 
225
  }
 
226
 
 
227
  // RAS / VIR
 
228
  for (rasj=0; rasj<num_ras; rasj++) {
 
229
    set_part(count, ir_cnt, vir, ras_opi[rasj], vir_orbs, ras_orbs[rasj], 
 
230
             ci2relpitz); 
 
231
  }
 
232
 
 
233
  // RAS / FZV
 
234
  if (!ignore_fz) {
 
235
    for (rasj=0; rasj<num_ras; rasj++) {
 
236
      set_part(count, ir_cnt, fzv, ras_opi[rasj], fzv_orbs, ras_orbs[rasj], 
 
237
               ci2relpitz); 
 
238
    }
 
239
  }
 
240
 
 
241
  // VIR / FZV
 
242
  if (!ignore_fz)
 
243
    set_part(count, ir_cnt, fzv, vir, fzv_orbs, vir_orbs, ci2relpitz);
 
244
 
 
245
  // check things
 
246
  if (count != npairs) {
 
247
    printf("(IndepPairs::set): mismatch in counted pairs!\n");
 
248
    fprintf(stderr, "(IndepPairs::set): mismatch in counted pairs!\n");
 
249
  }
 
250
 
 
251
 
 
252
}
 
253
 
 
254
 
 
255
/*!
 
256
** set_part()
 
257
**
 
258
** This function does the dirty work in setting up the independent pair
 
259
** arrays.
 
260
**
 
261
** \param count      = number of independent pairs so far
 
262
** \param ir_cnt     = count per irrep
 
263
** \param num_orbs_i = number of orbitals per irrep, pair i
 
264
** \param num_orbs_j = number of orbitals per irrep, pair j
 
265
** \param orbs_i     = orbital number for [irrep][cnt], pair i
 
266
** \param orbs_j     = orbital number for [irrep][cnt], pair j
 
267
** \param ci2relpitz = map CI orbital to relative Pitzer numbering
 
268
*/
 
269
void IndepPairs::set_part(int &count, int *ir_cnt, 
 
270
  int *num_orbs_i, int *num_orbs_j, int **orbs_i, int **orbs_j, 
 
271
  int *ci2relpitz)
 
272
{
 
273
  int i, j, irrep;
 
274
  int ir_count;
 
275
 
 
276
  for (irrep=0; irrep<nirreps; irrep++) {
 
277
    ir_count = ir_cnt[irrep];
 
278
    for (i=0; i<num_orbs_i[irrep]; i++) {
 
279
      for (j=0; j<num_orbs_j[irrep]; j++) {
 
280
        p[count] = orbs_i[irrep][i];
 
281
        q[count] = orbs_j[irrep][j];
 
282
        map_pair_ir[count] = irrep;
 
283
        map_pair_rel[count] = ir_count;
 
284
        ir_p[irrep][ir_count] = p[count];
 
285
        ir_q[irrep][ir_count] = q[count];
 
286
        ir_p_rel[irrep][ir_count] = ci2relpitz[p[count]];
 
287
        ir_q_rel[irrep][ir_count] = ci2relpitz[q[count]];
 
288
        ir_map_pair[irrep][ir_count] = count;
 
289
        count++;
 
290
        ir_count++;
 
291
      }
 
292
    }
 
293
  ir_cnt[irrep] = ir_count;
 
294
  }
 
295
 
 
296
}
223
297
 
224
298
 
225
299
IndepPairs::~IndepPairs() // Destructor
315
389
 
316
390
  fprintf(outfile, "%s\n", label);
317
391
  for (pair=0; pair<npairs; pair++) {
318
 
    fprintf(outfile, "Pair (%2d,%2d) = %12.6lf\n",
 
392
    fprintf(outfile, "Pair (%2d,%2d) = %12.7lf\n",
319
393
            p[pair], q[pair], arr[pair]);
320
394
  }
321
395
  fprintf(outfile, "\n");