tofcalgsec.cxx

Go to the documentation of this file.

#include "tofcalgsec.h"
#include "EventModel/Event.h"
#include "EventModel/EventModel.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartDataLocator.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/SmartRef.h"
#include "TSystem.h"
#include "TofRecEvent/RecBTofCalHit.h"
#include "TofRecEvent/RecETofCalHit.h"
#include "TofCalib.h"
#include "TofCalibFit.h"
#include "TofCalibManager.h"
#include "calib_barrel_atten.h"
#include "calib_barrel_common.h"
#include "calib_barrel_left.h"
#include "calib_barrel_left_offset1_bunch0_3.h"
#include "calib_barrel_left_offset1_bunch0_4.h"
#include "calib_barrel_left_offset1_bunch1_3.h"
#include "calib_barrel_left_offset1_bunch1_4.h"
#include "calib_barrel_left_offset1_bunch2_3.h"
#include "calib_barrel_left_offset1_bunch2_4.h"
#include "calib_barrel_left_offset1_bunch3_3.h"
#include "calib_barrel_left_offset1_bunch3_4.h"
#include "calib_barrel_left_offset2_bunch0_3.h"
#include "calib_barrel_left_offset2_bunch0_4.h"
#include "calib_barrel_left_offset2_bunch1_3.h"
#include "calib_barrel_left_offset2_bunch1_4.h"
#include "calib_barrel_left_offset2_bunch2_3.h"
#include "calib_barrel_left_offset2_bunch2_4.h"
#include "calib_barrel_left_offset2_bunch3_3.h"
#include "calib_barrel_left_offset2_bunch3_4.h"
#include "calib_barrel_q0.h"
#include "calib_barrel_right.h"
#include "calib_barrel_right_offset1_bunch0_3.h"
#include "calib_barrel_right_offset1_bunch0_4.h"
#include "calib_barrel_right_offset1_bunch1_3.h"
#include "calib_barrel_right_offset1_bunch1_4.h"
#include "calib_barrel_right_offset1_bunch2_3.h"
#include "calib_barrel_right_offset1_bunch2_4.h"
#include "calib_barrel_right_offset1_bunch3_3.h"
#include "calib_barrel_right_offset1_bunch3_4.h"
#include "calib_barrel_right_offset2_bunch0_3.h"
#include "calib_barrel_right_offset2_bunch0_4.h"
#include "calib_barrel_right_offset2_bunch1_3.h"
#include "calib_barrel_right_offset2_bunch1_4.h"
#include "calib_barrel_right_offset2_bunch2_3.h"
#include "calib_barrel_right_offset2_bunch2_4.h"
#include "calib_barrel_right_offset2_bunch3_3.h"
#include "calib_barrel_right_offset2_bunch3_4.h"
#include "calib_barrel_sigma.h"
#include "calib_barrel_veff.h"
#include "calib_endcap_atten.h"
#include "calib_endcap_left.h"
#include "calib_endcap_sigma.h"
#include "calib_endcap_veff.h"
#include "calib_etf_bunch.h"
#include "calib_etf_combine.h"
#include "calib_etf_left.h"
#include "calib_etf_right.h"
#include "calib_etf_veff.h"
#include "calib_mc_etf_combine.h"
#include "calib_mc_etf_left.h"
#include "calib_mc_etf_right.h"
#include <stdlib.h>
 
DECLARE_COMPONENT( tofcalgsec )
tofcalgsec::tofcalgsec( const std::string& name, ISvcLocator* pSvcLocator )
    : Algorithm( name, pSvcLocator ) {
  // set default values
  m_calibItem = "111111111";
  // declares
  declareProperty( "Online", m_online );
  declareProperty( "Calibration", m_calibration );
  declareProperty( "WorkDir", m_workdir );
  declareProperty( "InputDataDir", m_datafile_dir );
  declareProperty( "InputDataFiles_Barrel", m_datafile_barrel );
  declareProperty( "InputDataFiles_Endcap", m_datafile_endcap );
  declareProperty( "InputDataFiles_Etf", m_datafile_etf );
  declareProperty( "CalibItem", m_calibItem );
  declareProperty( "TimeCorrelationZBin", m_tcorrzbin = 23 );
  declareProperty( "BarrelSigmaZBin", m_barrelzbin = 5 );
  declareProperty( "EndcapSigmaRBin", m_endcaprbin = 5 );
  declareProperty( "EndcapQRBin", m_endcapQrbin = 5 );
}
 
StatusCode tofcalgsec::initialize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "tofcalgsec::initialize()!" << endmsg;
 
  if ( m_online )
  {
    NTuplePtr nt1( ntupleSvc(), "TofCalib/btrk" );
    NTuplePtr nt2( ntupleSvc(), "TofCalib/etrk" );
    NTuplePtr nt3( ntupleSvc(), "TofCalib/etf" );
    if ( nt1 || nt2 || nt3 )
    {
      mtuple_barrel = nt1;
      mtuple_endcap = nt2;
      mtuple_etf    = nt3;
    }
    else
    {
      mtuple_barrel = ntupleSvc()->book( "TofCalib/btrk", CLID_ColumnWiseTuple, "TofCalib" );
      mtuple_endcap = ntupleSvc()->book( "TofCalib/etrk", CLID_ColumnWiseTuple, "TofCalib" );
      mtuple_etf    = ntupleSvc()->book( "TofCalib/etf", CLID_ColumnWiseTuple, "TofCalib" );
 
      if ( mtuple_barrel ) { m_checkbarrel = new TofCalibCheck( mtuple_barrel ); }
      else
      {
        log << MSG::ERROR << "Cannot book N-tuple:" << long( mtuple_barrel ) << endmsg;
        return StatusCode::FAILURE;
      }
      if ( mtuple_endcap ) { m_checkendcap = new TofCalibCheck( mtuple_endcap ); }
      else
      {
        log << MSG::ERROR << "Cannot book N-tuple:" << long( mtuple_endcap ) << endmsg;
        return StatusCode::FAILURE;
      }
      if ( mtuple_etf ) { m_checketf = new TofCalibCheck( mtuple_etf ); }
      else
      {
        log << MSG::ERROR << "Cannot book N-tuple:" << long( mtuple_etf ) << endmsg;
        return StatusCode::FAILURE;
      }
    }
  }
  else
  {
    m_calibration = true; // offline
  }
 
  if ( !m_online || m_calibration )
  {
    // check workdir
    std::cout << " tofcalgsec checks your configurations ..." << std::endl;
    void* pdir = 0;
    if ( ( pdir = gSystem->OpenDirectory( m_workdir.c_str() ) ) == 0 )
    { // dir exists?
      std::cerr << "WorkDir " << m_workdir << " doesn't exist " << std::endl;
      if ( gSystem->MakeDirectory( m_workdir.c_str() ) == -1 )
      { // mkdir,fail to create?
        std::cerr << " Fail to create directory : " << m_workdir
                  << " Specify  ./ as current work directory" << std::endl;
        m_workdir = "./";
      }
    }
    else
    {
      gSystem->FreeDirectory( pdir );
      pdir = 0;
    }
  }
 
  if ( !m_online )
  {
    void* pdir = 0;
    if ( ( pdir = gSystem->OpenDirectory( m_datafile_dir.c_str() ) ) )
    {
      FileStat_t                    fs;
      std::vector<string>::iterator it = m_datafile_barrel.begin();
      for ( ; it != m_datafile_barrel.end(); it++ )
      {
        if ( ( *it ).size() > 0 )
        {
          std::string thefile = ( m_datafile_dir + "/" + ( *it ) );
          if ( gSystem->GetPathInfo( thefile.c_str(), fs ) == 0 )
          { m_barrelfile.push_back( thefile ); }
          else { std::cerr << " File " << thefile << " doesn't exist! " << std::endl; }
        }
      }
      it = m_datafile_endcap.begin();
      for ( ; it != m_datafile_endcap.end(); it++ )
      {
        if ( ( *it ).size() > 0 )
        {
          std::string thefile = ( m_datafile_dir + "/" + ( *it ) );
          if ( gSystem->GetPathInfo( thefile.c_str(), fs ) == 0 )
          { m_endcapfile.push_back( thefile ); }
          else { std::cerr << " File " << thefile << " doesn't exist! " << std::endl; }
        }
      }
      it = m_datafile_etf.begin();
      for ( ; it != m_datafile_etf.end(); it++ )
      {
        if ( ( *it ).size() > 0 )
        {
          std::string thefile = ( m_datafile_dir + "/" + ( *it ) );
          if ( gSystem->GetPathInfo( thefile.c_str(), fs ) == 0 )
          { m_etffile.push_back( thefile ); }
          else { std::cerr << " File " << thefile << " doesn't exist! " << std::endl; }
        }
      }
      gSystem->FreeDirectory( pdir );
      pdir = 0;
    }
    else
    {
      std::cerr << " Error : Please specify the InputDataDir which contains input data files "
                   "for calibration "
                << std::endl;
      exit( 0 );
    }
  }
 
  if ( !m_online || m_calibration )
  {
    std::cout << "******************* Report of before Calibration ********************"
              << std::endl
              << "* WorkDir   = " << m_workdir << " [ results are save in this directory ]   "
              << std::endl
              << "* WorkMode  = " << ( m_online ? "OnLine" : "OffLine" )
              << " [ run alone or with other algorithms ] " << std::endl
              << "* CalibItem = " << m_calibItem << " [ which calibraions you perform ]"
              << std::endl;
  }
 
  if ( !m_online )
  {
    std::cout << "* ==> InputDataDir : " << m_datafile_dir << std::endl
              << "*   ===>Files of Barrel : ";
    for ( std::vector<std::string>::iterator it = m_barrelfile.begin();
          it != m_barrelfile.end(); it++ )
    { std::cout << "'" << ( *it ) << "' "; }
    std::cout << std::endl << "*   ===>Files of Endcap : ";
    for ( std::vector<std::string>::iterator it = m_endcapfile.begin();
          it != m_endcapfile.end(); it++ )
    { std::cout << "'" << ( *it ) << "' "; }
    std::cout << std::endl << "*   ===>Files of Etf : ";
    for ( std::vector<std::string>::iterator it = m_etffile.begin(); it != m_etffile.end();
          it++ )
    { std::cout << "'" << ( *it ) << "' "; }
    std::cout << std::endl;
  }
  std::cout << "*********************************************************************"
            << std::endl;
 
  return StatusCode::SUCCESS;
}
 
StatusCode tofcalgsec::beginRun() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "tofcalgsec::beginRun()" << endmsg;
  return StatusCode::SUCCESS;
}
 
StatusCode tofcalgsec::execute() {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "start "
      << "tofcalgsec::execute()" << endmsg;
 
  if ( m_online )
  {
    SmartDataPtr<RecBTofCalHitCol> bhitcol( eventSvc(), "/Event/Recon/RecBTofCalHitCol" );
    if ( bhitcol )
    {
      m_checkbarrel->FillBarrelCol( bhitcol );
      if ( m_calibration )
      {
        TofCalibManager* manager = TofCalibManager::getManager();
        manager->dataSet()->setBarrelData( bhitcol );
      }
    }
    else
    {
      //      log << MSG::ERROR << " Can't get /Event/Recon/RecBTofCalHitCol in TDS!" <<
      //      endmsg; return StatusCode::SUCCESS;
    }
 
    SmartDataPtr<RecETofCalHitCol> ehitcol( eventSvc(), "/Event/Recon/RecETofCalHitCol" );
    if ( ehitcol )
    {
      m_checkendcap->FillEndcapCol( ehitcol );
      if ( m_calibration )
      { TofCalibManager::getManager()->dataSet()->setEndcapData( ehitcol ); }
    }
    else
    {
      //      log << MSG::ERROR << " Can't get /Event/Recon/RecETofCalHitCol in TDS!" <<endmsg;
      //      return StatusCode::SUCCESS;
    }
 
    if ( bhitcol )
    {
      m_checketf->FillEtfCol( bhitcol );
      if ( m_calibration ) { TofCalibManager::getManager()->dataSet()->setEtfData( bhitcol ); }
    }
    else
    {
      //      log << MSG::ERROR << " Can't get /Event/Recon/RecBTofCalHitCol in TDS!" <<
      //      endmsg; return StatusCode::SUCCESS;
    }
  }
 
  log << MSG::INFO << "end "
      << "tofcalgsec::execute()" << endmsg;
  return StatusCode::SUCCESS;
}
 
StatusCode tofcalgsec::finalize() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "tofcalgsec::finalize()" << endmsg;
 
  if ( m_online && !m_calibration )
  {
    if ( m_checkbarrel ) { delete m_checkbarrel; }
    if ( m_checkendcap ) { delete m_checkendcap; }
    if ( m_checketf ) { delete m_checketf; }
    return StatusCode::SUCCESS;
  }
 
  TofCalibManager* manager = TofCalibManager::getManager();
  if ( !m_online )
  {
    if ( m_barrelfile.empty() )
    {
      std::cout << " No barrle data files are valid, exit " << std::endl;
      exit( 0 );
    }
    else { manager->dataSet()->setBarrelDataFiles( m_barrelfile ); }
    if ( m_endcapfile.empty() )
    {
      std::cout << " No endcap data files are valid, exit " << std::endl;
      exit( 0 );
    }
    else { manager->dataSet()->setEndcapDataFiles( m_endcapfile ); }
    if ( m_etffile.empty() )
    {
      std::cout << " No etf data files are valid, exit " << std::endl;
      exit( 0 );
    }
    else { manager->dataSet()->setEtfDataFiles( m_etffile ); }
  }
 
  // barrel attenuation length calibration
  if ( testbit( 5 ) )
  {
    manager->addCalib( new calib_barrel_atten(), 1 );
    manager->addCalib( new calib_barrel_q0(), 1 );
  }
  // barrel effective velocity calibration
  if ( testbit( 4 ) ) { manager->addCalib( new calib_barrel_veff(), 1 ); }
  // barrel time calibration
  if ( testbit( 7 ) )
  {
    manager->addCalib( new calib_barrel_left(), 1 );
    if ( testbit( 8 ) )
    {
      manager->addCalib( new calib_barrel_left_offset1_bunch0_4(), true );
      manager->addCalib( new calib_barrel_left_offset1_bunch1_4(), true );
      manager->addCalib( new calib_barrel_left_offset1_bunch2_4(), true );
      manager->addCalib( new calib_barrel_left_offset1_bunch3_4(), true );
      manager->addCalib( new calib_barrel_left_offset2_bunch0_4(), true );
      manager->addCalib( new calib_barrel_left_offset2_bunch1_4(), true );
      manager->addCalib( new calib_barrel_left_offset2_bunch2_4(), true );
      manager->addCalib( new calib_barrel_left_offset2_bunch3_4(), true );
    }
    if ( !testbit( 8 ) )
    {
      manager->addCalib( new calib_barrel_left_offset1_bunch0_3(), true );
      manager->addCalib( new calib_barrel_left_offset1_bunch1_3(), true );
      manager->addCalib( new calib_barrel_left_offset1_bunch2_3(), true );
      manager->addCalib( new calib_barrel_left_offset1_bunch3_3(), true );
      manager->addCalib( new calib_barrel_left_offset2_bunch0_3(), true );
      manager->addCalib( new calib_barrel_left_offset2_bunch1_3(), true );
      manager->addCalib( new calib_barrel_left_offset2_bunch2_3(), true );
      manager->addCalib( new calib_barrel_left_offset2_bunch3_3(), true );
    }
    manager->addCalib( new calib_barrel_right(), 1 );
    if ( testbit( 8 ) )
    {
      manager->addCalib( new calib_barrel_right_offset1_bunch0_4(), true );
      manager->addCalib( new calib_barrel_right_offset1_bunch1_4(), true );
      manager->addCalib( new calib_barrel_right_offset1_bunch2_4(), true );
      manager->addCalib( new calib_barrel_right_offset1_bunch3_4(), true );
      manager->addCalib( new calib_barrel_right_offset2_bunch0_4(), true );
      manager->addCalib( new calib_barrel_right_offset2_bunch1_4(), true );
      manager->addCalib( new calib_barrel_right_offset2_bunch2_4(), true );
      manager->addCalib( new calib_barrel_right_offset2_bunch3_4(), true );
    }
    if ( !testbit( 8 ) )
    {
      manager->addCalib( new calib_barrel_right_offset1_bunch0_3(), true );
      manager->addCalib( new calib_barrel_right_offset1_bunch1_3(), true );
      manager->addCalib( new calib_barrel_right_offset1_bunch2_3(), true );
      manager->addCalib( new calib_barrel_right_offset1_bunch3_3(), true );
      manager->addCalib( new calib_barrel_right_offset2_bunch0_3(), true );
      manager->addCalib( new calib_barrel_right_offset2_bunch1_3(), true );
      manager->addCalib( new calib_barrel_right_offset2_bunch2_3(), true );
      manager->addCalib( new calib_barrel_right_offset2_bunch3_3(), true );
    }
  }
  // barrel sigma calibration
  if ( testbit( 6 ) )
  {
    manager->addCalib( new calib_barrel_common( m_tcorrzbin ), true );
    manager->addCalib( new calib_barrel_sigma( m_barrelzbin ), true );
  }
 
  // endcap attenuation length calibration
  if ( testbit( 1 ) ) { manager->addCalib( new calib_endcap_atten( m_endcapQrbin ), false ); }
  // endcap effective velocity calibration
  if ( testbit( 0 ) ) { manager->addCalib( new calib_endcap_veff(), false ); }
  // endcap time calibration
  if ( testbit( 3 ) ) { manager->addCalib( new calib_endcap_left(), 0 ); }
  // endcap sigma calibration
  if ( testbit( 2 ) ) { manager->addCalib( new calib_endcap_sigma( m_endcaprbin ), false ); }
  // etf effective velocity calibration
  if ( testbit( 9 ) ) { manager->addCalib( new calib_etf_veff(), 2 ); }
  // monte carlo etf time calibration
  if ( testbit( 11 ) )
  {
    manager->addCalib( new calib_mc_etf_combine(), 2 );
    manager->addCalib( new calib_mc_etf_left(), 2 );
    manager->addCalib( new calib_mc_etf_right(), 2 );
  }
  // etf time calibration
  if ( testbit( 10 ) )
  {
    manager->addCalib( new calib_etf_combine(), 2 );
    manager->addCalib( new calib_etf_left(), 2 );
    manager->addCalib( new calib_etf_right(), 2 );
  }
  // etf bunch offset
  if ( testbit( 12 ) )
  {
    if ( testbit( 8 ) ) { manager->addCalib( new calib_etf_bunch( 4 ), false ); }
    if ( !testbit( 8 ) ) { manager->addCalib( new calib_etf_bunch( 3 ), false ); }
  }
 
  manager->doCalibration();
 
  manager->fillTxt( m_workdir );
  manager->fillRoot( m_workdir );
 
  return StatusCode::SUCCESS;
}
 
tofcalgsec::~tofcalgsec() {}