4
Edward Valeev, June 2002
10
#include <libpsio/psio.h>
11
#include <libciomr/libciomr.h>
12
#include "slaterdset.h"
15
#define PSIO_INIT if (!psio_state()) { \
17
need_to_init_psio = 1; \
20
#define PSIO_OPEN(u,n) if (!psio_open_check(u)) { \
25
#define PSIO_CLOSE(u) if (!unit_opened) \
28
#define PSIO_DONE if (need_to_init_psio) \
34
void stringset_init(StringSet *sset, int size, int nelec, int nfzc,
35
short int *frozen_occ)
42
sset->strings = (String *) malloc(size*sizeof(String));
43
memset(sset->strings,0,size*sizeof(String));
45
sset->fzc_occ = (short int *) malloc(nfzc * sizeof(short int));
46
for (i=0; i<nfzc; i++) {
47
sset->fzc_occ[i] = frozen_occ[i];
53
/*! stringset_delete()
55
void stringset_delete(StringSet *sset)
57
if (sset->nfzc > 0) free(sset->fzc_occ);
61
if (sset->strings) free(sset->strings);
67
void stringset_add(StringSet *sset, int index, unsigned char *Occ)
70
int nact = sset->nelec - sset->nfzc;
73
if (index < sset->size && index >= 0) {
74
s = sset->strings + index;
77
s->occ = (short int*) malloc(nact*sizeof(short int));
84
void stringset_reindex(StringSet* sset, short int* mo_map)
88
int nstrings = sset->size;
89
int nact = sset->nelec - sset->nfzc;
91
for (core=0; core<sset->nfzc; core++) {
92
sset->fzc_occ[core] = mo_map[sset->fzc_occ[core]];
95
for(s=0; s<nstrings; s++) {
96
occ = (sset->strings + s)->occ;
97
for(mo=0; mo<nact; mo++)
98
occ[mo] = mo_map[occ[mo]];
102
void stringset_write(ULI unit, char *prefix, StringSet *sset)
105
int need_to_init_psio = 0;
107
char *size_key, *nelec_key, *nfzc_key, *strings_key, *fzc_occ_key;
111
PSIO_OPEN(unit,PSIO_OPEN_OLD)
113
size_key = (char *) malloc(strlen(prefix) + strlen(STRINGSET_KEY_SIZE) + 3);
114
sprintf(size_key,":%s:%s",prefix,STRINGSET_KEY_SIZE);
115
nelec_key = (char *) malloc(strlen(prefix) + strlen(STRINGSET_KEY_NELEC) + 3);
116
sprintf(nelec_key,":%s:%s",prefix,STRINGSET_KEY_NELEC);
117
nfzc_key = (char *) malloc(strlen(prefix) + strlen(STRINGSET_KEY_NFZC) + 3);
118
sprintf(nfzc_key,":%s:%s",prefix,STRINGSET_KEY_NFZC);
119
fzc_occ_key = (char *) malloc(strlen(prefix) +
120
strlen(STRINGSET_KEY_FZC_OCC) + 3);
121
sprintf(fzc_occ_key,":%s:%s",prefix,STRINGSET_KEY_FZC_OCC);
122
strings_key = (char *) malloc(strlen(prefix) + strlen(STRINGSET_KEY_STRINGS) + 3);
123
sprintf(strings_key,":%s:%s",prefix,STRINGSET_KEY_STRINGS);
125
psio_write_entry( unit, size_key, (char *)&sset->size, sizeof(int));
126
psio_write_entry( unit, nelec_key, (char *)&sset->nelec, sizeof(int));
127
psio_write_entry( unit, nfzc_key, (char *)&sset->nfzc, sizeof(int));
129
psio_write_entry( unit, fzc_occ_key, (char *)sset->fzc_occ,
130
sset->nfzc*sizeof(short int));
135
nact = sset->nelec - sset->nfzc;
136
for(i=0; i<size; i++) {
137
psio_write( unit, strings_key, (char *) &(sset->strings[i].index),
138
sizeof(int), ptr, &ptr);
139
psio_write( unit, strings_key, (char *) sset->strings[i].occ,
140
nact*sizeof(short int), ptr, &ptr);
154
void stringset_read(ULI unit, char *prefix, StringSet **stringset)
156
int i, size, nelec, nfzc, nact;
157
int need_to_init_psio = 0;
159
char *size_key, *nelec_key, *nfzc_key, *fzc_occ_key, *strings_key;
162
StringSet *sset = (StringSet *) malloc(sizeof(StringSet));
165
PSIO_OPEN(unit,PSIO_OPEN_OLD)
167
size_key = (char *) malloc( strlen(prefix) + strlen(STRINGSET_KEY_SIZE) + 3);
168
sprintf(size_key,":%s:%s",prefix,STRINGSET_KEY_SIZE);
169
nelec_key = (char *) malloc( strlen(prefix) + strlen(STRINGSET_KEY_NELEC) + 3);
170
sprintf(nelec_key,":%s:%s",prefix,STRINGSET_KEY_NELEC);
171
nfzc_key = (char *) malloc( strlen(prefix) + strlen(STRINGSET_KEY_NFZC) + 3);
172
sprintf(nfzc_key,":%s:%s",prefix,STRINGSET_KEY_NFZC);
173
fzc_occ_key = (char *) malloc(strlen(prefix) +
174
strlen(STRINGSET_KEY_FZC_OCC) + 3);
175
sprintf(fzc_occ_key,":%s:%s",prefix,STRINGSET_KEY_FZC_OCC);
176
strings_key = (char *) malloc( strlen(prefix) + strlen(STRINGSET_KEY_STRINGS) + 3);
177
sprintf(strings_key,":%s:%s",prefix,STRINGSET_KEY_STRINGS);
179
psio_read_entry( unit, size_key, (char *)&size, sizeof(int));
180
psio_read_entry( unit, nelec_key, (char *)&nelec, sizeof(int));
181
psio_read_entry( unit, nfzc_key, (char *)&nfzc, sizeof(int));
183
fzc_occ = (short int *) malloc(nfzc*sizeof(short int));
184
psio_read_entry( unit, fzc_occ_key, (char *)fzc_occ,
185
nfzc*sizeof(short int));
189
stringset_init(sset, size, nelec, nfzc, fzc_occ);
193
for(i=0; i<size; i++) {
194
psio_read( unit, strings_key, (char *) &(sset->strings[i].index), sizeof(int), ptr, &ptr);
195
sset->strings[i].occ = (short int*) malloc(nact*sizeof(short int));
196
psio_read( unit, strings_key, (char *) sset->strings[i].occ, nact*sizeof(short int), ptr, &ptr);
207
if (nfzc > 0) free(fzc_occ);
212
/*! slaterdetset_init()
214
void slaterdetset_init(SlaterDetSet *sdset, int size, StringSet *alphastrings, StringSet *betastrings)
217
sdset->dets = (SlaterDet *) malloc(size*sizeof(SlaterDet));
218
memset(sdset->dets,0,size*sizeof(SlaterDet));
219
sdset->alphastrings = alphastrings;
220
sdset->betastrings = betastrings;
223
/*! slaterdetset_delete()
225
void slaterdetset_delete(SlaterDetSet *sdset)
232
sdset->alphastrings = NULL;
233
sdset->betastrings = NULL;
236
/*! slaterdetset_delete_full()
238
void slaterdetset_delete_full(SlaterDetSet *sdset)
245
if (sdset->alphastrings) {
246
stringset_delete(sdset->alphastrings);
247
sdset->alphastrings = NULL;
249
if (sdset->betastrings) {
250
stringset_delete(sdset->betastrings);
251
sdset->betastrings = NULL;
257
void slaterdetset_add(SlaterDetSet *sdset, int index, int alphastring, int betastring)
260
StringSet *alphaset = sdset->alphastrings;
261
StringSet *betaset = sdset->betastrings;
263
if (index < sdset->size && index >= 0) {
264
det = sdset->dets + index;
267
if (alphastring < alphaset->size && alphastring >= 0)
268
det->alphastring = alphastring;
269
if (betastring < betaset->size && betastring >= 0)
270
det->betastring = betastring;
273
void slaterdetset_write(ULI unit, char *prefix, SlaterDetSet *sdset)
276
int need_to_init_psio = 0;
278
char *size_key, *set_key;
279
char *alphaprefix, *betaprefix;
283
PSIO_OPEN(unit,PSIO_OPEN_OLD)
285
alphaprefix = (char *) malloc( strlen(prefix) + strlen(SDSET_KEY_ALPHASTRINGS) + 2);
286
sprintf(alphaprefix,"%s:%s",prefix,SDSET_KEY_ALPHASTRINGS);
287
betaprefix = (char *) malloc( strlen(prefix) + strlen(SDSET_KEY_BETASTRINGS) + 2);
288
sprintf(betaprefix,"%s:%s",prefix,SDSET_KEY_BETASTRINGS);
290
stringset_write( unit, alphaprefix, sdset->alphastrings);
291
stringset_write( unit, betaprefix, sdset->betastrings);
296
size_key = (char *) malloc( strlen(prefix) + strlen(SDSET_KEY_SIZE) + 3);
297
sprintf(size_key,":%s:%s",prefix,SDSET_KEY_SIZE);
298
set_key = (char *) malloc( strlen(prefix) + strlen(SDSET_KEY_DETERMINANTS) + 3);
299
sprintf(set_key,":%s:%s",prefix,SDSET_KEY_DETERMINANTS);
301
psio_write_entry( unit, size_key, (char *)&sdset->size, sizeof(int));
302
psio_write_entry( unit, set_key, (char *)sdset->dets, sdset->size*sizeof(SlaterDet));
311
void slaterdetset_read(ULI unit, char *prefix, SlaterDetSet **slaterdetset)
314
int need_to_init_psio = 0;
316
char *size_key, *set_key;
317
char *alphaprefix, *betaprefix;
319
StringSet *alphastrings, *betastrings;
320
SlaterDetSet *sdset = (SlaterDetSet *) malloc(sizeof(SlaterDetSet));
323
PSIO_OPEN(unit,PSIO_OPEN_OLD)
325
alphaprefix = (char *) malloc( strlen(prefix) + strlen(SDSET_KEY_ALPHASTRINGS) + 2);
326
sprintf(alphaprefix,"%s:%s",prefix,SDSET_KEY_ALPHASTRINGS);
327
betaprefix = (char *) malloc( strlen(prefix) + strlen(SDSET_KEY_BETASTRINGS) + 2);
328
sprintf(betaprefix,"%s:%s",prefix,SDSET_KEY_BETASTRINGS);
330
stringset_read( unit, alphaprefix, &alphastrings);
331
stringset_read( unit, betaprefix, &betastrings);
336
size_key = (char *) malloc( strlen(prefix) + strlen(SDSET_KEY_SIZE) + 3);
337
sprintf(size_key,":%s:%s",prefix,SDSET_KEY_SIZE);
338
set_key = (char *) malloc( strlen(prefix) + strlen(SDSET_KEY_DETERMINANTS) + 3);
339
sprintf(set_key,":%s:%s",prefix,SDSET_KEY_DETERMINANTS);
341
psio_read_entry( unit, size_key, (char *)&size, sizeof(int));
342
slaterdetset_init(sdset,size,alphastrings,betastrings);
343
psio_read_entry( unit, set_key, (char *)sdset->dets, sdset->size*sizeof(SlaterDet));
351
*slaterdetset = sdset;
355
/*! slaterdetvector_init()
357
void slaterdetvector_init(SlaterDetVector *sdvector, SlaterDetSet *sdset)
359
sdvector->size = sdset->size;
360
sdvector->sdset = sdset;
361
sdvector->coeffs = init_array(sdvector->size);
364
/*! slaterdetvector_delete()
366
void slaterdetvector_delete(SlaterDetVector *sdvector)
369
sdvector->sdset = NULL;
370
if (sdvector->coeffs) {
371
free(sdvector->coeffs);
372
sdvector->coeffs = NULL;
377
/*! slaterdetvector_delete_full()
379
void slaterdetvector_delete_full(SlaterDetVector *sdvector)
382
if (sdvector->sdset) {
383
slaterdetset_delete_full(sdvector->sdset);
384
sdvector->sdset = NULL;
386
if (sdvector->coeffs) {
387
free(sdvector->coeffs);
388
sdvector->coeffs = NULL;
393
/*! slaterdetvector_add
395
void slaterdetvector_add(SlaterDetVector *sdvector, int index, double coeff)
397
if (index < sdvector->size && index >= 0) {
398
sdvector->coeffs[index] = coeff;
403
/*! slaterdetvector_set
405
void slaterdetvector_set(SlaterDetVector *sdvector, double *coeffs)
408
const int size = sdvector->size;
409
double *v = sdvector->coeffs;
411
for(i=0; i<size; i++)
418
** Use this if we only need to write a single vector. Otherwise, call
419
** slaterdetset_write(); slaterdetset_write_vect();
420
** to allow for multiple vectors per slaterdetset to be written to disk.
422
void slaterdetvector_write(ULI unit, char *prefix, SlaterDetVector *vector)
424
int need_to_init_psio = 0;
428
PSIO_OPEN(unit,PSIO_OPEN_OLD)
430
slaterdetset_write(unit, prefix, vector->sdset);
431
slaterdetset_write_vect(unit, prefix, vector->coeffs, vector->size, 0);
440
** This function already assumes we've already called slaterdetset_write()
441
** to write out the string and determinant information. This is only
442
** going to write out the coefficients. This has been split out because
443
** we might want to write several roots for a given determinant setup.
447
void slaterdetset_write_vect(ULI unit, char *prefix,
448
double *coeffs, int size, int vectnum)
450
int need_to_init_psio = 0;
455
PSIO_OPEN(unit,PSIO_OPEN_OLD)
457
if (vectnum < 0 || vectnum > 99) {
458
fprintf(stderr, "(slaterdetset_write_vect): vectnum out of bounds\n");
462
vector_key = (char *) malloc(strlen(prefix)+strlen(SDVECTOR_KEY_VECTOR)+5);
463
sprintf(vector_key,":%s:%s%2d",prefix,SDVECTOR_KEY_VECTOR,vectnum);
465
psio_write_entry(unit, vector_key, (char *)coeffs, size*sizeof(double));
476
** Use this if we only need to read a single vector. Otherwise, call
477
** slaterdetset_read(); slaterdetset_read_vect();
478
** to allow for multiple vectors per slaterdetset to be read from disk.
480
void slaterdetvector_read(ULI unit, char *prefix, SlaterDetVector **sdvector)
482
int need_to_init_psio = 0;
485
SlaterDetVector *vector = (SlaterDetVector *) malloc(sizeof(SlaterDetVector));
488
PSIO_OPEN(unit,PSIO_OPEN_OLD)
490
slaterdetset_read(unit, prefix, &sdset);
491
slaterdetvector_init(vector,sdset);
492
slaterdetset_read_vect(unit, prefix, vector->coeffs, vector->size, 0);
502
** This function already assumes we've already called slaterdetset_read()
503
** to read in the string and determinant information. This is only
504
** going to read in the coefficients. This has been split out because
505
** we might want to read several roots for a given determinant setup.
509
void slaterdetset_read_vect(ULI unit, char *prefix, double *coeffs,
510
int size, int vectnum)
512
int need_to_init_psio = 0;
517
PSIO_OPEN(unit,PSIO_OPEN_OLD)
519
vector_key = (char *) malloc(strlen(prefix)+strlen(SDVECTOR_KEY_VECTOR)+5);
520
sprintf(vector_key,":%s:%s%2d",prefix,SDVECTOR_KEY_VECTOR,vectnum);
522
psio_read_entry(unit, vector_key, (char *)coeffs, size*sizeof(double));