GetLCDeadMaterialTree Class Reference

#include <GetLCDeadMaterialTree.h>

Inheritance diagram for GetLCDeadMaterialTree:

Collaboration diagram for GetLCDeadMaterialTree:

Public Member Functions
	GetLCDeadMaterialTree (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~GetLCDeadMaterialTree ()
virtual StatusCode	initialize ()
virtual StatusCode	execute ()
virtual StatusCode	finalize ()
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef std::pair< std::string, xAOD::CaloCluster::MomentType >	moment_name_pair
typedef std::vector< moment_name_pair >	moment_name_vector
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::string	m_HadDMCoeffInitFile
	Name of text file with initial parameters for coefficients calculation.
TTree *	m_outputTree
	Output tree.
std::string	m_outputFileName
	Name of the output file to save tree in.
TFile *	m_outputFile
	Output file to save tree in.
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_clusterCollName
	Name of the uncalibrated CaloClusterContainer to use.
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_clusterCollNameCalib
	Name of the calibrated CaloClusterContainer to use.
CaloLocalHadCoeff *	m_HadDMCoeff
	Collection of dead material correction coeffitients.
CaloHadDMCoeffData *	m_data
	data to save into the tree
bool	m_doSaveCalibClusInfo
	save additional cluster info from calibrated collections
double	m_energyMin
std::vector< xAOD::CaloCluster::MomentType >	m_momentForDMArea
const CaloCell_ID *	m_calo_id
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 33 of file GetLCDeadMaterialTree.h.

Member Typedef Documentation

moment_name_pair

typedef std::pair<std::string,xAOD::CaloCluster::MomentType> GetLCDeadMaterialTree::moment_name_pair

private

Definition at line 94 of file GetLCDeadMaterialTree.h.

moment_name_vector

typedef std::vector<moment_name_pair> GetLCDeadMaterialTree::moment_name_vector

private

Definition at line 95 of file GetLCDeadMaterialTree.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

GetLCDeadMaterialTree()

GetLCDeadMaterialTree::GetLCDeadMaterialTree	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 58 of file GetLCDeadMaterialTree.cxx.

  : AthAlgorithm(name, pSvcLocator),
    m_HadDMCoeffInitFile("CaloHadDMCoeff_init_v2.txt"),
    m_outputTree(nullptr),
    m_outputFileName("DeadMaterialTree.root"),
    m_outputFile(nullptr),
    m_clusterCollName("CaloTopoClusters"),
    m_HadDMCoeff(nullptr),
    m_data(nullptr),
    m_doSaveCalibClusInfo(false),
    m_energyMin(200*MeV),
    m_calo_id(nullptr)
{
 
  // dead material zone description
  declareProperty("HadDMCoeffInitFile",m_HadDMCoeffInitFile);
 
  // Name of output file to save histograms in
  declareProperty("OutputFileName",m_outputFileName);
 
  // Name of ClusterContainer (uncalibrated) to use
  declareProperty("ClusterCollectionName",m_clusterCollName); 
 
  // Name of ClusterContainer (calibrated) to use
  declareProperty("ClusterCollectionNameCalib",m_clusterCollNameCalib); 
 
  // to save additional info from the collection with calibrated clusters
  declareProperty("doSaveCalibClusInfo", m_doSaveCalibClusInfo);
 
}

~GetLCDeadMaterialTree()

GetLCDeadMaterialTree::~GetLCDeadMaterialTree ( )

virtual

Definition at line 95 of file GetLCDeadMaterialTree.cxx.

{
  if( m_HadDMCoeff ) delete m_HadDMCoeff;
}

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode GetLCDeadMaterialTree::execute ( )

virtual

Definition at line 190 of file GetLCDeadMaterialTree.cxx.

{
  //bool useLink = true;
 
  /* ********************************************
  access to cluster container
  ******************************************** */
  SG::ReadHandle<xAOD::CaloClusterContainer> pClusColl (m_clusterCollName);
 
  /* ********************************************
  reading primary particle
  ******************************************** */
  const McEventCollection* truthEvent=nullptr;
  ATH_CHECK( evtStore()->retrieve(truthEvent, "TruthEvent") );
#ifdef HEPMC3
  const HepMC::ConstGenParticlePtr& gen  = truthEvent->at(0)->particles().front();
#else
  HepMC::GenEvent::particle_const_iterator pit  = truthEvent->at(0)->particles_begin();
  const HepMC::GenParticle * gen  = *pit;
#endif
 
  double mc_eta = gen->momentum().pseudoRapidity();
  double mc_phi = gen->momentum().phi();
 
  m_data->clear();
 
  m_data->m_mc_pdg = gen->pdg_id();
  m_data->m_mc_ener = gen->momentum().e();
  m_data->m_mc_eta = mc_eta;
  m_data->m_mc_phi = mc_phi;
 
  int nClus = pClusColl->size();
  m_data->m_ncls = nClus;
  m_data->m_cls_ener->resize(nClus, 0.0);
  m_data->m_cls_ener_unw->resize(nClus, 0.0);
  m_data->m_cls_lambda->resize(nClus, 0.0);
  m_data->m_cls_eta->resize(nClus, 0.0);
  m_data->m_cls_phi->resize(nClus, 0.0);
  //m_data->m_cls_emfrac->resize(nClus, 0.0);
  m_data->m_cls_smpener->resize(nClus);
  m_data->m_cls_smpener_unw->resize(nClus);
  //m_data->m_cls_ibin->resize(nClus);
  m_data->m_cls_eprep->resize(nClus);
  m_data->m_cls_dmener->resize(nClus);
  m_data->m_narea = m_HadDMCoeff->getSizeAreaSet();
  for(int i_cls=0; i_cls<nClus; i_cls++){
    //(*m_cls_ibin)[i_cls].resize(m_narea, -1);
    (*m_data->m_cls_smpener)[i_cls].resize(CaloSampling::Unknown, 0.0);
    (*m_data->m_cls_smpener_unw)[i_cls].resize(CaloSampling::Unknown, 0.0);
    (*m_data->m_cls_eprep)[i_cls].resize(m_data->m_narea, 0.0);
    (*m_data->m_cls_dmener)[i_cls].resize(m_data->m_narea, 0.0);
  }
  m_data->m_cls_engcalib->resize(nClus, 0.0);
  m_data->m_cls_recostat->resize(nClus, 0);
  m_data->m_cls_pi0prob->resize(nClus, 0.0);
  m_data->m_cls_isol->resize(nClus, 0.0);
  m_data->m_cls_oocener->resize(nClus, 0.0);
  m_data->m_cls_calib_emfrac->resize(nClus, 0.0);
  m_data->m_cls_engcalibpres->resize(nClus, 0.0);
 
  xAOD::CaloClusterContainer::const_iterator clusIter = pClusColl->begin();
  xAOD::CaloClusterContainer::const_iterator clusIterEnd = pClusColl->end();
  unsigned int iClus = 0;
  for( ;clusIter!=clusIterEnd;++clusIter,++iClus) {
    const xAOD::CaloCluster * theCluster = (*clusIter);
 
    (*m_data->m_cls_ener)[iClus] = theCluster->e();
    // cluster energy in samplings
    for(int i_smp=0; i_smp<(int)CaloSampling::Unknown; i_smp++){
      (*m_data->m_cls_smpener)[iClus][i_smp] = theCluster->eSample((CaloSampling::CaloSample)i_smp);
    }
 
    // calibration energy of clusters
    double mx_calib_tot=0;
    if( !theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ) {
      ATH_MSG_ERROR( "Moment ENG_CALIB_TOT is absent"   );
      return StatusCode::FAILURE;
    }
    m_data->m_engClusSumCalib += mx_calib_tot;
    (*m_data->m_cls_engcalib)[iClus] = mx_calib_tot;
    
    double mx_calib_emb0=0, mx_calib_eme0=0, mx_calib_tileg3=0;
    if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
    || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
    || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
      ATH_MSG_ERROR( "One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent"  );
      return StatusCode::FAILURE;
    }else{
       (*m_data->m_cls_engcalibpres)[iClus] = (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
    }
 
    if(m_doSaveCalibClusInfo) {
      SG::ReadHandle<xAOD::CaloClusterContainer> pClusCollCalib (m_clusterCollNameCalib);
      if(pClusColl->size() != pClusCollCalib->size()) {
        ATH_MSG_WARNING( "Different size of calibrated and uncalibrated cluster collection " 
                         << pClusColl->size() << " " << pClusCollCalib->size()  );
        return StatusCode::SUCCESS;
      }
 
      const xAOD::CaloCluster * theClusterCalib = pClusCollCalib->at(iClus);
 
      // reco status
      const CaloRecoStatus& recoStatus = theClusterCalib->recoStatus();
 
      (*m_data->m_cls_recostat)[iClus] = recoStatus.getStatusWord();
 
      // classification pi0 probability (available on calibrated cluster)
      double pi0Prob = 0;
      if( !theClusterCalib->retrieveMoment( xAOD::CaloCluster::EM_PROBABILITY, pi0Prob) ) {
        //ATH_MSG_ERROR( "Moment ENG_CALIB_TOT is absent"   );
        pi0Prob = -1.0;
      } else {
        if ( pi0Prob < 0 ) pi0Prob = 0;
        if ( pi0Prob > 1 ) pi0Prob = 1;
      }
      (*m_data->m_cls_pi0prob)[iClus] = pi0Prob;
    } // m_doSaveCalibClusInfo
 
    // cluster isolation moment and out of cluster energy
    double mx_isol;
    if ( !theCluster->retrieveMoment(xAOD::CaloCluster::ISOLATION, mx_isol)) {
      ATH_MSG_ERROR( "Moment ISOLATION is absent"   );
      return StatusCode::FAILURE;
    }else{
      (*m_data->m_cls_isol)[iClus] = mx_isol;
    }
 
    double mx_calib_oocL;
    if ( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_oocL)) {
      ATH_MSG_ERROR( "Moment ENG_CALIB_OUT_L is absent"   );
      return StatusCode::FAILURE;
    }else{
      (*m_data->m_cls_oocener)[iClus] = mx_calib_oocL;
    }
 
    double mx_calib_emfrac;
    if ( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_FRAC_EM, mx_calib_emfrac)) {
      ATH_MSG_WARNING( "Moment ENG_CALIB_FRAC_EM is absent"   );
      return StatusCode::FAILURE;
    }else{
      (*m_data->m_cls_calib_emfrac)[iClus] = mx_calib_emfrac;
    }
 
 
    // calculation of cluster energy and energy in samplings without accounting
    // cells weights
    xAOD::CaloCluster::const_cell_iterator cellIter    = theCluster->cell_begin();
    xAOD::CaloCluster::const_cell_iterator cellIterEnd = theCluster->cell_end();
    for(; cellIter != cellIterEnd; cellIter++ ){
      const CaloCell* pCell = (*cellIter);
      Identifier myId = pCell->ID();
      CaloSampling::CaloSample nsmp = (CaloSampling::CaloSample)m_calo_id->calo_sample(myId);
      (*m_data->m_cls_ener_unw)[iClus] += pCell->e();
      (*m_data->m_cls_smpener_unw)[iClus][(int)nsmp] += pCell->e();
    }
 
    double clusEner = (*m_data->m_cls_ener_unw)[iClus];
    double clusLambda=0;
    if (!theCluster->retrieveMoment(xAOD::CaloCluster::CENTER_LAMBDA,clusLambda)) {
      ATH_MSG_WARNING( "Moment CENTER_LAMBDA is absent"   );
      return StatusCode::FAILURE;
    }
    (*m_data->m_cls_lambda)[iClus] = clusLambda;
    (*m_data->m_cls_eta)[iClus] = theCluster->eta();
    (*m_data->m_cls_phi)[iClus] = theCluster->phi();
    if(clusEner > m_energyMin ) {
      //clusEner = log10(clusEner);
      //if(clusEner > 6.3) clusEner = 6.2999;
      //clusLambda = log10(clusLambda);
      //if(clusLambda > 4.0) clusLambda =  3.9999;
      //double clusEta=fabs(theCluster->eta());
 
      for(int i_dma=0; i_dma<m_data->m_narea; i_dma++){
        //(*m_cls_ibin)[iClus][i_dma] = m_HadDMCoeff->getBin(i_dma, (float)clusEmFrac, (float)clusEner, (float)clusLambda, (float)clusEta);
    double dmVal=0;
    if (!theCluster->retrieveMoment( m_momentForDMArea[i_dma],dmVal)) {
      ATH_MSG_WARNING( "Moment "<< m_momentForDMArea[i_dma] << " is absent"   );
      return StatusCode::FAILURE;
    }
        (*m_data->m_cls_dmener)[iClus][i_dma] = dmVal;
 
        // now we have to calculate cluster quantities which we will use later for
        // reconstruction of given dead material calibration moment
        double eprep = 0.0;
        double x(0), y(0);
        switch ( m_momentForDMArea[i_dma] ) {
          case xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0:
            x = (*m_data->m_cls_smpener_unw)[iClus][CaloSampling::PreSamplerB];
            if(x > 0.0) {
              eprep = x;
            }
            break;
          case xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0:
            x = (*m_data->m_cls_smpener_unw)[iClus][CaloSampling::EMB3];
            y = (*m_data->m_cls_smpener_unw)[iClus][CaloSampling::TileBar0];
            if(x>0.0 && y>0.0) {
              eprep = sqrt(x*y);
            }
            break;
          case xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3:
            x = (*m_data->m_cls_smpener_unw)[iClus][CaloSampling::TileGap3];
            if(x > 0.0) {
              eprep = x;
            }
            break;
          case xAOD::CaloCluster::ENG_CALIB_DEAD_EME0:
            x = (*m_data->m_cls_smpener_unw)[iClus][CaloSampling::PreSamplerE];
            if( x > 0.0 ) {
              eprep = x;
            }
            break;
          case xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0:
            x = (*m_data->m_cls_smpener_unw)[iClus][CaloSampling::EME3];
            y = (*m_data->m_cls_smpener_unw)[iClus][CaloSampling::HEC0];
            if(x>0.0 && y>0.0) {
              eprep = sqrt(x*y);
            }
            break;
          case xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL:
            eprep = (*m_data->m_cls_ener_unw)[iClus];
            break;
          case xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE:
            eprep = (*m_data->m_cls_ener_unw)[iClus];
            break;
          case xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS:
            eprep = (*m_data->m_cls_ener_unw)[iClus];
            break;
          default:
            ATH_MSG_ERROR( "No such moment registered " << m_momentForDMArea[i_dma]  );
            return StatusCode::FAILURE;
            break;
        }
        (*m_data->m_cls_eprep)[iClus][i_dma] = eprep;
 
      } // loop over dm areas
 
    } // good cluster
  } // loop over clusters
 
  // now we have to process special case, when we have DM energy, say, in front of the
  // calorimeter but there is no signal in presampler itself. When we have to add this
  // DM energy into 'unclassified' area
  for(int i_cls=0; i_cls<m_data->m_ncls; i_cls++){
    double edm_uncorrected = 0.0;
    for(int i_dma=0; i_dma<m_data->m_narea; i_dma++){
      xAOD::CaloCluster::MomentType xm = m_momentForDMArea[i_dma];
      if( (*m_data->m_cls_eprep)[i_cls][i_dma] <= 0.0 &&
         (xm == xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0 ||
          xm == xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0 ||
          xm == xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3 ||
          xm == xAOD::CaloCluster::ENG_CALIB_DEAD_EME0 ||
          xm == xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0) )
      {
        edm_uncorrected += (*m_data->m_cls_dmener)[i_cls][i_dma];
        (*m_data->m_cls_dmener)[i_cls][i_dma] = 0.0;
      }
    } // i_dma
    // now let's put this energy into unclassified area
    for(int i_dma=0; i_dma<m_data->m_narea; i_dma++){
      if( m_momentForDMArea[i_dma] == xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS) {
         (*m_data->m_cls_dmener)[i_cls][i_dma] += edm_uncorrected;
      }
    } // i_dma
  } // i_cls
 
  m_outputTree->Fill();
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

finalize()

StatusCode GetLCDeadMaterialTree::finalize ( )

virtual

Definition at line 175 of file GetLCDeadMaterialTree.cxx.

{
  ATH_MSG_INFO( "Writing out tree"  );
  m_outputFile->cd();
  m_outputTree->Write();
  m_outputFile->Close();
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode GetLCDeadMaterialTree::initialize ( )

virtual

Definition at line 105 of file GetLCDeadMaterialTree.cxx.

{
  ATH_CHECK(detStore()->retrieve(m_calo_id, "CaloCell_ID"));
 
  /* ********************************************
  set list of valid moments
  ******************************************** */
  moment_name_vector validNames;
  validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EMB0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0));
  validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILE0"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0));
  validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILEG3"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3));
  validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EME0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EME0));
  validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_HEC0"),xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0));
  validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_FCAL"),xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL));
  validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_LEAKAGE"),xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE));
  validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_UNCLASS"),xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS));
 
  /* ********************************************
  initial coefficients
  ******************************************** */
  CaloLocalHadCoeffHelper dmHelper;
  std::string fileName = PathResolver::find_file (m_HadDMCoeffInitFile, "DATAPATH");
  m_HadDMCoeff = dmHelper.InitDataFromFile(fileName.c_str());
  if( !m_HadDMCoeff ) {
    ATH_MSG_FATAL( " Error while initializing default dead material coefficients " );
    return StatusCode::FAILURE;
  }
  // how we have to set correspondance between dead material areas and calibration moments
  m_momentForDMArea.resize( m_HadDMCoeff->getSizeAreaSet());
  for(int i_dm=0; i_dm<m_HadDMCoeff->getSizeAreaSet(); i_dm++){
    bool isValid(false);
    for (const moment_name_pair& vname : validNames) {
      if ( m_HadDMCoeff->getArea(i_dm)->getTitle() == vname.first ) {
        m_momentForDMArea[i_dm] = vname.second;
        isValid = true;
        break;
      }
    }
    if ( !isValid) {
      ATH_MSG_FATAL( " Unknown moment name '" << m_HadDMCoeff->getArea(i_dm)->getTitle() << "' in the m_HadDMCoeff!" );
      return StatusCode::FAILURE;
    }
  }
 
  /* ********************************************
  output file&tree
  ******************************************** */
  m_data = new CaloHadDMCoeffData(nullptr);
 
  m_outputFile = new TFile(m_outputFileName.c_str(),"RECREATE");
  m_outputFile->cd();
 
  m_outputTree = m_data->MakeTree("DeadMaterialTree");
 
  ATH_CHECK( m_clusterCollName.initialize() );
  if (m_doSaveCalibClusInfo) {
    ATH_CHECK( m_clusterCollNameCalib.initialize() );
  }
  else {
    m_clusterCollNameCalib = "";
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

msg()

MsgStream & AthCommonMsg< Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_calo_id

const CaloCell_ID* GetLCDeadMaterialTree::m_calo_id

private

Definition at line 98 of file GetLCDeadMaterialTree.h.

m_clusterCollName

SG::ReadHandleKey<xAOD::CaloClusterContainer> GetLCDeadMaterialTree::m_clusterCollName

private

Name of the uncalibrated CaloClusterContainer to use.

Definition at line 72 of file GetLCDeadMaterialTree.h.

m_clusterCollNameCalib

SG::ReadHandleKey<xAOD::CaloClusterContainer> GetLCDeadMaterialTree::m_clusterCollNameCalib

private

Name of the calibrated CaloClusterContainer to use.

Definition at line 76 of file GetLCDeadMaterialTree.h.

m_data

CaloHadDMCoeffData* GetLCDeadMaterialTree::m_data

private

data to save into the tree

Definition at line 84 of file GetLCDeadMaterialTree.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doSaveCalibClusInfo

bool GetLCDeadMaterialTree::m_doSaveCalibClusInfo

private

save additional cluster info from calibrated collections

Definition at line 88 of file GetLCDeadMaterialTree.h.

m_energyMin

double GetLCDeadMaterialTree::m_energyMin

private

Definition at line 91 of file GetLCDeadMaterialTree.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_HadDMCoeff

CaloLocalHadCoeff* GetLCDeadMaterialTree::m_HadDMCoeff

private

Collection of dead material correction coeffitients.

Definition at line 80 of file GetLCDeadMaterialTree.h.

m_HadDMCoeffInitFile

std::string GetLCDeadMaterialTree::m_HadDMCoeffInitFile

private

Name of text file with initial parameters for coefficients calculation.

File contains binning info for cluster's emfrac, log10ener, log10lambda and eta to recover energy losses in specific dead material zones

Definition at line 49 of file GetLCDeadMaterialTree.h.

m_momentForDMArea

std::vector<xAOD::CaloCluster::MomentType> GetLCDeadMaterialTree::m_momentForDMArea

private

Definition at line 96 of file GetLCDeadMaterialTree.h.

m_outputFile

TFile* GetLCDeadMaterialTree::m_outputFile

private

Output file to save tree in.

Internal variable pointing to the output file.

Definition at line 68 of file GetLCDeadMaterialTree.h.

m_outputFileName

std::string GetLCDeadMaterialTree::m_outputFileName

private

Name of the output file to save tree in.

Use this property to set the name of the output file containing the DM data tree.

Definition at line 62 of file GetLCDeadMaterialTree.h.

m_outputTree

TTree* GetLCDeadMaterialTree::m_outputTree

private

Output tree.

Output tree to fill and save.

Definition at line 55 of file GetLCDeadMaterialTree.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• GetLCDeadMaterialTree.h
• GetLCDeadMaterialTree.cxx