#include <LArPhysWavePredictor.h>

Inheritance diagram for LArPhysWavePredictor:

Collaboration diagram for LArPhysWavePredictor:

Public Member Functions
	LArPhysWavePredictor (const std::string &name, ISvcLocator *pSvcLocator)

	~LArPhysWavePredictor ()

StatusCode	initialize ()

StatusCode	execute ()

StatusCode	stop ()

StatusCode	finalize ()

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	notFoundMsg (const HWIdentifier chid, const int gain, const char *value)

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
SG::ReadCondHandleKey< LArBadChannelCont >	m_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}

SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}

SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKeySC {this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"}

LArBadChannelMask	m_bcMask

Gaudi::Property< std::vector< std::string > >	m_problemsToMask {this,"ProblemsToMask",{}, "Bad-Channel categories to mask"}

const LArOnlineID_Base *	m_onlineHelper =nullptr

const CaloCell_Base_ID *	m_caloCellId =nullptr

bool	m_testmode

bool	m_storeEmpty

bool	m_dumpMphysMcali

bool	m_normalizeCali

bool	m_isSC

std::vector< std::string >	m_keyCali

std::string	m_keyPhys

std::string	m_keyMphysMcali

std::string	m_keyIdealPhys

std::string	m_keyFcal

std::string	m_groupingType

bool	m_useJOCaliPulseParams

double	m_Tcali

double	m_Fstep

bool	m_useJODetCellParams

double	m_Omega0

double	m_Taur

bool	m_isHEC

bool	m_useJOTdrift

std::vector< double >	m_Tdrift

bool	m_doubleTriangle

std::vector< double >	m_Tdrift2

std::vector< double >	m_wTriangle2

bool	m_useJOPhysCaliTdiff

int	m_timeShiftByIndex

bool	m_timeShiftByHelper

bool	m_timeShiftByLayer

std::vector< unsigned int >	m_TshiftLayer

bool	m_timeShiftByFEB

int	m_timeShiftGuardRegion

DataObjIDColl	m_extendedExtraObjects

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 26 of file LArPhysWavePredictor.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ LArPhysWavePredictor()

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

Definition at line 48 of file LArPhysWavePredictor.cxx.

  : AthAlgorithm(name, pSvcLocator),
    m_groupingType("FeedThrough") // SubDetector, Single, FeedThrough
 {
   declareProperty("TestMode",         m_testmode   = false);
   declareProperty("StoreEmpty",       m_storeEmpty = false);
   declareProperty("isSC", m_isSC = false);
  
   m_keyCali.clear() ;
   declareProperty("KeyCaliList",      m_keyCali);                  // Keys of LArCaliWaveContainers
   declareProperty("KeyPhys",          m_keyPhys = "LArPhysWave") ; // Key of LArPhysWaveContainer
   declareProperty("KeyIdealPhys",     m_keyIdealPhys   = "LArPhysWaveHECIdeal") ; // added by FT    
   declareProperty("KeyFcal",          m_keyFcal   = "FCALFromTB") ; // added by FT    
   declareProperty("KeyMphysMcali",    m_keyMphysMcali = "LArMphysOverMcal") ; // Key of LArMphysOverMcalComplete
   declareProperty("DumpMphysMcali",   m_dumpMphysMcali = false ) ; // for debugging
   declareProperty("NormalizeCali",    m_normalizeCali = false ) ; // for debugging
   declareProperty("isHEC",            m_isHEC = false ) ; 
  
   //
   // jobOptions for calibration pulse paramers (Tcali, Fstep)
   //
   declareProperty("UseCaliPulseParamsFromJO", m_useJOCaliPulseParams = false );
   declareProperty("Tcali", m_Tcali = 450. ); 
   declareProperty("Fstep", m_Fstep = 0.07 ); 
   
   declareProperty("UseDetCellParamsFromJO"  , m_useJODetCellParams   = false );
   declareProperty("Omega0", m_Omega0 = 0. ); // Omega0 == 0 will skip injection point correction 
   declareProperty("Taur",   m_Taur   = 0. ); 
   
   //
   // jobOptions for drift time of predicted pulses (Tdrift)
   //
   declareProperty("UseTdriftFromJO", m_useJOTdrift = false );
   m_Tdrift.clear();
   double default_Tdrift[4] = { 420 , 475 , 475 , 475 } ;
   for ( unsigned i=0;i<4;i++) m_Tdrift.push_back(default_Tdrift[i]);
   declareProperty("Tdrift", m_Tdrift) ;
   m_Tdrift2.clear();
   double default_Tdrift2[4] = { 1200. , 1200. , 1200. , 1200. } ;
   for ( unsigned i=0;i<4;i++) m_Tdrift2.push_back(default_Tdrift2[i]);
   declareProperty("Tdrift2", m_Tdrift2) ;
   m_wTriangle2.clear();
   double default_wTriangle2[4] = { 0.01 , 0.01 , 0.01 , 0.01 } ;
   for ( unsigned i=0;i<4;i++) m_wTriangle2.push_back(default_wTriangle2[i]);
   declareProperty("WeightTriangle2", m_wTriangle2) ;
   declareProperty("UseDoubleTriangle", m_doubleTriangle = false );
   
   //
   // jobOptions for time shift of predicted pulses
   // 
   declareProperty("UseTimeShiftFromJO",   m_useJOPhysCaliTdiff   = false );
   declareProperty("TimeShiftByIndex" ,    m_timeShiftByIndex     = 0);
   declareProperty("TimeShiftByHelper",    m_timeShiftByHelper    = false);
   declareProperty("TimeShiftByLayer",     m_timeShiftByLayer     = false) ;
   declareProperty("TimeShiftByFEB",       m_timeShiftByFEB       = false) ;
   declareProperty("TimeShiftGuardRegion", m_timeShiftGuardRegion = 0 ) ;  
   m_TshiftLayer.clear();
   unsigned int default_TshiftLayer[4] = { 0 , 0 , 0 , 0 } ;
   for ( unsigned i=0;i<4;i++)  m_TshiftLayer.push_back(default_TshiftLayer[i]);
   declareProperty("Tshift",m_TshiftLayer) ;
   
   // Grouping type
   declareProperty("GroupingType",      m_groupingType);  
 }

◆ ~LArPhysWavePredictor()

LArPhysWavePredictor::~LArPhysWavePredictor ( )

default

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode LArPhysWavePredictor::execute ( )

inline

Definition at line 34 of file LArPhysWavePredictor.h.

34 {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 LArPhysWavePredictor::finalize ( )

inline

Definition at line 36 of file LArPhysWavePredictor.h.

36 {return StatusCode::SUCCESS;}

◆ initialize()

StatusCode LArPhysWavePredictor::initialize ( )

Definition at line 118 of file LArPhysWavePredictor.cxx.

 {
   if ( ! m_doubleTriangle ) {
       ATH_MSG_INFO( "Using standard triangular ionization pulse" ) ;
   } else {
     ATH_MSG_INFO( "Using refined ionization pulse (double triangle)" ) ;
   }
  
   StatusCode sc;
   if ( m_isSC ) {
     const LArOnline_SuperCellID* ll;
     ATH_CHECK(detStore()->retrieve(ll, "LArOnline_SuperCellID"));
     m_onlineHelper = (const LArOnlineID_Base*)ll;
     ATH_MSG_DEBUG("Found the LArOnlineID helper");
     const CaloCell_SuperCell_ID* scid;
     ATH_CHECK(detStore()->retrieve(scid, "CaloCell_SuperCell_ID" ));
     m_caloCellId= (const CaloCell_Base_ID*)scid;
  
   } else { // m_isSC
     const LArOnlineID* ll;
     ATH_CHECK(detStore()->retrieve(ll, "LArOnlineID") );
     m_onlineHelper = (const LArOnlineID_Base*)ll;
     ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
      const CaloCell_ID* cid;
     ATH_CHECK(detStore()->retrieve(cid, "CaloCell_ID" ));
     m_caloCellId= (const CaloCell_Base_ID*)cid;
   }
  
   ATH_CHECK( m_BCKey.initialize() );
   ATH_CHECK( m_cablingKey.initialize() );
   ATH_CHECK( m_cablingKeySC.initialize(m_isSC) );
   ATH_CHECK( m_bcMask.buildBitMask(m_problemsToMask,msg()));
  
   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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ notFoundMsg()

void LArPhysWavePredictor::notFoundMsg	(	const HWIdentifier	chid,
		const int	gain,
		const char *	value
	)

private

Definition at line 726 of file LArPhysWavePredictor.cxx.

                                                                                                  {
   SG::ReadCondHandle<LArBadChannelCont> bcContHdl{m_BCKey};
   const LArBadChannelCont* bcCont{*bcContHdl};
  
   if (m_bcMask.cellShouldBeMasked(bcCont,chid)) {
     ATH_MSG_WARNING( "Cannot access " << value << " for known bad channel channel " << m_onlineHelper->channel_name(chid)
               << ", gain = " << gain << ". Will use jobO setting." ) ;
   }
   else {    
     LArBadChanBitPacking packer;
     const LArBadChannel bc = bcCont->status(chid);
     const std::string badChanStatus=packer.stringStatus(bc);
  
     ATH_MSG_ERROR( "Cannot access " << value << " for channel " << m_onlineHelper->channel_name(chid) 
             << ", gain = " << gain << " BC status=[" << badChanStatus << "]. Will use jobO setting." );
   }
   }

◆ 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();
   }

◆ stop()

StatusCode LArPhysWavePredictor::stop ( )

Definition at line 167 of file LArPhysWavePredictor.cxx.

 {
   ATH_MSG_INFO( "... in stop()" ) ;
   
   LArWaveHelper larWaveHelper;
  
   // Get access to the Detector Store
   //StoreGateSvc* detStore; 
   //StatusCode sc = service("DetectorStore",detStore);
   //if (sc!=StatusCode::SUCCESS) {
   //  ATH_MSG_ERROR( "Cannot get DetectorStore!" );
   //  return sc;
   //}
   
   // Retrieve LArPhysWaveTool
   ToolHandle<LArPhysWaveTool> larPhysWaveTool("LArPhysWaveTool");
   StatusCode sc=larPhysWaveTool.retrieve();
   if (sc!=StatusCode::SUCCESS) {
     ATH_MSG_ERROR( " Can't get LArPhysWaveTool " );
     return sc;
   }
  
   // Retrieve LArPhysWaveHECTool   // added by FT
   ToolHandle<LArPhysWaveHECTool> larPhysWaveHECTool("LArPhysWaveHECTool");
   if(m_isSC || m_isHEC){
     sc=larPhysWaveHECTool.retrieve();
     if (sc!=StatusCode::SUCCESS) {
       ATH_MSG_ERROR( " Can't get LArPhysWaveHECTool " );
       return sc;
     }}
  
   
   // Retrieve cabling
   const LArOnOffIdMapping* cabling(nullptr);
   if( m_isSC ){
     SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC};
     cabling = {*cablingHdl};
     if(!cabling) {
     ATH_MSG_ERROR("Do not have mapping object " << m_cablingKeySC.key());
         return StatusCode::FAILURE;
     }
   }else{
     SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
     cabling = {*cablingHdl};
     if(!cabling) {
        ATH_MSG_ERROR("Do not have mapping object " << m_cablingKey.key());
        return StatusCode::FAILURE;
     }
   }
  
   // Get parameters from detStore (access through abtract interfaces)
   const ILArCaliPulseParams* larCaliPulseParams = nullptr;
   const ILArDetCellParams*   larDetCellParams = nullptr;  
   const ILArTdrift*          larTdrift = nullptr;
   const ILArPhysCaliTdiff*   larPhysCaliTdiff = nullptr;
  
   if ( !m_useJOCaliPulseParams ) {
     sc = detStore()->retrieve(larCaliPulseParams);
     if ( sc == StatusCode::FAILURE ) {
       ATH_MSG_WARNING( "Cannot retrieve LArCaliPulseParams" ) ;
       return sc;
     } else {
       ATH_MSG_INFO( "LArCaliPulseParams successfully retrieved" ) ;
     }
   }
  
   if ( !m_useJODetCellParams ) {
     if (!m_isHEC ) {
       sc = detStore()->retrieve(larDetCellParams);
       if ( sc == StatusCode::FAILURE ) {
     ATH_MSG_WARNING( "Cannot retrieve LArDetCellParams" );
     return sc;
       }else {
     ATH_MSG_INFO( "LArDetCellParams successfully retrieved" );
       }
     }else{
       m_useJODetCellParams = true ;
     }
   }
   
   if ( !m_useJOTdrift ) {
     sc = detStore()->retrieve(larTdrift);
     if ( sc == StatusCode::FAILURE ) {
       ATH_MSG_WARNING( "Cannot retrieve LArTdriftComplete" );
       return sc;
     }else {
       ATH_MSG_INFO( "LArTdriftComplete successfully retrieved" );
     }
   }
   
   if ( !m_useJOPhysCaliTdiff ) {
     sc = detStore()->retrieve(larPhysCaliTdiff);
     if ( sc == StatusCode::FAILURE ) {
       ATH_MSG_WARNING( "Cannot retrieve LArPhysCaliTdiff" ); 
       return sc;
     }else {
       ATH_MSG_INFO( "LArPhysCaliTdiff successfully retrieved" );
     }
   }
   
   const ILArFEBTimeOffset* larFebTshift = nullptr;  
   if ( m_useJOPhysCaliTdiff ) { // no LArPhysCaliTdiffComplete found, or manual time shift selected
     if ( m_timeShiftByHelper ) {
       ATH_MSG_INFO( "Will use helper class for start time." );
       m_timeShiftByIndex = -1 ;
       m_timeShiftByLayer = false ;
       m_timeShiftByFEB   = false ;
     }  
     if ( m_timeShiftByIndex != -1 ) {
       ATH_MSG_INFO( "Manually shifting pulses by time index " << m_timeShiftByIndex );
       m_timeShiftByLayer = false ;
       m_timeShiftByFEB   = false ;
     }
     if ( m_timeShiftByLayer ) {
       ATH_MSG_INFO( "Manually shifting pulses by *layer-dependent* time indexes." );
       m_timeShiftByFEB   = false ;
     }
     if ( m_timeShiftByFEB ) {
       ATH_MSG_INFO( "Manually shifting pulses by *FEB* time indexes." );
       sc = detStore()->retrieve(larFebTshift);
       if (sc.isFailure())
          larFebTshift = nullptr;
     }
   }
   
   const LArPhysWaveContainer *fcalPhysWaves=nullptr;
  
   if ( m_isSC ) { //retrieve FCAL phys waves from COOL
     sc = detStore()->retrieve(fcalPhysWaves, m_keyFcal);
     if ( sc.isFailure() || !fcalPhysWaves) {
       ATH_MSG_WARNING( "Cannot retrieve FCAL Phys waves" ); 
       return sc;
     }else {
       ATH_MSG_INFO( "LArPhysCaliTdiff successfully retrieved" );
     }
   }
  
   int nchannel = 0 ;
   
   // Create LArPhysWaveContainer for predicted physics waveforms
   std::unique_ptr<LArPhysWaveContainer> larPhysWaveContainer = std::make_unique<LArPhysWaveContainer>();
  
   sc=larPhysWaveContainer->setGroupingType(m_groupingType,msg());
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed to set groupingType for LArPhysWaveContainer object" );
     return sc;
   }
  
   sc=larPhysWaveContainer->initialize(); 
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed initialize LArPhysWaveContainer object" );
     return sc;
   }   
  
   // Create LArMphysOverMcalComplete for predicted Mphys/Mcali
   std::unique_ptr<LArMphysOverMcalComplete> MphysOverMcalComplete = std::make_unique<LArMphysOverMcalComplete>(); 
   sc=MphysOverMcalComplete->setGroupingType(m_groupingType,msg());
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed to set groupingType for LArMphysOverMcalComplete object" );
     return sc;
   }
  
   sc=MphysOverMcalComplete->initialize(); 
   if (sc.isFailure()) {
     ATH_MSG_ERROR( "Failed initialize LArMphysOverMcalComplete object" );
     return sc;
   }   
   
   FILE* f = nullptr;
   if (m_dumpMphysMcali) {
      f = fopen("MphysOverMcali.dat","w");
      fprintf(f,"# Region Layer Eta Phi Gain  MphysMcali\n");
   }
   FileCloser fcloser (f);
   
   std::vector<int> nTotal;
   std::vector<int> noTcali;
   std::vector<int> noFstep;
   std::vector<int> noOmega0;
   std::vector<int> noTaur;
   std::vector<int> noTdrift;
   std::vector<int> noTdiff;
           
   unsigned maxgain = m_isSC ? CaloGain::LARNGAIN : 1;
   for ( unsigned i=0; i<maxgain; ++i ) {
     nTotal.push_back(0);
     noTcali.push_back(0);
     noFstep.push_back(0);
     noOmega0.push_back(0);
     noTaur.push_back(0);
     noTdrift.push_back(0);
     noTdiff.push_back(0);
   }
  
   // Get current LArPhysWaveContainer
   const LArPhysWaveContainer* larIdealPhysWaveContainer=nullptr;
   if(m_isHEC || m_isSC){
     ATH_CHECK(detStore()->retrieve(larIdealPhysWaveContainer,m_keyIdealPhys));
     ATH_MSG_INFO("LArPhysWaveContainer with (key = " << m_keyIdealPhys << ") reading from StoreGate" );
   }
     
   // get the calibration waveforms from the detector store 
  
   int NPhysWave=0;
   int NMPMC=0;  
  
   for (const std::string& key : m_keyCali) { // Loop over all LArCaliWave containers that are to be processed
  
     // Get current LArCaliWaveContainer
     const LArCaliWaveContainer* caliWaveContainer;
     sc = detStore()->retrieve(caliWaveContainer,key);
     if (sc.isFailure()) {
        //log << MSG::INF0 << "LArCaliWaveContainer (key = " << key << ") not found in StoreGate" );
        continue;   
     }
     if ( caliWaveContainer == nullptr ) {
        ATH_MSG_INFO( "LArCaliWaveContainer (key = " << key << ") is empty" );
        continue;
     }
     
     ATH_MSG_INFO( "Processing LArCaliWaveContainer from StoreGate, key = " << key );
     
     for ( unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; ++ gain ) { // loop over gain in the current   LArCaliWAveContainer
       
       ATH_MSG_INFO( "Now processing gain = " << gain << " in LArCaliWaveContainer with key = " << key );
     
  
       // loop over current cali wave container
       typedef LArCaliWaveContainer::ConstConditionsMapIterator const_iterator;
       const_iterator itVec   = caliWaveContainer->begin(gain);
       const_iterator itVec_e = caliWaveContainer->end(gain);
       for (; itVec != itVec_e; ++itVec) { // loop over channels for a given gain
         
         for (const LArCaliWave& larCaliWave : *itVec) { // loop over DAC values for a given channel
  
           ATH_MSG_DEBUG((*itVec).size() << " LArCaliWaves found for channel " << m_onlineHelper->channel_name(itVec.channelId()) << " 0x" 
                << std::hex << itVec.channelId().get_identifier32().get_compact() << std::dec);
       const HWIdentifier chid = itVec.channelId();
           //
       // region and layer information are needed
       Identifier id;
       try {
             id = cabling->cnvToIdentifier(chid);
           } catch (LArID_Exception & execpt) {
         ATH_MSG_ERROR( "LArCabling exception caught for channel 0x" << MSG::hex << chid << MSG::dec 
             << ". Skipping channel." ) ;
             continue ;
       }
  
       int region = m_caloCellId->region(id);
           int layer  = m_caloCellId->sampling(id);
  
       if ( nchannel < 100 || ( nchannel < 1000 && nchannel%100==0 ) || nchannel%1000==0 ) 
          ATH_MSG_INFO( "Processing calibration waveform number " << nchannel );
  
           if(m_onlineHelper->isFCALchannel(chid)) {
              if(!m_isSC) continue; // Skip if it is FCAL ini standard readout
              LArPhysWave fcalw; 
              // we have only 3 FCAL phys waves, according a layer
              switch (layer) {
                 case 1: fcalw = fcalPhysWaves->get(HWIdentifier(0x3b300000),0); break;
                 case 2: fcalw = fcalPhysWaves->get(HWIdentifier(0x3b348000),0); break;
                 case 3: fcalw = fcalPhysWaves->get(HWIdentifier(0x3b368000),0); break;
                 default : ATH_MSG_ERROR("Wrong layer for FCAL SC: "<<layer<<" skipping channel 0x"<< MSG::hex << chid << MSG::dec); continue;
              }
                           
              larPhysWaveContainer->setPdata(chid,fcalw, gain);
              continue;
           } //isFCALchannel 
  
  
       if ( larCaliWave.getFlag() == LArWave::dac0 )  continue ; // skip dac0 waves          
       // TODO: here we should add a DAC selection mechanism for TCM method
  
           nTotal[gain]++; // counter of processed pulse per gain 
  
           ATH_MSG_VERBOSE("Predicting physics waveform for channel 0x" << MSG::hex << chid << MSG::dec 
               << " (gain = " << gain << " - DAC = " << larCaliWave.getDAC() << ")");
  
       // calibration pulse copy (working around the const iterator to be able to manipulate it...)
       LArCaliWave theLArCaliWave = larCaliWave;
           ++nchannel;
       
       if ( !cabling->isOnlineConnected(chid)  ) { // unconnected channel : skipping ...          
         ATH_MSG_VERBOSE("Unconnected channel 0x" << MSG::hex << chid << MSG::dec 
                 << ". Skipping channel.");
         continue ;    
       }
  
       // Get the parameters corresponding to current LArCaliWave
       float Tcali;
       float Fstep;
       float Omega0;
       float Taur;
       float Tdrift;
       int   Tdiff;
       
       // LArCaliPulseParams: if not fould, will use jobOptions values
       if ( !m_useJOCaliPulseParams ) {
              Tcali = larCaliPulseParams->Tcal(chid,gain) ;
  
          if ( Tcali <= 1.0+LArCaliPulseParamsComplete::ERRORCODE ) {
            notFoundMsg(chid,gain,"Tcali");
            Tcali = m_Tcali;
            noTcali[gain]++;
          }
          Fstep = larCaliPulseParams->Fstep(chid,gain) ;
          if ( Fstep <= 1.0+LArCaliPulseParamsComplete::ERRORCODE ) {
            notFoundMsg(chid,gain,"Fstep");
            Fstep = m_Fstep;
            noFstep[gain]++;
          }
           } else {
         Tcali = m_Tcali;
         Fstep = m_Fstep;
       }
       
       // LArDetCellParams: if not found, will not apply injection point correction
           if ( !m_useJODetCellParams ) {
          Omega0 = larDetCellParams->Omega0(chid,gain) ;
          if ( Omega0 <= 1.0+LArDetCellParamsComplete::ERRORCODE ) {
            notFoundMsg(chid,gain,"Omega0");
            Omega0 = m_Omega0;
            noOmega0[gain]++;
          }
          Taur = larDetCellParams->Taur(chid,gain) ;
          if ( Taur <= 1.0+LArDetCellParamsComplete::ERRORCODE ) {
            notFoundMsg(chid,gain,"Taur");
            Taur = m_Taur;
            noTaur[gain]++;
          }
       } else {
         Omega0 = m_Omega0;
         Taur   = m_Taur;
       }
       
           // LArTdrift: if not found will be set to jobOptions settings (or defaults if none) according to layer
       if ( !m_useJOTdrift ) {
         Tdrift = larTdrift->Tdrift(chid) ;
          if ( Tdrift <= 1.0+LArTdriftComplete::ERRORCODE ) {
            notFoundMsg(chid,gain,"Tdrift");
            //ATH_MSG_ERROR( "Cannot access Tdrift for channel 0x" << MSG::hex << chid << MSG::dec 
            //   << ". Will use jobOption setting." ) ;
         if ( layer>=0 && layer<4 ) 
           Tdrift = m_Tdrift[layer]; // Set drift time according to layer
         else 
           Tdrift = 475.;  // very crude! 
         noTdrift[gain]++;
          }
       } else { // use jobOptions settings
         if ( layer>=0 && layer<4 ) 
           Tdrift = m_Tdrift[layer]; // Set drift time according to layer
         else 
           Tdrift = 475.;  // very crude! 
       }
  
       
           // LArPhysCaliTdiff: if not found, will use jobOptions settings
       Tdiff = 0 ; // default value if everything else fails...
       if ( !m_useJOPhysCaliTdiff ) {
          Tdiff = (int)larPhysCaliTdiff->Tdiff(chid,gain) ;
          if ( Tdiff <= 1.0+LArPhysCaliTdiffComplete::ERRORCODE ) {
            notFoundMsg(chid,gain,"Tdiff");
             Tdiff = 0 ;
         m_useJOPhysCaliTdiff = true ;
         noTdiff[gain]++;
          }
           }
       if ( m_useJOPhysCaliTdiff ) {
         if ( m_timeShiftByHelper ) {
           Tdiff  = larWaveHelper.getStart(theLArCaliWave) ;
           Tdiff -= m_timeShiftGuardRegion ;
         }
         if ( m_timeShiftByIndex != 0 ) {
           Tdiff = m_timeShiftByIndex;
         }
         if ( m_timeShiftByLayer ) {
           Tdiff = m_TshiftLayer[layer] ;
         }
         if ( m_timeShiftByFEB && larFebTshift ) {
           const HWIdentifier febid = m_onlineHelper->feb_Id(chid);
           Tdiff  = (int)larFebTshift->TimeOffset(febid);
           Tdiff -= m_timeShiftGuardRegion ;
         }
           }
  
           // Fill the LArWFParams structure to be used by the LArPhysWaveTool
           float Tshaper  = 15. ;
       float Amplitude = 1. ;
           LArWFParams wfParams(Tcali,Fstep,Tdrift,Omega0,Taur,Tshaper,Amplitude);
           wfParams.setFlag( 0 ) ;  // this should contain the method used to find parameters and the gain
           wfParams.setTdiff(Tdiff);
           
       ATH_MSG_VERBOSE( "wfParams: " << Tcali << " " <<Fstep<<" " <<Tdrift<<" "<<Omega0<<" "<<Taur<<" "<<Tdiff<<" "<<layer<<" "<<region );
           // calibration pulse normalization 
       // (should be done here instead than in LArPhysWaveTool to get 
       // the correct Mphys/Mcali in case of double triangle prediction)
       if ( m_normalizeCali ) {
         double peak = theLArCaliWave.getSample(larWaveHelper.getMax(theLArCaliWave));
             ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << chid << MSG::dec << " -> Applying normalisation (CaliWave peak = " << peak << ")");
             if ( peak <=0 ) {
                ATH_MSG_WARNING( "Peak value <=0 , cannot normalize!" ) ;
             } else {
                theLArCaliWave = LArCaliWave( (theLArCaliWave*(1./peak)).getWave(),
                          theLArCaliWave.getErrors(),
                          theLArCaliWave.getTriggers(),
                          theLArCaliWave.getDt(), 
                          theLArCaliWave.getDAC(),
                          theLArCaliWave.getIsPulsedInt(),
                          theLArCaliWave.getFlag() );
             }
           } 
       
       //
       // Predict the Physics Waveform
       //      
       LArPhysWave larPhysWave;
       float MphysMcali ;    
       //if(larIdealPhysWaveContainer && m_caloCellId->is_lar_hec(id)) {
           // decide by online helper, not sure if offline is working for SC
       if(larIdealPhysWaveContainer && m_onlineHelper->isHECchannel(chid)) {
         const LArPhysWave& laridealPhysWave = larIdealPhysWaveContainer -> get(chid,gain);
         int LArWaveFlag=LArWave::predCali;    // 111 - for HEC Wave
         //int LArIdealPhysWaveFlag=LArWave::predCali;    // 111 - for HEC Wave
         ATH_MSG_DEBUG( "Using HEC tool to predict LArPhysWave for channel " <<  chid.get_identifier32().get_compact());
         
         sc = larPhysWaveHECTool->makeLArPhysWaveHEC(wfParams,theLArCaliWave,larPhysWave,laridealPhysWave,MphysMcali,chid,gain,LArWaveFlag);
         
         //laridealPhysWave.setFlag( LArIdealPhysWaveFlag ) ;
       }
       else {
         ATH_MSG_DEBUG( "Using EM tool to predict LArPhysWave for channel 0x" << chid.get_identifier32().get_compact() );
         sc = larPhysWaveTool->makeLArPhysWave(wfParams,theLArCaliWave,region,layer,larPhysWave,MphysMcali);
           }
       if (sc.isFailure()) {
         ATH_MSG_FATAL( "Cannot predict LArPhysWave for channel " << chid.get_identifier32().get_compact() );
         continue;
       }
       larPhysWave.setFlag( LArWave::predCali ) ;
  
       if ( m_doubleTriangle ) { // mix of Tdrift ...
         ATH_MSG_DEBUG("Applying double triangle correction");
         if ( region==0 && layer>=0 && layer<4 && m_wTriangle2[layer]>0 ) {  // EMB: set drift times and weight according to layer
           LArWFParams wfParams2 = wfParams ;
           wfParams2.setTdrift(m_Tdrift2[layer]);
           LArPhysWave larPhysWave2;
           float MphysMcali2 ;
           sc = larPhysWaveTool->makeLArPhysWave(wfParams2,theLArCaliWave,region,layer,larPhysWave2,MphysMcali2);
           if (sc.isFailure()) {
                 ATH_MSG_FATAL( "Cannot predict LArPhysWave for channel 0x" << MSG::hex << chid << MSG::dec << "with double triangle."  );
                 continue;
           }
           larPhysWave = LArPhysWave ( ( larPhysWave*(1.-m_wTriangle2[layer])+larPhysWave2*m_wTriangle2[layer] ).getWave() ,
                                 larPhysWave.getDt(), 
                                 larPhysWave.getFlag() ) ;
           // Double-triagle predicion was used, Mphys/Mcali should be recomputed... 
           MphysMcali = larPhysWave.getSample(larWaveHelper.getMax(larPhysWave))/theLArCaliWave.getSample(larWaveHelper.getMax(theLArCaliWave));
         } else {
           ATH_MSG_WARNING( "Double triangle implemented only for EMB, skip channel!" ) ;
         }
       } // end if 2nd triangle
           
       // Apply time shift...
       if ( Tdiff !=0 ) {
         ATH_MSG_DEBUG("Time shift for channel " << (itVec.channelId()).get_compact() << " is " 
               << Tdiff << " samples (" << Tdiff*larPhysWave.getDt() << " ns)");
         larPhysWave = LArPhysWave( (larWaveHelper.translate(larPhysWave,-Tdiff,0)).getWave() ,
                                        larPhysWave.getDt(), 
                        larPhysWave.getFlag() ) ;
       }
           
       // Add predicted physics wave to container
           larPhysWaveContainer->setPdata(chid,larPhysWave,gain);
           NPhysWave++; 
  
       // Add Mphys/Mcali to container
       if (MphysMcali<=0.) {
          MphysMcali = LArMphysOverMcalComplete::ERRORCODE ;
       }
       ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << chid << MSG::dec << " -> Mphys/Mcali = " << MphysMcali);
       MphysOverMcalComplete->set(chid,gain,MphysMcali);
       NMPMC++;
       if ( m_dumpMphysMcali ) { 
          int eta = m_caloCellId->eta(id);
          int phi = m_caloCellId->phi(id);
          fprintf( f , "%2d %2d %3d %3d  %2u %8.3f \n", region, layer, eta, phi, gain, MphysMcali ) ;
       } //end if m_dumpMphysMcal
       
         } // end loop over DAC value for a given cell
     if ( m_testmode && nchannel>=1 ) break;
       }  // end loop over cells for a given gain
       if ( m_testmode && nchannel>=1 ) break;
     } // end loop over gains for a give container
     if ( m_testmode && nchannel>=1 ) break;
   }  // End loop over all CaliWave containers
  
   //ATH_MSG_INFO( " Summary : Number of cells with a PhysWave values computed : " << larPhysWaveContainer->totalNumberOfConditions()  );
   //ATH_MSG_INFO( " Summary : Number of cells with a MphysOverMcal values computed : " << MphysOverMcalComplete->totalNumberOfConditions()  );
   ATH_MSG_INFO( " Summary : Number of cells with a PhysWave values computed : " << NPhysWave  );
   ATH_MSG_INFO( " Summary : Number of cells with a MphysOverMcal values computed : " << NMPMC  );
   ATH_MSG_INFO( " Summary : Number of Barrel PS cells side A or C (connected+unconnected):  3904+ 192 " );
   ATH_MSG_INFO( " Summary : Number of Barrel    cells side A or C (connected+unconnected): 50944+2304 " );
   ATH_MSG_INFO( " Summary : Number of EMEC      cells side A or C (connected+unconnected): 31872+3456 " );
   ATH_MSG_INFO( " Summary : Number of HEC       cells side A or C (connected+unconnected):  2816+ 256 " );
   ATH_MSG_INFO( " Summary : Number of FCAL      cells side A or C (connected+unconnected):  1762+  30 " );
  
   ATH_MSG_DEBUG("LArPhysWaveContainer->totalNumberOfConditions()     = " <<  larPhysWaveContainer->totalNumberOfConditions());
   ATH_MSG_DEBUG("LArMphysOverMcalComplete->totalNumberOfConditions() = " <<  MphysOverMcalComplete->totalNumberOfConditions());
  
   // final report
  ATH_MSG_INFO( "\n Final report \n" );
   for ( unsigned theGain = CaloGain::LARHIGHGAIN ; theGain < CaloGain::LARNGAIN ; ++theGain ) { 
  
     ATH_MSG_INFO( " *** Gain = " << theGain << " ***" );
     if ( !m_useJOCaliPulseParams ) {
        ATH_MSG_INFO( "\t" << noTcali[theGain]  << " / " << nTotal[theGain] << " channel(s) missing Tcali"  );
        ATH_MSG_INFO( "\t" << noFstep[theGain]  << " / " << nTotal[theGain] << " channel(s) missing Fstep"  );
     }
     if ( !m_useJODetCellParams ) {  
        ATH_MSG_INFO( "\t" << noOmega0[theGain] << " / " << nTotal[theGain] << " channel(s) missing Omega0"  );
        ATH_MSG_INFO( "\t" << noTaur[theGain]   << " / " << nTotal[theGain] << " channel(s) missing Taur"    );
     }
     if ( !m_useJOTdrift )
        ATH_MSG_INFO( "\t" << noTdrift[theGain] << " / " << nTotal[theGain] << " channel(s) missing Tdrift" );
     if ( !m_useJOPhysCaliTdiff )
        ATH_MSG_INFO( "\t" << noTdiff[theGain]  << " / " << nTotal[theGain] << " channel(s) missing Tdiff"  );       
   }
   ATH_MSG_INFO( "\n" );
  
   // Record LArPhysWaveContainer to DetectorStore
   sc = detStore()->record(std::move(larPhysWaveContainer),m_keyPhys);
   if (sc.isFailure()) {
     ATH_MSG_FATAL( "Cannot record LArPhysWaveContainer to StoreGate! key=" << m_keyPhys );
     return StatusCode::FAILURE;
   }
  
   // Record LArMphysOverMcalComplete to DetectorStore
   sc = detStore()->record(std::move(MphysOverMcalComplete),m_keyMphysMcali); 
   if (sc.isFailure()) {
     ATH_MSG_FATAL( "Cannot record LArMphysOverMcalComplete to StoreGate! key=" << m_keyMphysMcali );
     return StatusCode::FAILURE;
   }
   
   // Symlink LArMphysOverMcalComplete to ILArMphysOverMcal for further use
   ATH_MSG_DEBUG("Trying to symlink ILArMphysOverMcal with LArMphysOverMcalComplete...");
   sc = detStore()->symLink(ClassID_traits<LArMphysOverMcalComplete>::ID(),m_keyMphysMcali,ClassID_traits<ILArMphysOverMcal>::ID());
   if (sc.isFailure()) {
       ATH_MSG_FATAL( "Could not symlink ILArMphysOverMcal with LArMphysOverMcalComplete." );
       return StatusCode::FAILURE;
   } 
   ATH_MSG_INFO( "ILArMphysOverMcal symlink with LArMphysOverMcalComplete successfully" ) ;
   
   ATH_MSG_INFO( "LArPhysWavePredictor finalized!" );  
   
   return StatusCode::SUCCESS;
 }

◆ 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, PyAthena::Alg, and AthHistogramAlgorithm.

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_BCKey

SG::ReadCondHandleKey<LArBadChannelCont> LArPhysWavePredictor::m_BCKey {this, "BadChanKey", "LArBadChannel", "SG key for LArBadChan object"}

private

Definition at line 40 of file LArPhysWavePredictor.h.

◆ m_bcMask

LArBadChannelMask LArPhysWavePredictor::m_bcMask

private

Definition at line 44 of file LArPhysWavePredictor.h.

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArPhysWavePredictor::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}

private

Definition at line 41 of file LArPhysWavePredictor.h.

◆ m_cablingKeySC

SG::ReadCondHandleKey<LArOnOffIdMapping> LArPhysWavePredictor::m_cablingKeySC {this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"}

private

Definition at line 42 of file LArPhysWavePredictor.h.

◆ m_caloCellId

const CaloCell_Base_ID* LArPhysWavePredictor::m_caloCellId =nullptr

private

Definition at line 49 of file LArPhysWavePredictor.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_doubleTriangle

bool LArPhysWavePredictor::m_doubleTriangle

private

Definition at line 76 of file LArPhysWavePredictor.h.

◆ m_dumpMphysMcali

bool LArPhysWavePredictor::m_dumpMphysMcali

private

Definition at line 52 of file LArPhysWavePredictor.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_Fstep

double LArPhysWavePredictor::m_Fstep

private

Definition at line 66 of file LArPhysWavePredictor.h.

◆ m_groupingType

std::string LArPhysWavePredictor::m_groupingType

private

Definition at line 62 of file LArPhysWavePredictor.h.

◆ m_isHEC

bool LArPhysWavePredictor::m_isHEC

private

Definition at line 72 of file LArPhysWavePredictor.h.

◆ m_isSC

bool LArPhysWavePredictor::m_isSC

private

Definition at line 54 of file LArPhysWavePredictor.h.

◆ m_keyCali

std::vector<std::string> LArPhysWavePredictor::m_keyCali

private

Definition at line 56 of file LArPhysWavePredictor.h.

◆ m_keyFcal

std::string LArPhysWavePredictor::m_keyFcal

private

Definition at line 60 of file LArPhysWavePredictor.h.

◆ m_keyIdealPhys

std::string LArPhysWavePredictor::m_keyIdealPhys

private

Definition at line 59 of file LArPhysWavePredictor.h.

◆ m_keyMphysMcali

std::string LArPhysWavePredictor::m_keyMphysMcali

private

Definition at line 58 of file LArPhysWavePredictor.h.

◆ m_keyPhys

std::string LArPhysWavePredictor::m_keyPhys

private

Definition at line 57 of file LArPhysWavePredictor.h.

◆ m_normalizeCali

bool LArPhysWavePredictor::m_normalizeCali

private

Definition at line 53 of file LArPhysWavePredictor.h.

◆ m_Omega0

double LArPhysWavePredictor::m_Omega0

private

Definition at line 69 of file LArPhysWavePredictor.h.

◆ m_onlineHelper

const LArOnlineID_Base* LArPhysWavePredictor::m_onlineHelper =nullptr

private

Definition at line 48 of file LArPhysWavePredictor.h.

◆ m_problemsToMask

Gaudi::Property<std::vector<std::string> > LArPhysWavePredictor::m_problemsToMask {this,"ProblemsToMask",{}, "Bad-Channel categories to mask"}

private

Definition at line 45 of file LArPhysWavePredictor.h.

◆ m_storeEmpty

bool LArPhysWavePredictor::m_storeEmpty

private

Definition at line 51 of file LArPhysWavePredictor.h.

◆ m_Taur

double LArPhysWavePredictor::m_Taur

private

Definition at line 70 of file LArPhysWavePredictor.h.

◆ m_Tcali

double LArPhysWavePredictor::m_Tcali

private

Definition at line 65 of file LArPhysWavePredictor.h.

◆ m_Tdrift

std::vector<double> LArPhysWavePredictor::m_Tdrift

private

Definition at line 75 of file LArPhysWavePredictor.h.

◆ m_Tdrift2

std::vector<double> LArPhysWavePredictor::m_Tdrift2

private

Definition at line 77 of file LArPhysWavePredictor.h.

◆ m_testmode

bool LArPhysWavePredictor::m_testmode

private

Definition at line 50 of file LArPhysWavePredictor.h.

◆ m_timeShiftByFEB

bool LArPhysWavePredictor::m_timeShiftByFEB

private

Definition at line 85 of file LArPhysWavePredictor.h.

◆ m_timeShiftByHelper

bool LArPhysWavePredictor::m_timeShiftByHelper

private

Definition at line 82 of file LArPhysWavePredictor.h.

◆ m_timeShiftByIndex

int LArPhysWavePredictor::m_timeShiftByIndex

private

Definition at line 81 of file LArPhysWavePredictor.h.

◆ m_timeShiftByLayer

bool LArPhysWavePredictor::m_timeShiftByLayer

private

Definition at line 83 of file LArPhysWavePredictor.h.

◆ m_timeShiftGuardRegion

int LArPhysWavePredictor::m_timeShiftGuardRegion

private

Definition at line 86 of file LArPhysWavePredictor.h.

◆ m_TshiftLayer

std::vector<unsigned int> LArPhysWavePredictor::m_TshiftLayer

private

Definition at line 84 of file LArPhysWavePredictor.h.

◆ m_useJOCaliPulseParams

bool LArPhysWavePredictor::m_useJOCaliPulseParams

private

Definition at line 64 of file LArPhysWavePredictor.h.

◆ m_useJODetCellParams

bool LArPhysWavePredictor::m_useJODetCellParams

private

Definition at line 68 of file LArPhysWavePredictor.h.

◆ m_useJOPhysCaliTdiff

bool LArPhysWavePredictor::m_useJOPhysCaliTdiff

private

Definition at line 80 of file LArPhysWavePredictor.h.

◆ m_useJOTdrift

bool LArPhysWavePredictor::m_useJOTdrift

private

Definition at line 74 of file LArPhysWavePredictor.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.

◆ m_wTriangle2

std::vector<double> LArPhysWavePredictor::m_wTriangle2

private

Definition at line 78 of file LArPhysWavePredictor.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ LArPhysWavePredictor()

◆ ~LArPhysWavePredictor()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ notFoundMsg()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ stop()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_BCKey

◆ m_bcMask

◆ m_cablingKey

◆ m_cablingKeySC

◆ m_caloCellId

◆ m_detStore

◆ m_doubleTriangle

◆ m_dumpMphysMcali

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_Fstep

◆ m_groupingType

◆ m_isHEC

◆ m_isSC

◆ m_keyCali

◆ m_keyFcal

◆ m_keyIdealPhys

◆ m_keyMphysMcali

◆ m_keyPhys

◆ m_normalizeCali

◆ m_Omega0

◆ m_onlineHelper

◆ m_problemsToMask

◆ m_storeEmpty

◆ m_Taur

◆ m_Tcali

◆ m_Tdrift

◆ m_Tdrift2

◆ m_testmode

◆ m_timeShiftByFEB

◆ m_timeShiftByHelper

◆ m_timeShiftByIndex

◆ m_timeShiftByLayer

◆ m_timeShiftGuardRegion

◆ m_TshiftLayer

◆ m_useJOCaliPulseParams

◆ m_useJODetCellParams