DSQSS
1.1
|
00001 00002 #ifndef MEASURE_H 00003 #define MEASURE_H 00004 00005 //###################################################################### 00006 00007 #include <stdio.h> 00008 #include "name.h" 00009 #include "parameter.hpp" 00010 #include "measure_specific.h" 00011 00012 //###################################################################### 00013 00014 class Estimate { 00015 00016 public: 00017 00018 const char* key; 00019 double value ,s1; 00020 double error; 00021 00022 void set_key(string s) { key = s.c_str(); }; 00023 00024 void reset() { 00025 key = "undefined"; 00026 value = 0.0; 00027 error = 0.0; 00028 }; 00029 00030 Estimate() { reset(); }; 00031 00032 Estimate(char* k) { set_key(k); reset(); }; 00033 00034 void operator =( Estimate E ) { 00035 value = E.value; 00036 error = E.error; 00037 }; 00038 00039 void dump() { 00040 printf(" %6s = %16.6e %16.6e\n", key, value, error); 00041 }; 00042 00043 }; 00044 00045 //###################################################################### 00046 00047 class Accumulator : public Estimate { 00048 00049 private: 00050 00051 int n; 00052 //kota double s1; 00053 // double s1; 00054 double s2; 00055 00056 public: 00057 00058 void reset() { 00059 n = 0; 00060 s1 = 0.0; 00061 s2 = 0.0; 00062 }; 00063 00064 Accumulator() : Estimate::Estimate() { 00065 reset(); 00066 }; 00067 00068 Accumulator(char* k) : Estimate::Estimate(k) { 00069 reset(); 00070 }; 00071 00072 ~Accumulator() {}; 00073 00074 void accumulate(double x) { 00075 n++; 00076 s1 += x; 00077 s2 += (x*x); 00078 }; 00079 00080 void accumulatex(double x) { 00081 n++; 00082 s1 += x; 00083 s2 += (x*x); 00084 }; 00085 // ++++ edit rep sakakura ++++ 00086 double acc_get_value(){return s1;} 00087 double acc_put_value(double x){value=x;} 00088 double acc_get_error(){return s2;} 00089 double acc_put_error(double x, int nx){ 00090 error=x; 00091 // cout <<"nx = " <<nx <<endl; 00092 // value=s1; 00093 if (nx>2) { 00094 error = error - value * value; 00095 error /= (double)(nx-1); 00096 error = sqrt(error); 00097 } else{ 00098 error = 0.0;} 00099 } 00100 00101 // ++++ edit rep sakakura ++++ 00102 00103 void average() { 00104 value = 0.0; 00105 error = 0.0; 00106 if ( n > 0 ) { 00107 value = s1 / (double)n; 00108 error = s2 / (double)n; 00109 if ( n > 1 ) { 00110 error = error - value * value; 00111 error /= (double)(n-1); 00112 error = sqrt(error); 00113 } else { 00114 error = 0.0; 00115 } 00116 } 00117 }; 00118 00119 }; 00120 00121 //###################################################################### 00122 00123 class Measurement { 00124 00125 private: 00126 00127 int NACC; 00128 int NPHY; 00129 Parameter& P; 00130 Lattice& LAT; 00131 Algorithm& ALG; 00132 double* Q; // 00133 00134 public: 00135 00136 Accumulator* ACC; // accumurator of snapshot values 00137 Accumulator* PHY; // accumurator of set averages 00138 // == edit rep sakakura === 00139 Accumulator** PHYX; // accumurator of set averages 00140 // Accumulator* PHYE; // accumurator of set averages 00141 00142 00143 double ediag; 00144 int nkink; 00145 // == edit rep sakakura === 00146 00147 double EBASE; 00148 00149 Measurement(Parameter& P0, Lattice& L, Algorithm& A); 00150 ~Measurement(); 00151 void measure(); 00152 void summary(); 00153 void setinit(); 00154 00155 // == edit rep sakakura === 00156 void summary_REP(int index); 00157 // void dumpX(int i); 00158 void setsummary(int index); 00159 double get_data(); 00160 double get_ediag(); 00161 int get_nkink(); 00162 // void setsummary(); 00163 // == edit rep sakakura === 00164 00165 void accumulate_length(double len); 00166 void dump(); 00167 void show(FILE*); 00168 int imin(int n, double* t); 00169 00170 00171 // double get_data(); 00172 }; 00173 00174 //###################################################################### 00175 inline int Measurement::imin(int n, double* t) { 00176 if ( n==0 ) { printf("imin> Error. n = 0.\n"); exit(0); } 00177 int i = 0; 00178 double tmin = t[0]; 00179 for ( int j=1; j<n; j++) { 00180 if ( t[j] < tmin ) { 00181 i = j; 00182 tmin = t[j]; 00183 } 00184 } 00185 return i; 00186 } 00187 //###################################################################### 00188 inline Measurement::Measurement(Parameter& P0, Lattice& L, Algorithm& A) : 00189 P(P0), LAT(L), ALG(A) 00190 { 00191 00192 if (DEBUG) printf("\nMeasurement::Measurement> Start.\n"); 00193 00194 NACC = Specific::NACC; 00195 NPHY = Specific::NPHY; 00196 Q = new double[NPHY]; 00197 ACC = new Accumulator[NACC]; 00198 PHY = new Accumulator[NPHY]; 00199 00200 // == edit rep sakakura == 00201 // PHYE = new Accumulator[P.NREP]; 00202 PHYX = new Accumulator*[NPHY]; 00203 00204 for (int i=0;i<NPHY;i++){ 00205 PHYX[i]=new Accumulator[P.NREP]; 00206 } 00207 00208 for (int i=0; i<P.NREP; i++) { PHYX[1][i].reset(); } 00209 00210 // for (int i=0; i<P.NREP; i++) { PHYE[i].reset(); } 00211 00212 // == edit rep sakakura == 00213 00214 00215 for (int i=0; i<NACC; i++) { ACC[i].reset(); } 00216 00217 for (int i=0; i<NPHY; i++) { PHY[i].reset(); } 00218 00219 for (int i=0; i<NACC; i++) { ACC[i].set_key( Specific::ANAME[i] ); } 00220 00221 for (int i=0; i<NPHY; i++) { PHY[i].set_key( Specific::PNAME[i] ); } 00222 00223 // setting EBASE 00224 00225 EBASE = 0.0; 00226 for (int i=0; i<LAT.NINT; i++) { 00227 InteractionProperty& IP = LAT.I(i).property(); 00228 double eb = IP.EBASE; 00229 EBASE += eb; 00230 } 00231 00232 if (DEBUG) printf("Measurement::Measurement> End.\n"); 00233 00234 } 00235 00236 //====================================================================== 00237 00238 inline Measurement::~Measurement() { 00239 // printf("*** Destroying Measurement\n"); 00240 delete [] Q; 00241 delete [] ACC; 00242 delete [] PHY; 00243 //======== edit rep sakakura =======// 00244 for (int i=0;i<NPHY;i++){ 00245 delete [] PHYX[i]; 00246 } 00247 delete [] PHYX; 00248 // delete [] PHYE; 00249 //======== edit rep sakakura =======// 00250 } 00251 00252 //====================================================================== 00253 00254 inline void Measurement::setinit() { 00255 00256 for (int i=0; i<NACC; i++) ACC[i].reset(); 00257 } 00258 00259 //====================================================================== 00260 00261 inline void Measurement::summary() { 00262 00263 for (int i=0; i<NPHY; i++) { 00264 PHY[i].average(); 00265 } 00266 00267 } 00268 00269 //====================================================================== 00270 00271 inline void Measurement::show(FILE* F) { 00272 for (int i=0; i<NPHY; i++) { 00273 fprintf(F,"R %-6s = %16.10e %16.10e\n", 00274 PHY[i].key, PHY[i].value, PHY[i].error); 00275 } 00276 } 00277 00278 //====================================================================== 00279 00280 inline void Measurement::dump() { 00281 printf("\n"); 00282 printf(">>> Dumping accumurators :\n"); 00283 for (int i=0; i<NACC; i++) { 00284 printf(" ACC[%2d] = %16.6f\n", i, ACC[i].value); 00285 } 00286 printf("\n"); 00287 for (int i=0; i<=NPHY; i++) { 00288 printf(" %s = phy[%2d] = %16.6f %16.6f\n", PHY[i].key, i, PHY[i].value, PHY[i].error); 00289 } 00290 } 00291 00292 //====================================================================== 00293 00294 inline void Measurement::accumulate_length(double len) { 00295 ACC[Specific::LE1].accumulate(len); 00296 } 00297 00298 //inline double Measurement::get_data(){ 00299 // return PHY[1].value; 00300 //}; 00301 00302 #include "measure_specific.cc" 00303 00304 #endif 00305 00306 // ---------------------------------------------------------------------- 00307 // === edit rep sakakura === 00308 00309 //inline void Measurement::dumpX(int i) { 00310 // printf ("index=%d,%12.5f %12.5f\n",i,PHYX[1][i].value,PHYX[1][i].error); 00311 00312 // cout << PHYE[0].value <<" dumpx "<<i<< endl; 00313 00314 // printf ("index=%d,%12.5f %12.5f\n",i,PHYE[i].value,PHYE[i].error); 00315 //} 00316 inline double Measurement::get_data(){ 00317 return PHY[1].value; 00318 } 00319 00320 inline double Measurement::get_ediag(){ 00321 return ediag; 00322 } 00323 00324 inline int Measurement::get_nkink(){ 00325 return nkink; 00326 } 00327 00328 inline void Measurement::summary_REP(int index) { 00329 00330 double buf0[NPHY][P.NREP],buf1[NPHY][P.NREP]; 00331 00332 for (int i=0; i<P.NREP; i++){ 00333 for (int j=0; j<NPHY; j++){ 00334 buf0[j][i] = PHYX[j][i].acc_get_value(); 00335 } 00336 } 00337 00338 double size = P.NREP * NPHY; 00339 00340 00341 // gather value 00342 #ifdef KASHIWA 00343 MPI_Allreduce(&buf0,&buf1,size,MPI_DOUBLE_PRECISION,MPI_SUM,MPI_COMM_WORLD); 00344 #else 00345 MPI::COMM_WORLD.Allreduce(&buf0,&buf1,size,MPI::DOUBLE,MPI::SUM); 00346 #endif 00347 00348 for (int i=0; i<NPHY; i++){ 00349 PHY[i].acc_put_value(buf1[i][index]/P.NSET); 00350 } 00351 00352 for (int i=0; i<P.NREP; i++){ 00353 for (int j=0; j<NPHY; j++){ 00354 buf0[j][i] = PHYX[j][i].acc_get_error(); 00355 buf1[j][i] = 0; 00356 } 00357 } 00358 00359 // gather error 00360 #ifdef KASHIWA 00361 MPI_Allreduce(&buf0,&buf1,size,MPI_DOUBLE_PRECISION,MPI_SUM,MPI_COMM_WORLD); 00362 #else 00363 MPI::COMM_WORLD.Allreduce(&buf0,&buf1,size,MPI::DOUBLE,MPI::SUM); 00364 #endif 00365 00366 for (int i=0; i<NPHY; i++){ 00367 PHY[i].acc_put_error(buf1[i][index]/P.NSET,P.NSET); 00368 } 00369 00370 }