lootSpillFiles.cxx

Go to the documentation of this file.

#include "lootSpillFiles.h"
#include "TSystem.h"
#include "TFile.h"
#include "TTree.h"
#include "TString.h"
#include "Validity/VldTimeStamp.h"
#include "SpillTiming/SpillTimeND.h"
#include "DatabaseInterface/DbiWriter.h"
#include "DatabaseInterface/DbiStatement.h"
#include "DatabaseInterface/DbiCascader.h"
#include <vector>
#include <iostream>
#include <fstream>

using namespace std;

void createSpillTables()
{
  int  dbNo = 0; // or whatever cascade entry you need
  DbiStatement* s = DbiTableProxyRegistry::Instance()
    .GetCascader()
    .CreateStatement(dbNo);

  s->ExecuteUpdate("create table if not exists SPILLTIMENDVLD ("
                   " SEQNO         int not null primary key auto_increment,"
                   " TIMESTART     datetime not null,"
                   " TIMEEND       datetime not null,"
                   " DETECTORMASK  tinyint,"
                   " SIMMASK       tinyint,"
                   " TASK          int,"
                   " AGGREGATENO   int,"
                   " CREATIONDATE  datetime not null,"
                   " INSERTDATE    datetime not null )");

  s->ExecuteUpdate("create table if not exists SPILLTIMEND ("
                   " SEQNO integer,"
                   " SECOND integer,"
                   " NANOSEC integer, "
                   " index (SEQNO))");

  delete s;  //Drop statement to release connection.
  s = 0;
}


void lootSpillFiles(const char* path, const char* logfile)
{
  // Loot the given directory for goblin files.
  void* dir = gSystem->OpenDirectory(path);
  while(1) {
    const char* entry = gSystem->GetDirEntry(dir);
    if(!entry) break;
    TString entrystr(entry);
    if((entrystr.Contains("spilltime") && entrystr.Contains(".dat"))) {
      cout << "Looking at " << entry << endl;
      char filename[1000];
      sprintf(filename,"%s/%s",path,entry);
      bool good = true;
      
      {
        ifstream lootfile(logfile);
        if(!lootfile.good()) cout << "Can't find logfile " << logfile << endl;
        char line[1000];
        while((!lootfile.eof())&&(lootfile.good())) {
          lootfile.getline(line,1000,'\n');
          if(strcmp(line,filename)==0) good=false;
        }
        lootfile.close();
      }      

      if(good) {
        lootSpillFile(filename);

        // Log that this file is processed.
        ofstream lootfile(logfile,ios_base::out|ios_base::ate|ios_base::app);
        lootfile << filename << endl;
        lootfile.close();
        
      } else
        cout << "Already processed file " << filename << endl;
    }
  }
}

bool TimeIsValid( int timet, int startt )
{
  if(timet<1072918800) return false; // Before 2004
  if(timet>1577840400) return false; // after 2020
  if(abs(timet-startt)>600000) return false; // within a week of the current start time
  return true;
}

// How to loot a file:
void lootSpillFile(const char* infile) 
{
  char filename[1000];
  strcpy(filename,infile);

  bool gzipped = false;
  TString tfile(infile);
  if(tfile.EndsWith(".gz")) {
    gzipped = true;
    gSystem->Exec(Form("gunzip %s -c > /tmp/temp_spilldata.dat",infile));
    sprintf(filename,"/tmp/temp_spilldata.dat");
  }

  ifstream file(filename);
  if(!file.good()){
    cout << "Problem reading file " << filename << endl;
    return;
  }

  int stampsec;
  int stampnsec;
  int type;
  int spill;

  // Get first guess at start/end times:
  int timeStart = 2000000000;
  int timeEnd   = -100000000;

  // Build a vector of the data:
  vector<VldTimeStamp> data;
  //VldTimeStamp data[100000];
  UInt_t ndata = 0;

  char cline[1000];
  //string constants. From TimeGoblin/SpillHandler.cxx
  string Start("Start:");
  string Stop("Stop:");

  while((!file.eof())&&(file.good())) {
    file.getline(cline,1000,'\n');
    
    string line(cline);

    if(line.size()<=0) continue;
    
    if(line[0]=='#') {
      // It's a comment line.
      string::size_type pos;    

      pos = line.find(Start);
      if(pos!=string::npos) {
        // Found start line.
        if(sscanf(cline+pos+Start.size(),"%d",&stampsec)>0) {
          if(stampsec<timeStart) timeStart=stampsec;      
          if(stampsec>timeEnd  ) timeEnd=stampsec;        
          cout << "Start: " << stampsec << endl;
        } else {
          cout << "Couldn't interpret Start: line" << endl;
        }
      }

      pos = line.find(Stop);
      if(pos!=string::npos) {
        // Found start line.
        if(sscanf(cline+pos+Stop.size(),"%d",&stampsec)>0) {
          if(stampsec<timeStart) timeStart=stampsec;      
          if(stampsec>timeEnd  ) timeEnd=stampsec;        
          cout << "Stop: " << stampsec << endl;
        } else {
          cout << "Couldn't interpret Stop: line" << endl;
        }
      }
      
    } else {
      // ordinary line.
      int res = sscanf(cline,"%d %d %d %d",&stampsec,&stampnsec,&type,&spill);
      if(res==4) {
        //if(type==3)  // only genuine stamps now are written.
          
        if(TimeIsValid(stampsec,timeStart)) {
          if((stampsec+1) > timeEnd  ) timeEnd = stampsec+1;
          if((stampsec  ) < timeStart) timeStart = stampsec;
          
          VldTimeStamp stamp(stampsec,stampnsec);
          //cout  << stampsec << "\t" << stampnsec << "\t" << stamp.AsString() << endl;
          
          //data[ndata] = stamp;
          data.push_back(stamp);      
          ndata++;
        } else {
          cout << "Invalid timestamp: " << cline << endl;
        }       
      } else {
        cout << "Bad line: " << cline << endl;
      }
    }
  }
  
  //if(ndata>0) // Write the DB table even if no rows!
  {

  VldTimeStamp vldStart(timeStart,0);
  VldTimeStamp vldEnd(timeEnd,0);

  cout << "Time start: " << timeStart << "\t" << vldStart.AsString() << endl;
  cout << "Time end: "   << timeEnd   << "\t" << vldEnd.AsString() << endl;  

  VldTimeStamp vldCreate = vldStart;
  
  VldRange range( (int)Detector::kNear,
                  (int)SimFlag::kData,
                  vldStart,
                  vldEnd,
                  Form("Timestamps looted from TimeGoblin file %s by script $ Id: $",infile)
                  );

  cout << "Starting write: " << range.AsString() << endl;

  DbiWriter<SpillTimeND> writer (range,
                                 -1, //Aggregate
                                 SpillTimeND::kTask_TimeGoblin,  //task
                                 vldCreate, // Creation date
                                 0,   // db no
                                 Form("Timestamps looted from TimeGoblin spilltime.dat file %s by script $ Id: $",infile)
                                 );

  for(UInt_t i = 0; i<ndata; i++) {
    SpillTimeND datum(data[i]);
    writer << datum;
  }

  writer.Close();
  }


  if(gzipped) gSystem->Exec("rm /tmp/temp_spilldata.dat");
}

---