DetVerSvc.cxx

Go to the documentation of this file.

#include "Gaudi/Interfaces/IOptionsSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/Parsers.h"
#include "GaudiKernel/SmartIF.h"
#include "TFile.h"
#include "TTree.h"
#include <dlfcn.h>
#include <fstream>
 
#include "RawDataCnvSvc/IRawDataInputSvc.h"
#include "RealizationSvc/IRealizationSvc.h"
 
#include "DetVerSvc.h"
 
using Gaudi::Interfaces::IOptionsSvc;
using PropsVec = std::vector<std::tuple<std::string, std::string>>;
 
DECLARE_COMPONENT( DetVerSvc )
 
namespace DetVerSvcPack {
  int ( *pf_helper )( ISvcLocator* );
}
 
DetVerSvc::DetVerSvc( const std::string& name, ISvcLocator* svcloc )
    : base_class( name, svcloc ) {
  if ( getenv( "DETVERSVCROOT" ) )
    m_conf = std::string( getenv( "DETVERSVCROOT" ) ) + "/share/config.txt";
  else m_conf = "";
 
  declareProperty( "Config", m_conf );
  m_phase = -1;
}
 
DetVerSvc::~DetVerSvc() {}
 
StatusCode DetVerSvc::initialize() {
  Service::initialize();
 
  MsgStream log( msgSvc(), name() );
  info() << name() << ": Start of run initialisation" << endmsg;
 
  // assert m_conf is a valid file
  if ( access( m_conf.c_str(), F_OK ) < 0 )
  {
    log << MSG::FATAL << "Cann't find config file: " << m_conf << endmsg;
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}
 
StatusCode DetVerSvc::finalize() {
  MsgStream log( msgSvc(), name() );
  info() << name() << ": End of Run finalize" << endmsg;
 
  return StatusCode::SUCCESS;
}
 
int DetVerSvc::phase() {
  if ( m_phase < 1 || m_phase > 3 ) // phase has not been retrieved
  {
    if ( serviceLocator()->existsService( "RawDataInputSvc" ) ) // case: Input RAW
    {
      // Try to get runNo from RawDataInputSvc, then get phase from runNo
      SmartIF<IRawDataInputSvc> raw_svc = service<IRawDataInputSvc>( "RawDataInputSvc" );
      if ( !raw_svc )
      {
        error() << "Failed to get RawDataInputSvc" << endmsg;
        exit( 1 );
      }
      m_phase = fromRun( raw_svc->runNo() );
    }
    else if ( serviceLocator()->existsService( "EventCnvSvc" ) ) // case: Input root
    {
      // ==========================================================
      // Total procedure:
      // [1] Get "EventCnvSvc.digiRootInputFile" from JobOptionsSvc
      // [2] Parse and get first input file by std::regex
      // [3] Open the file and get run number from the first entry
      // ==========================================================
 
      // Get digiRootInputFile from JobOptionsSvc
      SmartIF<IOptionsSvc> opt_svc = service<IOptionsSvc>( "JobOptionsSvc" );
      if ( !opt_svc )
      {
        error() << "Failed to get JobOptionsSvc" << endmsg;
        exit( 1 );
      }
      std::vector<std::string> digi_inputs;
      Gaudi::Parsers::parse( digi_inputs,
                             opt_svc->get( "EventCnvSvc.digiRootInputFile", "" ) );
      if ( digi_inputs.size() == 0 )
      {
        error() << "Failed to get digiRootInputFile" << endmsg;
        exit( 1 );
      }
 
      debug() << "Match result: " << digi_inputs[0] << std::endl;
 
      // Open the file and get run number from the first entry
      TFile* file = TFile::Open( digi_inputs[0].c_str(), "READ" );
      TTree* tree = (TTree*)file->Get( "Event" );
      tree->SetMakeClass( 1 );
      int run;
      tree->SetBranchAddress( "m_runId", &run );
      tree->GetEntry( 0 );
 
      m_phase = fromRun( abs( run ) );
    }
    else if ( serviceLocator()->existsService( "RealizationSvc" ) ) // case: Simulation
    {
      // Try to get runNo from RealizationSvc, then get phase from runNo
      SmartIF<IRealizationSvc> real_svc = service<IRealizationSvc>( "RealizationSvc" );
      if ( !real_svc )
      {
        error() << "Failed to get RealizationSvc" << endmsg;
        exit( 1 );
      }
      m_phase = fromRun( abs( real_svc->getRunId() ) );
    }
  }
 
  debug() << "m_phase: " << m_phase << std::endl;
 
  // This check seems stupid, but just let it be here. :)
  if ( m_phase < 1 || m_phase > 3 )
  {
    error() << "Phase is not in {1, 2, 3}" << endmsg;
    exit( 1 );
  }
 
  return m_phase;
}
 
int DetVerSvc::fromRun( unsigned int run ) {
  std::vector<int> runList;
  // parse m_conf
  int           iTmp;
  std::ifstream fs( m_conf.c_str() );
  fs >> iTmp;
  while ( !fs.eof() )
  {
    runList.push_back( iTmp );
    fs >> iTmp;
  }
 
  // return phase from run
  int phase = 1;
  for ( int sep : runList )
  {
    if ( run < sep ) { break; }
    ++phase;
  }
  return phase;
}