Merge branch 'charm' of charmgit:charm into charm
[charm.git] / examples / amr / jacobi2D / jacobi2DAMR.C
1 #include "jacobi2DAMR.h"
2 #include "jacobi2DAMR.decl.h"
3 /*
4 ********************************************
5 User Code for 2D
6 ********************************************
7 */
8
9 AmrUserData* AmrUserData :: createData()
10 {
11   Jacobi2DAMR *instance = new Jacobi2DAMR;
12   return (AmrUserData *)instance;
13 }
14
15 AmrUserData* AmrUserData :: createData(void *data, int dataSize)
16 {
17   Jacobi2DAMR *instance = new Jacobi2DAMR(data , dataSize);
18   return (AmrUserData *) instance;
19 }
20
21
22 void AmrUserData :: deleteNborData(void* data)
23 {
24   delete (double *) data;
25 }
26
27 void AmrUserData :: deleteChildData(void* data)
28 {
29   delete (double *) data;
30 }
31
32
33
34 void Jacobi2DAMR :: doComputation(void)
35 {
36   for(int i=1; i <= cellSize ;i++) 
37     for(int j=1; j<=cellSize;j++) 
38       newDataGrid[i][j] = 0.2 * (dataGrid[i][j-1] + dataGrid[i][j+1] 
39                                  +dataGrid[i][j] +dataGrid[i-1][j] +dataGrid[i+1][j]);
40   copyGrid();
41   
42 }
43
44 void Jacobi2DAMR :: copyGrid(void) 
45 {
46   for(int i=0; i< cellSize+2; i++)
47     for(int j=0; j<cellSize+2; j++){
48       dataGrid[i][j] = newDataGrid[i][j];
49       newDataGrid[i][j] = 10.0;
50     }
51 }
52
53 void ** Jacobi2DAMR :: getNborMsgArray(int* sizePtr)
54 {
55   //gives the size of each individual column in bytes
56   *sizePtr = cellSize* sizeof(double);
57   //since we are using 2D mesh so have an array of size 4
58   double ** dataArray = new double* [4];
59   for(int i =0;i<4;i++) {
60     dataArray[i] = new double[cellSize];
61   }
62   //To my Right neighbor
63   copyColumn(dataArray[0], cellSize);
64   //To my left neighbor
65   copyColumn(dataArray[1], 1);
66   //To my Down neighbor
67   copyRow(dataArray[2], cellSize);
68   //To my Up neighbor
69   copyRow(dataArray[3], 1);
70   return (void **) dataArray;
71 }
72
73 void **Jacobi2DAMR :: fragmentNborData(void *data, int* sizePtr)
74 {
75   int elements = (*sizePtr)/sizeof(double);
76   int newElements = elements/2;
77   double **fragmentedArray = new double* [2];
78   double *indata = (double *)data;
79   if(elements %2 == 0){
80     *sizePtr = newElements * sizeof(double);
81     for(int i=0; i<2; i++) {
82       fragmentedArray[i] = new double[newElements];
83       for(int j=0; j<newElements;j++)
84         fragmentedArray[i][j] = indata[i*newElements + j];
85     }
86   }
87   else {
88     *sizePtr =( ++newElements)*sizeof(double);
89     for(int i=0; i<2; i++) {
90       fragmentedArray[i] = new double[newElements];
91       for(int j=0; j<newElements-1;j++)
92         fragmentedArray[i][j] = indata[i*newElements + j];
93     }
94     fragmentedArray[1][newElements-1] = indata[elements -1];
95     fragmentedArray[0][newElements-1] = (fragmentedArray[0][newElements -2] + fragmentedArray[1][0])/2;
96   }
97   return (void **)fragmentedArray;
98     
99 }
100
101 void Jacobi2DAMR :: store(void* data , int dataSize , int neighborSide)
102 {
103   //  if(dataSize>0)
104   //    CkPrintf("neighborSide %d, size %d\n",neighborSide, dataSize);
105   if(dataSize/sizeof(double) == cellSize) {
106     switch(neighborSide) {
107     case 0:
108       copyToColumn((double*) data, 0);
109       break;
110     case 1:
111       copyToColumn((double *) data, cellSize+1);
112       break;
113     case 2:
114       copyToRow((double *) data, 0);
115       break;
116     case 3:
117       copyToRow((double *) data, cellSize+1);
118       break;
119     }
120   }
121   //  else
122     //    CkError("Error: Jacobi::store...wrong sized message size %d cellsize %d\n",
123     //      dataSize/sizeof(double), cellSize);
124 }
125
126 void Jacobi2DAMR :: combineAndStore(void *data1, void* data2, int dataSize,int neighborSide) {
127   int size = dataSize /sizeof(double);
128   double * buf = new double[2*size];
129   double *tmpbuf = buf + size;
130   memcpy((void *)buf, data1, dataSize);
131   memcpy((void *)tmpbuf, data2, dataSize);
132   DEBUGJ(("Calling store from combine and store msg size %d\n",dataSize));
133   store((void *)buf,(2*dataSize),neighborSide);
134   delete buf;
135 }
136
137 bool Jacobi2DAMR :: refineCriterion(void) 
138 {
139   double average = sumofGrid()/(cellSize*cellSize);
140   //  CkPrintf("refineCriterion: average %lf \n",average);
141   if(average < 15.0 && cellSize >= 4)
142     return true;
143   else
144     return false;
145 }
146
147 void** Jacobi2DAMR :: fragmentForRefine(int *sizePtr)
148 {
149   // CkError("Error: Jacobi ::fragment for refine\n");
150   //return (void **) NULL;
151    int newSize = cellSize/2;
152   *sizePtr = newSize*newSize*sizeof(double);
153
154   double ** dataArray = new double* [4];
155   for(int i=0;i<4;i++) {
156     dataArray[i] = new double[newSize*newSize];
157     for(int j=1;j<=newSize;j++){
158       for(int k=1;k<=newSize;k++)
159         dataArray[i][(j-1)*newSize+(k-1)] = dataGrid[((i/2)%2)*newSize+j][(i%2)*newSize+k];
160     }
161   }
162   return (void **)dataArray;
163   
164 }
165 PUPable_def(AmrUserData);
166
167 #include "jacobi2DAMR.def.h"