...

diff --git a/configcache.h b/configcache.h
index 8146b276c4d33ba7635e261aa48861e35d34f202..5e48cbf06bf39fabc957a0b34a753acba240b0c7 100644 (file)
--- a/configcache.h
+++ b/configcache.h
@@ -49,11 +49,12 @@ class configcache{
   int inFilesLeft() { return inFiles.size(); }
   char* getConfigMem() { return configMem; }
   int getConfigSize() { return configSize; }
   int inFilesLeft() { return inFiles.size(); }
   char* getConfigMem() { return configMem; }
   int getConfigSize() { return configSize; }

+  bool isOutFileOpen () { return outFile.is_open(); }
+  void finishOutFile();

 
  private:
   ostream* log;
   infiledesc openFileDesc;
 
  private:
   ostream* log;
   infiledesc openFileDesc;

-  void finishOutFile();

   int getParIndex(const string& parid);
   int NEQUI;
   int NSKIP;
   int getParIndex(const string& parid);
   int NEQUI;
   int NSKIP;

diff --git a/hypercache.cpp b/hypercache.cpp
index b2a0b256f4671ac59830a4e212f1c103f866a5a7..81b7b3cec42bc23936d1108254ed2677431a216d 100644 (file)
--- a/hypercache.cpp
+++ b/hypercache.cpp
@@ -11,6 +11,7 @@ int hypercache::NEQUI;
 int hypercache::NSKIP;
 int hypercache::nequileft;
 pair<int, char*> hypercache::mostEquilibratedConfig;
 int hypercache::NSKIP;
 int hypercache::nequileft;
 pair<int, char*> hypercache::mostEquilibratedConfig;

+int hypercache::lastWrittenObsEquis;

 
 void hypercache::initCache(configcache **cache,
                           const string& cacheid, const int& nequi, const int& nskip, const string& datadir, 
 
 void hypercache::initCache(configcache **cache,
                           const string& cacheid, const int& nequi, const int& nskip, const string& datadir, 


@@ -88,7 +89,8 @@ bool hypercache::readC() {
     activeCFile = "";
 
   /* try to find more equilibrated config-file configuration for equilibration in excluded files */
     activeCFile = "";
 
   /* try to find more equilibrated config-file configuration for equilibration in excluded files */

-  if ( nequileft > 0 && C->inFilesLeft() > 0 ) {
+  if ( ( nequileft >= 0 || ( ! readAtLeastOneConfig ) ) && C->inFilesLeft() > 0 ) {
+    int nEquiLeftBeforeExcludedFileCheck = nequileft;

     *log << "HYPERCACHE: Trying to find more equilibrated config in excluded files." << endl << flush;
 
     char *tmpconfig = (char*) malloc(C->getConfigSize());
     *log << "HYPERCACHE: Trying to find more equilibrated config in excluded files." << endl << flush;
 
     char *tmpconfig = (char*) malloc(C->getConfigSize());


@@ -106,32 +108,34 @@ bool hypercache::readC() {
       }
       
       if (nequileftReadConfig_ex <= nequileft) {
       }
       
       if (nequileftReadConfig_ex <= nequileft) {

-       *log << "HYPERCACHE: Found more equilibrated or same equilibrated excluded config-file configuration for equilibration." << endl << flush;

        nequileft = nequileftReadConfig_ex;
        nequileft = nequileftReadConfig_ex;

-       readAtLeastOneConfig = true;
+       readAtLeastOneConfig = false;

       }
       else if (nequileftReadConfig_ex > nequileft) {
       }
       else if (nequileftReadConfig_ex > nequileft) {

-       *log << "HYPERCACHE: Excluded config-file configuration for equilibration is less equilibrated than actual config." << endl << flush;

        memcpy (C->getConfigMem(), tmpconfig, C->getConfigSize());
       }
     }
     free(tmpconfig);
        memcpy (C->getConfigMem(), tmpconfig, C->getConfigSize());
       }
     }
     free(tmpconfig);

+
+    if (nEquiLeftBeforeExcludedFileCheck > nequileft)
+      *log << "HYPERCACHE: Found more equilibrated or same equilibrated excluded config-file configuration for equilibration." << endl << flush;
+    else
+      *log << "HYPERCACHE: Excluded config-file configuration for equilibration is less equilibrated than actual config." << endl << flush;

   }
 
   /* storing most equilibrated config */
   if ( nequileft < mostEquilibratedConfig.first && readAtLeastOneConfig ) {
   }
 
   /* storing most equilibrated config */
   if ( nequileft < mostEquilibratedConfig.first && readAtLeastOneConfig ) {

-    *log << "HYPERCACHE: Storing a copy of so far most equilibrated config with nequileft = " << nequileft << endl << flush;
+    //*log << "HYPERCACHE: Storing a copy of so far most equilibrated config with nequileft = " << nequileft << endl << flush;

     mostEquilibratedConfig.first = nequileft;
     memcpy(mostEquilibratedConfig.second, C->getConfigMem(), C->getConfigSize());
   }
 
     mostEquilibratedConfig.first = nequileft;
     memcpy(mostEquilibratedConfig.second, C->getConfigMem(), C->getConfigSize());
   }
 

-  

   /* injecting back most equilibrated config if nothing could be used anymore */
   /* injecting back most equilibrated config if nothing could be used anymore */

-  if ( nequileft > 0 && mostEquilibratedConfig.first < nequileft ) {
+  if ( (!readAtLeastOneConfig) && mostEquilibratedConfig.first < nequileft ) {

     *log << "HYPERCACHE: Injecting back most equilibrated stored config with nequileft = " << mostEquilibratedConfig.first << endl << flush;
     nequileft = mostEquilibratedConfig.first;
     memcpy(C->getConfigMem(), mostEquilibratedConfig.second, C->getConfigSize());
     *log << "HYPERCACHE: Injecting back most equilibrated stored config with nequileft = " << mostEquilibratedConfig.first << endl << flush;
     nequileft = mostEquilibratedConfig.first;
     memcpy(C->getConfigMem(), mostEquilibratedConfig.second, C->getConfigSize());

-    readAtLeastOneConfig = false;
+    //readAtLeastOneConfig = false;

   }
 
   return readAtLeastOneConfig;
   }
 
   return readAtLeastOneConfig;


@@ -147,12 +151,17 @@ void hypercache::writeC() {
   activeCFile = fileOfPath( C->getOutFileName().substr( 0, C->getOutFileName().length()-4 ) );
 }
 
   activeCFile = fileOfPath( C->getOutFileName().substr( 0, C->getOutFileName().length()-4 ) );
 }
 

-void hypercache::writeO(int obsid, int actnequi) {
+void hypercache::writeO(int obsid) {
+  if ( ( lastWrittenObsEquis + NSKIP != NEQUI-nequileft-NSKIP ) && Os[obsid]->isOutFileOpen() )
+    Os[obsid]->finishOutFile();
+

   if ( activeCFile != "" ) {
     unsigned long afilehash = configcache::hash(activeCFile);
   if ( activeCFile != "" ) {
     unsigned long afilehash = configcache::hash(activeCFile);

-    Os[obsid]->writeHeader("concurrent_cfile", (char*)(&afilehash), sizeof(unsigned long), actnequi);
+    Os[obsid]->writeHeader("concurrent_cfile", (char*)(&afilehash), sizeof(unsigned long), NEQUI-nequileft-NSKIP);

   }
   }

-  Os[obsid]->writeConfig(actnequi); 
+  Os[obsid]->writeConfig(NEQUI-nequileft-NSKIP); 
+
+  lastWrittenObsEquis = NEQUI-nequileft-NSKIP;

 }
 
 void hypercache::readO(int obsid, bool& readnewconfig, int& nequileft) {
 }
 
 void hypercache::readO(int obsid, bool& readnewconfig, int& nequileft) {

diff --git a/hypercache.h b/hypercache.h
index 20ce840c7bd7e40cfba78207bff7a76221a8cfdd..efb97fa686bd6cdbd8d5205a702df682b9437faa 100644 (file)
--- a/hypercache.h
+++ b/hypercache.h
@@ -28,7 +28,7 @@ class hypercache {
   static void setPara(const string& parid, const double& value);
   static void readO(int obsid, bool& readnewconfig, int& nequileft);
   static bool readC();
   static void setPara(const string& parid, const double& value);
   static void readO(int obsid, bool& readnewconfig, int& nequileft);
   static bool readC();

-  static void writeO(int obsid, int actnequi);
+  static void writeO(int obsid);

   static void writeC();
   static void writeHeaderO(int obsid, const string& headerid, char *header, long unsigned int size, int actnequi) { Os[obsid]->writeHeader(headerid, header, size, actnequi); }
   static void *getHeaderO(int obsid, const string& headerid) { Os[obsid]->getHeader(headerid); }
   static void writeC();
   static void writeHeaderO(int obsid, const string& headerid, char *header, long unsigned int size, int actnequi) { Os[obsid]->writeHeader(headerid, header, size, actnequi); }
   static void *getHeaderO(int obsid, const string& headerid) { Os[obsid]->getHeader(headerid); }


@@ -68,6 +68,8 @@ class hypercache {
   static int nequileft;
 
   static pair<int, char*> mostEquilibratedConfig;
   static int nequileft;
 
   static pair<int, char*> mostEquilibratedConfig;

+
+  static int lastWrittenObsEquis;

 };
 
 #endif
 };
 
 #endif

diff --git a/o815/o815.cpp b/o815/o815.cpp
index 9afaa0cb7344e66e398beffb51255bed5467985e..3511d80b163472ce8232e7fc032b9552b0d26719 100644 (file)
--- a/o815/o815.cpp
+++ b/o815/o815.cpp
@@ -143,16 +143,18 @@ void o815::mainLoop() {
        
        hypercache::readO( (*obsit)->ocid, readnewObs, nequileftNewObs );
 
        
        hypercache::readO( (*obsit)->ocid, readnewObs, nequileftNewObs );
 

-       if( ! readnewObs ) {
+       if ( readnewObs && nequileftNewObs < 0 ) {
+         (*obsit)->meas(true);
+       }
+       else {

          if (!nextAlready) {
            Sim->nextConfig();
            nextAlready = true;
          }
          (*obsit)->meas(false);
          if (!nextAlready) {
            Sim->nextConfig();
            nextAlready = true;
          }
          (*obsit)->meas(false);

-         hypercache::writeO( (*obsit)->ocid, comargs.nmeas );
+         hypercache::writeO( (*obsit)->ocid );

        }
        }

-       else
-         (*obsit)->meas(true);
+         

       }
       while( measProg.madeStep(imeas) ) 
        *out->log << "O815: " << measProg.done()*100 << "% of measurements done." << endl << flush;
       }
       while( measProg.madeStep(imeas) ) 
        *out->log << "O815: " << measProg.done()*100 << "% of measurements done." << endl << flush;

diff --git a/o815/sim.cpp b/o815/sim.cpp
index fe30ec5edd3242f02d71cd4a761cc82bde08f2c4..ec1ca89bcbecf959148d5caffeaf47ec42dcf39a 100644 (file)
--- a/o815/sim.cpp
+++ b/o815/sim.cpp
@@ -28,13 +28,10 @@ void o815::sim::nextConfig() {
   }
 
   /* make skip if no config could be read or one skip is left after equilibration */
   }
 
   /* make skip if no config could be read or one skip is left after equilibration */

-  if ( (! readAtLeastOneConfig) || (hypercache::getNEquiLeft() == 0) ) {
-    cout << "SKIPPING" << endl;
+  if ( (! readAtLeastOneConfig) || (hypercache::getNEquiLeft() >= 0) ) {

     for (int iskip=0; iskip<nskip; iskip++) {
       _makeSweep();
     }
     hypercache::writeC();
   }
     for (int iskip=0; iskip<nskip; iskip++) {
       _makeSweep();
     }
     hypercache::writeC();
   }

-
-  cout << hypercache::getNEquiLeft() << endl;

 }
 }