← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/bin/cclambda/get_params.cc

  • Committer: Bazaar Package Importer
  • Author(s): Michael Banck, Michael Banck, Daniel Leidert
  • Date: 2009-02-23 00:12:02 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090223001202-rutldoy3dimfpesc
Tags: 3.4.0-1
* New upstream release.

[ Michael Banck ]
* debian/patches/01_DESTDIR.dpatch: Refreshed.
* debian/patches/02_FHS.dpatch: Removed, applied upstream.
* debian/patches/03_debian_docdir: Likewise.
* debian/patches/04_man.dpatch: Likewise.
* debian/patches/06_466828_fix_gcc_43_ftbfs.dpatch: Likewise.
* debian/patches/07_464867_move_executables: Fixed and refreshed.
* debian/patches/00list: Adjusted.
* debian/control: Improved description.
* debian/patches-held: Removed.
* debian/rules (install/psi3): Do not ship the ruby bindings for now.

[ Daniel Leidert ]
* debian/rules: Fix txtdir via DEB_MAKE_INSTALL_TARGET.
* debian/patches/01_DESTDIR.dpatch: Refreshed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/bin/cclambda/get_params.cc
 
1
/*! \file
 
2
    \ingroup CCLAMBDA
 
3
    \brief Enter brief description of file here 
 
4
*/
 
5
#include <cstdio>
 
6
#include <cstdlib>
 
7
#include <cstring>
 
8
#include <cmath>
 
9
#include <libipv1/ip_lib.h>
 
10
#include <libciomr/libciomr.h>
 
11
#include <psifiles.h>
 
12
#include <libqt/qt.h>
 
13
#include <libchkpt/chkpt.h>
 
14
#include "MOInfo.h"
 
15
#include "Params.h"
 
16
#include "Local.h"
 
17
#define EXTERN
 
18
#include "globals.h"
 
19
 
 
20
namespace psi { namespace cclambda {
 
21
 
 
22
void get_params(void)
 
23
{
 
24
  int errcod, iconv,i,j,k,l,prop_sym,prop_root, excited_method=0;
 
25
        int *states_per_irrep, prop_all, lambda_and_Ls = 0;
 
26
  char lbl[32];
 
27
  char *junk;
 
28
 
 
29
  /* check WFN keyword in input */
 
30
  errcod = ip_string("WFN", &(params.wfn), 0);
 
31
        excited_method = cc_excited(params.wfn);
 
32
 
 
33
  if(!strcmp(params.wfn,"CC2") || !strcmp(params.wfn,"EOM_CC2")) {
 
34
    psio_read_entry(CC_INFO, "CC2 Energy", (char *) &(moinfo.ecc),
 
35
                    sizeof(double));
 
36
    fprintf(outfile,  "\tCC2 energy          (CC_INFO) = %20.15f\n",moinfo.ecc);
 
37
    fprintf(outfile,  "\tTotal CC2 energy    (CC_INFO) = %20.15f\n",
 
38
            moinfo.eref+moinfo.ecc);
 
39
  }
 
40
  else if(!strcmp(params.wfn,"CCSD") || !strcmp(params.wfn,"EOM_CCSD")) {
 
41
    psio_read_entry(CC_INFO, "CCSD Energy", (char *) &(moinfo.ecc),
 
42
                    sizeof(double));
 
43
    fprintf(outfile,  "\tCCSD energy         (CC_INFO) = %20.15f\n",moinfo.ecc);
 
44
    fprintf(outfile,  "\tTotal CCSD energy   (CC_INFO) = %20.15f\n",
 
45
            moinfo.eref+moinfo.ecc);
 
46
  }
 
47
  else if(!strcmp(params.wfn,"CC3") || !strcmp(params.wfn,"EOM_CC3")) {
 
48
    psio_read_entry(CC_INFO, "CC3 Energy", (char *) &(moinfo.ecc),
 
49
                    sizeof(double));
 
50
    fprintf(outfile,  "\tCC3 energy          (CC_INFO) = %20.15f\n",moinfo.ecc);
 
51
    fprintf(outfile,  "\tTotal CC3 energy    (CC_INFO) = %20.15f\n",
 
52
            moinfo.eref+moinfo.ecc);
 
53
  }
 
54
 
 
55
  /* read in the easy-to-understand parameters */
 
56
 
 
57
  params.convergence = 1e-7;
 
58
  errcod = ip_data("CONVERGENCE","%d",&(iconv),0);
 
59
  if(errcod == IPE_OK) params.convergence = 1.0*pow(10.0,(double) -iconv);
 
60
 
 
61
  params.restart = 1;
 
62
  errcod = ip_boolean("RESTART", &(params.restart),0);
 
63
  if(!moinfo.phase) params.restart = 0;
 
64
 
 
65
  fndcor(&(params.memory),infile,outfile);
 
66
 
 
67
  params.print = 0;
 
68
  errcod = ip_data("PRINT", "%d", &(params.print),0);
 
69
 
 
70
  params.cachelev = 2;
 
71
  errcod = ip_data("CACHELEV", "%d", &(params.cachelev),0);
 
72
 
 
73
  params.sekino = 0;
 
74
  if(ip_exist("SEKINO",0)) {
 
75
    errcod = ip_boolean("SEKINO", &params.sekino, 0);
 
76
    if(errcod != IPE_OK) params.sekino = 0;
 
77
  }
 
78
 
 
79
  params.diis = 1;
 
80
  errcod = ip_boolean("DIIS", &params.diis, 0);
 
81
 
 
82
  params.aobasis = 0;
 
83
  errcod = ip_boolean("AO_BASIS", &(params.aobasis),0);
 
84
  params.aobasis = 0;  /* AO basis code not yet working for lambda */
 
85
 
 
86
  if(ip_exist("ABCD",0)) {
 
87
    errcod = ip_string("ABCD", &(params.abcd), 0);
 
88
    if(strcmp(params.abcd,"NEW") && strcmp(params.abcd,"OLD")) {
 
89
      fprintf(outfile, "Invalid ABCD algorithm: %s\n", params.abcd);
 
90
      exit(PSI_RETURN_FAILURE);
 
91
    }
 
92
  }
 
93
  else params.abcd = strdup("NEW");
 
94
 
 
95
  params.num_amps = 10;
 
96
  if(ip_exist("NUM_AMPS",0)) {
 
97
    errcod = ip_data("NUM_AMPS", "%d", &(params.num_amps), 0);
 
98
  }
 
99
 
 
100
  /* Determine DERTYPE */
 
101
  params.dertype = 0;
 
102
  if(ip_exist("DERTYPE",0)) {
 
103
    errcod = ip_string("DERTYPE", &(junk),0);
 
104
    if(errcod != IPE_OK) {
 
105
      printf("Invalid value of input keyword DERTYPE: %s\n", junk);
 
106
      exit(PSI_RETURN_FAILURE); 
 
107
                }
 
108
    else if(!strcmp(junk,"NONE")) params.dertype = 0;
 
109
    else if(!strcmp(junk,"FIRST")) params.dertype = 1;
 
110
    else if(!strcmp(junk,"RESPONSE")) params.dertype = 3; /* linear response */
 
111
    else {
 
112
      printf("Invalid value of input keyword DERTYPE: %s\n", junk);
 
113
      exit(PSI_RETURN_FAILURE); 
 
114
    }
 
115
    free(junk);
 
116
  }
 
117
        else { /* DERTYPE is absent, assume 1 if jobtype=opt; 0 if jobtype=oeprop */
 
118
    ip_string("JOBTYPE", &(junk),0);
 
119
    if(!strcmp(junk,"OEPROP")) params.dertype = 0;
 
120
    else if(!strcmp(junk,"OPT")) params.dertype = 1;
 
121
    else {
 
122
      printf("Don't know what to do with DERTYPE missing and jobtype: %s\n", junk);
 
123
      exit(PSI_RETURN_FAILURE); 
 
124
    }
 
125
    free(junk);
 
126
        }
 
127
 
 
128
  /* begin local parameters */
 
129
  params.local = 0;
 
130
  errcod = ip_boolean("LOCAL", &(params.local),0);
 
131
  local.cutoff = 0.02;
 
132
  errcod = ip_data("LOCAL_CUTOFF", "%lf", &(local.cutoff), 0);
 
133
  if(ip_exist("LOCAL_METHOD",0)) {
 
134
    errcod = ip_string("LOCAL_METHOD", &(local.method), 0);
 
135
    if(strcmp(local.method,"AOBASIS") && strcmp(local.method,"WERNER")) {
 
136
      fprintf(outfile, "Invalid local correlation method: %s\n", local.method);
 
137
      exit(PSI_RETURN_FAILURE);
 
138
    }
 
139
  }
 
140
  else if(params.local) {
 
141
    local.method = (char *) malloc(7 * sizeof(char));
 
142
    sprintf(local.method, "%s", "WERNER");
 
143
  }
 
144
 
 
145
  if(ip_exist("LOCAL_WEAKP",0)) {
 
146
    errcod = ip_string("LOCAL_WEAKP", &(local.weakp), 0);
 
147
    if(strcmp(local.weakp,"MP2") && strcmp(local.weakp,"NEGLECT") && strcmp(local.weakp,"NONE")) {
 
148
      fprintf(outfile, "Invalid method for treating local pairs: %s\n", local.weakp);
 
149
      exit(PSI_RETURN_FAILURE);
 
150
    }
 
151
  }
 
152
  else if(params.local) {
 
153
    local.weakp = (char *) malloc(4 * sizeof(char));
 
154
    sprintf(local.weakp, "%s", "NONE");
 
155
  }
 
156
  
 
157
  if(params.dertype == 3)
 
158
    local.filter_singles = 0;
 
159
  else
 
160
    local.filter_singles = 1;
 
161
  ip_boolean("LOCAL_FILTER_SINGLES", &(local.filter_singles), 0);
 
162
 
 
163
  local.cphf_cutoff = 0.10;
 
164
  ip_data("LOCAL_CPHF_CUTOFF", "%lf", &(local.cphf_cutoff), 0);
 
165
 
 
166
  local.freeze_core = NULL;
 
167
  ip_string("FREEZE_CORE", &local.freeze_core, 0);
 
168
  if(local.freeze_core == NULL) local.freeze_core = strdup("FALSE");
 
169
 
 
170
  if(ip_exist("LOCAL_PAIRDEF",0)){
 
171
    errcod = ip_string("LOCAL_PAIRDEF", &(local.pairdef), 0);
 
172
    if(strcmp(local.pairdef,"BP") && strcmp(local.pairdef,"RESPONSE")) {
 
173
      fprintf(outfile, "Invalid keyword for strong/weak pair definition: %s\n", local.pairdef);
 
174
      exit(PSI_RETURN_FAILURE);
 
175
    }
 
176
  }
 
177
  else if(params.local && params.dertype == 3)
 
178
    local.pairdef = strdup("RESPONSE");
 
179
  else if(params.local)
 
180
    local.pairdef = strdup("BP");
 
181
 
 
182
        /* Now setup the structure which determines what will be solved */ 
 
183
        /* if --zeta, use Xi and solve for Zeta */
 
184
        /* if (DERTYPE == FIRST) determine ground vs. excited from wfn.
 
185
            if ground, do only lambda.
 
186
                        if excited, compute only one L chosen as described below.
 
187
                        */
 
188
        /* if (DERTYPE == RESPONSE), determine ground vs. excited from wfn.
 
189
            Compute lambda.
 
190
                        if excited, also do L(s) chosen as described below */
 
191
        /* if (DERTYPE == NONE) determine ground vs. excited from wfn.
 
192
            Compute lambda.
 
193
                        if excited, also do L(s) chosen as described below */
 
194
/* To determine which L(s) to compute for multiple L(s):
 
195
          Check PROP_ALL in input
 
196
                 - If (PROP_ALL == true), compute L for all excited states.
 
197
                 - If false, check PROP_SYM for irrep desired, and PROP_ROOT
 
198
                             for root desired, as in cceom. */
 
199
/* To determine which L(s) to compute for single L(s) 
 
200
                 - Check PROP_SYM for irrep desired, and PROP_ROOT
 
201
                             for root desired, as in cceom. */
 
202
 
 
203
  /* setup property variables for excited states */
 
204
  if (cc_excited(params.wfn)) {
 
205
    chkpt_init(PSIO_OPEN_OLD);
 
206
    if (chkpt_rd_override_occ()) {
 
207
      states_per_irrep = chkpt_rd_statespi();
 
208
    }
 
209
    else {
 
210
      ip_count("STATES_PER_IRREP", &i, 0);
 
211
            states_per_irrep = (int *) malloc(moinfo.nirreps * sizeof(int));
 
212
      for (i=0;i<moinfo.nirreps;++i)
 
213
        errcod = ip_data("STATES_PER_IRREP","%d",&(states_per_irrep[i]),1,i);
 
214
    }
 
215
    chkpt_close();
 
216
 
 
217
          prop_all = 0;
 
218
          if (ip_exist("PROP_ALL",0)) ip_boolean("PROP_ALL",&prop_all,0);
 
219
                /* command-line overrides this keyword (at least for now) */
 
220
                if (params.all) prop_all = 1;
 
221
 
 
222
          if (ip_exist("PROP_SYM",0)) {  /* read symmetry of state for properties */
 
223
      ip_data("PROP_SYM","%d",&(prop_sym),0);
 
224
      prop_sym -= 1;
 
225
      prop_sym = moinfo.sym^prop_sym;
 
226
          }
 
227
    else { /* just use last irrep of states requested for symmetry of states */
 
228
      for (i=0;i<moinfo.nirreps;++i) {
 
229
                    if (states_per_irrep[i] > 0)
 
230
          prop_sym = i^moinfo.sym;
 
231
                  }
 
232
    }
 
233
 
 
234
    if (ip_exist("PROP_ROOT",0)) { /* read prop_root */
 
235
      ip_data("PROP_ROOT","%d",&(prop_root),0);
 
236
      prop_root -= 1;
 
237
          }
 
238
          else { /* just use highest root, if you need only one of them */
 
239
            prop_root = states_per_irrep[prop_sym^moinfo.sym];
 
240
                        prop_root -= 1;
 
241
          }
 
242
        }
 
243
        
 
244
 
 
245
  if (params.zeta) { /* only use Xi to solve for Zeta */
 
246
          params.nstates = 1;
 
247
    pL_params = (struct L_Params *) malloc(params.nstates * sizeof(struct L_Params));
 
248
    psio_read_entry(CC_INFO, "XI Irrep", (char *) &i,sizeof(int));
 
249
    fprintf(outfile,"\tIrrep of Zeta       (CC_INFO) = %d\n", i);
 
250
    pL_params[0].irrep = prop_sym = i; /* is this always A1? I forget */
 
251
    pL_params[0].root = prop_root = 0;
 
252
    pL_params[0].ground = 0;
 
253
    pL_params[0].cceom_energy = 0.0;
 
254
    pL_params[0].R0 = 0.0; /* <Zeta0|R0> = 0, since zeta_0 = 0 */
 
255
    sprintf(pL_params[0].L1A_lbl,"ZIA");
 
256
    sprintf(pL_params[0].L1B_lbl,"Zia");
 
257
    sprintf(pL_params[0].L2AA_lbl,"ZIJAB");
 
258
    sprintf(pL_params[0].L2BB_lbl,"Zijab");
 
259
    sprintf(pL_params[0].L2AB_lbl,"ZIjAb");
 
260
    sprintf(pL_params[0].L2RHF_lbl,"2ZIjAb - ZIjbA");
 
261
  }
 
262
        else if (params.dertype == 1) { /* analytic gradient, ignore prop_all */
 
263
          if (!cc_excited(params.wfn)) { /* do only lambda for ground state */
 
264
            params.nstates = 1;
 
265
      pL_params = (struct L_Params *) malloc(params.nstates * sizeof(struct L_Params));
 
266
      pL_params[0].irrep = 0;
 
267
      pL_params[0].root = -1;
 
268
      pL_params[0].ground = 1;
 
269
      pL_params[0].R0 = 1.0;
 
270
      pL_params[0].cceom_energy = 0.0;
 
271
      sprintf(pL_params[0].L1A_lbl,"LIA %d %d",0, -1);
 
272
      sprintf(pL_params[0].L1B_lbl,"Lia %d %d",0, -1);
 
273
      sprintf(pL_params[0].L2AA_lbl,"LIJAB %d %d",0, -1);
 
274
      sprintf(pL_params[0].L2BB_lbl,"Lijab %d %d",0, -1);
 
275
      sprintf(pL_params[0].L2AB_lbl,"LIjAb %d %d",0, -1);
 
276
      sprintf(pL_params[0].L2RHF_lbl,"2LIjAb - LIjbA %d %d",0, -1);
 
277
                }
 
278
                else { /* do only one L for excited state */
 
279
                  params.nstates = 1;
 
280
      pL_params = (struct L_Params *) malloc(params.nstates * sizeof(struct L_Params));
 
281
      pL_params[0].irrep = prop_sym;
 
282
      pL_params[0].root = prop_root;
 
283
      pL_params[0].ground = 0;
 
284
      if(!strcmp(params.wfn,"EOM_CC2")) {
 
285
        sprintf(lbl,"EOM CC2 Energy for root %d %d", prop_sym, prop_root);
 
286
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[0].cceom_energy),sizeof(double));
 
287
        sprintf(lbl,"EOM CC2 R0 for root %d %d", prop_sym, prop_root);
 
288
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[0].R0),sizeof(double));
 
289
      }
 
290
      else if(!strcmp(params.wfn,"EOM_CCSD")) {
 
291
        sprintf(lbl,"EOM CCSD Energy for root %d %d", prop_sym, prop_root);
 
292
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[0].cceom_energy),sizeof(double));
 
293
        sprintf(lbl,"EOM CCSD R0 for root %d %d", prop_sym, prop_root);
 
294
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[0].R0),sizeof(double));
 
295
      }
 
296
      else if(!strcmp(params.wfn,"EOM_CC3")) {
 
297
        sprintf(lbl,"EOM CC3 Energy for root %d %d", prop_sym, prop_root);
 
298
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[0].cceom_energy),sizeof(double));
 
299
        sprintf(lbl,"EOM CC3 R0 for root %d %d", prop_sym, prop_root);
 
300
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[0].R0),sizeof(double));
 
301
      }
 
302
      sprintf(pL_params[0].L1A_lbl,"LIA %d %d",prop_sym, prop_root);
 
303
      sprintf(pL_params[0].L1B_lbl,"Lia %d %d",prop_sym, prop_root);
 
304
      sprintf(pL_params[0].L2AA_lbl,"LIJAB %d %d",prop_sym, prop_root);
 
305
      sprintf(pL_params[0].L2BB_lbl,"Lijab %d %d",prop_sym, prop_root);
 
306
      sprintf(pL_params[0].L2AB_lbl,"LIjAb %d %d",prop_sym, prop_root);
 
307
      sprintf(pL_params[0].L2RHF_lbl,"2LIjAb - LIjbA %d %d",prop_sym, prop_root);
 
308
                }
 
309
  }
 
310
        else if (params.dertype == 3) { /* response calculation */
 
311
          if (!cc_excited(params.wfn)) { /* ground state */
 
312
            params.nstates = 1;
 
313
      pL_params = (struct L_Params *) malloc(params.nstates * sizeof(struct L_Params));
 
314
      pL_params[0].irrep = 0;
 
315
      pL_params[0].root = -1;
 
316
      pL_params[0].ground = 1;
 
317
      pL_params[0].R0 = 1.0;
 
318
      pL_params[0].cceom_energy = 0.0;
 
319
      sprintf(pL_params[0].L1A_lbl,"LIA %d %d",0, -1);
 
320
      sprintf(pL_params[0].L1B_lbl,"Lia %d %d",0, -1);
 
321
      sprintf(pL_params[0].L2AA_lbl,"LIJAB %d %d",0, -1);
 
322
      sprintf(pL_params[0].L2BB_lbl,"Lijab %d %d",0, -1);
 
323
      sprintf(pL_params[0].L2AB_lbl,"LIjAb %d %d",0, -1);
 
324
      sprintf(pL_params[0].L2RHF_lbl,"2LIjAb - LIjbA %d %d",0, -1);
 
325
                }
 
326
                else { /* excited state */
 
327
                  lambda_and_Ls = 1; /* code is below */
 
328
                }
 
329
        }
 
330
        else if (params.dertype == 0) {
 
331
          if (!cc_excited(params.wfn)) { /* ground state */
 
332
            params.nstates = 1;
 
333
      pL_params = (struct L_Params *) malloc(params.nstates * sizeof(struct L_Params));
 
334
      pL_params[0].irrep = 0;
 
335
      pL_params[0].root = -1;
 
336
      pL_params[0].ground = 1;
 
337
      pL_params[0].R0 = 1.0;
 
338
      pL_params[0].cceom_energy = 0.0;
 
339
      sprintf(pL_params[0].L1A_lbl,"LIA %d %d",0, -1);
 
340
      sprintf(pL_params[0].L1B_lbl,"Lia %d %d",0, -1);
 
341
      sprintf(pL_params[0].L2AA_lbl,"LIJAB %d %d",0, -1);
 
342
      sprintf(pL_params[0].L2BB_lbl,"Lijab %d %d",0, -1);
 
343
      sprintf(pL_params[0].L2AB_lbl,"LIjAb %d %d",0, -1);
 
344
      sprintf(pL_params[0].L2RHF_lbl,"2LIjAb - LIjbA %d %d",0, -1);
 
345
                }
 
346
                else { /* excited state */
 
347
                  lambda_and_Ls = 1; /* code is below */
 
348
                }
 
349
        }
 
350
 
 
351
 
 
352
  /* do lambda for ground state AND do L(s) for excited states */
 
353
  if (lambda_and_Ls) {
 
354
    /* determine number of states to converge */
 
355
          params.nstates = 1; /* for ground state */
 
356
                if (prop_all) {
 
357
                  for (i=0; i<moinfo.nirreps; ++i) 
 
358
                          params.nstates += states_per_irrep[i]; /* do all L(s) */
 
359
                }
 
360
                else {
 
361
                  params.nstates += 1; /* do only one L */
 
362
                }
 
363
 
 
364
    pL_params = (struct L_Params *) malloc(params.nstates * sizeof(struct L_Params));
 
365
 
 
366
                /* ground state */
 
367
    pL_params[0].irrep = 0;
 
368
    pL_params[0].root = -1;
 
369
    pL_params[0].ground = 1;
 
370
    pL_params[0].R0 = 1.0;
 
371
    pL_params[0].cceom_energy = 0.0;
 
372
    sprintf(pL_params[0].L1A_lbl,"LIA %d %d",0, -1);
 
373
    sprintf(pL_params[0].L1B_lbl,"Lia %d %d",0, -1);
 
374
    sprintf(pL_params[0].L2AA_lbl,"LIJAB %d %d",0, -1);
 
375
    sprintf(pL_params[0].L2BB_lbl,"Lijab %d %d",0, -1);
 
376
    sprintf(pL_params[0].L2AB_lbl,"LIjAb %d %d",0, -1);
 
377
    sprintf(pL_params[0].L2RHF_lbl,"2LIjAb - LIjbA %d %d",0, -1);
 
378
 
 
379
                if (prop_all) { /* do all L(s) */
 
380
                  k=1;
 
381
                    for (i=0; i<moinfo.nirreps; ++i)  { /* look over irrep of L(s) */
 
382
                                  for (j=0; j < states_per_irrep[i^moinfo.sym]; ++j) {
 
383
            pL_params[k].irrep = i;
 
384
            pL_params[k].root = j;
 
385
            pL_params[k].ground = 0;
 
386
 
 
387
            if(!strcmp(params.wfn,"EOM_CC2")) {
 
388
              sprintf(lbl,"EOM CC2 Energy for root %d %d", i, j);
 
389
              psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[k].cceom_energy),sizeof(double));
 
390
              sprintf(lbl,"EOM CC2 R0 for root %d %d", i, j);
 
391
              psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[k].R0),sizeof(double));
 
392
            }
 
393
            else if(!strcmp(params.wfn,"EOM_CCSD")) {
 
394
              sprintf(lbl,"EOM CCSD Energy for root %d %d", i, j);
 
395
              psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[k].cceom_energy),sizeof(double));
 
396
              sprintf(lbl,"EOM CCSD R0 for root %d %d", i, j);
 
397
              psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[k].R0),sizeof(double));
 
398
            }
 
399
            else if(!strcmp(params.wfn,"EOM_CC3")) {
 
400
              sprintf(lbl,"EOM CC3 Energy for root %d %d", i, j);
 
401
              psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[k].cceom_energy),sizeof(double));
 
402
              sprintf(lbl,"EOM CC3 R0 for root %d %d", i, j);
 
403
              psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[k].R0),sizeof(double));
 
404
            }
 
405
 
 
406
            sprintf(pL_params[k].L1A_lbl,"LIA %d %d",i, j);
 
407
            sprintf(pL_params[k].L1B_lbl,"Lia %d %d",i, j);
 
408
            sprintf(pL_params[k].L2AA_lbl,"LIJAB %d %d",i, j);
 
409
            sprintf(pL_params[k].L2BB_lbl,"Lijab %d %d",i, j);
 
410
            sprintf(pL_params[k].L2AB_lbl,"LIjAb %d %d",i, j);
 
411
            sprintf(pL_params[k].L2RHF_lbl,"2LIjAb - LIjbA %d %d",i, j);
 
412
                                                k++;
 
413
                                        }
 
414
                          }
 
415
                }
 
416
                else { /* use prop_sym and prop_root determined above from input or inferrence */
 
417
      pL_params[1].irrep = prop_sym;
 
418
      pL_params[1].root = prop_root;
 
419
      pL_params[1].ground = 0;
 
420
 
 
421
      if(!strcmp(params.wfn,"EOM_CC2")) {
 
422
        sprintf(lbl,"EOM CC2 Energy for root %d %d", prop_sym, prop_root);
 
423
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[1].cceom_energy),sizeof(double));
 
424
        sprintf(lbl,"EOM CC2 R0 for root %d %d", prop_sym, prop_root);
 
425
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[1].R0),sizeof(double));
 
426
      }
 
427
      else if(!strcmp(params.wfn,"EOM_CCSD")) {
 
428
        sprintf(lbl,"EOM CCSD Energy for root %d %d", prop_sym, prop_root);
 
429
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[1].cceom_energy),sizeof(double));
 
430
        sprintf(lbl,"EOM CCSD R0 for root %d %d", prop_sym, prop_root);
 
431
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[1].R0),sizeof(double));
 
432
      }
 
433
      else if(!strcmp(params.wfn,"EOM_CC3")) {
 
434
        sprintf(lbl,"EOM CC3 Energy for root %d %d", prop_sym, prop_root);
 
435
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[1].cceom_energy),sizeof(double));
 
436
        sprintf(lbl,"EOM CC3 R0 for root %d %d", prop_sym, prop_root);
 
437
        psio_read_entry(CC_INFO, lbl, (char *) &(pL_params[1].R0),sizeof(double));
 
438
      }
 
439
 
 
440
      sprintf(pL_params[1].L1A_lbl,"LIA %d %d", prop_sym, prop_root);
 
441
      sprintf(pL_params[1].L1B_lbl,"Lia %d %d", prop_sym, prop_root);
 
442
      sprintf(pL_params[1].L2AA_lbl,"LIJAB %d %d", prop_sym, prop_root);
 
443
      sprintf(pL_params[1].L2BB_lbl,"Lijab %d %d", prop_sym, prop_root);
 
444
      sprintf(pL_params[1].L2AB_lbl,"LIjAb %d %d", prop_sym, prop_root);
 
445
      sprintf(pL_params[1].L2RHF_lbl,"2LIjAb - LIjbA %d %d", prop_sym, prop_root);
 
446
                }
 
447
  }
 
448
 
 
449
 
 
450
  params.maxiter = 50 * params.nstates;
 
451
  errcod = ip_data("MAXITER","%d",&(params.maxiter),0);
 
452
 
 
453
  fprintf(outfile, "\n\tInput parameters:\n");
 
454
  fprintf(outfile, "\t-----------------\n");
 
455
  fprintf(outfile, "\tMaxiter       =    %4d\n", params.maxiter);
 
456
  fprintf(outfile, "\tConvergence   = %3.1e\n", params.convergence);
 
457
  fprintf(outfile, "\tRestart       =     %s\n", params.restart ? "Yes" : "No");
 
458
  fprintf(outfile, "\tCache Level   =     %1d\n", params.cachelev);
 
459
  fprintf(outfile, "\tModel III     =     %s\n", params.sekino ? "Yes" : "No");
 
460
  fprintf(outfile, "\tDIIS          =     %s\n", params.diis ? "Yes" : "No");
 
461
  fprintf(outfile, "\tAO Basis      =     %s\n", 
 
462
          params.aobasis ? "Yes" : "No");
 
463
  fprintf(outfile, "\tABCD            =     %s\n", params.abcd);
 
464
  fprintf(outfile, "\tLocal CC        =     %s\n", params.local ? "Yes" : "No");
 
465
  if(params.local) {
 
466
    fprintf(outfile, "\tLocal Cutoff    = %3.1e\n", local.cutoff);
 
467
    fprintf(outfile, "\tLocal Method    =    %s\n", local.method);
 
468
    fprintf(outfile, "\tWeak pairs      =    %s\n", local.weakp);
 
469
    fprintf(outfile, "\tFilter singles  =    %s\n", local.filter_singles ? "Yes" : "No");
 
470
    fprintf(outfile, "\tLocal pairs       =    %s\n", local.pairdef);
 
471
    fprintf(outfile, "\tLocal CPHF cutoff =  %3.1e\n", local.cphf_cutoff);
 
472
  }
 
473
 
 
474
  fprintf(outfile,"\tParamaters for left-handed eigenvectors:\n");
 
475
  fprintf(outfile,"\t    Irr   Root  Ground-State?    EOM energy        R0\n");
 
476
  for (i=0; i<params.nstates; ++i) {
 
477
    fprintf(outfile,"\t%3d %3d %5d %10s %18.10lf %14.10lf\n", i+1, pL_params[i].irrep, pL_params[i].root+1,
 
478
            (pL_params[i].ground ? "Yes":"No"), pL_params[i].cceom_energy, pL_params[i].R0);
 
479
  }
 
480
 
 
481
  for (i=0; i<params.nstates; ++i) {
 
482
    fprintf(outfile,"\tLabels for eigenvector %d:\n\t%s, %s, %s, %s, %s, %s\n",
 
483
            i+1,pL_params[i].L1A_lbl,pL_params[i].L1B_lbl,pL_params[i].L2AA_lbl,pL_params[i].L2BB_lbl,
 
484
            pL_params[i].L2AB_lbl, pL_params[i].L2RHF_lbl);
 
485
  }
 
486
 
 
487
  fflush(outfile);
 
488
  return;
 
489
}
 
490
 
 
491
}} // namespace psi::cclambda