HarpoConfig.cxx

Go to the documentation of this file.

// 
// File HarpoConfig.cxx
//
#include <climits>
#include <cassert>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <getopt.h>
//
#include <libgen.h>

#include "TROOT.h"
#include "HarpoConfig.h"
//#include "HarpoReader.h"
#include "TSystem.h"
#include "TError.h"
#include "TPRegexp.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TIterator.h"

#include "HarpoPedMgr.h"
#include "HarpoPedestal.h"


HarpoConfig * gHConfig = 0; // Global Pointer
hReaderType HarpoConfig::gHReaderType = hRawReader; // raw reader as default

// Reader types
// 0: one detector, 1: HarpoReaderRaw, 2: HarpoReaderSim, 3: HarpoReaderRoot
static int type; // copy of gHReaderType

static const char* const short_options = "hvDs:S:d:c:n:f:t:e:r:o:b:T:X:Y:P:W:a:p:";

static const struct option long_options[] = {
  { "help", 0, NULL, 'h' },
  { "verbose", 0, NULL, 'v' },
  { "debug", 0, NULL, 'D' },
  { "skip", 1, NULL, 's' },
  { "split", 1, NULL, 'S' },
  { "dets", 1, NULL, 'd' },
  { "config", 1, NULL, 'c' },
  { "nevents", 1, NULL, 'n' },
  { "from", 1, NULL, 'f' },
  { "to", 1, NULL, 't' },
  { "event", 1, NULL, 'e' },
  { "run", 1, NULL, 'r' },
  { "output", 1, NULL, 'o' },
  { "hbook", 1, NULL, 'b' },
  { "type", 1, NULL, 'T' },
  { "xdcc", 1, NULL, 'X' },
  { "ydcc", 1, NULL, 'Y' },
  { "pmm2", 1, NULL, 'P' },
  { "det", 0, &type, hDummyReader },
  { "raw", 0, &type, hRawReader },
  { "sim", 0, &type, hSimReader },
  { "root",0, &type, hRootReader },
  { "writer",1,NULL,'W' },
  { "analyses", 1, NULL, 'a' },
  { "rawpedfile", 1, NULL, 'p' },
  { NULL, 0, NULL, 0 }
};


void HarpoConfig::help()
{
  printf("Usage: %s -c cfgfile OPTIONS [x_rawfile] [y_rawfile] ...\n",ProgramName->Data());
  printf("  Where options :\n\n"
         "  -h, --help\t print this text and exit\n"
         "  -v, --verbose\t increase verbosity level, can be repeated several times\n"
         "  -D, --debug\t increase debug level can repeat several times\n"
         "  -s NNN , --skip\t skip NNN events out of NNN+1\n"
         "  -S NNN , --split\t split output file every NNN events\n"
         "  -n NNN , --nevents\t number events to process\n"
         "  -f NNN , --from\t special processing for events starting from this number\n"
         "  -t NNN , --to\t special processing for events end at this event number\n"
         "  -r NNN , --run\t run number , do not guess from file name\n"
         "  -e NNN , --event\t number to show\n"
         "  -c FILE, --config\t config file name\n"
         "  -o FILE, --output\t output root file name\n\n"
         "  -b FILE, --hbook\t output root histograms file name\n\n"
         "  -d mask, --dets\t (default 0x3) active detectors mask\n"
         "  -d det, --dets\t detector id for reader type 'det'\n"
         "\n"
         "  -T type, --type\t (default) 1: read real data, 2: generate simulated data, 3: read ROOT file\n"
         "or --det , --raw, --sim, --root for one detector, raw, sim and ROOT\n"
         "\n"
         " -X type, --xdcc\t  x dcc reader type 0: T3k , 1: MINOS\n"
         " -Y type, --ydcc\t  y dcc reader type 0: T3k , 1: MINOS\n"
         " -P type, --pmm2\t  pmm2 reader type 0:TEXT, 1:WIN, 2:Linux, 3:WIN(LLR)\n"
         " -W 0|1 --writer\t  Disble(0)/Enable(1) Out Tree writing (default:enabled).\n"
         " -a LIST, --analyses\t list of HarpoAnalyses, separated by spaces\n"
         " -p FILE, --rawpedfile root file with femion pedistals and sigmas\t \n"
         "\n");
  exit(1);
}


HarpoConfig::HarpoConfig()
{
  ULong64_t i;
  
  gHarpoDebug = 0; // Do not knnow how do this better
  /* TROOT *root = */ ROOT::GetROOT();
  DetNo = -1;  // NODET
  Verbose = 0;
  MaxEvents = LONG_MAX;
  FromEvent = 0;
  ToEvent = LONG_MAX;
  nEvent = LONG_MAX;
  fSkipEvents = 0;
  RunNo = 0;
  fSplit = 0;
  fWriterEnabled = true;

  fInFile = new TString *[gkNDetectors];
  for (i=0;i<gkNDetectors;i++){
    fInFile[i] = (TString *) NULL;
    tDetRdr[i] = 1;
  }
  tDetRdr[PMM2] = 2; // default: Linux Reader 
  fOutFile = (TString *) NULL;
  fHistFile = (TString *) NULL;

  ProgramName = new TString("N/A");
  WorkDir = new TString("N/A");
  DataDir = new TString("N/A");
  fPedFile = NULL;
  fDbUrl = NULL;    
  //  fDbTables = NULL; /// Db tables for read, separated by comma
  fPedMgr = NULL;

  // Harpo Analyse GLOBALS
  gHDetSet = HarpoDetSet::Instance();
  gHDetSet->SetMask(0l); //empty
  gHConfig = this;
  infiles = false;
}

HarpoConfig::HarpoConfig(int argc, char **argv,ULong64_t ndetmask)
{

  // g++ on SL6 not aloow call HarpoConfig();; 
  ULong64_t i;
  
  gHarpoDebug = 0; // Do not nknow how do this better
  /* TROOT *root = */  ROOT::GetROOT();
  DetNo = -1;  // NODET
  Verbose = 0;
  MaxEvents = LONG_MAX;
  FromEvent = 0;
  ToEvent = LONG_MAX;
  nEvent = LONG_MAX;
  fSkipEvents = 0;
  RunNo = 0;
  fSplit = 0;
  fWriterEnabled = true;

  fInFile = new TString *[gkNDetectors];
  for (i=0;i<gkNDetectors;i++){
    fInFile[i] = (TString *) NULL;
    tDetRdr[i] = 1;
  }
  tDetRdr[PMM2] = 2; // default: Linux Reader 
  fOutFile = (TString *) NULL;
  fHistFile = (TString *) NULL;

  ProgramName = new TString("N/A");
  WorkDir = new TString("N/A");
  DataDir = new TString("N/A");
  fPedFile = NULL;
  fDbUrl = NULL;    
  //  fDbTables = NULL; /// Db tables for read, separated by comma
  fPedMgr = NULL;

  // Harpo Analyse GLOBALS
  gHDetSet = HarpoDetSet::Instance();
  gHDetSet->SetMask(0l); //empty
  gHConfig = this;
  infiles = false;

  fAnalyses = new TString("");

  DataDir = new TString(gSystem->Getenv("HARPO_DATA_DIR"));

  fPedMgr = new HarpoPedMgr() ;

  if (gHReaderType==hDummyReader) 
    {
      gHDetSet->SetMask(0l); // no mask single detector ????
      DetNo = ndetmask; // use mask as detector number
    }
  else 
    {
      gHDetSet->SetMask(ndetmask); // 0x3 default
    }
  ParseArgs(argc,argv,ndetmask);

}

HarpoDetSet * HarpoConfig::GetDetSet()
{
  return HarpoDetSet::Instance();
}

void HarpoConfig::ParseArgs(int argc, char **argv,ULong64_t ndetmask)
{

  int c;
  
  //    int digit_optind = 0;
  
  delete ProgramName;
  ProgramName = new TString(basename(argv[0]));
  delete WorkDir; 
  WorkDir = new TString(dirname(argv[0]));

  type = (int) gHReaderType;  //  from global reader type

  while (1) {
    //      int this_option_optind = optind ? optind : 1;
    int option_index = 0;
    
    c = getopt_long(argc, argv, short_options,
                    long_options, &option_index);
    
    if (c == -1) break;

    switch (c) {
    case 0:
      printf("option %s", long_options[option_index].name);
      if (optarg)
        printf(" with arg %s", optarg);
      printf("\n");
      break;

    case 'h':
      help();
      break;
        
    case 'v':
      //        printf("option v\n");
      Verbose++;
      break;
      
    case 's':
      //printf("option s\n");
      fSkipEvents = strtol(optarg,NULL,0);
      break;
      
    case 'S':
      //printf("option s\n");
      fSplit = strtol(optarg,NULL,0);
      break;
      
    case 'D':
      //        printf("option v\n");
      gHarpoDebug++;
      break;
      
    case 'r':
      RunNo = strtol(optarg,NULL,0);
      break;
      
    case 'e':
      nEvent = strtol(optarg,NULL,0);
      break;
      
    case 'n':
      MaxEvents = strtol(optarg,NULL,0);
      break;
      
    case 'f':
      FromEvent = strtol(optarg,NULL,0);
      break;
      
    case 't':
      ToEvent = strtol(optarg,NULL,0);
      break;
      
    case 'c':
      //        std::cout << " c opt ==============================" << std::endl;
      if (SetCfgFile(optarg) ) {
        if (ReadCfgFile()) {
          if(Verbose) std::cout << "Config Ok" << std::endl;
        } else {
          std::cout << "Error in Config File Parsing " << std::endl;
          assert(0);
        }
      } else {
      std::cout << "Config File Read Error" << std::endl;
      }
      break;
      
    case 'o':
      if (fOutFile != NULL) delete fOutFile;
      fOutFile = new TString(optarg);
      break;
      
    case 'b':
      if (fHistFile != NULL) delete fHistFile;
      fHistFile = new TString(optarg);
      break;
      
    case 'p':
      if (fPedFile != NULL) delete fPedFile;
      fPedFile = new TString(optarg);
      break;
      
    case 'a':
      //      fAnalyses = new TString(optarg);
      fAnalyses->Append(" ");
      fAnalyses->Append(optarg);
      break;
      
    case 'd':
      ndetmask = strtol(optarg,NULL,0);
      break;
      
    case 'T':
      type = strtol(optarg,NULL,0);
      break;
      
    case 'X':
      tDetRdr[XDCC] = strtol(optarg,NULL,0);
      break;
      
    case 'Y':
      tDetRdr[YDCC] = strtol(optarg,NULL,0);
      break;
      
    case 'P':
      tDetRdr[PMM2] = strtol(optarg,NULL,0);
      break;

    case 'W':
      fWriterEnabled = (strtol(optarg,NULL,0) != 0);
      break;
      
    case '?':
      printf("UNKNOWN option\n");
      help();
      break;

    default:
      printf("?? getopt returned character code 0%o ??\n", c);
    }
  }
  //printf ("optind %d argc %d\n ",optind,argc);

  if (ndetmask==0) Warning (__FUNCTION__,"Zero Detector Set.\n");
  gHDetSet->SetMask(ndetmask);
  
  gHReaderType = hReaderType(type);
  
  switch(gHReaderType){
  case hRawReader:
    Info(__FUNCTION__,"+++RAW Reader selected.\n");
    break;
  case hSimReader:
    Info(__FUNCTION__,"+++SIM Reader selected.\n");
    break;
  case hRootReader:
    Info(__FUNCTION__,"+++ROOT Reader selected.\n");
    break;
  case hDummyReader:
    Info(__FUNCTION__,"+++DUMMY Reader selected.\n");
    break;
  }

  if ( ! infiles ) {
    int i = 0;
    // Data reader, one file per detector
    if (gHReaderType==hRawReader && (argc - optind) == gHDetSet->countDets()) {
      while (optind < argc) { 
        while (! gHDetSet->isExist(i)) { // Skip if nor in mask
          i++;
        } 
        if( gSystem->AccessPathName(argv[optind])){
          printf("Cannot access file %s\n",argv[optind]);
          exit(1);
        }else{
          //      std::cout << "Infile "<< i <<" " << argv[optind] << std::endl;
          fInFile[i] = new TString(argv[optind]);
          i++;
          optind++;
        }
      }
    }
    // SIM reader takes no input
    else if (gHReaderType==hSimReader && (argc - optind) == 0) 
      {
        fInFile[0] = NULL;
      }
    // ROOT reader needs 1 input
    else if (gHReaderType==hRootReader && (argc - optind) == 1)
      {
        if( gSystem->AccessPathName(argv[optind])){
          printf("Cannot access file %s\n",argv[optind]);
          exit(1);
        }else{
          fInFile[0] = new TString(argv[optind]);
          optind++;
        }  
      }
    // Dummy Reader  needs 1 input
    else if (gHReaderType==hDummyReader && (argc - optind) == 1)
      {
        if( gSystem->AccessPathName(argv[optind])){
          printf("Cannot access file %s\n",argv[optind]);
          exit(1);
        }else{
          fInFile[0] = new TString(argv[optind]);
          optind++;
        }
      }
    else
      {
        printf("Wrong number of input files (%d)\n",argc-optind);
        help();
      }
  }

  // Guess run number from file name
  if ( RunNo == 0 && fInFile[0] != NULL) {
    Int_t nmatched = 0;
    //    char * fn = strdup(fInFile[0]->Data());
    //char * bn = basename(fn);
    //int nmatched = sscanf(bn,"x_run%lld.dat",&run);
    //free(fn);
    TPRegexp runre("run(\\d+)");
    TString file(*fInFile[0]);

    TObjArray *subStrL = runre.MatchS(file);
    if(subStrL->GetEntries()<1){
      Info(__FUNCTION__," Could not Guess Run Number");
    }else{
      const TString srun = ((TObjString *)subStrL->At(1))->GetString();
      nmatched = subStrL->GetLast();
      //std::cout << "my run guess "<< srun <<" " << nmatched << std::endl;
      if (nmatched == 1) {
        RunNo = std::atol(srun);
        Info(__FUNCTION__," Guessed Run Num %lld",RunNo);
      }
    }
  }

  //TODO place and verification
  if (fPedFile == NULL){
    if (gHReaderType ==  hRawReader)
      fPedFile = new TString("${HARPO_DATA_DIR}/harpopedsraw.root");
    else
      fPedFile = new TString("");
  }
  gSystem->ExpandPathName(*fPedFile);
   
  if ( (fPedMgr != NULL) && (fPedFile != NULL ) &&
       ((gHReaderType ==  hDummyReader)|| (gHReaderType ==  hRawReader))) {
    fPedMgr->SetFile(fPedFile);
  }

  //    printf("Verbose %d\n",Verbose);
  
  return;
}
//
// Config File
//

Bool_t HarpoConfig::ReadCfgFile() // Read config file in libconfig format
{
  ULong64_t ndetmask;
  ndetmask = gHDetSet->GetMask();
  Long64_t verbose,verplus, dbgplus, runNo, Split;
  Long64_t skip, maxevents, nevent,fromevent, toevent;
  Bool_t WriterEnabled;
  TString *histfile, *outfile, *pedfile, *dburl, *infile;
  std::cout << "Reading Config --> " << *fCfgFile << std::endl;
  try {
    // Globals
    if (Lookup("verbose",verplus)) {
      verbose = gHConfig->GetVerbose();
      verbose += verplus; // command line and cfg verbse
      gHConfig->SetVerbose(verbose);
      std::cout << "cfg Verbose " << verbose << std::endl;
    }
    if (Lookup("debug",dbgplus)) {
      gHarpoDebug += dbgplus; // command line and cfg verbse
      std::cout << "cfg Debug " << gHarpoDebug << std::endl;
    }
    // config
    if (Lookup("config.run",runNo)) {
      gHConfig->SetRunNo(runNo);
      if ( Verbose > 1 ) std::cout << "cfg Run No " << runNo << std::endl;
    }
    
    if (Lookup("config.split",Split)) {
      gHConfig->SetSplit(Split);
      if ( Verbose > 1 ) std::cout << "Split output file every " << fSplit << " events" << std::endl;
    }
    
    if (Lookup("config.skip",skip)) {
      gHConfig->SetSkipEvents(skip);
      if ( Verbose > 1 )
        std::cout << "Skip " << skip << " events between two analyses" << std::endl;
    }

    if (Lookup("config.writer_enable",WriterEnabled)) {
      gHConfig->SetWriterEnable(WriterEnabled);
      if ( Verbose > 1 ) std::cout << "Tree Putput Writer Enabled " 
                                   <<  std::boolalpha << WriterEnabled
                                   <<  std::noboolalpha  << std::endl;
    }

    if (Lookup("config.dets",ndetmask)) {
     gHDetSet->SetMask(ndetmask);
     if ( Verbose > 1 ) std::cout << "cfg detmask " << std::endl;
    }

    if (Lookup("config.maxevents",maxevents)) {
      gHConfig->SetMaxEvents(maxevents);
      if ( Verbose > 1 )
        std::cout << "cfg Max Events " << maxevents << std::endl;
    }

    if (Lookup("config.event",nevent)) {
      gHConfig->SetNEvent(nevent);
      if ( Verbose > 1 )  std::cout << "cfg Event No " << nevent << std::endl;
    }
    
    if (Lookup("config.from",fromevent)) {
      gHConfig->SetFromEvent(fromevent);
      if ( Verbose > 1 )
        std::cout << "cfg From Event No " << fromevent << std::endl;
    }

    if (Lookup("config.to",toevent)) {
      gHConfig->SetToEvent(toevent);
      if ( Verbose > 1 )
        std::cout << "cfg To Event No " << toevent << std::endl;
    }

      if (Lookup("config.hfile",histfile)) {
        gHConfig->SetHistFile((char *)histfile->Data());
        if ( Verbose > 1 )
          std::cout << "cfg Hist File " << *histfile << std::endl;
      }

    TString* analysesTmp;
    if (Lookup("config.analyses",analysesTmp)){
      fAnalyses->Append(" ");
      fAnalyses->Append(*analysesTmp);
      if ( Verbose > 1 ) std::cout << "cfg Analyses list " << fAnalyses << std::endl;
    }

    if (Lookup("config.ofile",outfile)) {
      gHConfig->SetOutFile((char *)outfile);
      if ( Verbose > 1 ) std::cout << "cfg Out File " << *outfile << std::endl;
    }

    if (Exist("config.infiles")) {
      infiles = true;
      Int_t slen = getSettingLength("config.infiles"); 
      //std::cout << " slen " << slen << " ndet " << gHDetSet->countDets() << std::endl;
      if ( slen != gHDetSet->countDets()) help();
      UInt_t i = 0;
      Int_t j = 0;
      while (j < slen) { 
        while (! gHDetSet->isExist(i)) { // Skip if nor in mask
          i++;
        }

        if (LookupElem("config.infiles",j++,infile)) {
          gHConfig->SetInFile((char *)infile,i);
          if ( Verbose > 1 ) { std::cout << "cfg inFile " << i << std::endl;
            std::cout << "New fInFile["<< i << "] " << *infile  << std::endl;
          }
          i++;
        }
      }
    }
    // rundb section
    if (Lookup("rundb.rawpedfile", pedfile)) {
      gHConfig->SetPedFile((char *)pedfile->Data());
      if ( Verbose > 1 )
        std::cout << "rundb raw peds File " << *pedfile << std::endl;
    }

    if (Lookup("rundb.dburl",dburl)) {
      gHConfig->SetDbUrl((char *)dburl->Data());
      if ( Verbose > 1 ) std::cout << "rundb db url " << *dburl 
                                   << " " << dburl->IsNull() << std::endl;
    }    
    return true;
  }
  catch (...)
    {
      std::cout << "config file failed" << std::endl;
    }
  
  return false;
}


Long64_t HarpoConfig::GetDetRdrType(HarpoDetType nDet)
{
  if (nDet>=0 && (unsigned)nDet<gkNDetectors){
    return tDetRdr[nDet];
  }
  return 0;
}

void HarpoConfig::SetDetRdrType(HarpoDetType nDet,Long64_t rtype)
{
  if (nDet>=0 && (unsigned)nDet<gkNDetectors){
    tDetRdr[nDet] = rtype;
  }
}

HarpoConfig::~HarpoConfig()
{
  
  // Delete All TStrings
  delete ProgramName;
  delete WorkDir;
  delete DataDir;
  if (fPedFile != NULL) delete fPedFile;
  if (fOutFile != NULL) delete fOutFile;
  if (fHistFile != NULL) delete fHistFile;
  delete [] fInFile;
  //  if ( fRunConfig != NULL ) delete fRunConfig;
  if ( fPedMgr != NULL ) delete fPedMgr;
  //  delete gHDetSet;
}


void HarpoConfig::SetInFile(char *fin,Int_t plane)
{
  if ((plane < 0) || (plane >= (Int_t )gkNDetectors)) return; // rise bad detector
  gHDetSet->Set(plane);
  fInFile[plane] = new TString(fin);
}

void HarpoConfig::SetOutFile(char *fout)
{
  if (fOutFile != NULL) delete fOutFile;
  fOutFile = new TString(fout);
}

void HarpoConfig::SetHistFile(char *fout)
{
  if (fHistFile != NULL) delete fHistFile;
  fHistFile = new TString(fout);
}

void HarpoConfig::SetAnalyses(char *fout)
{
  fAnalyses = new TString(fout);
}

// Set Pedestal File
void HarpoConfig::SetPedFile(char * pfile)
{
  if (fPedFile != NULL) delete fPedFile;
  fPedFile = new TString(pfile);
}

// Set harpo database server URL
void HarpoConfig::SetDbUrl(char * url)
{
  if (fDbUrl != NULL) delete fDbUrl;
  fDbUrl = new TString(url);
}

// // Set list of tables for reading
// void HarpoConfig::SetDbTables(TObjArray *tables)
// {
//   fDbTables = *tables;
// }

void HarpoConfig::SetDataDir(char *datadir)
{
if (DataDir != NULL) delete DataDir;
DataDir = new TString(datadir);
}

void HarpoConfig::print() const{
  std::cout << "--- HarpoConfig" << std::endl 
             << "ProgramName : " << *ProgramName << std::endl 
             << "WorkDir : " << *WorkDir << std::endl 
             << "RunNo : " << RunNo  << std::endl
             << "MaxEvents : " << MaxEvents  << std::endl
             << "FromEvent : " << FromEvent << std::endl 
             << "ToEvent : " << ToEvent << std::endl
             << "N Event : " << nEvent << std::endl; 
  
 
  std::cout << "+++ Harpo Reader Type " << gHReaderType << std::endl; 

  if (fCfgFile != NULL)  std::cout << "fCfgFile : " << *fCfgFile  << std::endl; 

  if(gHReaderType == hRawReader){
    ULong64_t ndet;
    for(ndet=0;ndet<gkNDetectors;ndet++) {
      if (gHDetSet->isExist(ndet)) {
        std::cout  << "fInFile[" << ndet << "] : " <<  *fInFile[ndet]  << std::endl;
        std::cout  << "ReaderType[" << ndet << "] : " <<  tDetRdr[ndet]  << std::endl;
      }
    }
  }
  if(gHReaderType == hRootReader || gHReaderType == hDummyReader)
    std::cout  << "fInFile[0] : " <<  *fInFile[0]  << std::endl;
  if (fHistFile != NULL) std::cout  << "fHistFile : " <<  *fHistFile  << std::endl;
  if (fOutFile != NULL)  std::cout << "fOutFile : " << *fOutFile  << std::endl;
  if (fAnalyses != NULL) std::cout  << "fAnalyses : " <<  *fAnalyses  << std::endl;
}