← Back to branch summary

~ubuntu-branches/ubuntu/quantal/psicode/quantal

« back to all changes in this revision

Viewing changes to src/bin/detci/oldcode/mitrush_update.cc

  • 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:
src/bin/detci/oldcode/mitrush_update.cc
 
1
/* need to fix to add phase.  should probably move most of code
 
2
** to a mitrush_blk_upd() function in C
 
3
*/
 
4
void mitrush_update(CIvect &Cc, CIvect &Cl, CIvect &Sc, CIvect &Sl,
 
5
      double norm, double acur, double alast)
 
6
{
 
7
   double *ccptr, *clptr, *scptr, *slptr;
 
8
   int i,al,bl,ai,bi,blk;
 
9
   int cac,cbc,len;
 
10
 
 
11
   if (Cc.icore == 1 && Cl.icore == 1 && Sc.icore == 1 && Sl.icore == 1) {
 
12
      if (Cc.Ms0) {
 
13
         for (blk=0; blk < Cc.num_blocks; blk++) {
 
14
            cac = Cc.Ia_code[blk];
 
15
            cbc = Cc.Ib_code[blk];
 
16
            if (cac < cbc) continue;
 
17
            if (cac != cbc) {
 
18
               len = Cc.Ia_size[blk] * Cc.Ib_size[blk];
 
19
               ccptr = Cc.blocks[blk][0];
 
20
               clptr = Cl.blocks[blk][0];
 
21
               scptr = Sc.blocks[blk][0];
 
22
               slptr = Sl.blocks[blk][0];
 
23
               for (i=0; i<len; i++) {
 
24
                  ccptr[i] = norm * (acur * ccptr[i] + alast * clptr[i]);
 
25
                  scptr[i] = norm * (acur * scptr[i] + alast * slptr[i]);
 
26
                  }
 
27
               for (i=0; i<H0block.size; i++) {
 
28
                  al = H0block.alplist[i];
 
29
                  bl = H0block.betlist[i];
 
30
                  ai = H0block.alpidx[i];
 
31
                  bi = H0block.betidx[i];
 
32
                  if (al == cac && bl == cbc) {
 
33
                     H0block.c0b[i] = Cc.blocks[blk][ai][bi];
 
34
                     H0block.s0b[i] = Sc.blocks[blk][ai][bi];
 
35
                     } 
 
36
                  else if (al == cbc && bl == cac) {
 
37
                     H0block.c0b[i] = Cc.blocks[blk][bi][ai];
 
38
                     H0block.s0b[i] = Sc.blocks[blk][bi][ai];
 
39
                     }
 
40
                  }
 
41
               }
 
42
            if (cac == cbc) {
 
43
               len = Cc.Ia_size[blk] * Cc.Ib_size[blk];
 
44
               ccptr = Cc.blocks[blk][0];
 
45
               clptr = Cl.blocks[blk][0];
 
46
               scptr = Sc.blocks[blk][0];
 
47
               slptr = Sl.blocks[blk][0];
 
48
               for (i=0; i<len; i++) {
 
49
                  ccptr[i] = norm * (acur * ccptr[i] + alast * clptr[i]);
 
50
                  scptr[i] = norm * (acur * scptr[i] + alast * slptr[i]);
 
51
                  }
 
52
               for (i=0; i<H0block.size; i++) {
 
53
                  al = H0block.alplist[i];
 
54
                  bl = H0block.betlist[i];
 
55
                  ai = H0block.alpidx[i];
 
56
                  bi = H0block.betidx[i];
 
57
                  if (al == cac && bl == cbc) {
 
58
                     H0block.c0b[i] = Cc.blocks[blk][ai][bi];
 
59
                     H0block.s0b[i] = Sc.blocks[blk][ai][bi];
 
60
                     }
 
61
                  }
 
62
               }
 
63
            } /* end loop over blocks */
 
64
         } /* end Ms0 case */
 
65
 
 
66
      else { /* not Ms = 0 */
 
67
         for (blk=0; blk < Cc.num_blocks; blk++) {
 
68
            cac = Cc.Ia_code[blk];
 
69
            cbc = Cc.Ib_code[blk];
 
70
            len = Cc.Ia_size[blk] * Cc.Ib_size[blk];
 
71
            ccptr = Cc.blocks[blk][0];
 
72
            clptr = Cl.blocks[blk][0];
 
73
            scptr = Sc.blocks[blk][0];
 
74
            slptr = Sl.blocks[blk][0];
 
75
            for (i=0; i<len; i++) {
 
76
               ccptr[i] = norm * (acur * ccptr[i] + alast * clptr[i]);
 
77
               scptr[i] = norm * (acur * scptr[i] + alast * slptr[i]);
 
78
               }
 
79
            for (i=0; i<H0block.size; i++) {
 
80
               al = H0block.alplist[i];
 
81
               bl = H0block.betlist[i];
 
82
               ai = H0block.alpidx[i];
 
83
               bi = H0block.betidx[i];
 
84
               if (al == cac && bl == cbc) {
 
85
                  H0block.c0b[i] = Cc.blocks[blk][ai][bi];
 
86
                  H0block.s0b[i] = Sc.blocks[blk][ai][bi];
 
87
                  }
 
88
               }
 
89
            } /* end loop over blocks */
 
90
         } /* end Ms != 0 case */
 
91
 
 
92
      } /* end all in-core option */
 
93
   else {
 
94
      printf("(mitrush_update): unrecognized icore option\n");
 
95
      return;
 
96
      }
 
97
}
 
98