~ubuntu-branches/ubuntu/precise/psicode/precise

« back to all changes in this revision

Viewing changes to src/bin/input/build_so_classes.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Banck
  • Date: 2006-09-10 14:01:33 UTC
  • Revision ID: james.westby@ubuntu.com-20060910140133-ib2j86trekykfsfv
Tags: upstream-3.2.3
ImportĀ upstreamĀ versionĀ 3.2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#define EXTERN
 
2
#include <stdio.h>
 
3
#include <stdlib.h>
 
4
#include <libciomr/libciomr.h>
 
5
#include <math.h>
 
6
#include "input.h"
 
7
#include "global.h"
 
8
#include "defines.h"
 
9
 
 
10
 
 
11
void build_so_classes()
 
12
{
 
13
  int i,j,l,tmp;
 
14
  int atom, ua;
 
15
  int kfirst, klast;
 
16
  int class,lmax,irr,ao,symop,char_i;
 
17
  int ao_first, ao_last, ao_max, ao_irr;
 
18
  int class_first, class_last, uc;
 
19
  int shell, shell_first, shell_last;
 
20
  int **class_num_angmom;
 
21
  int **coeff_irr;
 
22
  int so_cnt, so_blk_lim, so_blk_off, cnt;
 
23
  int ao_offset;
 
24
  int basisfn_num_in_symblk;
 
25
  int *first_basisfn_in_symblk_offset;
 
26
  int *first_basisfn_in_symblk;
 
27
 
 
28
 
 
29
    /*----------------------------------------------------------------
 
30
      Compute maximum angular momentum number for each class of atoms
 
31
     ----------------------------------------------------------------*/
 
32
 
 
33
    max_angmom_class = init_int_array(num_classes);
 
34
    class_num_angmom = init_int_matrix(num_classes,max_angmom+1);
 
35
    for(i=0;i<num_atoms;i++) {
 
36
      kfirst = first_shell_on_atom[i];
 
37
      klast = kfirst + nshells_per_atom[i];
 
38
      class = atom_class[i];
 
39
      for(j=kfirst;j<klast;j++) {
 
40
        max_angmom_class[class] = (max_angmom_class[class] > shell_ang_mom[j]) ? max_angmom_class[class] : shell_ang_mom[j];
 
41
        class_num_angmom[class][shell_ang_mom[j]]++;
 
42
      }
 
43
    }
 
44
    
 
45
    /*-----------------------
 
46
      Allocate global arrays
 
47
     -----------------------*/
 
48
 
 
49
    num_cart_so_in_class = (int ***) malloc(num_classes*sizeof(int **));
 
50
    for(class=0;class<num_classes;class++)
 
51
      num_cart_so_in_class[class] = init_int_matrix(max_angmom_class[class]+1,nirreps);
 
52
    class_so_coeff = (double ****) malloc(num_classes*sizeof(double ***));
 
53
    for(i=0;i<num_classes;i++)
 
54
      class_so_coeff[i] = (double ***) malloc((max_angmom_class[i]+1)*sizeof(double **));
 
55
    if (puream) {
 
56
      num_pureang_so_in_class = (int ***) malloc(num_classes*sizeof(int **));
 
57
      for(class=0;class<num_classes;class++)
 
58
        num_pureang_so_in_class[class] = init_int_matrix(max_angmom_class[class]+1,nirreps);
 
59
    }
 
60
    
 
61
 
 
62
    /*----------------------
 
63
      Allocate local arrays
 
64
     -----------------------*/
 
65
 
 
66
    coeff_irr = init_int_matrix(nirreps,ioff[max_angmom+1]);
 
67
 
 
68
    
 
69
    /*------------------------------------------------------------------------------------------------------------------------
 
70
      Loop over each unique class, each angular momentum number within class, irreps, and basis function types
 
71
      and 1) count number of SO in each representation num_cart_so_in_class[class][l][irr] generated by a shell of ang momentum l
 
72
      on an atom of a unique class "uc" or its symmetry equivalent classes;
 
73
      2) form matrices of coefficients and labels for classes equivalent to the unique class "uc"
 
74
     ------------------------------------------------------------------------------------------------------------------------*/
 
75
    for(uc=0;uc<num_unique_classes;uc++) {
 
76
      class = uc2c[uc];
 
77
      class_first = class;
 
78
      class_last = class + unique_class_degen[uc];
 
79
      lmax = max_angmom_class[class];
 
80
      for(l=0;l<=lmax;l++) {
 
81
        ao_max = ioff[l+1];
 
82
        for(symop=0;symop<nirreps;symop++)
 
83
          if (class_orbit[class][symop] == class)
 
84
            for(irr=0;irr<nirreps;irr++)
 
85
              for(ao=0;ao<ao_max;ao++)
 
86
                coeff_irr[irr][ao] += irr_char[irr][symop]*ao_type_transmat[l][symop][ao];
 
87
        for(irr=0;irr<nirreps;irr++)
 
88
          for(ao=0;ao<ao_max;ao++)
 
89
            if (coeff_irr[irr][ao] > 0)
 
90
              for(i=class_first;i<class_last;i++)
 
91
                num_cart_so_in_class[i][l][irr] += 1;
 
92
 
 
93
        if (puream) {
 
94
          for(irr=0;irr<nirreps;irr++)
 
95
            for(i=class_first;i<class_last;i++)
 
96
              num_pureang_so_in_class[i][l][irr] = num_cart_so_in_class[i][l][irr];
 
97
          for(ao_irr=0;ao_irr<nirreps;ao_irr++)
 
98
            if (num_cart_so[l][ao_irr] != 0)
 
99
              for(ao=0;ao<ao_max;ao++)
 
100
                if (ao_type_irr[l][ao] == ao_irr) {
 
101
                  for(irr=0;irr<nirreps;irr++)
 
102
                    if (coeff_irr[irr][ao] > 0)
 
103
                      for(i=class_first;i<class_last;i++)
 
104
                        num_pureang_so_in_class[i][l][irr] -= num_redun_so[l][ao_irr];
 
105
                  break;
 
106
                }
 
107
        }
 
108
 
 
109
        /*---------------------------------
 
110
          Remove after testing is complete
 
111
         ---------------------------------*/
 
112
        if (print_lvl >= DEBUGPRINT) {
 
113
          fprintf(outfile,"    Class = %d  l = %d\n     Number of cartesian SOs in symmetry blocks:",class+1,l);
 
114
          for(irr=0;irr<nirreps;irr++)
 
115
            fprintf(outfile," %d",num_cart_so_in_class[class][l][irr]);
 
116
          fprintf(outfile,"\n\n");
 
117
          if (puream) {
 
118
            fprintf(outfile,"    Class = %d  l = %d\n     Number of pure angular momentum SOs in symmetry blocks:",class+1,l);
 
119
            for(irr=0;irr<nirreps;irr++)
 
120
              fprintf(outfile," %d",num_pureang_so_in_class[class][l][irr]);
 
121
            fprintf(outfile,"\n\n");
 
122
          }
 
123
        }
 
124
 
 
125
        /*Compute SO coefficients and labels for ALL classes - children of a unique class "class"*/
 
126
        for(i=class_first;i<class_last;i++) {
 
127
          class_so_coeff[i][l] = init_matrix(ao_max*unique_class_degen[uc],ao_max);
 
128
          for(irr=0;irr<nirreps;irr++)
 
129
            bzero((char *)coeff_irr[irr],sizeof(int)*ao_max);
 
130
          for(symop=0;symop<nirreps;symop++)
 
131
            if (class_orbit[class_first][symop] == i)
 
132
              for(irr=0;irr<nirreps;irr++)
 
133
                if (num_cart_so_in_class[class][l][irr] != 0) /*There are SOs in this class and ang. momentum type*/
 
134
                  for(ao=0;ao<ao_max;ao++)
 
135
                    coeff_irr[irr][ao] += irr_char[irr][symop]*ao_type_transmat[l][symop][ao];
 
136
          so_cnt = 0;
 
137
          for(irr=0;irr<nirreps;irr++)
 
138
            if (num_cart_so_in_class[class][l][irr] != 0)
 
139
              for(ao=0;ao<ao_max;ao++)
 
140
                if (coeff_irr[irr][ao] != 0)
 
141
                  class_so_coeff[i][l][so_cnt++][ao] = sign(coeff_irr[irr][ao]);
 
142
        }
 
143
        for(irr=0;irr<nirreps;irr++)
 
144
          bzero((char *)coeff_irr[irr],sizeof(int)*ao_max);
 
145
      }
 
146
    }
 
147
 
 
148
    /*---------------------------------
 
149
      Remove after testing is complete
 
150
     ---------------------------------*/
 
151
    if (print_lvl >= DEBUGPRINT)
 
152
      for(uc=0;uc<num_unique_classes;uc++) {
 
153
        class = uc2c[uc];
 
154
        class_first = class;
 
155
        class_last = class + unique_class_degen[uc];
 
156
        lmax = max_angmom_class[class];
 
157
        for(i=class_first;i<class_last;i++) {
 
158
          fprintf(outfile,"\n    Class = %d\n",i+1);
 
159
          for(l=0;l<=lmax;l++) {
 
160
            ao_max = ioff[l+1];
 
161
            fprintf(outfile,"     l = %d\n",l);
 
162
            for(j=0;j<ao_max*unique_class_degen[uc];j++) {
 
163
              fprintf(outfile,"     ");
 
164
              for(ao=0;ao<ao_max;ao++)
 
165
                fprintf(outfile,"    %4.1lf",class_so_coeff[i][l][j][ao]);
 
166
              fprintf(outfile,"\n");
 
167
            }
 
168
          }
 
169
        }
 
170
      }
 
171
 
 
172
    return;
 
173
}
 
174
 
 
175
 
 
176