DSQSS  1.1
measure.hpp
説明を見る。
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 }
 全て クラス ネームスペース ファイル 関数 変数 型定義 列挙型の値 フレンド マクロ定義