hmdcbitflipcor.cc

Go to the documentation of this file.

//*-- AUTHOR : Y.C.Pachmayer
//*-- Modified :
//_HADES_CLASS_DESCRIPTION 
///////////////////////////////////////////////////////////////////////////////
//
// HMdcBitFlipCor
// corrects bitflips of a whole mbo
//
///////////////////////////////////////////////////////////////////////////////

using namespace std;
#include "hmdcbitflipcor.h"
#include "TROOT.h"
#include "hmdcdef.h"
#include "hmdcbitflipcorpar.h"
#include "hmdcgeompar.h"
#include "hspecgeompar.h"
#include "hiterator.h"
#include "hcategory.h"
#include "hruntimedb.h"
#include "hmdcdetector.h"
#include "hades.h"
#include "heventheader.h"
#include "hevent.h"
#include "hmdcraweventheader.h"
#include "hmdcraw.h"
#include "hmdcrawcor.h"
#include "hlocation.h"
#include "hspectrometer.h" 
#include "hmatrixcategory.h"

ClassImp(HMdcBitFlipCor)


HMdcBitFlipCor::HMdcBitFlipCor(const Text_t *name,const Text_t *title, Int_t PHist, Int_t PRawCor) : HReconstructor(name,title) {
  initVariables();
  phist=PHist;
  prawcor=PRawCor;
}

HMdcBitFlipCor::HMdcBitFlipCor(void) : HReconstructor("HMdcBitFlipCor","HMdcBitFlipCor") {
  initVariables();
  phist=0;
  prawcor=0;
}

HMdcBitFlipCor::~HMdcBitFlipCor(void){
  if (mdcrawiter) delete mdcrawiter;
}

void HMdcBitFlipCor::setRootOutputFilename(TString name)
{

  if(name.CompareTo("")==0)
    {
      Error("HMdcCosmicsSimul:setRootOutPutFilename()","NO ROOT OUTPUT SPEZIFIED!");
      exit(1);
    }
  else
    {
      rootoutputfilename=name;
    }
}

void HMdcBitFlipCor::setAsciiOutputFilename(TString name)
{

  if(name.CompareTo("")==0)
    {
      Error("HMdcCosmicsSimul:setAsciiOutPutFilename()","NO ASCII OUTPUT SPEZIFIED!");
      exit(1);
    }
  else
    {
      asciioutputfilename=name;
    }
}

void HMdcBitFlipCor::initVariables()
{
  catmHMdcRaw=0;
  mdcraw=0;
  mdcrawiter=0;


  rawREH=0;
  iterREH=0;

  rawcorCat=0;
  rawcor=0;
  loc.set(4,0,0,0,0);

  asciioutputfile=0;
  rootoutputfile=0;

  for(Int_t s=0;s<6;s++)
    {
      for(Int_t m=0; m<4; m++)
        {
          for(Int_t mbo=0; mbo<16;mbo++)
            {
              for(Int_t v=0; v<9;v++)
                {
                  paramsbitcorrection[s][m][mbo][v]=-10;
                }
            }
        }
    }

  for(Int_t s=0;s<6;s++)
    {
      for(Int_t m=0; m<4; m++)
        {
          for(Int_t mbo=0; mbo<16; mbo++)
            {
              counterevents[s][m][mbo]=0;
              countersavedtime1[s][m][mbo]=0;
              countersavedtime2[s][m][mbo]=0;

              histtime1b[s][m][mbo]=0;
              histtime1g[s][m][mbo]=0;
              histtime2b[s][m][mbo]=0;
              histtime2g[s][m][mbo]=0;
            }
        }
    }

}

void HMdcBitFlipCor::createHists()
{
  // hists are created

  for(Int_t s=0;s<6;s++)
    {
      for(Int_t m=0; m<4; m++)
        {
          for(Int_t mbo=0; mbo<16; mbo++)
            {
              sprintf(title, "time1 raw before bitshift corrs%im%imbo%i",s,m,mbo);
              sprintf(name, "time1rawbeforebitcors%im%imbo%i",s,m,mbo);
              sprintf(xtitle, "time1 [ch]");
              sprintf(ytitle, "#");
              histtime1b[s][m][mbo] = new TH1F(name, title, 1024, 0, 2048);
              histtime1b[s][m][mbo] -> SetXTitle(xtitle);
              histtime1b[s][m][mbo] -> SetYTitle(ytitle);
              
              sprintf(title, "time1 raw after bitshift corrs%im%imbo%i",s,m,mbo);
              sprintf(name, "time1rawafterbitcors%im%imbo%i",s,m,mbo);
              sprintf(xtitle, "time1 [ch]");
              sprintf(ytitle, "#");
              histtime1g[s][m][mbo] = new TH1F(name, title, 1024, 0, 2048);
              histtime1g[s][m][mbo] -> SetXTitle(xtitle);
              histtime1g[s][m][mbo] -> SetYTitle(ytitle);
              
              
              sprintf(title, "time2 raw before bitshift corrs%im%imbo%i",s,m,mbo);
              sprintf(name, "time2rawbeforebitcors%im%imbo%i",s,m,mbo);
              sprintf(xtitle, "time2 [ch]");
              sprintf(ytitle, "#");
              histtime2b[s][m][mbo] = new TH1F(name, title, 1024, 0, 2048);
              histtime2b[s][m][mbo] -> SetXTitle(xtitle);
              histtime2b[s][m][mbo] -> SetYTitle(ytitle);
              
              sprintf(title, "time2 raw after bitshift corrs%im%imbo%i",s,m,mbo);
              sprintf(name, "time2rawafterbitcors%im%imbo%i",s,m,mbo);
              sprintf(xtitle, "time2 [ch]");
              sprintf(ytitle, "#");
              histtime2g[s][m][mbo] = new TH1F(name, title, 1024, 0, 2048);
              histtime2g[s][m][mbo] -> SetXTitle(xtitle);
              histtime2g[s][m][mbo] -> SetYTitle(ytitle);
              
            }
        }
    }
  
 

}

Bool_t HMdcBitFlipCor::init(void) {
  
  rtdb=gHades->getRuntimeDb();

  catmHMdcRaw=gHades->getCurrentEvent()->getCategory(catMdcRaw);
  if (!catmHMdcRaw) {
    Error("HMdcBitFlipCor::init()","NO HMDCRAW FOUND!");
    return kFALSE;
  }
  mdcrawiter=(HIterator *)catmHMdcRaw->MakeIterator();
  if(!mdcrawiter)
    {
      return kFALSE;
    }

  catmHMdcRawEventHeader=gHades->getCurrentEvent()->getCategory(catMdcRawEventHeader);
  if (!catmHMdcRawEventHeader) {
    Error("HMdcBitFlipCor::init()","NO HMDCRAW FOUND!");
    return kFALSE;
  }
  iterREH=(HIterator *)catmHMdcRawEventHeader->MakeIterator();
  if(!iterREH)
    {
      return kFALSE;
    }

  if(phist==1)
    {
      createHists();
    }

  getParameterContainers();

 if(prawcor==1)
   {
     rawcorCat=(HCategory*)((HMdcDetector*)(((HSpectrometer*)(gHades->getSetup()))->getDetector("Mdc"))->buildCategory(catMdcRawCor));   
     if (!rawcorCat) return kFALSE;
     else ((HEvent*)(gHades->getCurrentEvent()))->addCategory(catMdcRawCor,rawcorCat,"Mdc");
   }
     

  return kTRUE;

}

void HMdcBitFlipCor::getParameterContainers()
{
  fMdcBitFlipCorPar=(HMdcBitFlipCorPar*)rtdb->getContainer("MdcBitFlipCorPar");  
  if(!fMdcBitFlipCorPar)
    {
      Error("HMdcBitFlipCorPar:getParameterContainer()","ZERO POINTER FOR HMDCBITFLIPCORPAR RECIEVED!");
      exit(1);
    }
}

Bool_t HMdcBitFlipCor::reinit(void) {
  fparamsbitcorrection();
  
  return kTRUE;
}

Bool_t  HMdcBitFlipCor::fparamsbitcorrection()
{
  if(fMdcBitFlipCorPar==0){printf("Error fMdcBitFlipCorPar ... not found \n");}
  for(Int_t s=0;s<6;s++)
    {
      for(Int_t m=0; m<4; m++)
        {
          for(Int_t mbo=0; mbo<16;mbo++)
            {
              for(Int_t v=0; v<9;v++)
                {
                  paramsbitcorrection[s][m][mbo][v]=fMdcBitFlipCorPar->getBitFlipCorParameter(s,m,mbo,v);
                }
            }
        }
    }
  //fMdcBitFlipCorPar->printParam();
  return kTRUE;
     
}

Int_t HMdcBitFlipCor::execute(void) {

  resetVar();
  iterREH->Reset();
  while ( (rawREH=(HMdcRawEventHeader *)iterREH->Next()) != 0 ){ 
    trigtype=rawREH->getTriggerType();
  }

  mdcrawiter->Reset();
  while ( (mdcraw=(HMdcRaw *)mdcrawiter->Next()) != 0 )
    {
      if(trigtype!=9)
        {
          mdcraw->getAddress(sector, module, mbo, tdc);
         
          loc[0]=sector;
          loc[1]=module;
          loc[2]=mbo;
          loc[3]=tdc;

          if(prawcor==1)
            {
              rawcor=(HMdcRawCor *)rawcorCat->getSlot(loc);
              rawcor=new(rawcor)HMdcRawCor;
              rawcor->setAddress(sector, module, mbo, tdc);
            }

          time1=mdcraw->getTime(1);
          time2=mdcraw->getTime(2);
          if(paramsbitcorrection[sector][module][mbo][0]>0)
            {  
              counterevents[sector][module][mbo]++;
              if(phist==1)
                {
                  histtime1b[sector][module][mbo]->Fill(time1);
                  histtime2b[sector][module][mbo]->Fill(time2);
                }
              
              if(time1>paramsbitcorrection[sector][module][mbo][2])
                {
                  if(prawcor==1)
                    {
                      rawcor->setTimeShift(paramsbitcorrection[sector][module][mbo][4],1);
                      rawcor->setFlagRaw(1);
                    }
                  mdcraw->setTimeNew(time1+paramsbitcorrection[sector][module][mbo][4],1);
                  if(phist==1)
                    {
                      histtime1g[sector][module][mbo]->Fill(time1+paramsbitcorrection[sector][module][mbo][4]);
                    }
                  countersavedtime1[sector][module][mbo]++;
                }
              else
                {
                  if(time1<paramsbitcorrection[sector][module][mbo][1])
                    {
                      if(prawcor==1)
                        {
                          rawcor->setTimeShift(paramsbitcorrection[sector][module][mbo][3],1);
                          rawcor->setFlagRaw(1);
                        }
                      mdcraw->setTimeNew(time1+paramsbitcorrection[sector][module][mbo][3],1);
                      if(phist==1)
                        {
                          histtime1g[sector][module][mbo]->Fill(time1+paramsbitcorrection[sector][module][mbo][3]);
                        }
                      countersavedtime1[sector][module][mbo]++;
                    }
                  else
                    {
                       if(prawcor==1)
                         {
                           rawcor->setTimeShift(0,1);
                           rawcor->setFlagRaw(0);
                         }
                      if(phist==1)
                        {
                          histtime1g[sector][module][mbo]->Fill(time1);
                        }
                    }
                }
              
               
              if(time2>paramsbitcorrection[sector][module][mbo][6])
                {
                   if(prawcor==1)
                    {
                      rawcor->setTimeShift(paramsbitcorrection[sector][module][mbo][8],2);
                      if(rawcor->getFlagRaw()>-1)
                        {
                          rawcor->setFlagRaw(3);
                        }
                      else
                        {
                          rawcor->setFlagRaw(2);
                        }
                    }
                  mdcraw->setTimeNew(time2+paramsbitcorrection[sector][module][mbo][8],2);

                  if(phist==1)
                    {
                      histtime2g[sector][module][mbo]->Fill(time2+paramsbitcorrection[sector][module][mbo][8]);
                    }
                  countersavedtime2[sector][module][mbo]++;
                }
              else
                {
                  if(time2<paramsbitcorrection[sector][module][mbo][5])
                    {
                       if(prawcor==1)
                         {
                           rawcor->setTimeShift(paramsbitcorrection[sector][module][mbo][7],2);
                           if(rawcor->getFlagRaw()>-1)
                             {
                               rawcor->setFlagRaw(3);
                             }
                           else
                             {
                               rawcor->setFlagRaw(2);
                             }
                         }
                      mdcraw->setTimeNew(time2+paramsbitcorrection[sector][module][mbo][7],2);
                      if(phist==1)
                        {
                          histtime2g[sector][module][mbo]->Fill(time2+paramsbitcorrection[sector][module][mbo][7]);
                        }
                      countersavedtime2[sector][module][mbo]++;
                    }
                  else
                    {
                       if(prawcor==1)
                         {
                           rawcor->setTimeShift(0,2);
                           rawcor->setFlagRaw(0);
                         }
                      if(phist==1)
                        {
                          histtime2g[sector][module][mbo]->Fill(time2);
                        }
                    }
                }
            }
          else
            {
               if(prawcor==1)
                    {
                      rawcor->setFlagRaw(0);
                      rawcor->setTimeShift(0,1);
                      rawcor->setTimeShift(0,2);
                    }
            }
          
        }
    }

  return 0;
  
}


Bool_t HMdcBitFlipCor::finalize(void) {
  if(phist==1)
    {
      asciioutputfile = fopen(asciioutputfilename.Data(),"w");
    }
     
  for(Int_t s=0;s<6;s++)
    {
      for(Int_t m=0; m<4; m++)
        {
          for(Int_t mbo=0; mbo<16; mbo++)
            {
              if(counterevents[s][m][mbo]!=0)
                {
                  cout << " sector " << s << " module " << m << " mbo " << mbo << endl;
                  cout << " number of events " << counterevents[s][m][mbo] << endl;
                  cout << " number of events which were rescued due to time1 correction " << countersavedtime1[s][m][mbo] << endl;
                  cout << " number of events which were rescued due to time2 correction " << countersavedtime2[s][m][mbo] << endl;
                  Float_t savedevents1=(Float_t) countersavedtime1[s][m][mbo]/counterevents[s][m][mbo];
                  Float_t savedevents2=(Float_t) countersavedtime2[s][m][mbo]/counterevents[s][m][mbo];
                  cout << " % of rescued time1 events " << savedevents1*100  << endl;
                  cout << " % of rescued time2 events " << savedevents2*100  << endl;
        
                  if(phist==1)
                    {
                      fprintf(asciioutputfile,"%s%i%s%i%s%i%s%i%s%i%s%i\n","sector ",s," module ",m," mbo ", mbo," no of events " , counterevents[s][m][mbo], " saved time1 " , countersavedtime1[s][m][mbo], " saved time2 ", countersavedtime2[s][m][mbo]);
                    }
                }
            }
        }
    }

  if(phist==1)
    {
      fclose(asciioutputfile);
      
      
      
      rootoutputfile=new TFile(rootoutputfilename.Data(),"RECREATE");
      rootoutputfile->cd();


      for(Int_t s=0;s<6;s++)
        {
          for(Int_t m=0; m<4; m++)
            {
              for(Int_t mbo=0; mbo<16; mbo++)
                {
                  if((histtime1b[s][m][mbo]->GetEntries())>0)
                    {
                      histtime1b[s][m][mbo]->Write();
                    }
                  if(histtime1g[s][m][mbo]->GetEntries()>0)
                    {
                      histtime1g[s][m][mbo]->Write();
                    }
                  if(histtime2b[s][m][mbo]->GetEntries()>0)
                    {
                      histtime2b[s][m][mbo]->Write();
                    }
                  if(histtime2g[s][m][mbo]->GetEntries()>0)
                    {
                      histtime2g[s][m][mbo]->Write();
                    }
                }
            }
        }
      
      rootoutputfile->Save();
      rootoutputfile->Close();
    }

  return kTRUE;

}