TofCalibManager.cxx

Go to the documentation of this file.

#include "TofCalibManager.h"
#include "TFile.h"
#include "TTree.h"
 
TofCalibManager* TofCalibManager::m_manager = 0;
TofCalibManager* TofCalibManager::getManager() {
  if ( m_manager == 0 ) { m_manager = new TofCalibManager; }
  return m_manager;
}
 
TofCalibManager::TofCalibManager() {
  m_dataset = new TofDataSet;
  return;
}
 
TofCalibManager::~TofCalibManager() {
  if ( !calib_barrel_item.empty() )
  {
    std::vector<TofCalib*>::iterator iter = calib_barrel_item.begin();
    for ( ; iter != calib_barrel_item.end(); iter++ )
    {
      if ( ( *iter ) ) delete ( *iter );
    }
    calib_barrel_item.clear();
  }
  if ( !calib_endcap_item.empty() )
  {
    std::vector<TofCalib*>::iterator iter = calib_endcap_item.begin();
    for ( ; iter != calib_endcap_item.end(); iter++ )
    {
      if ( ( *iter ) ) delete ( *iter );
    }
    calib_endcap_item.clear();
  }
  if ( !calib_etf_item.empty() )
  {
    std::vector<TofCalib*>::iterator iter = calib_etf_item.begin();
    for ( ; iter != calib_etf_item.end(); iter++ )
    {
      if ( ( *iter ) ) delete ( *iter );
    }
    calib_etf_item.clear();
  }
  if ( !calibration_barrel_item.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_barrel_item.begin();
    for ( ; iter != calibration_barrel_item.end(); iter++ )
    {
      if ( ( *iter ) ) delete ( *iter );
    }
    calibration_barrel_item.clear();
  }
  if ( !calibration_barrel_item2.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_barrel_item2.begin();
    for ( ; iter != calibration_barrel_item2.end(); iter++ )
    {
      if ( ( *iter ) ) delete ( *iter );
    }
    calibration_barrel_item2.clear();
  }
  if ( !calibration_endcap_item.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_endcap_item.begin();
    for ( ; iter != calibration_endcap_item.end(); iter++ )
    {
      if ( ( *iter ) ) delete ( *iter );
    }
    calibration_endcap_item.clear();
  }
 
  delete m_dataset;
  return;
}
 
void TofCalibManager::addCalib( TofCalib* cal_item1, int isbarrel ) {
  if ( isbarrel == 1 ) { calib_barrel_item.push_back( cal_item1 ); }
  else if ( isbarrel == 0 ) { calib_endcap_item.push_back( cal_item1 ); }
  else if ( isbarrel == 2 ) { calib_etf_item.push_back( cal_item1 ); }
  else
  { cout << "Tof::tofcalgsec::TofCalibManaer: addCalib: isbarrel is OUT of range!" << endl; }
  return;
}
 
void TofCalibManager::addCalib( TofCalibFit* cal_item2, bool isbarrel ) {
  if ( isbarrel )
  {
    if ( cal_item2->name() == "calib_barrel_sigma" )
    { calibration_barrel_item2.push_back( cal_item2 ); }
    else { calibration_barrel_item.push_back( cal_item2 ); }
  }
  else
  {
    //    calibration_endcap_item.push_back(cal_item2);
    calibration_etf_item.push_back( cal_item2 );
  }
  return;
}
 
void TofCalibManager::doCalibration() {
 
  if ( !calib_barrel_item.empty() || !calibration_barrel_item.empty() )
  {
    std::cout << "Begin barrel counters calibration..." << std::endl;
    std::cout << setiosflags( ios::left ) << setw( 10 ) << "TOF ID" << setw( 8 ) << "Entries"
              << setw( 30 ) << "What Calibration" << std::endl;
    HepVector tcorrelation;
    for ( unsigned int i = 0; i < NBarrel; i++ )
    {
      RecordSet* barrelData = m_dataset->getBarrelData( i );
      if ( !calib_barrel_item.empty() )
      {
        std::vector<TofCalib*>::iterator iter1 = calib_barrel_item.begin();
        for ( ; iter1 != calib_barrel_item.end(); iter1++ )
        {
          ( *iter1 )->reset();
          ( *iter1 )->calculate( barrelData, i );
        }
      }
      if ( !calibration_barrel_item.empty() )
      {
        std::vector<TofCalibFit*>::iterator iter2 = calibration_barrel_item.begin();
        for ( ; iter2 != calibration_barrel_item.end(); iter2++ )
        {
          ( *iter2 )->calculate( barrelData, i );
          if ( i == ( NBarrel - 1 ) )
          {
            if ( ( *iter2 )->name() == "calib_barrel_common" )
            { tcorrelation = ( *iter2 )->tcorrelation(); }
          }
        }
      }
    }
 
    for ( unsigned int i = 0; i < NBarrel; i++ )
    {
      RecordSet* barrelData = m_dataset->getBarrelData( i );
      if ( !calibration_barrel_item2.empty() )
      {
        std::vector<TofCalibFit*>::iterator iter2 = calibration_barrel_item2.begin();
        for ( ; iter2 != calibration_barrel_item2.end(); iter2++ )
        {
          if ( i == 0 )
          {
            if ( ( *iter2 )->name() == "calib_barrel_sigma" )
            { ( *iter2 )->setTCorrelation( tcorrelation ); }
          }
          ( *iter2 )->calculate( barrelData, i );
        }
      }
    }
  }
 
  if ( !calib_endcap_item.empty() || !calibration_endcap_item.empty() )
  {
    std::cout << "Begin endcap counters calibration..." << std::endl;
    std::cout << setiosflags( ios::left ) << setw( 10 ) << "TOF ID" << setw( 8 ) << "Entries"
              << setw( 30 ) << "What Calibration" << std::endl;
    for ( unsigned int i = 0; i < NEndcap; i++ )
    {
      RecordSet* endcapData = m_dataset->getEndcapData( i );
      if ( !calib_endcap_item.empty() )
      {
        std::vector<TofCalib*>::iterator iter1 = calib_endcap_item.begin();
        for ( ; iter1 != calib_endcap_item.end(); iter1++ )
        {
          ( *iter1 )->reset();
          ( *iter1 )->calculate( endcapData, i );
        }
      }
      if ( !calibration_endcap_item.empty() )
      {
        std::vector<TofCalibFit*>::iterator iter2 = calibration_endcap_item.begin();
        for ( ; iter2 != calibration_endcap_item.end(); iter2++ )
        { ( *iter2 )->calculate( endcapData, i ); }
      }
    }
  }
 
  if ( !calib_etf_item.empty() || !calibration_etf_item.empty() )
  {
    std::cout << "Begin ETF(MRPC) calibration..." << std::endl;
    std::cout << setiosflags( ios::left ) << setw( 10 ) << "TOF ID *12 + STRIP" << setw( 8 )
              << "Entries" << setw( 30 ) << "What Calibration" << std::endl;
    HepVector tcorrelation;
    for ( unsigned int i = 0; i < NEtf * NStrip; i++ )
    {
      RecordSet* etfData = m_dataset->getEtfData( i );
      if ( !calib_etf_item.empty() )
      {
        std::vector<TofCalib*>::iterator iter1 = calib_etf_item.begin();
        for ( ; iter1 != calib_etf_item.end(); iter1++ )
        {
          ( *iter1 )->reset();
          ( *iter1 )->calculate( etfData, i );
        }
      }
      if ( !calibration_etf_item.empty() )
      {
        std::vector<TofCalibFit*>::iterator iter2 = calibration_etf_item.begin();
        for ( ; iter2 != calibration_etf_item.end(); iter2++ )
        { ( *iter2 )->calculate( etfData, i ); }
      }
    }
  }
 
  return;
}
 
void TofCalibManager::fillTxt( string& dir ) {
 
  if ( !calib_barrel_item.empty() )
  {
    std::vector<TofCalib*>::iterator iter = calib_barrel_item.begin();
    for ( ; iter != calib_barrel_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".txt" );
      ( *iter )->fillTxt( fname.c_str() );
    }
  }
 
  if ( !calib_endcap_item.empty() )
  {
    std::vector<TofCalib*>::iterator iter = calib_endcap_item.begin();
    for ( ; iter != calib_endcap_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".txt" );
      ( *iter )->fillTxt( fname.c_str() );
    }
  }
 
  if ( !calib_etf_item.empty() )
  {
    std::vector<TofCalib*>::iterator iter = calib_etf_item.begin();
    for ( ; iter != calib_etf_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".txt" );
      ( *iter )->fillTxt( fname.c_str() );
    }
  }
 
  if ( !calibration_barrel_item.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_barrel_item.begin();
    for ( ; iter != calibration_barrel_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".txt" );
      ( *iter )->fillTxt( fname.c_str() );
    }
  }
  if ( !calibration_barrel_item2.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_barrel_item2.begin();
    for ( ; iter != calibration_barrel_item2.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".txt" );
      ( *iter )->fillTxt( fname.c_str() );
    }
  }
 
  if ( !calibration_endcap_item.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_endcap_item.begin();
    for ( ; iter != calibration_endcap_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".txt" );
      ( *iter )->fillTxt( fname.c_str() );
    }
  }
 
  if ( !calibration_etf_item.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_etf_item.begin();
    for ( ; iter != calibration_etf_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".txt" );
      ( *iter )->fillTxt( fname.c_str() );
    }
  }
 
  return;
}
 
void TofCalibManager::fillRoot( string& dir ) {
  int  count = 1;
  char filename1[256];
  sprintf( filename1, "%s/barrel%i.root", dir.c_str(), count );
  TFile  f1( filename1, "RECREATE" );
  TTree* ntbarrel = new TTree( "btrk", "barrel data after calibration" );
 
  int    run;
  int    event;
  int    tofid;
  int    strip;
  double qleft;
  double qright;
  double tleft;
  double tright;
  double zrhit;
  double dt;
  double texp;
  double path;
  double phi;
  double theta;
  double p;
  double t0;
  double q0;
  int    hitcase;
 
  ntbarrel->Branch( "run", &run, "run/I" );
  ntbarrel->Branch( "event", &event, "event/I" );
  ntbarrel->Branch( "tofid", &tofid, "tofid/I" );
  ntbarrel->Branch( "qleft", &qleft, "qleft/D" );
  ntbarrel->Branch( "qright", &qright, "qright/D" );
  ntbarrel->Branch( "tleft", &tleft, "tleft/D" );
  ntbarrel->Branch( "tright", &tright, "tright/D" );
  ntbarrel->Branch( "zrhit", &zrhit, "zrhit/D" );
  ntbarrel->Branch( "texp", &texp, "texp/D" );
  ntbarrel->Branch( "path", &path, "path/D" );
  ntbarrel->Branch( "phi", &phi, "phi/D" );
  ntbarrel->Branch( "theta", &theta, "theta/D" );
  ntbarrel->Branch( "p", &p, "p/D" );
  ntbarrel->Branch( "t0", &t0, "t0/D" );
  ntbarrel->Branch( "q0", &q0, "q0/D" );
  ntbarrel->Branch( "hitcase", &hitcase, "hitcase/I" );
 
  int counter = 0;
  std::cout << "begin to write..." << filename1 << std::endl;
  for ( unsigned int i = 0; i < NBarrel; i++ )
  {
    std::cout << "\r\b Writing record ... " << ( int( ( ++counter ) * 100. / NBarrel ) )
              << "%";
    RecordSet*                     barrelData = m_dataset->getBarrelData( i );
    std::vector<Record*>::iterator iter       = barrelData->begin();
    for ( ; iter != barrelData->end(); iter++ )
    {
      run     = ( *iter )->run();
      event   = ( *iter )->event();
      tofid   = ( *iter )->tofid();
      qleft   = ( *iter )->qleft();
      qright  = ( *iter )->qright();
      tleft   = ( *iter )->tleft();
      tright  = ( *iter )->tright();
      zrhit   = ( *iter )->zrhit();
      texp    = ( *iter )->texp();
      path    = ( *iter )->path();
      phi     = ( *iter )->phi();
      theta   = ( *iter )->theta();
      p       = ( *iter )->p();
      t0      = ( *iter )->t0();
      q0      = ( *iter )->q0();
      hitcase = ( *iter )->hitcase();
      ntbarrel->Fill();
    }
  }
  std::cout << std::endl;
  ntbarrel->Write();
  delete ntbarrel;
  f1.Close();
 
  char filename2[256];
  sprintf( filename2, "%s/endcap%i.root", dir.c_str(), count );
  TFile  f2( filename2, "RECREATE" );
  TTree* ntendcap = new TTree( "etrk", "endcap data after calibration" );
 
  ntendcap->Branch( "run", &run, "run/I" );
  ntendcap->Branch( "event", &event, "event/I" );
  ntendcap->Branch( "tofid", &tofid, "tofid/I" );
  ntendcap->Branch( "qleft", &qleft, "qleft/D" );
  ntendcap->Branch( "qright", &qright, "qright/D" );
  ntendcap->Branch( "tleft", &tleft, "tleft/D" );
  ntendcap->Branch( "tright", &tright, "tright/D" );
  ntendcap->Branch( "zrhit", &zrhit, "zrhit/D" );
  ntendcap->Branch( "texp", &texp, "texp/D" );
  ntendcap->Branch( "path", &path, "path/D" );
  ntendcap->Branch( "phi", &phi, "phi/D" );
  ntendcap->Branch( "theta", &theta, "theta/D" );
  ntendcap->Branch( "p", &p, "p/D" );
  ntendcap->Branch( "t0", &t0, "t0/D" );
  ntendcap->Branch( "q0", &q0, "q0/D" );
  ntendcap->Branch( "hitcase", &hitcase, "hitcase/I" );
 
  counter = 0;
  std::cout << "begin to write..." << filename2 << std::endl;
  for ( unsigned int i = 0; i < NEndcap; i++ )
  {
    std::cout << "\r\b Writing record ... " << ( int( ( ++counter ) * 100. / NEndcap ) )
              << "%";
    RecordSet*                     endcapData = m_dataset->getEndcapData( i );
    std::vector<Record*>::iterator iter       = endcapData->begin();
    for ( ; iter != endcapData->end(); iter++ )
    {
      run     = ( *iter )->run();
      event   = ( *iter )->event();
      tofid   = ( *iter )->tofid();
      qleft   = ( *iter )->qleft();
      qright  = ( *iter )->qright();
      tleft   = ( *iter )->tleft();
      tright  = ( *iter )->tright();
      zrhit   = ( *iter )->zrhit();
      texp    = ( *iter )->texp();
      path    = ( *iter )->path();
      phi     = ( *iter )->phi();
      theta   = ( *iter )->theta();
      p       = ( *iter )->p();
      t0      = ( *iter )->t0();
      q0      = ( *iter )->q0();
      hitcase = ( *iter )->hitcase();
      ntendcap->Fill();
    }
  }
  std::cout << std::endl;
  ntendcap->Write();
  delete ntendcap;
  f2.Close();
 
  char filename3[256];
  sprintf( filename3, "%s/etf%i.root", dir.c_str(), count );
  TFile  f3( filename3, "RECREATE" );
  TTree* ntetf = new TTree( "etf", "en data after calibration" );
 
  ntetf->Branch( "run", &run, "run/I" );
  ntetf->Branch( "event", &event, "event/I" );
  ntetf->Branch( "tofid", &tofid, "tofid/I" );
  ntetf->Branch( "strip", &strip, "strip/I" );
  ntetf->Branch( "qleft", &qleft, "qleft/D" );
  ntetf->Branch( "qright", &qright, "qright/D" );
  ntetf->Branch( "tleft", &tleft, "tleft/D" );
  ntetf->Branch( "tright", &tright, "tright/D" );
  ntetf->Branch( "zrhit", &zrhit, "zrhit/D" );
  ntetf->Branch( "dt", &dt, "dt/D" );
  ntetf->Branch( "texp", &texp, "texp/D" );
  ntetf->Branch( "path", &path, "path/D" );
  ntetf->Branch( "phi", &phi, "phi/D" );
  ntetf->Branch( "p", &p, "p/D" );
  ntetf->Branch( "t0", &t0, "t0/D" );
  ntetf->Branch( "q0", &q0, "q0/D" );
  ntetf->Branch( "hitcase", &hitcase, "hitcase/I" );
 
  counter = 0;
  std::cout << "begin to write..." << filename3 << std::endl;
  for ( unsigned int i = 0; i < NEtf * NStrip; i++ )
  {
    std::cout << "\r\b Writing record ... "
              << ( int( ( ++counter ) * 100. / ( NEtf * NStrip ) ) ) << "%";
    RecordSet*                     etfData = m_dataset->getEtfData( i );
    std::vector<Record*>::iterator iter    = etfData->begin();
    for ( ; iter != etfData->end(); iter++ )
    {
      run     = ( *iter )->run();
      event   = ( *iter )->event();
      tofid   = ( *iter )->tofid();
      strip   = ( *iter )->strip();
      qleft   = ( *iter )->qleft();
      qright  = ( *iter )->qright();
      tleft   = ( *iter )->tleft();
      tright  = ( *iter )->tright();
      zrhit   = ( *iter )->zrhit();
      dt      = ( *iter )->dt();
      texp    = ( *iter )->texp();
      path    = ( *iter )->path();
      phi     = ( *iter )->phi();
      p       = ( *iter )->p();
      t0      = ( *iter )->t0();
      q0      = ( *iter )->q0();
      hitcase = ( *iter )->hitcase();
      ntetf->Fill();
    }
  }
  std::cout << std::endl;
  ntetf->Write();
  delete ntetf;
  f3.Close();
 
  if ( !calibration_barrel_item.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_barrel_item.begin();
    for ( ; iter != calibration_barrel_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".root" );
      ( *iter )->fillRoot( fname.c_str() );
    }
  }
  if ( !calibration_barrel_item2.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_barrel_item2.begin();
    for ( ; iter != calibration_barrel_item2.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".root" );
      ( *iter )->fillRoot( fname.c_str() );
    }
  }
 
  if ( !calibration_endcap_item.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_endcap_item.begin();
    for ( ; iter != calibration_endcap_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".root" );
      ( *iter )->fillRoot( fname.c_str() );
    }
  }
 
  if ( !calibration_etf_item.empty() )
  {
    std::vector<TofCalibFit*>::iterator iter = calibration_etf_item.begin();
    for ( ; iter != calibration_etf_item.end(); iter++ )
    {
      string fname = dir + string( "/" ) + ( *iter )->name() + string( ".root" );
      ( *iter )->fillRoot( fname.c_str() );
    }
  }
 
  return;
}