flight/ToFReprocessing/ToFreproc.cpp

#if !defined(__CINT__) || defined(__MAKECINT__)


#include <fstream>
#include <sstream>
#include <string>
#include <math.h>
#include <iostream>
#include <TTree.h>
#include <TClassEdit.h>
#include <TObject.h>
#include <TList.h>
#include <TSystem.h>
#include <TSystemDirectory.h>
#include <TString.h>
#include <TFile.h>
#include <TClass.h>
#include <TCanvas.h>
#include <TH1.h>
#include <TH1F.h>
#include <TH2D.h>
#include <TLatex.h>
#include <TPad.h>
#include <TPaveLabel.h>
#include <TChain.h>
#include <TGraph.h>
#include <TMultiGraph.h>
#include <TLine.h>
#include <TStyle.h>
#include <TF1.h>
#include <TH1F.h>
#include <TTree.h>
#include <TCanvas.h>
#include <PamLevel2.h>
#include <iomanip>
//
#include <ToFCore.h>
//
// Declaration of the core fortran routines
//
#define tofl2com tofl2com_
extern "C" int tofl2com();
#define toftrk toftrk_
extern "C" int toftrk();
///extern "C" int toftrk(float);
#define rdtofcal rdtofcal_
extern "C" int rdtofcal(char [], int *);

using namespace std;

#endif

//===================================
// global variables
//===================================
TString   DIR;
TString   OUTF;
TString   LIST;
TString   OPTIONS;
TString   CALIBF;

PamLevel2 *pam_event = NULL;

//==========================================
//000000000000000000000000000000000000000000
//==========================================
Int_t Loop(TString ddir,TString list, TString options){
  //
  //
  extern struct ToFInput  tofinput_;
  extern struct ToFOutput tofoutput_;
  //  --------------------
  //  read input file/list
  //  --------------------
  pam_event = new PamLevel2(ddir,list,options);
  pam_event->SetSELLI(2);
  TTree::SetMaxTreeSize(1000*Long64_t(2000000000)); 
  //
  TString outfile_t = "";
  outfile_t = OUTF;
  outfile_t.Append(".root");
  TFile *outft = (TFile*)gROOT->FindObject(outfile_t); 
  if (outft) outft->Close();
  outft = new TFile(outfile_t,"RECREATE");
  if(outft->IsZombie()){
    cout << "Output file could not be created\n";
    return 1;
  };
  cout << "Created output file: "<<outft->GetName()<<endl;
  //
  outft->cd();
  ToFLevel2 *tof = new ToFLevel2();
  ToFdEdx *tofdedx = new ToFdEdx();
  TTree *toft = new TTree("ToF","PAMELA Level2 ToF data");
  toft->SetAutoSave(900000000000000LL);          
  tof->Set();//ELENA **TEMPORANEO?**
  toft->Branch("ToFLevel2","ToFLevel2",&tof);
  //
  pam_event->CreateCloneTrees(outft);
  //
  Int_t ntrkentry = 0;
  Int_t npmtentry = 0;
  //
  ULong64_t nevents = pam_event->GetEntries();
  printf("\n\n Running on %llu events \n\n",nevents);
  //
  TFile *tfile = TFile::Open(list.Data(),"READ");
  TTree *toftr = (TTree*)tfile->Get("ToF");
  ToFLevel2 *tofl2 = new ToFLevel2();
  toftr->SetBranchAddress("ToFLevel2", &tofl2);
  ULong64_t ntofev = toftr->GetEntries();
  printf(" ToF events are %llu \n",ntofev);
  //
  //
  GL_PARAM *glparam = new GL_PARAM();
  TrkLevel2 *trk = new TrkLevel2();
  //
  TString host;
  TString user;
  TString psw;
  const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");
  const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");
  const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");
  if ( !pamdbhost ) pamdbhost = "";
  if ( !pamdbuser ) pamdbuser = "";
  if ( !pamdbpsw ) pamdbpsw = "";
  if ( strcmp(pamdbhost,"") ) host = pamdbhost;
  if ( strcmp(pamdbuser,"") ) user = pamdbuser;
  if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;
  //
  //
  TSQLServer *dbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
  if ( !dbc->IsConnected() ) return 1;
  stringstream myquery;
  myquery.str("");
  myquery << "SET time_zone='+0:00'";
  dbc->Query(myquery.str().c_str());
  glparam->Query_GL_PARAM(1,1,dbc); // parameters stored in DB in GL_PRAM table
  trk->LoadField(glparam->PATH+glparam->NAME);
  //
  Long64_t myrun = 0;
  Long64_t mysrun = -1;
  Int_t adc[4][12];
  Int_t tdc[4][12];
  Float_t tdcc[4][12];
  //
  Bool_t defcal = true;
  for(ULong64_t iev=0; iev<nevents; iev++){      


    //==================================================================


    //  for(ULong64_t iev=0; iev<50; iev++){      
    //
    if ( !(iev%1000) ) printf(" %iK \n",(int)iev/1000);
    pam_event->Clear();
    //
    if( pam_event->GetEntry(iev) ){
      //
      pam_event->FillCloneTrees();
      toftr->GetEntry(iev);
      //
      // variable to save information about the tof calibration used
      //
      //
      myrun=pam_event->GetRunInfo()->ID;
      if ( myrun != mysrun ){
        //      printf(" rhtime %u myrun %i mysrun %i \n",pam_event->GetRunInfo()->RUNHEADER_TIME,(int)myrun,(int)mysrun);
        mysrun = myrun;
        //


        Int_t error=glparam->Query_GL_PARAM(pam_event->GetRunInfo()->RUNHEADER_TIME,204,dbc); // parameters stored in DB in GL_PRAM table
        if ( error<0 ) {
          return(1);
        };
        //
        tofdedx->ReadParAtt((glparam->PATH+glparam->NAME).Data());
        
        //
        error=glparam->Query_GL_PARAM(pam_event->GetRunInfo()->RUNHEADER_TIME,205,dbc); // parameters stored in DB in GL_PRAM table
        if ( error<0 ) {
          return(1);
        };
        //
        tofdedx->ReadParPos((glparam->PATH+glparam->NAME).Data());
        
        //
        error=glparam->Query_GL_PARAM(pam_event->GetRunInfo()->RUNHEADER_TIME,206,dbc); // parameters stored in DB in GL_PRAM table
        if ( error<0 ) {
          return(1);
        };
        //
        tofdedx->ReadParBBneg((glparam->PATH+glparam->NAME).Data());
        
        //
        error=glparam->Query_GL_PARAM(pam_event->GetRunInfo()->RUNHEADER_TIME,207,dbc); // parameters stored in DB in GL_PRAM table
        if ( error<0 ) {
          return(1);
        };
        //
        tofdedx->ReadParBBpos((glparam->PATH+glparam->NAME).Data());
        
        //
        error=glparam->Query_GL_PARAM(pam_event->GetRunInfo()->RUNHEADER_TIME,208,dbc); // parameters stored in DB in GL_PRAM table
        if ( error<0 ) {
          return(1);
        };
        //
        tofdedx->ReadParDesatBB((glparam->PATH+glparam->NAME).Data());
        
        
        tofdedx->CheckConnectors(pam_event->GetRunInfo()->RUNHEADER_TIME,glparam,dbc);
        
        
        error=glparam->Query_GL_PARAM(pam_event->GetRunInfo()->RUNHEADER_TIME,201,dbc); // parameters stored in DB in GL_PRAM table
        if ( error<0 ) {
          return(1);
        };
        //
        printf(" Reading ToF parameter file: %s \n",(glparam->PATH+glparam->NAME).Data());
        //
        if ( (UInt_t)glparam->TO_TIME != (UInt_t)4294967295UL ) defcal = false;
        //
        Int_t nlen = (Int_t)(glparam->PATH+glparam->NAME).Length();
        rdtofcal((char *)(glparam->PATH+glparam->NAME).Data(),&nlen);
        //
      };      
      //


      //================================================================
      //==================================================================
      //---  Define absolute time
      UInt_t tabs=pam_event->GetOrbitalInfo()->absTime;
      
      printf(" ATIME %u re %u \n",(Int_t)tabs,(UInt_t)iev);

      //==================================================================
      Float_t dedx_corr_m[2000][48],dedx_corr[48];
      Double_t mtime[2000],t1,t2,tm;
      Float_t yhelp1,yhelp2,slope,inter,thelp1,thelp2;
      Float_t xmean1,xwidth1;

      Int_t ical,ii,j,jj;

      if (iev==0) {

        ical=0;  // counter set to zero if first-time reading

        //-----------------------------------------------------------
        // Here I  read the dEdx_korr parameters
        //-----------------------------------------------------------

        jj=0;

        ifstream fin(CALIBF.Data());

        while (! fin.eof()) {
          fin>>t1>>tm>>t2;
          //      cout<<jj<<" "<<tm<<endl;
          cout << setiosflags(ios::fixed)  << setw(10) << setprecision(3) << tm << endl;
          mtime[jj]=tm;
          for (ii=0; ii<48;ii++) {
            fin>>j>>xmean1>>xwidth1;
            dedx_corr_m[jj][ii]=xmean1;
          }
          jj=jj+1;
          //      printf(" kk %i \n",jj);
        }
        //      printf(" 1ical %i \n",ical);

        fin.close();


        while (tabs<mtime[ical] || tabs > mtime[ical+1]) {
          //      printf(" ical %i \n",ical);
          ical = ical+1;
        }
        //      ical = ical-1;
        cout<<"abs time "<<tabs<<" limit low "<<mtime[ical]<<" limit up "<<mtime[ical+1]<<" ical "<<ical<<endl;
      } // if iev==0...

      //==================================================================
      //==  End of first time reading & filling the array
      //==================================================================

      //==================================================================
      //==  if time is outside time limits: 
      //==================================================================

      if (tabs<mtime[ical] || tabs>mtime[ical+1]) {
        cout<<"Checking Time Limits!"<<endl;
        ical=0;
        while (tabs > mtime[ical+1] || tabs<mtime[ical]) {
          ical = ical+1;
        }
        //      ical = ical-1;
        cout<<"abs time "<<tabs<<" limit low "<<mtime[ical]<<" limit up "<<mtime[ical+1]<<" ical "<<ical<<endl;
      };

      //      printf(" 2ical %i \n",ical);
      //==================================================================
      //== interpolate betwen time limits
      //==================================================================

      thelp1 = mtime[ical];
      thelp2 = mtime[ical+1];

      for (ii=0; ii<48;ii++) {
        yhelp1 = dedx_corr_m[ical][ii];
        //      yhelp1 = 6.;
        if ( yhelp1 < 0.1 ) yhelp1 = 6.;
        yhelp2 = dedx_corr_m[ical+1][ii];
        //      yhelp2 = 6.;
        if ( yhelp2 < 0.1 ) yhelp2 = 6.;
        slope  = (yhelp2-yhelp1)/(thelp2-thelp1);
        inter  = yhelp1 - slope*thelp1;
        dedx_corr[ii] = slope*tabs + inter;
        //       if (ii==0) cout<<thelp1<<" "<<thelp2<<" "<<tabs<<" "<<yhelp1<<" "<<yhelp2<<" "<<dedx_corr[0]<<endl;
      }

      //================================================================
      //================================================================
      //      printf("cpippo \n");

      // process tof data
      //
      for (Int_t hh=0; hh<12;hh++){
        for (Int_t kk=0; kk<4;kk++){
          adc[kk][hh] = 4095;
          tdc[kk][hh] = 4095;
          tdcc[kk][hh] = 4095.;
          tofinput_.adc[hh][kk] = 4095;
          tofinput_.tdc[hh][kk] = 4095;
        };
      };
      //      memset(adc, 0, 12*4*sizeof(Int_t));
      //      memset(tdc, 0, 12*4*sizeof(Int_t));
      Int_t gg = 0;
      Int_t hh = 0;
      Int_t adcf[48];
      memset(adcf, 0, 48*sizeof(Int_t));
      Int_t tdcf[48];
      memset(tdcf, 0, 48*sizeof(Int_t));
      for (Int_t pm=0; pm < tofl2->ntrk() ; pm++){
        ToFTrkVar *ttf = tofl2->GetToFTrkVar(pm);
        for ( Int_t nc=0; nc < ttf->npmttdc; nc++){
          if ( (ttf->tdcflag).At(nc) != 0 ) tdcf[(ttf->pmttdc).At(nc)] = 1;
        };
        for ( Int_t nc=0; nc < ttf->npmtadc; nc++){
          if ( (ttf->adcflag).At(nc) != 0 ) adcf[(ttf->pmtadc).At(nc)] = 1;
        };
      };
      //
      for (Int_t pm=0; pm < tofl2->npmt() ; pm++){
        ToFPMT *pmt = tofl2->GetToFPMT(pm);
        tofl2->GetPMTIndex(pmt->pmt_id, gg, hh);
        if ( adcf[pmt->pmt_id] == 0 ){
          tofinput_.adc[gg][hh] = (int)pmt->adc;
          adc[hh][gg] = (int)pmt->adc;
        };
        if ( tdcf[pmt->pmt_id] == 0 ){
          tofinput_.tdc[gg][hh] = (int)pmt->tdc;
          tdc[hh][gg] = (int)pmt->tdc;
        };
        tdcc[hh][gg] = (float)pmt->tdc_tw;
        //        Int_t pppid = tof->GetPMTid(hh,gg);
        //      printf(" pm %i pmt_id %i pppid %i hh %i gg %i tdcc %f tdc %f adc %f \n",pm,pmt->pmt_id,pppid,hh,gg,pmt->tdc_tw,pmt->tdc,pmt->adc);
      };
      for (Int_t hh=0; hh<12;hh++){
        for (Int_t kk=0; kk<4;kk++){      
          tofdedx->Init(kk,hh,adc[kk][hh]);
        };
      };
      //      for (Int_t pm=0; pm <48 ; pm++){
      //        tof->GetPMTIndex(pm, gg, hh);
      //        tofinput_.tdc[hh][gg] = (int)500.;
      //        tofinput_.adc[hh][gg] = (int)500.;
      //        tdc[hh][gg] = (int)500.;
      //        adc[hh][gg] = (int)500.;
      //        //      printf(" hh %i gg %i tdc %f adc %f \n",hh,gg,pmt->tdc,pmt->adc);
      //    };
      //
      for (Int_t hh=0; hh<5;hh++){
        tofinput_.patterntrig[hh]=pam_event->GetTrigLevel2()->patterntrig[hh];
      };            
      //
      tof->Clear();
      Int_t pmt_id = 0;
      ToFPMT *t_pmt = new ToFPMT();
      if(!(tof->PMT))tof->PMT = new TClonesArray("ToFPMT",12); //ELENA
      TClonesArray &tpmt = *tof->PMT;
      ToFTrkVar *t_tof = new ToFTrkVar();
      if(!(tof->ToFTrk))tof->ToFTrk = new TClonesArray("ToFTrkVar",2); //ELENA           
      TClonesArray &t = *tof->ToFTrk;
      //
      //
      // Here we have calibrated data, ready to be passed to the FORTRAN routine which will extract common and track-related  variables.
      //
      npmtentry = 0;
      //
      ntrkentry = 0;
      //
      // Calculate tracks informations from ToF alone
      //
      tofl2com();
      //
      memcpy(tof->tof_j_flag,tofoutput_.tof_j_flag,6*sizeof(Int_t));
      //
      t_tof->trkseqno = -1;
      //
      // and now we must copy from the output structure to the level2 class:
      //
      t_tof->npmttdc = 0;
      //
      for (Int_t hh=0; hh<12;hh++){
        for (Int_t kk=0; kk<4;kk++){
          if ( tofoutput_.tofmask[hh][kk] != 0 ){
            pmt_id = tof->GetPMTid(kk,hh);
            t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);
            t_tof->tdcflag.AddAt(tofoutput_.tdcflagtof[hh][kk],t_tof->npmttdc); // gf: Jan 09/07
            t_tof->npmttdc++;
          };
        };
      };
      for (Int_t kk=0; kk<13;kk++){
        t_tof->beta[kk] = tofoutput_.betatof_a[kk];     
      }
      //
      memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));
      memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));
      memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));
      memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));
      { 
        Float_t xtof_temp[6]={0.,t_tof->xtofpos[0],t_tof->xtofpos[1],0.,0.,t_tof->xtofpos[2]};
        Float_t ytof_temp[6]={t_tof->ytofpos[0],0.,0.,t_tof->ytofpos[1],t_tof->ytofpos[2],0.};
        tofdedx->Process(pam_event->GetOrbitalInfo()->absTime,t_tof->beta[12], (Float_t *)xtof_temp,(Float_t *)ytof_temp);
      }
      t_tof->npmtadc = 0;


      for (Int_t hh=0; hh<12;hh++){
        for (Int_t kk=0; kk<4;kk++){
          pmt_id = tof->GetPMTid(kk,hh);
          if ( tofdedx->GetdEdx_pmt(pmt_id)>-1. ){
            t_tof->dedx.AddAt((tofdedx->GetdEdx_pmt(pmt_id)*36./pow(dedx_corr[pmt_id],2)),t_tof->npmtadc);
            t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
            t_tof->adcflag.AddAt(0,t_tof->npmtadc); // gf: Jan 09/07
            t_tof->npmtadc++;
          };
        };
      };
//       for (Int_t hh=0; hh<12;hh++){
//      for (Int_t kk=0; kk<4;kk++){
//           if ( tofoutput_.adctof_c[hh][kk] < 1000 ){
//          //      t_tof->dedx.AddAt(tofoutput_.adctof_c[hh][kk],t_tof->npmtadc); // EMILIANO
//          pmt_id = tof->GetPMTid(kk,hh); 
//          t_tof->dedx.AddAt((tofoutput_.adctof_c[hh][kk]*4./dedx_corr[pmt_id]),t_tof->npmtadc); // EMILIANO
//          t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
//          t_tof->adcflag.AddAt(tofoutput_.adcflagtof[hh][kk],t_tof->npmtadc); // gf: Jan 09/07
//          t_tof->npmtadc++;
//        };
//      };
//       };
      //

      //
      new(t[ntrkentry]) ToFTrkVar(*t_tof);
      ntrkentry++;      
      t_tof->Clear();
      //
      //
      //
      t_pmt->Clear();
      //
      for (Int_t hh=0; hh<12;hh++){
        for (Int_t kk=0; kk<4;kk++){
          // new WM
          //      if ( tofoutput_.tdc_c[hh][kk] < 4095 || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){     
          if ( tdcc[kk][hh] < 4095. || adc[kk][hh] < 4095  || tdc[kk][hh] < 4095 ){        
            //
            t_pmt->pmt_id = tof->GetPMTid(kk,hh);
            t_pmt->tdc_tw = tofoutput_.tdc_c[hh][kk];
            t_pmt->adc = (Float_t)adc[kk][hh];
            t_pmt->tdc = (Float_t)tdc[kk][hh];
            //
            new(tpmt[npmtentry]) ToFPMT(*t_pmt);
            npmtentry++;        
            t_pmt->Clear();
          };
        };
      };      
      //
      // Calculate track-related variables 
      //
      if ( pam_event->GetTrkLevel2()->ntrk() > 0 ){
        //
        // We have at least one track
        //
        //
        // Run over tracks
        //
        for(Int_t nt=0; nt < pam_event->GetTrkLevel2()->ntrk(); nt++){  
          //
          TrkTrack *ptt = pam_event->GetTrkLevel2()->GetStoredTrack(nt); 
          //
          // Copy the alpha vector in the input structure
          //
          for (Int_t e = 0; e < 5 ; e++){
            tofinput_.al_pp[e] = ptt->al[e];
          };      
          //
          // Get tracker related variables for this track
          //
          toftrk();
          //      toftrk(thelp);
          //
          // Copy values in the class from the structure (we need to use a temporary class to store variables).
          //
          t_tof->npmttdc = 0;
          for (Int_t hh=0; hh<12;hh++){
            for (Int_t kk=0; kk<4;kk++){
              if ( tofoutput_.tofmask[hh][kk] != 0 ){
                pmt_id = tof->GetPMTid(kk,hh);
                t_tof->pmttdc.AddAt(pmt_id,t_tof->npmttdc);
                t_tof->tdcflag.AddAt(tofoutput_.tdcflag[hh][kk],t_tof->npmttdc); // gf: Jan 09/07
                t_tof->npmttdc++;
              };
            };
          };
          for (Int_t kk=0; kk<13;kk++){
            t_tof->beta[kk] = tofoutput_.beta_a[kk];    
          };
          //
          memcpy(t_tof->xtofpos,tofoutput_.xtofpos,sizeof(t_tof->xtofpos));
          memcpy(t_tof->ytofpos,tofoutput_.ytofpos,sizeof(t_tof->ytofpos));
          memcpy(t_tof->xtr_tof,tofoutput_.xtr_tof,sizeof(t_tof->xtr_tof));
          memcpy(t_tof->ytr_tof,tofoutput_.ytr_tof,sizeof(t_tof->ytr_tof));
          //
          tofdedx->Process(pam_event->GetOrbitalInfo()->absTime,t_tof->beta[12], (Float_t *)t_tof->xtr_tof,(Float_t *)t_tof->ytr_tof);
          t_tof->npmtadc = 0;
          for (Int_t hh=0; hh<12;hh++){
            for (Int_t kk=0; kk<4;kk++){
              pmt_id = tof->GetPMTid(kk,hh);
              if ( tofdedx->GetdEdx_pmt(pmt_id) > -1. ){
                t_tof->dedx.AddAt((tofdedx->GetdEdx_pmt(pmt_id)*36./pow(dedx_corr[pmt_id],2)),t_tof->npmtadc);
                t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
                t_tof->adcflag.AddAt(0,t_tof->npmtadc); // gf: Jan 09/07
                printf(" nt %i npmtadc %i dedx %f dedx corr %f\n",nt,t_tof->npmtadc,(tofdedx->GetdEdx_pmt(pmt_id)*36./pow(dedx_corr[pmt_id],2)),dedx_corr[pmt_id]);
                t_tof->npmtadc++;
              };
              
            };
          };
//        t_tof->npmtadc = 0;
//        for (Int_t hh=0; hh<12;hh++){
//          for (Int_t kk=0; kk<4;kk++){
//            if ( tofoutput_.adc_c[hh][kk] < 1000 ){
//              //          t_tof->dedx.AddAt(tofoutput_.adc_c[hh][kk],t_tof->npmtadc); // EMILIANO
//              pmt_id = tof->GetPMTid(kk,hh); 
//              t_tof->dedx.AddAt((tofoutput_.adc_c[hh][kk]*4./dedx_corr[pmt_id]),t_tof->npmtadc); // EMILIANO
//              t_tof->pmtadc.AddAt(pmt_id,t_tof->npmtadc);
//              t_tof->adcflag.AddAt(tofoutput_.adcflag[hh][kk],t_tof->npmtadc); // gf: Jan 09/07
//              t_tof->npmtadc++;
//            };
//          };
//        };
          //

          //
          // Store the tracker track number in order to be sure to have shyncronized data during analysis
          //
          t_tof->trkseqno = nt;
          //
          // create a new object for this event with track-related variables
          //
          new(t[ntrkentry]) ToFTrkVar(*t_tof);
          ntrkentry++;  
          t_tof->Clear();
          //
        }; // loop on all the tracks
      }; 
      //
      tof->unpackError = tofl2->unpackError;
      if ( defcal ){
        tof->default_calib = 1;
      } else {
        tof->default_calib = 0;
      };
      //
      // Fill the rootple 
      //
      toft->Fill();
      //    
      //        toft->Show();
      //        toftr->Show();
      //
      delete t_tof;
      //
      //
    };
    //
  };
  //
  pam_event->Clear();
  //
  outft->cd();
  pam_event->WriteCloneTrees();
  toftr->Delete();

  toft->Write();
  outft->Close();
  //
  return 0;
  //  
}

/////////////////////////////////////////////////////////////////

#if !defined(__CINT__) 

void usage(){

  cout << "------------------------------------------------------------"<<endl;
  cout << "Loop over events (on one or more Level2-files), applying some selection cuts (defined in My-Selection.cpp), \n";
  cout << "creating output histograms (defined in My-Histos.cpp) and/or trees with selected events. \n \n ";
  cout << "USAGE:"<<endl;
  cout << "-processDir  DIR     -  Level2 data directory \n";
  cout << "-processList LIST    -  list  of files (.txt) or single file (.root) to be analysed \n";
  cout << "-outputFile  PATH    -  name of the output file \n";
  cout << "-calibFile PATH+NAME -  name of the calibration file \n";
  cout << "-NumEvents   XXX     -  number of events to be analysed \n";
  cout << "--debug, -g          -  debug mode \n";
  cout << "--help, -h           -  print this help \n";
  cout << "-options [ options ] -  options: \n";
  cout << "                        fillHistos --> create an output file with histograms  \n";
  cout << "                        fillTree   --> create an output file with trees storing the selected events \n ";
  cout << "                        +(-)ALL    --> inlcude(exclude) all trees and branches \n "   ;
  cout << "                        +(-)TRK1 +(-)TRK2 +(-)CAL1 +(-)CAL2 +(-)TOF +(-)TRG +(-)ND +(-)S4 +(-)ORB --> inlcude(exclude) trees and branches  \n"  ; 
  cout << "------------------------------------------------------------"<<endl;
}
//
int HandleInputPar(int argc, char **argv){

  if(argc>1){
                
    if(!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help") ){
      usage();
      return(1);
    };
    // -----------------------
    // Read input parameters
    // -----------------------  
    DIR     = gSystem->WorkingDirectory();
    LIST    = "";
    OUTF    = "myfile";
    OPTIONS = "+AUTO -TOF";
                
    for (int i = 1; i < argc; i++){             
      // -----------------------------------------------------//
      if (!strcmp(argv[i], "-processDir")){
        if (++i >= argc) throw -1;
        DIR = argv[i];
        cout << "processDir "<<DIR<<endl;
        continue;
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-processList")){
        if (++i >= argc) throw -1;
        LIST = argv[i];
        cout << "processList "<<LIST<<endl;
        continue;
      }  
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-outputFile")){
        if (++i >= argc) throw -1;
        OUTF = argv[i];
        cout << "outputFile "<<OUTF<<endl;
        continue;
      }  
      // -----------------------------------------------------//
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-calibFile")){
        if (++i >= argc) throw -1;
        CALIBF = argv[i];
        cout << "calibFile "<<CALIBF<<endl;
        continue;
      }  
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-options")){
        if (++i >= argc) throw -1;
        OPTIONS = argv[i];
        if( OPTIONS.Contains("[") ){
          do{
            if (++i >= argc) throw -1;
            OPTIONS.Append(argv[i]);
          }while(!OPTIONS.Contains("]"));
        }else cout << "wrong option format --> ignoring " << endl;
      }
      else{
        cout << "Unidentified input parameter. Ignored."<< endl;
      };
    };
  }else{
    usage();
    return(1);
  };
  // -----------------------
  // Check input parameters
  // -----------------------  
        
                
  return(0);
        
};
// 

int main(int argc, char **argv)
{
        
  if( HandleInputPar(argc,argv) )return(1);
        
  cout << "OPTIONS "<<OPTIONS<<endl;
  Loop(DIR,LIST,OPTIONS);
    
  cout << "Back to main - end"<<endl;
    
  return 0;
        
};

#endif