LArOFCAlg Class Reference

#include <LArOFCAlg.h>

Inheritance diagram for LArOFCAlg:

Classes
class	Looper
struct	perChannelData_t

Public Member Functions
	LArOFCAlg (const std::string &name, ISvcLocator *pSvcLocator)
StatusCode	initialize ()
StatusCode	execute ()
virtual StatusCode	stop ()
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 ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	process (perChannelData_t &, const LArOnOffIdMapping *cabling) const
bool	verify (const HWIdentifier chid, const std::vector< float > &OFCa, const std::vector< float > &OFCb, const std::vector< float > &Shape, const char *ofcversion, const unsigned phase) const
StatusCode	initPhysWaveContainer (const LArOnOffIdMapping *cabling)
StatusCode	initCaliWaveContainer ()
Eigen::VectorXd	getDelta (std::vector< float > &samples, const HWIdentifier chid, unsigned nSamples) const
bool	useDelta (const HWIdentifier chid, const int jobOFlag, const LArOnOffIdMapping *cabling) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static void	optFilt (const std::vector< float > &gWave_in, const std::vector< float > &gDerivWave_in, const Eigen::MatrixXd &autoCorrInv, std::vector< float > &OFCa, std::vector< float > &OFCb)
static void	optFiltDelta (const std::vector< float > &gWave_in, const std::vector< float > &gDerivWave_in, const Eigen::MatrixXd &autoCorrInv, const Eigen::VectorXd &delta, std::vector< float > &vecOFCa, std::vector< float > &vecOFCb)
static void	optFiltPed (const std::vector< float > &gWave_in, const std::vector< float > &gDerivWave_in, const Eigen::MatrixXd &autoCorrInv, std::vector< float > &OFCa, std::vector< float > &OFCb)
static void	printOFCVec (const std::vector< float > &vec, MsgStream &mLog)

Private Attributes
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"}
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager >	m_caloSuperCellMgrKey
std::vector< perChannelData_t >	m_allChannelData
unsigned int	m_nPoints {0}
StringProperty	m_dumpOFCfile {this, "DumpOFCfile", ""}
StringArrayProperty	m_keylist {this, "KeyList", {}, "List of keys to process"}
BooleanProperty	m_verify {this, "Verify", true, "Verufy OFCs after computation"}
BooleanProperty	m_normalize {this, "Normalize", false, "Normalize input wave"}
BooleanProperty	m_timeShift {this, "TimeShift", false, "Shifting input wave"}
IntegerProperty	m_timeShiftByIndex {this, "TimeShiftByIndex", -1, "shifting by n bins input wave"}
LArCaliWaveContainer *	m_waveCnt_nc =nullptr
UnsignedIntegerProperty	m_nSamples {this, "Nsample", 5, "How many sample to compute"}
UnsignedIntegerProperty	m_nPhases {this, "Nphase", 50, "How many sphases to compute"}
UnsignedIntegerProperty	m_dPhases {this, "Dphase", 1, "Number of samples between two neighboring phases (OFC sets)"}
UnsignedIntegerProperty	m_nDelays {this, "Ndelay", 24, "Number of delays in one clock"}
FloatProperty	m_addOffset {this, "AddTimeOffset", 0., "Time offset to add"}
ToolHandle< ILArAutoCorrDecoderTool >	m_AutoCorrDecoder {this,"DecoderTool",{} }
ToolHandle< ILArAutoCorrDecoderTool >	m_AutoCorrDecoderV2 {this,"DecoderToolV2", {} }
const CaloDetDescrManager_Base *	m_calo_dd_man {}
const LArOnlineID_Base *	m_onlineID {}
const LArOFCBinComplete *	m_larPhysWaveBin {}
DoubleProperty	m_errAmpl {this, "ErrAmplitude", 0.01, "Allowed amplitude difference in check"}
DoubleProperty	m_errTime {this, "ErrTime", 0.01, "Allowed time difference in check"}
BooleanProperty	m_readCaliWave {this, "ReadCaliWave", true, "If false PhysWave is input"}
BooleanProperty	m_fillShape {this, "FillShape", false, "Fill also shape object"}
StringProperty	m_ofcKey {this, "KeyOFC", "LArOFC", "Output key non-pileup OFCs"}
StringProperty	m_ofcKeyV2 {this, "KeyOFCV2", "LArOFCV2", "Output key pileup OFCs"}
StringProperty	m_shapeKey {this, "KeyShape", "LArShape", "Output key Shape object"}
BooleanProperty	m_storeMaxPhase {this,"StoreMaxPhase", false, "Store phase of input wave max.?"}
StringProperty	m_ofcBinKey {this, "LArOFCBinKey", "LArOFCPhase","Key for storing OFCBin object for MAx phase"}
StringProperty	m_groupingType {this, "GroupingType", "SubDetector","Which grouping type to use"}
StringProperty	m_larPhysWaveBinKey {this,"LArPhysWaveBinKey", "", "Key for object to choose bin"}
IntegerProperty	m_useDelta {this, "UseDelta", 0, "0= not use Delta, 1=only EMECIW/HEC/FCAL, 2=all , 3 = only EMECIW/HEC/FCAL1+high eta FCAL2-3"}
IntegerProperty	m_useDeltaV2 {this, "UseDeltaV2", 0, "Same af before for Delta"}
BooleanProperty	m_computeV2 {this, "ComputeOFCV2", false, "Compute pileup OFCs?"}
BooleanProperty	m_computePed {this, "ComputeOFCPed", false, "Compute OFCs with additional constraint to pedestal?"}
IntegerProperty	m_nThreads {this, "nThreads", -1, "-1: No TBB, 0: Let TBB decide, >0 number of threads"}
BooleanProperty	m_readDSPConfig {this, "ReadDSPConfig", false, "Read DSPConfig object ?"}
StringProperty	m_DSPConfigFolder {this,"DSPConfigFolder","/LAR/Configuration/DSPConfiguration", "Folder for DSPConfig object"}
std::unique_ptr< LArDSPConfig >	m_DSPConfig
BooleanProperty	m_forceShift {this, "ForceShift", false, "Forcing shift of input wave ?"}
BooleanProperty	m_isSC {this, "isSC", false, "Running on cells or supercells?"}
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

Static Private Attributes
static const float	m_fcal3Delta [5] ={0.0790199937765, 0.0952000226825, 0.0790199937765, 0.0952000226825, 0.0790199937765}
static const float	m_fcal2Delta [5] ={-0.01589001104, -0.0740399733186, -0.01589001104, -0.0740399733186, -0.01589001104}
static const float	m_fcal1Delta [5] ={0.0679600232979, -0.139479996869, 0.0679600232979, -0.139479996869, 0.0679600232979}

Detailed Description

Definition at line 39 of file LArOFCAlg.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

LArOFCAlg()

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

Definition at line 40 of file LArOFCAlg.cxx.

    : AthAlgorithm(name, pSvcLocator)
{}

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 LArOFCAlg::execute ( )

inline

Definition at line 46 of file LArOFCAlg.h.

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

inline

Definition at line 48 of file LArOFCAlg.h.

{return StatusCode::SUCCESS;}

getDelta()

Eigen::VectorXd LArOFCAlg::getDelta ( std::vector< float > & samples, const HWIdentifier chid, unsigned nSamples ) const

private

Definition at line 853 of file LArOFCAlg.cxx.

                                                                                                            {
 
  if (nSamples>5) nSamples=5;
 
  Eigen::VectorXd delta(nSamples); //return value
 
  if (m_onlineID->isFCALchannel(chid) ){
    // FCAL use fixed delta from data. 
    const int slot = m_onlineID->slot(chid) ; 
    if ( slot <=9){ // FCAL 1
      for (unsigned i=0;i<nSamples;++i) {
    delta[i]=m_fcal1Delta[i];
      }
    }else
      if(slot <=13){ // FCAL 2
    for (unsigned i=0;i<nSamples;++i) {
      delta[i]=m_fcal2Delta[i];
    }
      }else {  //FCAL 3 
    for (unsigned i=0;i<nSamples;++i) {
      delta[i]=m_fcal3Delta[i];
    }
      }
 
  }else
    { // from Shape 
      float odd = 0.;
      float even = 0.;
      for (unsigned int i = 0;i<samples.size();++i) {
      if (i%2==0){
        even  += samples[i];
      }
      else {
        odd += samples[i];
      }
    }
 
      for (unsigned i=0;i<nSamples;++i) {
    if (i%2==0)
      delta[i]=even;
    else
      delta[i]=odd;
      }
    }
 
  return delta;
 
}

initCaliWaveContainer()

StatusCode LArOFCAlg::initCaliWaveContainer ( )

private

Definition at line 623 of file LArOFCAlg.cxx.

                                            {
 
  typedef LArCaliWaveContainer::ConstConditionsMapIterator WAVEIT;
  for (unsigned k=0 ; k<m_keylist.size() ; k++ ) { // Loop over all containers that are to be processed (e.g. different gains)
    ATH_MSG_INFO( "Processing WaveContainer from StoreGate! key = " << m_keylist[k] );
 
    //Input cali-wave might come from the same job. In this case we see a non-const container in SG probably w/o corrections applied.
    //Try non-const retrieve:
    const LArCaliWaveContainer* waveCnt = nullptr;
    m_waveCnt_nc=detStore()->tryRetrieve<LArCaliWaveContainer>(m_keylist[k]);
    if (m_waveCnt_nc) {
      waveCnt=m_waveCnt_nc; //Retain const pointer
      if (!m_waveCnt_nc->correctionsApplied()) {
    ATH_MSG_INFO( "LArCaliWaveContainer: Corrections not yet applied, applying them now..." );
    if (m_waveCnt_nc->applyCorrections().isFailure()) {
      ATH_MSG_ERROR( "Failed to apply corrections to LArCaliWaveContainer!" );
      return StatusCode::FAILURE;
    }
    else {
      ATH_MSG_INFO("Applied corrections to non-const Wave container");
    }
      }
    }
    else {
      waveCnt=detStore()->tryConstRetrieve<LArCaliWaveContainer>(m_keylist[k]);
      if (!waveCnt) {
    ATH_MSG_ERROR( "Failed to retrieve a LArCaliWaveContainer with key " << m_keylist[k] );
    return  StatusCode::FAILURE;
      }
    }   
   
 
    m_allChannelData.reserve(std::max(m_allChannelData.size()*3/2,m_allChannelData.size()+128*waveCnt->size()));// Size doesn't give the expected response on a ConditionsContainer
 
    for (unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; gain++ ) { // loop on possible gains
      WAVEIT it=waveCnt->begin(gain);
      WAVEIT it_e=waveCnt->end(gain);
      for (;it!=it_e;++it) {
    const LArCaliWaveVec& wVec=*it;
    for (const auto& cw : wVec) {
      const LArWaveCumul* wave= &(cw); //down-cast
      if (!wave->isEmpty()) {
        m_allChannelData.emplace_back(wave,it.channelId(),gain);
      }
    }
      } //end loop over channels
    }//end loop over gains
  }//end loop over SG keys
  return StatusCode::SUCCESS;
}

initialize()

StatusCode LArOFCAlg::initialize

(

)

Definition at line 46 of file LArOFCAlg.cxx.

                                {
 
  m_nPoints = m_nDelays * ( m_nSamples-1 ) + m_nPhases * m_dPhases ;
 
  if ( m_nSamples>32 ) {
    ATH_MSG_ERROR( "You are not allowed to compute OFC for Nsamples = " << m_nSamples ) ;
    return  StatusCode::FAILURE;
  } 
 
  StatusCode sc = m_AutoCorrDecoder.retrieve();
  if (sc.isFailure()) {
        ATH_MSG_FATAL( "Could not retrieve AutoCorrDecoder " << m_AutoCorrDecoder );
        return StatusCode::FAILURE;
  } else {
     ATH_MSG_INFO( "Retrieved Decoder Tool: "<< m_AutoCorrDecoder );
  }
 
 
  if (m_computeV2) {
    sc = m_AutoCorrDecoderV2.retrieve();
    if (sc.isFailure()) {
      ATH_MSG_FATAL( "Could not retrieve AutoCorrDecoderV2 " << m_AutoCorrDecoderV2 );
      return StatusCode::FAILURE;
    } else {
      ATH_MSG_INFO( "Retrieved Decoder Tool: "<< m_AutoCorrDecoderV2 );
    }
  }
 
  if ( m_isSC ) {
    const LArOnline_SuperCellID* ll;
    sc = detStore()->retrieve(ll, "LArOnline_SuperCellID");
    if (sc.isFailure()) {
      msg(MSG::ERROR) << "Could not get LArOnlineID helper !" << endmsg;
      return StatusCode::FAILURE;
    }
    else {
      m_onlineID = static_cast<const LArOnlineID_Base*>(ll);
      ATH_MSG_DEBUG("Found the LArOnlineID helper");
    }
  } else { // m_isSC
    const LArOnlineID* ll;
    sc = detStore()->retrieve(ll, "LArOnlineID");
    if (sc.isFailure()) {
      msg(MSG::ERROR) << "Could not get LArOnlineID helper !" << endmsg;
      return StatusCode::FAILURE;
    }
    else {
      m_onlineID = static_cast<const LArOnlineID_Base*>(ll);
      ATH_MSG_DEBUG(" Found the LArOnlineID helper. ");
    }
  }
  
  ATH_CHECK( m_cablingKeySC.initialize(m_isSC) );
  ATH_CHECK( m_caloSuperCellMgrKey.initialize(m_isSC) );
  ATH_CHECK( m_cablingKey.initialize(!m_isSC) );
  ATH_CHECK( m_caloMgrKey.initialize(!m_isSC) );
 
  ATH_MSG_INFO( "Number of wave points needed : " << m_nPoints  ) ;
  if (m_computeV2) {
    ATH_MSG_INFO( "Will compute two flavors of OFCs" );
    ATH_MSG_INFO( "Version 1: useDelta= " << m_useDelta <<", output key: " <<  m_ofcKey << " AutoCorrDecoder: " << m_AutoCorrDecoder.name() );
    ATH_MSG_INFO( "Version 2: useDelta= " << m_useDeltaV2 <<", output key: " <<  m_ofcKeyV2 << " AutoCorrDecoder: " << m_AutoCorrDecoderV2.name() );
  }
  return StatusCode::SUCCESS;
}

initPhysWaveContainer()

StatusCode LArOFCAlg::initPhysWaveContainer ( const LArOnOffIdMapping * cabling )

private

Definition at line 589 of file LArOFCAlg.cxx.

                                                                            {
 
  typedef LArPhysWaveContainer::ConstConditionsMapIterator WAVEIT;
 
  for (unsigned k=0 ; k<m_keylist.size() ; k++ ) { // Loop over all containers that are to be processed (e.g. different gains)
    ATH_MSG_INFO( "Processing WaveContainer from StoreGate! key = " << m_keylist[k] );
 
    const LArPhysWaveContainer* waveCnt;
    StatusCode sc=detStore()->retrieve(waveCnt,m_keylist[k]);
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Failed to retrieve a LArPhysWaveContainer with key " << m_keylist[k] );
      return sc;
    }
      
    m_allChannelData.reserve(std::max(m_allChannelData.size()*3/2,m_allChannelData.size()+128*waveCnt->size()));// Size doesn't give the expected response on a ConditionsContainer
 
    for (unsigned gain = CaloGain::LARHIGHGAIN ; gain < CaloGain::LARNGAIN ; gain++ ) { // loop on possible gains
      WAVEIT it=waveCnt->begin(gain);
      WAVEIT it_e=waveCnt->end(gain);
      for (;it!=it_e;++it) {
    const HWIdentifier chid=it.channelId();
    if (cabling->isOnlineConnected (chid)){
      const LArWaveCumul* wave= &(*it); //down-cast
      if (!wave->isEmpty()) {
        m_allChannelData.emplace_back(wave, chid,gain);
      }
    }
      } //end loop over channels
    }//end loop over gains
  }//end loop over SG keys
  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);
  }

optFilt()

void LArOFCAlg::optFilt ( const std::vector< float > & gWave_in, const std::vector< float > & gDerivWave_in, const Eigen::MatrixXd & autoCorrInv, std::vector< float > & OFCa, std::vector< float > & OFCb )

staticprivate

Definition at line 675 of file LArOFCAlg.cxx.

                                                                   { // Output variables;
  assert(gWave.size()==gDerivWave.size());
  //assert autoCorr size ....
  const int optNpt = gWave.size();
  
  Eigen::VectorXd gResp(optNpt), gDerivResp(optNpt);
  for (int i=0;i<optNpt;i++) {
    gResp[i] = gWave[i];
    gDerivResp[i] = gDerivWave[i];
  }
 
  Eigen::Matrix2d isol;
  isol << 
    (gResp.transpose()*acInverse*gResp)[0],
    (gResp.transpose()*acInverse*gDerivResp)[0],
    (gDerivResp.transpose()*acInverse*gResp)[0],
    (gDerivResp.transpose()*acInverse*gDerivResp)[0];
 
  Eigen::Vector2d Amp; 
  Eigen::Vector2d Atau;
  Eigen::Vector2d Ktemp;
  Eigen::Matrix2d isolInv = isol.inverse();
 
  //  we solve for the lagrange multiplers
  Ktemp[0] = 1.;
  Ktemp[1] = 0.;
  Amp = isolInv*Ktemp;
  
  Ktemp[0] = 0.; 
  Ktemp[1] = -1.;
  Atau = isolInv*Ktemp;
 
  // we express the a and b vectors in terms of the lagrange multipliers
  Eigen::VectorXd OFCa = Amp[0]*acInverse*gResp + Amp[1]*acInverse*gDerivResp;
  Eigen::VectorXd OFCb = Atau[0]*acInverse*gResp + Atau[1]*acInverse*gDerivResp;
  
  //Convert back to std::vector
  vecOFCa.resize(optNpt);
  vecOFCb.resize(optNpt);
  for (int i=0;i<optNpt;i++) {
    vecOFCa[i]=OFCa[i];
    vecOFCb[i]=OFCb[i];
  }
  }

optFiltDelta()

void LArOFCAlg::optFiltDelta ( const std::vector< float > & gWave_in, const std::vector< float > & gDerivWave_in, const Eigen::MatrixXd & autoCorrInv, const Eigen::VectorXd & delta, std::vector< float > & vecOFCa, std::vector< float > & vecOFCb )

staticprivate

HepVector delta(5) ;

delta[0]=3.79198742146; delta[1]=-4.84165741965; delta[2]=3.20189843985; delta[3]=-5.90850592618; delta[4]=1.8260451328;

Definition at line 773 of file LArOFCAlg.cxx.

                                                                        { 
 
  
 
  assert(gWave.size()==gDerivWave.size());
  //assert autoCorr size ....
  const int optNpt = gWave.size();
  
  Eigen::VectorXd gResp(optNpt), gDerivResp(optNpt);
  for (int i=0;i<optNpt;i++) {
    gResp[i] = gWave[i];
    gDerivResp[i] = gDerivWave[i];
  }
 
  // try 3X3 matrix with offsets
 
  
  Eigen::Matrix3d isol;
  isol << 
    (gResp.transpose()*acInverse*gResp)[0],
    (gResp.transpose()*acInverse*gDerivResp),
    (gResp.transpose()*acInverse*delta)[0],
    
    (gDerivResp.transpose()*acInverse*gResp)[0],
    (gDerivResp.transpose()*acInverse*gDerivResp)[0],
    (gDerivResp.transpose()*acInverse*delta)[0],
    
    (delta.transpose()*acInverse*gResp)[0],
    (delta.transpose()*acInverse*gDerivResp)[0],
    (delta.transpose()*acInverse*delta)[0];
  
 
  Eigen::Vector3d Amp; 
  Eigen::Vector3d Atau;
  Eigen::Vector3d Ktemp;
  Eigen::Matrix3d isolInv = isol.inverse();
 
  //  we solve for the lagrange multiplers
 
  Ktemp[0] = 1.;
  Ktemp[1] = 0.;
  Ktemp[2] = 0.;
 
  Amp = isolInv*Ktemp;
    
  Ktemp[0] = 0.; 
  Ktemp[1] = -1.;
  Atau = isolInv*Ktemp;
 
  // we express the a and b vectors in terms of the lagrange multipliers
  Eigen::VectorXd OFCa = Amp[0]*acInverse*gResp + Amp[1]*acInverse*gDerivResp + Amp[2]*acInverse * delta;
  Eigen::VectorXd OFCb = Atau[0]*acInverse*gResp + Atau[1]*acInverse*gDerivResp + Atau[2]*acInverse * delta  ;
 
 
  //Convert back to std::vector
  vecOFCa.resize(optNpt);
  vecOFCb.resize(optNpt);
  for (int i=0;i<optNpt;i++) {
    vecOFCa[i]=OFCa[i];
    vecOFCb[i]=OFCb[i];
  }
  }

optFiltPed()

void LArOFCAlg::optFiltPed ( const std::vector< float > & gWave_in, const std::vector< float > & gDerivWave_in, const Eigen::MatrixXd & autoCorrInv, std::vector< float > & OFCa, std::vector< float > & OFCb )

staticprivate

Definition at line 721 of file LArOFCAlg.cxx.

                                                                   { // Output variables;
  assert(gWave.size()==gDerivWave.size());
  //assert autoCorr size ....
  const int optNpt = gWave.size();
  
  Eigen::VectorXd gResp(optNpt), gDerivResp(optNpt);
  for (int i=0;i<optNpt;i++) {
    gResp[i] = gWave[i];
    gDerivResp[i] = gDerivWave[i];
  }
 
  Eigen::Matrix3d isol;
  Eigen::Vector3d Kunit(1.,1.,1.);
  auto s3=(gDerivResp.transpose()*acInverse*gResp)[0];
  auto s4=(gResp.transpose()*acInverse*Kunit)[0];
  auto s5=(gDerivResp.transpose()*acInverse*Kunit)[0];
  isol << 
    (gResp.transpose()*acInverse*gResp)[0], s3, s4,
    s3, (gDerivResp.transpose()*acInverse*gResp)[0], s5,
    s4, s5, (Kunit.transpose()*acInverse*Kunit)[0];
 
  Eigen::Vector3d Amp; 
  Eigen::Vector3d Atau;
  Eigen::Vector3d Ktemp;
  Eigen::Matrix3d isolInv = isol.inverse();
 
  //  we solve for the lagrange multiplers
  Ktemp[0] = 1.;
  Ktemp[1] = 0.;
  Ktemp[2] = 0.;
  Amp = isolInv*Ktemp;
  
  Ktemp[0] = 0.; 
  Ktemp[1] = -1.;
  Ktemp[2] = 0.;
  Atau = isolInv*Ktemp;
 
  // we express the a and b vectors in terms of the lagrange multipliers
  Eigen::VectorXd OFCa = Amp[0]*acInverse*gResp + Amp[1]*acInverse*gDerivResp + Amp[2]*acInverse*Kunit;
  Eigen::VectorXd OFCb = Atau[0]*acInverse*gResp + Atau[1]*acInverse*gDerivResp + Atau[2]*acInverse*Kunit;
  
  //Convert back to std::vector
  vecOFCa.resize(optNpt);
  vecOFCb.resize(optNpt);
  for (int i=0;i<optNpt;i++) {
    vecOFCa[i]=OFCa[i];
    vecOFCb[i]=OFCb[i];
  }
  }

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.

printOFCVec()

void LArOFCAlg::printOFCVec ( const std::vector< float > & vec, MsgStream & mLog )

staticprivate

Definition at line 994 of file LArOFCAlg.cxx.

                                                                        {
  mLog << MSG::WARNING << "OFCs";
    for(float v : vec) 
      mLog << " " << v;
  mLog << endmsg;
}

process()

void LArOFCAlg::process ( perChannelData_t & chanData, const LArOnOffIdMapping * cabling ) const

private

Definition at line 395 of file LArOFCAlg.cxx.

                                                                                          {
 
  LArWaveHelper larWaveHelper;
  const LArWaveCumul* nextWave=chanData.inputWave;
  if (!nextWave) {
    ATH_MSG_ERROR( "input wave is 0" );
    return;
  }
 
  if ( nextWave->getFlag() == LArWave::dac0 ) return ; // skip dac0 waves
 
  const HWIdentifier ch_id=chanData.chid;
  const unsigned gain=chanData.gain;
  ATH_MSG_DEBUG( "Computing OFC for channel " << m_onlineID->channel_name(ch_id) << " in gain = " << gain);
      
      
  // check constistency of settings
  if ( m_nPoints > nextWave->getSize() ) {
    ATH_MSG_ERROR( "Channel " << m_onlineID->channel_name(ch_id) <<": Wave size (" << nextWave->getSize() 
            << ") is too small to fit your OFC request (" << m_nPoints << " points)" ) ;
    chanData.shortWave=true;
    return;
  }
 
  // the current waveform
  LArWave aWave = *nextWave; // Actually *copying* the Wave to get rid of the const: need to manipulate Wave to normalize...
 
  if (m_larPhysWaveBin) {
    const int bin = m_larPhysWaveBin->bin(ch_id,gain);
    if (bin>-998) { //>ERRORCODE
      ATH_MSG_VERBOSE("Channel " << m_onlineID->channel_name(ch_id) << ": shift by index " << bin);
      aWave=larWaveHelper.translate(aWave,-bin,0);
    }
    else
      ATH_MSG_VERBOSE("Channel 0x" << MSG::hex << ch_id.get_identifier32().get_compact() << MSG::dec << ": No valid index for shifting");
  }//end if larPhysWaveBin
 
 
  // normalize input wave, if requested      
  if (m_normalize) {
    const double peak = aWave.getSample( larWaveHelper.getMax(aWave) );
    if ( peak == 0 ) {
      ATH_MSG_ERROR( "Wave maximum is zero, skipping channel " << m_onlineID->channel_name(ch_id) ) ;
      return;
    }
 
    ATH_MSG_VERBOSE("Channel 0x" << m_onlineID->channel_name(ch_id) << " has amplitude = " << peak << ": normalizing...");
    aWave = aWave * (1./peak);
  } 
 
  ATH_MSG_VERBOSE("Channel " << m_onlineID->channel_name(ch_id) <<  " has now amplitude = " <<  aWave.getSample( larWaveHelper.getMax(aWave)));
  // compute tstart to shift input wave, if requested
  if ( m_timeShift ) {
    if( m_timeShiftByIndex == -1 ) {
      chanData.tstart = larWaveHelper.getStart(aWave) ;
    } else {
      chanData.tstart = m_timeShiftByIndex;
    }
  }
      
  ATH_MSG_DEBUG("Channel" << m_onlineID->channel_name(ch_id) << ", Tstart = " << chanData.tstart);
 
  //Calculate derivative for this wave
  LArWave aDerivedWave = larWaveHelper.derive_smooth(aWave);
 
  chanData.timeBinWidthOFC = m_dPhases*aWave.getDt();
 
  float maxSampleValAt3=-1;
      
  //prepare output vectors
  chanData.ofc_a.resize(m_nPhases);
  chanData.ofc_b.resize(m_nPhases);  
  chanData.shape.resize(m_nPhases);     
  chanData.shapeDer.resize(m_nPhases);  
 
  if (m_computeV2) {
     chanData.ofcV2_a.resize(m_nPhases);
     chanData.ofcV2_b.resize(m_nPhases);  
  }
 
 
  const Eigen::MatrixXd acInverse=m_AutoCorrDecoder->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples).inverse();
  Eigen::MatrixXd acInverseV2;
  if (m_computeV2)
    acInverseV2=m_AutoCorrDecoderV2->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples).inverse();
 
  unsigned tShift=0;
  if(m_readDSPConfig && m_DSPConfig){
     if(m_DSPConfig->peakSample(m_onlineID->feb_Id(ch_id)) < 2 ) { // 2 is canonical value for peak
        tShift = 2 - m_DSPConfig->peakSample(m_onlineID->feb_Id(ch_id));
     }
  }
  if(m_forceShift) tShift=1;
 
  ATH_MSG_DEBUG("Channel " << m_onlineID->channel_name(ch_id) << "shift: " << tShift);
 
  for (unsigned iPhase=0;iPhase<m_nPhases;iPhase++) { //Loop over all phases
        
    ATH_MSG_VERBOSE ("Channel " << m_onlineID->channel_name(ch_id) 
             << ", Gain = " << gain << ", Phase = " << iPhase << ":");
 
 
    //Reference to the samples and deriviative to be filled
    std::vector<float>& theSamples=chanData.shape[iPhase];
    std::vector<float>& theSamplesDer=chanData.shapeDer[iPhase];
 
    //Extract the points where we compute the OFCs from the wave and the derived wave
    //and fill the samples an derivative vector
    theSamples.reserve(m_nSamples);
    theSamplesDer.reserve(m_nSamples);
    for (unsigned iSample=0;iSample<m_nSamples;++iSample){ //Loop over all samples
      const unsigned tbin = chanData.tstart + iPhase*m_dPhases + (iSample+tShift)*m_nDelays ;   
      theSamples.push_back( aWave.getSample(tbin) );
      theSamplesDer.push_back( aDerivedWave.getSample(tbin) );
    } //End loop over samples
 
 
    if (m_storeMaxPhase && m_nSamples>2 && theSamples[2]>maxSampleValAt3) {
      maxSampleValAt3=theSamples[2];
      chanData.phasewMaxAt3=iPhase;
    }
 
    bool thisChanUseDelta=useDelta(ch_id,m_useDelta,cabling);
    bool thisChanUseDeltaV2=m_computeV2 && useDelta(ch_id,m_useDeltaV2,cabling);
    Eigen::VectorXd delta;
 
    if (thisChanUseDelta || thisChanUseDeltaV2) { // will need delta for at least one of the two versions
      std::vector<float> theSamples32;
      theSamples32.reserve(32);
      for (unsigned iSample=0;iSample<32 ;++iSample){ //Loop over all samples
    const unsigned tbin = chanData.tstart + iPhase*m_dPhases + (iSample+tShift)*m_nDelays ;     
    if (tbin>=aWave.getSize()) continue;
    theSamples32.push_back( aWave.getSample(tbin) );
      } //End loop over samples
      delta=getDelta(theSamples32,ch_id,m_nSamples);
    }
 
    //OFC V1 computiation (i.e. not pileup-optimized)
    //Reference to the OFCa and OFCb to be filled
    std::vector<float>& vOFC_a= chanData.ofc_a[iPhase];
    std::vector<float>& vOFC_b= chanData.ofc_b[iPhase];
 
    if(m_computePed){
      optFiltPed(theSamples,theSamplesDer,acInverse,vOFC_a,vOFC_b);
    } else {
       if (thisChanUseDelta) {      
         optFiltDelta(theSamples,theSamplesDer,acInverse,delta,vOFC_a,vOFC_b);  
       } 
       else { //don't use Delta
         optFilt(theSamples,theSamplesDer,acInverse,vOFC_a,vOFC_b);
       }
    }
    
    // verify OFC consistency
    if (m_verify) {
      chanData.faultyOFC |= verify(chanData.chid,vOFC_a,vOFC_b,theSamples,"OFC",iPhase);
    } 
    
 
    if (m_computeV2) {
      //OFC V2 computiation (i.e. pileup-optimized)
      //Reference to the OFCa and OFCb to be filled
      std::vector<float>& vOFCV2_a= chanData.ofcV2_a[iPhase];
      std::vector<float>& vOFCV2_b= chanData.ofcV2_b[iPhase];
      
      if(m_computePed){
    optFiltPed(theSamples,theSamplesDer,acInverseV2,vOFCV2_a,vOFCV2_b);
      } else {
         if (thisChanUseDeltaV2) {
           optFiltDelta(theSamples,theSamplesDer,acInverseV2,delta,vOFCV2_a,vOFCV2_b);
         } 
         else { //don't use Delta
           optFilt(theSamples,theSamplesDer,acInverseV2,vOFCV2_a,vOFCV2_b);
         }
      }
 
      // verify OFC consistency
      if (m_verify) {
    chanData.faultyOFC |= verify(chanData.chid,vOFCV2_a,vOFCV2_b,theSamples,"OFCV2",iPhase);
      } 
    }//end if computeV2
  } //End loop over all phases
 
  // in case we're dealing with a LArPhysWave, add any possible previous time shift
  if (!m_readCaliWave) {
    const LArPhysWave* pwave=dynamic_cast<const LArPhysWave*>(nextWave);
    if (pwave)
      chanData.tstart += pwave->getTimeOffset()+m_addOffset;
  }
  }

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 LArOFCAlg::stop ( )

virtual

TBB global control parameter

Definition at line 113 of file LArOFCAlg.cxx.

{
 
  ATH_MSG_DEBUG( "In LArOFCAlg finalize()");
  
  ATH_MSG_INFO( "Number of samples            : " << m_nSamples ) ;
  ATH_MSG_INFO( "Number of delays acquired    : " << m_nDelays  ) ;
  ATH_MSG_INFO( "Number of phases in OFC      : " << m_nPhases  ) ;
  ATH_MSG_INFO( "Spacing between two phases   : " << m_dPhases  ) ;
 
  
  const LArOnOffIdMapping* cabling{nullptr};
  if(m_isSC) {
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKeySC};
    ATH_CHECK(cablingHdl.isValid());
    cabling = *cablingHdl;
 
    if (m_useDelta == 3 || m_useDeltaV2==3){
      SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloSuperCellMgrHandle{m_caloSuperCellMgrKey};
      ATH_CHECK(caloSuperCellMgrHandle.isValid());
      m_calo_dd_man = *caloSuperCellMgrHandle;
    }
  }
  else {
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
    ATH_CHECK(cablingHdl.isValid());
    cabling = *cablingHdl;
 
    if (m_useDelta == 3 || m_useDeltaV2==3){
      SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
      ATH_CHECK(caloMgrHandle.isValid());
      m_calo_dd_man = *caloMgrHandle;
    }
  }
 
  if ( m_timeShift ) {
    if( m_timeShiftByIndex == -1 ) {
      ATH_MSG_INFO( "    Will use helper class for start time." );
    } else {
      ATH_MSG_INFO( "    Manually shifting pulses by time index " << m_timeShiftByIndex );
    }
  }
  
  if (!m_larPhysWaveBinKey.empty()) {
    ATH_CHECK(detStore()->retrieve(m_larPhysWaveBin,m_larPhysWaveBinKey));
  }
 
  if (m_readCaliWave) {
    ATH_CHECK(this->initCaliWaveContainer());
  }
  else {
    ATH_CHECK(this->initPhysWaveContainer(cabling));
  }
 
  if (m_readDSPConfig) {
    const AthenaAttributeList* attrList=nullptr;
    ATH_CHECK(detStore()->retrieve(attrList, m_DSPConfigFolder));
    
    const coral::Blob& blob = (attrList->coralList())["febdata"].data<coral::Blob>();
    if (blob.size()<3) {
      ATH_MSG_INFO( "Found empty blob, nothing to do");
    } else {
      m_DSPConfig = std::make_unique<LArDSPConfig>(attrList);
    }
  }
 
  if (m_allChannelData.empty()) {
    ATH_MSG_ERROR( "No input waves found" );
    return StatusCode::FAILURE;
  }

  if (m_nThreads>-1) {
    //There are sone external tools, etc. that potentially cached stuff.
    //We need to call them at least once to make sure all caches are filled before we go multi-threaded
    perChannelData_t& chanData=m_allChannelData[0];
 
    m_AutoCorrDecoder->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples);
    if (m_computeV2)
      m_AutoCorrDecoderV2->AutoCorr(chanData.chid,(CaloGain::CaloGain)chanData.gain,m_nSamples);
      
    Identifier id=cabling->cnvToIdentifier(chanData.chid);
    if (m_useDelta==3 || m_useDeltaV2) {
      m_calo_dd_man->get_element(id);
    }
 
    std::ignore = m_onlineID->isFCALchannel(chanData.chid);
 
 
    if (!m_larPhysWaveBinKey.empty()) {
        m_larPhysWaveBin->bin(chanData.chid,(CaloGain::CaloGain)chanData.gain);
    }
    std::unique_ptr<tbb::global_control> tbbgc;
 
    if (m_nThreads>0) {
      tbbgc=std::make_unique<tbb::global_control>( tbb::global_control::max_allowed_parallelism, m_nThreads);
    }
 
    //Instanciated the functor and start parallel_for
    Looper looper(&m_allChannelData,cabling, this);
    tbb::blocked_range<size_t> range(0, m_allChannelData.size());
    ATH_MSG_INFO( "Starting parallel execution" );
    tbb::parallel_for(tbb::blocked_range<size_t>(0, m_allChannelData.size()),looper);
 
    ATH_MSG_INFO( "Done with parallel execution" );
 
  }
  else {
    ATH_MSG_INFO( "Single threaded execution" );
    for (perChannelData_t& chanData : m_allChannelData) {
      this->process(chanData,cabling);
    }
  }

 
  // OFC persistent object
  std::unique_ptr<LArOFCComplete> larOFCComplete=std::make_unique<LArOFCComplete>();
  StatusCode sc = larOFCComplete->setGroupingType(m_groupingType,msg());
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to set groupingType for LArOFCComplete object" );
    return sc;
  }
  sc=larOFCComplete->initialize(); 
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed initialize LArOFCComplete object" );
    return sc;
  }
 
 
  std::unique_ptr<LArOFCComplete> larOFCCompleteV2=std::make_unique<LArOFCComplete>();
  sc = larOFCComplete->setGroupingType(m_groupingType,msg());
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed to set groupingType for LArOFCComplete object" );
    return sc;
  }
  sc=larOFCCompleteV2->initialize(); 
  if (sc.isFailure()) {
    ATH_MSG_ERROR( "Failed initialize LArOFCComplete object" );
    return sc;
  }
 
 
  std::unique_ptr<LArOFCBinComplete> larOFCBinComplete;
  if (m_storeMaxPhase) {
    larOFCBinComplete=std::make_unique<LArOFCBinComplete>();
    sc=larOFCBinComplete->setGroupingType(m_groupingType,msg());
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Failed to set groupingType for LArOFCBinComplete object" );
      return sc;
    }
    sc  = larOFCBinComplete->initialize(); 
    if ( sc.isFailure() ) {
      ATH_MSG_ERROR( "Could not initialize LArOFCComplete data object - exit!" ) ;
      return sc ;
    }
  }
 
  // LArShape persistent object
  std::unique_ptr<LArShapeComplete> larShapeComplete;
  if (m_fillShape) {
    larShapeComplete = std::make_unique<LArShapeComplete>();
    sc=larShapeComplete->setGroupingType(m_groupingType,msg());
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Failed to set groupingType for LArShapeComplete object" );
      return sc;
    }
    sc=larShapeComplete->initialize(); 
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Failed initialize LArShapeComplete object" );
      return sc;
    }
  }
 
 
  //Counters (for information only):
  unsigned nChannels=0;
  unsigned nFailed=0;
 
  for (const perChannelData_t& chanData : m_allChannelData) {
    ++nChannels;
    if (chanData.faultyOFC) ++nFailed;
    // register channel to LArOFCComplete
    const HWIdentifier ch_id=chanData.chid;
    const int gain=chanData.gain;
    ATH_MSG_DEBUG( "add to LArOFCComplete, channel " << m_onlineID->channel_name(ch_id) << ", gain=" << (int)gain);
    const std::vector<std::vector<float> > & allPhaseOFCa=chanData.ofc_a;
    const std::vector<std::vector<float> > & allPhaseOFCb=chanData.ofc_b;
    const std::vector<std::vector<float> > & allPhaseShape=chanData.shape;
    const std::vector<std::vector<float> > & allPhaseShapeDer=chanData.shapeDer;
    larOFCComplete->set(ch_id,gain,allPhaseOFCa,allPhaseOFCb,chanData.tstart,chanData.timeBinWidthOFC);
    if (larOFCBinComplete) larOFCBinComplete->set(ch_id,gain,chanData.phasewMaxAt3);      
    if ( m_fillShape ) larShapeComplete->set(ch_id,gain,allPhaseShape,allPhaseShapeDer,chanData.tstart,chanData.timeBinWidthOFC);      
    
    
    if (m_computeV2) {
      const std::vector<std::vector<float> > & allPhaseOFCV2a=chanData.ofcV2_a;
      const std::vector<std::vector<float> > & allPhaseOFCV2b=chanData.ofcV2_b;
      larOFCCompleteV2->set(ch_id,gain,allPhaseOFCV2a,allPhaseOFCV2b,chanData.tstart,chanData.timeBinWidthOFC);
    }
    
  } // end loop over m_allChannelData
 
  ATH_MSG_INFO( " Summary : Computed OFCs for " << nChannels << " channels * gains" );
  if (nFailed) 
    ATH_MSG_ERROR( "Number of channels * gains with failed OFC verification: " <<  nFailed );
 
  if ( !m_dumpOFCfile.empty()) {
    ATH_MSG_INFO( "Dumping OFCs to file " << m_dumpOFCfile ) ;
    larOFCComplete->dumpOFC(m_dumpOFCfile) ;
  }
 
  sc = detStore()->record(std::move(larOFCComplete),m_ofcKey);
  if (sc.isFailure()) {
      ATH_MSG_ERROR( "Could not record LArOFCComplete to DetStore with key " << m_ofcKey );
      return StatusCode::FAILURE;
  }
  ATH_MSG_INFO( "LArOFCComplete object recorded with key " << m_ofcKey ) ;
 
  sc=detStore()->symLink(ClassID_traits<LArOFCComplete>::ID(),m_ofcKey,ClassID_traits<ILArOFC>::ID());
  if (sc.isFailure()) {
      ATH_MSG_ERROR( "Could not symlink ILArOFC with LArOFCComplete." );
      return StatusCode::FAILURE;
  } 
  ATH_MSG_INFO( "Symlink with ILArOFC done" ) ;
  
 
  // record and symlink second version of LArOFCComplete object
  if (m_computeV2) {
    sc = detStore()->record(std::move(larOFCCompleteV2),m_ofcKeyV2);
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Could not record LArOFCComplete to DetStore with key " << m_ofcKeyV2 );
      return StatusCode::FAILURE;
    }
    ATH_MSG_INFO( "LArOFCComplete object recorded with key " << m_ofcKeyV2 ) ;
 
    sc=detStore()->symLink(ClassID_traits<LArOFCComplete>::ID(),m_ofcKeyV2,ClassID_traits<ILArOFC>::ID());
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Could not symlink ILArOFC with LArOFCComplete." );
      return StatusCode::FAILURE;
    } 
    ATH_MSG_INFO( "Symlink with ILArOFC done" ) ;
  }
 
  if (larOFCBinComplete) {
    sc = detStore()->record(std::move(larOFCBinComplete),m_ofcBinKey);
    if (sc.isFailure()) {
       ATH_MSG_ERROR( "Could not record LArOFCBinCompete object" );
       return StatusCode::FAILURE;
    }
  }
  
  // record and symlink LArShapeComplete object
  if ( m_fillShape ) {
    ATH_MSG_DEBUG( "Trying to record LArShapeComplete object to detector store, key = " << m_shapeKey);
    sc = detStore()->record(std::move(larShapeComplete),m_shapeKey);
    if (sc.isFailure()) {
       ATH_MSG_ERROR( "Could not record LArShapeComplete to DetStore with key " << m_shapeKey );
       return StatusCode::FAILURE;
    }
    ATH_MSG_INFO( "LArShapeComplete object recorded to DetStore successfully with key " << m_shapeKey ) ;
    ATH_MSG_DEBUG( "Trying to symlink ILArShape with LArShapeComplete");
    sc=detStore()->symLink(ClassID_traits<LArShapeComplete>::ID(),m_shapeKey,ClassID_traits<ILArShape>::ID());
    if (sc.isFailure()) {
      ATH_MSG_ERROR( "Could not symlink ILArShape with LArShapeComplete." );
      return StatusCode::FAILURE;
    } 
    ATH_MSG_INFO( "ILArShape symlink with LArShapeComplete successfully" ) ;
  }  
 
 
  //Undo corrections, if they are applied by this algo:
  if (m_waveCnt_nc) {
    ATH_CHECK(m_waveCnt_nc->undoCorrections());
    ATH_MSG_INFO("Reverted corrections of non-cost wave container");
  }
 
  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, 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);
      }
    }
  }

useDelta()

bool LArOFCAlg::useDelta ( const HWIdentifier chid, const int jobOFlag, const LArOnOffIdMapping * cabling ) const

private

Definition at line 902 of file LArOFCAlg.cxx.

                                                                                                            {
 
  if (jobOFlag==2){
      return true;
    }
 
  if(jobOFlag==1) { // only HEC/EMECIW/FCAL
    if (m_onlineID->isEMECIW(chid) || m_onlineID->isFCALchannel(chid) || m_onlineID->isHECchannel(chid)) {
      return true;
    }
  }
 
  if(jobOFlag==3) { // only HEC/EMECIW/FCAL1 and high eta FCAL2-3 
    if (m_onlineID->isEMECIW(chid) ||  m_onlineID->isHECchannel(chid)) {
      return true;
    }
    else if (m_onlineID->isFCALchannel(chid) ){
 
      if (cabling->isOnlineConnected (chid)){
    Identifier ofl_id = cabling->cnvToIdentifier(chid);
    const CaloDetDescrElement* dde = m_calo_dd_man->get_element(ofl_id);
    if (! dde) {
      ATH_MSG_ERROR( " dde = 0 , onl_id, ofl_id= "<< chid<<" "<<ofl_id );
      return false; // Exception better? 
    }
    if ( m_isSC ) {
      CaloCell_SuperCell_ID::CaloSample sampling = dde->getSampling();
      if (sampling==CaloCell_ID::FCAL0){
        return true;
      }
      else {
        if (fabs(dde->eta())>4.0){
         return true;
        }
      }
    } else {
      CaloCell_ID::CaloSample sampling = dde->getSampling();
      if (sampling==CaloCell_ID::FCAL0){
        return true;
      }
      else {
        if (fabs(dde->eta())>4.0){
         return true;
        }
      }
    }
    
      }//end if connected
    }//end if isFCALchannel
 
  }//else if jobOFlag=3
 
  return false;
}

verify()

bool LArOFCAlg::verify ( const HWIdentifier chid, const std::vector< float > & OFCa, const std::vector< float > & OFCb, const std::vector< float > & Shape, const char * ofcversion, const unsigned phase ) const

private

Definition at line 958 of file LArOFCAlg.cxx.

                                                                                                  {
 
  bool result=false;
  float recAmpl=0, recTime=0;
  for (unsigned iSample=0;iSample<m_nSamples;++iSample){
 
#ifdef LAROFCALG_DEBUGOUTPUT
    ATH_MSG_VERBOSE("a["<<iSample<<"]="<<vOFC_a[iSample] << " b["<<iSample<<"]="<<vOFC_b[iSample] 
            << " Sample=" << aWave.getSample(tbin));
#endif
    recAmpl += OFCa[iSample] * Shape[iSample];
    recTime += OFCb[iSample] * Shape[iSample];
  } //End loop over samples
 
  if (recAmpl != 0) {
    recTime /= recAmpl ;
  }
 
  // At this point the reconstructed amplitude must be = 1 by definition, whatever the initial normalisation!
  ATH_MSG_VERBOSE("recAmp=" << recAmpl << " ; recTime=" << recTime);
  if ( fabs(1.-recAmpl) > m_errAmpl ) {
    ATH_MSG_WARNING( "Applying phase " << phase << " of " << ofcversion << " to original wave yields an Amplitude of "<< recAmpl 
              << " instead of 1. -> Wrong OFCs? channel " << m_onlineID->channel_name(chid) );
    LArOFCAlg::printOFCVec(OFCa,msg());
    result=true;
  }
  if ( fabs(recTime) > m_errTime ) {
    ATH_MSG_WARNING( "Applying  phase " << phase << " of " << ofcversion << " to original wave yields a time offset of " << recTime 
               << " -> Wrong OFCs? channel " << m_onlineID->channel_name(chid) );
    LArOFCAlg::printOFCVec(OFCb,msg());
    result=true; 
  }
  return result;
}

Member Data Documentation

m_addOffset

FloatProperty LArOFCAlg::m_addOffset {this, "AddTimeOffset", 0., "Time offset to add"}

private

Definition at line 137 of file LArOFCAlg.h.

{this, "AddTimeOffset", 0., "Time offset to add"} ;

m_allChannelData

std::vector<perChannelData_t> LArOFCAlg::m_allChannelData

private

Definition at line 94 of file LArOFCAlg.h.

m_AutoCorrDecoder

ToolHandle<ILArAutoCorrDecoderTool> LArOFCAlg::m_AutoCorrDecoder {this,"DecoderTool",{} }

private

Definition at line 139 of file LArOFCAlg.h.

{this,"DecoderTool",{} };

m_AutoCorrDecoderV2

ToolHandle<ILArAutoCorrDecoderTool> LArOFCAlg::m_AutoCorrDecoderV2 {this,"DecoderToolV2", {} }

private

Definition at line 140 of file LArOFCAlg.h.

{this,"DecoderToolV2", {} };

m_cablingKey

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

private

Definition at line 52 of file LArOFCAlg.h.

{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};

m_cablingKeySC

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

private

Definition at line 53 of file LArOFCAlg.h.

{this,"ScCablingKey","LArOnOffIdMapSC","SG Key of SC LArOnOffIdMapping object"};

m_calo_dd_man

const CaloDetDescrManager_Base* LArOFCAlg::m_calo_dd_man {}

private

Definition at line 142 of file LArOFCAlg.h.

{};

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> LArOFCAlg::m_caloMgrKey

private

Initial value:

{ this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" }

Definition at line 55 of file LArOFCAlg.h.

                                                        { this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" };

m_caloSuperCellMgrKey

SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> LArOFCAlg::m_caloSuperCellMgrKey

private

Initial value:

{ this
      , "CaloSuperCellDetDescrManager"
      , "CaloSuperCellDetDescrManager"
      , "SG Key for CaloSuperCellDetDescrManager in the Condition Store" }

Definition at line 60 of file LArOFCAlg.h.

                                                                          { this
      , "CaloSuperCellDetDescrManager"
      , "CaloSuperCellDetDescrManager"
      , "SG Key for CaloSuperCellDetDescrManager in the Condition Store" };

m_computePed

BooleanProperty LArOFCAlg::m_computePed {this, "ComputeOFCPed", false, "Compute OFCs with additional constraint to pedestal?"}

private

Definition at line 163 of file LArOFCAlg.h.

{this,    "ComputeOFCPed", false,      "Compute OFCs with additional constraint to pedestal?"};

m_computeV2

BooleanProperty LArOFCAlg::m_computeV2 {this, "ComputeOFCV2", false, "Compute pileup OFCs?"}

private

Definition at line 162 of file LArOFCAlg.h.

{this,     "ComputeOFCV2",  false,      "Compute pileup OFCs?"};

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_dPhases

UnsignedIntegerProperty LArOFCAlg::m_dPhases {this, "Dphase", 1, "Number of samples between two neighboring phases (OFC sets)"}

private

Definition at line 135 of file LArOFCAlg.h.

{this, "Dphase", 1, "Number of samples between two neighboring phases (OFC sets)"};

m_DSPConfig

std::unique_ptr<LArDSPConfig> LArOFCAlg::m_DSPConfig

private

Definition at line 168 of file LArOFCAlg.h.

m_DSPConfigFolder

StringProperty LArOFCAlg::m_DSPConfigFolder {this,"DSPConfigFolder","/LAR/Configuration/DSPConfiguration", "Folder for DSPConfig object"}

private

Definition at line 167 of file LArOFCAlg.h.

{this,"DSPConfigFolder","/LAR/Configuration/DSPConfiguration", "Folder for DSPConfig object"};

m_dumpOFCfile

StringProperty LArOFCAlg::m_dumpOFCfile {this, "DumpOFCfile", ""}

private

Definition at line 123 of file LArOFCAlg.h.

{this, "DumpOFCfile", ""};

m_errAmpl

DoubleProperty LArOFCAlg::m_errAmpl {this, "ErrAmplitude", 0.01, "Allowed amplitude difference in check"}

private

Definition at line 146 of file LArOFCAlg.h.

{this, "ErrAmplitude", 0.01, "Allowed amplitude difference in check"};

m_errTime

DoubleProperty LArOFCAlg::m_errTime {this, "ErrTime", 0.01, "Allowed time difference in check"}

private

Definition at line 147 of file LArOFCAlg.h.

{this, "ErrTime",      0.01, "Allowed time difference in check"};

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_fcal1Delta

const float LArOFCAlg::m_fcal1Delta ={0.0679600232979, -0.139479996869, 0.0679600232979, -0.139479996869, 0.0679600232979}

staticprivate

Definition at line 851 of file LArOFCAlg.h.

:public AthAlgorithm {
  //Acutally this algo can do internal multi-threading at finalize 
  //but not the way regular athenaMT works, so the thread-safety checker complains 
public:
 
  LArOFCAlg (const std::string& name, ISvcLocator* pSvcLocator);
  StatusCode initialize();
  StatusCode execute() {return StatusCode::SUCCESS;}
  virtual StatusCode stop();
  StatusCode finalize(){return StatusCode::SUCCESS;}
 
private:
 
  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"};
 
  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey { this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" };
 
  SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> m_caloSuperCellMgrKey { this
      , "CaloSuperCellDetDescrManager"
      , "CaloSuperCellDetDescrManager"
      , "SG Key for CaloSuperCellDetDescrManager in the Condition Store" };
 
  struct perChannelData_t {
    //Input:
    const LArWaveCumul* inputWave;
    HWIdentifier chid;
    unsigned gain;
 
    //Output:
    std::vector<std::vector<float> > ofc_a;
    std::vector<std::vector<float> > ofc_b;
 
    std::vector<std::vector<float> > ofcV2_a;
    std::vector<std::vector<float> > ofcV2_b;
 
    std::vector<std::vector<float> >shape;
    std::vector<std::vector<float> >shapeDer;
    
    float tstart;
    float timeBinWidthOFC;
    unsigned phasewMaxAt3;
    bool faultyOFC;
    bool shortWave;
 
 
    perChannelData_t(const LArWaveCumul* wave, const HWIdentifier hi, const unsigned g) : 
      inputWave(wave), chid(hi), gain(g),tstart(0), timeBinWidthOFC(25./24), phasewMaxAt3(0), faultyOFC(false), shortWave(false) {};
 
  };
 
 
  std::vector<perChannelData_t> m_allChannelData;
 
  static void           optFilt(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, //input variables
             std::vector<float>& OFCa, std::vector<float>& OFCb // Output variables;
             ) ; 
 
  static void           optFiltDelta(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, 
                  const Eigen::VectorXd& delta, //input variables
                  std::vector<float>& vecOFCa, std::vector<float>& vecOFCb // Output variables;
                  ) ; 
 
  static void           optFiltPed(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, //input variables
             std::vector<float>& OFCa, std::vector<float>& OFCb // Output variables;
             ) ; 
 
  void process(perChannelData_t&, const LArOnOffIdMapping* cabling) const;
 
 
  bool verify(const HWIdentifier chid, const std::vector<float>& OFCa, const std::vector<float>& OFCb, 
          const std::vector<float>& Shape, const char* ofcversion, const unsigned phase) const;
 
  static void printOFCVec(const std::vector<float>& vec, MsgStream& mLog) ;
 
  
  StatusCode     initPhysWaveContainer(const LArOnOffIdMapping* cabling);
  StatusCode     initCaliWaveContainer();
 
  unsigned int  m_nPoints{0};
    
  StringProperty           m_dumpOFCfile{this, "DumpOFCfile", ""};
  StringArrayProperty      m_keylist{this, "KeyList", {}, "List of keys to process"};
  BooleanProperty          m_verify{this, "Verify", true, "Verufy OFCs after computation"}; 
  BooleanProperty          m_normalize{this, "Normalize", false, "Normalize input wave"};
  BooleanProperty          m_timeShift{this, "TimeShift", false, "Shifting input wave"};
  IntegerProperty          m_timeShiftByIndex{this, "TimeShiftByIndex", -1, "shifting by n bins input wave"} ;
 
 
  LArCaliWaveContainer*    m_waveCnt_nc=nullptr;
 
  UnsignedIntegerProperty  m_nSamples{this, "Nsample", 5, "How many sample to compute"};
  UnsignedIntegerProperty  m_nPhases{this, "Nphase", 50, "How many sphases to compute"};
  UnsignedIntegerProperty  m_dPhases{this, "Dphase", 1, "Number of samples between two neighboring phases (OFC sets)"};
  UnsignedIntegerProperty  m_nDelays{this, "Ndelay", 24, "Number of delays in one clock"};
  FloatProperty            m_addOffset{this, "AddTimeOffset", 0., "Time offset to add"} ;
 
  ToolHandle<ILArAutoCorrDecoderTool> m_AutoCorrDecoder{this,"DecoderTool",{} };
  ToolHandle<ILArAutoCorrDecoderTool> m_AutoCorrDecoderV2{this,"DecoderToolV2", {} };
 
  const CaloDetDescrManager_Base* m_calo_dd_man{};
  const LArOnlineID_Base*  m_onlineID{};
  const LArOFCBinComplete* m_larPhysWaveBin{};
 
  DoubleProperty m_errAmpl{this, "ErrAmplitude", 0.01, "Allowed amplitude difference in check"};
  DoubleProperty m_errTime{this, "ErrTime",      0.01, "Allowed time difference in check"};
 
  BooleanProperty          m_readCaliWave{this, "ReadCaliWave",  true,       "If false PhysWave is input"};
  BooleanProperty          m_fillShape{this,    "FillShape",     false,      "Fill also shape object"};
  StringProperty           m_ofcKey{this,       "KeyOFC",        "LArOFC",   "Output key non-pileup OFCs"}; 
  StringProperty           m_ofcKeyV2{this,     "KeyOFCV2",      "LArOFCV2", "Output key pileup OFCs"}; 
  StringProperty           m_shapeKey{this,     "KeyShape",      "LArShape", "Output key Shape object"}; 
  BooleanProperty          m_storeMaxPhase{this,"StoreMaxPhase", false,      "Store phase of input wave max.?"};
  StringProperty           m_ofcBinKey{this,    "LArOFCBinKey",  "LArOFCPhase","Key for storing OFCBin object for MAx phase"};
 
  StringProperty           m_groupingType{this,  "GroupingType",  "SubDetector","Which grouping type to use"};
  StringProperty           m_larPhysWaveBinKey{this,"LArPhysWaveBinKey", "",  "Key for object to choose bin"};
 
  IntegerProperty          m_useDelta{this,      "UseDelta",      0,          "0= not use Delta, 1=only EMECIW/HEC/FCAL, 2=all , 3 = only EMECIW/HEC/FCAL1+high eta FCAL2-3"};
  IntegerProperty          m_useDeltaV2{this,    "UseDeltaV2",    0,          "Same af before for Delta"};
  BooleanProperty          m_computeV2{this,     "ComputeOFCV2",  false,      "Compute pileup OFCs?"};
  BooleanProperty          m_computePed{this,    "ComputeOFCPed", false,      "Compute OFCs with additional constraint to pedestal?"};
  IntegerProperty          m_nThreads{this,      "nThreads",      -1,         "-1: No TBB, 0: Let TBB decide, >0 number of threads"};
 
  BooleanProperty          m_readDSPConfig{this, "ReadDSPConfig", false,      "Read DSPConfig object ?"};
  StringProperty           m_DSPConfigFolder{this,"DSPConfigFolder","/LAR/Configuration/DSPConfiguration", "Folder for DSPConfig object"};
  std::unique_ptr<LArDSPConfig>  m_DSPConfig;
 
  BooleanProperty          m_forceShift{this,     "ForceShift",   false,       "Forcing shift of input wave ?"};
 
  BooleanProperty m_isSC{this, "isSC", false, "Running on cells or supercells?"};
 
  Eigen::VectorXd getDelta(std::vector<float>& samples, const HWIdentifier chid, unsigned nSamples) const;
 
 
 
  bool useDelta(const HWIdentifier chid, const int jobOFlag, const LArOnOffIdMapping* cabling) const;
 
  static const float m_fcal3Delta[5];
  static const float m_fcal2Delta[5];
  static const float m_fcal1Delta[5];
 
 
  //Functor for processing with TBB
  class  ATLAS_NOT_THREAD_SAFE Looper {
    //The way this class gets used is actually thread-safe
  public:
    Looper(std::vector<perChannelData_t>* p, const LArOnOffIdMapping* cabling, const LArOFCAlg* a) : m_perChanData(p), m_cabling(cabling), m_ofcAlg(a) {};
    void operator() (tbb::blocked_range<size_t>& r) const {
      for (size_t i=r.begin();i!=r.end();++i) {
    m_ofcAlg->process(m_perChanData->at(i),m_cabling);
      }
    }
  private:
    std::vector<perChannelData_t>* m_perChanData;
    const LArOnOffIdMapping* m_cabling;
    const LArOFCAlg* m_ofcAlg;
  };
};
 
 
#endif
 

m_fcal2Delta

const float LArOFCAlg::m_fcal2Delta ={-0.01589001104, -0.0740399733186, -0.01589001104, -0.0740399733186, -0.01589001104}

staticprivate

Definition at line 850 of file LArOFCAlg.h.

:public AthAlgorithm {
  //Acutally this algo can do internal multi-threading at finalize 
  //but not the way regular athenaMT works, so the thread-safety checker complains 
public:
 
  LArOFCAlg (const std::string& name, ISvcLocator* pSvcLocator);
  StatusCode initialize();
  StatusCode execute() {return StatusCode::SUCCESS;}
  virtual StatusCode stop();
  StatusCode finalize(){return StatusCode::SUCCESS;}
 
private:
 
  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"};
 
  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey { this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" };
 
  SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> m_caloSuperCellMgrKey { this
      , "CaloSuperCellDetDescrManager"
      , "CaloSuperCellDetDescrManager"
      , "SG Key for CaloSuperCellDetDescrManager in the Condition Store" };
 
  struct perChannelData_t {
    //Input:
    const LArWaveCumul* inputWave;
    HWIdentifier chid;
    unsigned gain;
 
    //Output:
    std::vector<std::vector<float> > ofc_a;
    std::vector<std::vector<float> > ofc_b;
 
    std::vector<std::vector<float> > ofcV2_a;
    std::vector<std::vector<float> > ofcV2_b;
 
    std::vector<std::vector<float> >shape;
    std::vector<std::vector<float> >shapeDer;
    
    float tstart;
    float timeBinWidthOFC;
    unsigned phasewMaxAt3;
    bool faultyOFC;
    bool shortWave;
 
 
    perChannelData_t(const LArWaveCumul* wave, const HWIdentifier hi, const unsigned g) : 
      inputWave(wave), chid(hi), gain(g),tstart(0), timeBinWidthOFC(25./24), phasewMaxAt3(0), faultyOFC(false), shortWave(false) {};
 
  };
 
 
  std::vector<perChannelData_t> m_allChannelData;
 
  static void           optFilt(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, //input variables
             std::vector<float>& OFCa, std::vector<float>& OFCb // Output variables;
             ) ; 
 
  static void           optFiltDelta(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, 
                  const Eigen::VectorXd& delta, //input variables
                  std::vector<float>& vecOFCa, std::vector<float>& vecOFCb // Output variables;
                  ) ; 
 
  static void           optFiltPed(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, //input variables
             std::vector<float>& OFCa, std::vector<float>& OFCb // Output variables;
             ) ; 
 
  void process(perChannelData_t&, const LArOnOffIdMapping* cabling) const;
 
 
  bool verify(const HWIdentifier chid, const std::vector<float>& OFCa, const std::vector<float>& OFCb, 
          const std::vector<float>& Shape, const char* ofcversion, const unsigned phase) const;
 
  static void printOFCVec(const std::vector<float>& vec, MsgStream& mLog) ;
 
  
  StatusCode     initPhysWaveContainer(const LArOnOffIdMapping* cabling);
  StatusCode     initCaliWaveContainer();
 
  unsigned int  m_nPoints{0};
    
  StringProperty           m_dumpOFCfile{this, "DumpOFCfile", ""};
  StringArrayProperty      m_keylist{this, "KeyList", {}, "List of keys to process"};
  BooleanProperty          m_verify{this, "Verify", true, "Verufy OFCs after computation"}; 
  BooleanProperty          m_normalize{this, "Normalize", false, "Normalize input wave"};
  BooleanProperty          m_timeShift{this, "TimeShift", false, "Shifting input wave"};
  IntegerProperty          m_timeShiftByIndex{this, "TimeShiftByIndex", -1, "shifting by n bins input wave"} ;
 
 
  LArCaliWaveContainer*    m_waveCnt_nc=nullptr;
 
  UnsignedIntegerProperty  m_nSamples{this, "Nsample", 5, "How many sample to compute"};
  UnsignedIntegerProperty  m_nPhases{this, "Nphase", 50, "How many sphases to compute"};
  UnsignedIntegerProperty  m_dPhases{this, "Dphase", 1, "Number of samples between two neighboring phases (OFC sets)"};
  UnsignedIntegerProperty  m_nDelays{this, "Ndelay", 24, "Number of delays in one clock"};
  FloatProperty            m_addOffset{this, "AddTimeOffset", 0., "Time offset to add"} ;
 
  ToolHandle<ILArAutoCorrDecoderTool> m_AutoCorrDecoder{this,"DecoderTool",{} };
  ToolHandle<ILArAutoCorrDecoderTool> m_AutoCorrDecoderV2{this,"DecoderToolV2", {} };
 
  const CaloDetDescrManager_Base* m_calo_dd_man{};
  const LArOnlineID_Base*  m_onlineID{};
  const LArOFCBinComplete* m_larPhysWaveBin{};
 
  DoubleProperty m_errAmpl{this, "ErrAmplitude", 0.01, "Allowed amplitude difference in check"};
  DoubleProperty m_errTime{this, "ErrTime",      0.01, "Allowed time difference in check"};
 
  BooleanProperty          m_readCaliWave{this, "ReadCaliWave",  true,       "If false PhysWave is input"};
  BooleanProperty          m_fillShape{this,    "FillShape",     false,      "Fill also shape object"};
  StringProperty           m_ofcKey{this,       "KeyOFC",        "LArOFC",   "Output key non-pileup OFCs"}; 
  StringProperty           m_ofcKeyV2{this,     "KeyOFCV2",      "LArOFCV2", "Output key pileup OFCs"}; 
  StringProperty           m_shapeKey{this,     "KeyShape",      "LArShape", "Output key Shape object"}; 
  BooleanProperty          m_storeMaxPhase{this,"StoreMaxPhase", false,      "Store phase of input wave max.?"};
  StringProperty           m_ofcBinKey{this,    "LArOFCBinKey",  "LArOFCPhase","Key for storing OFCBin object for MAx phase"};
 
  StringProperty           m_groupingType{this,  "GroupingType",  "SubDetector","Which grouping type to use"};
  StringProperty           m_larPhysWaveBinKey{this,"LArPhysWaveBinKey", "",  "Key for object to choose bin"};
 
  IntegerProperty          m_useDelta{this,      "UseDelta",      0,          "0= not use Delta, 1=only EMECIW/HEC/FCAL, 2=all , 3 = only EMECIW/HEC/FCAL1+high eta FCAL2-3"};
  IntegerProperty          m_useDeltaV2{this,    "UseDeltaV2",    0,          "Same af before for Delta"};
  BooleanProperty          m_computeV2{this,     "ComputeOFCV2",  false,      "Compute pileup OFCs?"};
  BooleanProperty          m_computePed{this,    "ComputeOFCPed", false,      "Compute OFCs with additional constraint to pedestal?"};
  IntegerProperty          m_nThreads{this,      "nThreads",      -1,         "-1: No TBB, 0: Let TBB decide, >0 number of threads"};
 
  BooleanProperty          m_readDSPConfig{this, "ReadDSPConfig", false,      "Read DSPConfig object ?"};
  StringProperty           m_DSPConfigFolder{this,"DSPConfigFolder","/LAR/Configuration/DSPConfiguration", "Folder for DSPConfig object"};
  std::unique_ptr<LArDSPConfig>  m_DSPConfig;
 
  BooleanProperty          m_forceShift{this,     "ForceShift",   false,       "Forcing shift of input wave ?"};
 
  BooleanProperty m_isSC{this, "isSC", false, "Running on cells or supercells?"};
 
  Eigen::VectorXd getDelta(std::vector<float>& samples, const HWIdentifier chid, unsigned nSamples) const;
 
 
 
  bool useDelta(const HWIdentifier chid, const int jobOFlag, const LArOnOffIdMapping* cabling) const;
 
  static const float m_fcal3Delta[5];
  static const float m_fcal2Delta[5];
  static const float m_fcal1Delta[5];
 
 
  //Functor for processing with TBB
  class  ATLAS_NOT_THREAD_SAFE Looper {
    //The way this class gets used is actually thread-safe
  public:
    Looper(std::vector<perChannelData_t>* p, const LArOnOffIdMapping* cabling, const LArOFCAlg* a) : m_perChanData(p), m_cabling(cabling), m_ofcAlg(a) {};
    void operator() (tbb::blocked_range<size_t>& r) const {
      for (size_t i=r.begin();i!=r.end();++i) {
    m_ofcAlg->process(m_perChanData->at(i),m_cabling);
      }
    }
  private:
    std::vector<perChannelData_t>* m_perChanData;
    const LArOnOffIdMapping* m_cabling;
    const LArOFCAlg* m_ofcAlg;
  };
};
 
 
#endif
 

m_fcal3Delta

const float LArOFCAlg::m_fcal3Delta ={0.0790199937765, 0.0952000226825, 0.0790199937765, 0.0952000226825, 0.0790199937765}

staticprivate

Definition at line 849 of file LArOFCAlg.h.

:public AthAlgorithm {
  //Acutally this algo can do internal multi-threading at finalize 
  //but not the way regular athenaMT works, so the thread-safety checker complains 
public:
 
  LArOFCAlg (const std::string& name, ISvcLocator* pSvcLocator);
  StatusCode initialize();
  StatusCode execute() {return StatusCode::SUCCESS;}
  virtual StatusCode stop();
  StatusCode finalize(){return StatusCode::SUCCESS;}
 
private:
 
  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"};
 
  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey { this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" };
 
  SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> m_caloSuperCellMgrKey { this
      , "CaloSuperCellDetDescrManager"
      , "CaloSuperCellDetDescrManager"
      , "SG Key for CaloSuperCellDetDescrManager in the Condition Store" };
 
  struct perChannelData_t {
    //Input:
    const LArWaveCumul* inputWave;
    HWIdentifier chid;
    unsigned gain;
 
    //Output:
    std::vector<std::vector<float> > ofc_a;
    std::vector<std::vector<float> > ofc_b;
 
    std::vector<std::vector<float> > ofcV2_a;
    std::vector<std::vector<float> > ofcV2_b;
 
    std::vector<std::vector<float> >shape;
    std::vector<std::vector<float> >shapeDer;
    
    float tstart;
    float timeBinWidthOFC;
    unsigned phasewMaxAt3;
    bool faultyOFC;
    bool shortWave;
 
 
    perChannelData_t(const LArWaveCumul* wave, const HWIdentifier hi, const unsigned g) : 
      inputWave(wave), chid(hi), gain(g),tstart(0), timeBinWidthOFC(25./24), phasewMaxAt3(0), faultyOFC(false), shortWave(false) {};
 
  };
 
 
  std::vector<perChannelData_t> m_allChannelData;
 
  static void           optFilt(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, //input variables
             std::vector<float>& OFCa, std::vector<float>& OFCb // Output variables;
             ) ; 
 
  static void           optFiltDelta(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, 
                  const Eigen::VectorXd& delta, //input variables
                  std::vector<float>& vecOFCa, std::vector<float>& vecOFCb // Output variables;
                  ) ; 
 
  static void           optFiltPed(const std::vector<float> &gWave_in, const std::vector<float>  &gDerivWave_in, const Eigen::MatrixXd& autoCorrInv, //input variables
             std::vector<float>& OFCa, std::vector<float>& OFCb // Output variables;
             ) ; 
 
  void process(perChannelData_t&, const LArOnOffIdMapping* cabling) const;
 
 
  bool verify(const HWIdentifier chid, const std::vector<float>& OFCa, const std::vector<float>& OFCb, 
          const std::vector<float>& Shape, const char* ofcversion, const unsigned phase) const;
 
  static void printOFCVec(const std::vector<float>& vec, MsgStream& mLog) ;
 
  
  StatusCode     initPhysWaveContainer(const LArOnOffIdMapping* cabling);
  StatusCode     initCaliWaveContainer();
 
  unsigned int  m_nPoints{0};
    
  StringProperty           m_dumpOFCfile{this, "DumpOFCfile", ""};
  StringArrayProperty      m_keylist{this, "KeyList", {}, "List of keys to process"};
  BooleanProperty          m_verify{this, "Verify", true, "Verufy OFCs after computation"}; 
  BooleanProperty          m_normalize{this, "Normalize", false, "Normalize input wave"};
  BooleanProperty          m_timeShift{this, "TimeShift", false, "Shifting input wave"};
  IntegerProperty          m_timeShiftByIndex{this, "TimeShiftByIndex", -1, "shifting by n bins input wave"} ;
 
 
  LArCaliWaveContainer*    m_waveCnt_nc=nullptr;
 
  UnsignedIntegerProperty  m_nSamples{this, "Nsample", 5, "How many sample to compute"};
  UnsignedIntegerProperty  m_nPhases{this, "Nphase", 50, "How many sphases to compute"};
  UnsignedIntegerProperty  m_dPhases{this, "Dphase", 1, "Number of samples between two neighboring phases (OFC sets)"};
  UnsignedIntegerProperty  m_nDelays{this, "Ndelay", 24, "Number of delays in one clock"};
  FloatProperty            m_addOffset{this, "AddTimeOffset", 0., "Time offset to add"} ;
 
  ToolHandle<ILArAutoCorrDecoderTool> m_AutoCorrDecoder{this,"DecoderTool",{} };
  ToolHandle<ILArAutoCorrDecoderTool> m_AutoCorrDecoderV2{this,"DecoderToolV2", {} };
 
  const CaloDetDescrManager_Base* m_calo_dd_man{};
  const LArOnlineID_Base*  m_onlineID{};
  const LArOFCBinComplete* m_larPhysWaveBin{};
 
  DoubleProperty m_errAmpl{this, "ErrAmplitude", 0.01, "Allowed amplitude difference in check"};
  DoubleProperty m_errTime{this, "ErrTime",      0.01, "Allowed time difference in check"};
 
  BooleanProperty          m_readCaliWave{this, "ReadCaliWave",  true,       "If false PhysWave is input"};
  BooleanProperty          m_fillShape{this,    "FillShape",     false,      "Fill also shape object"};
  StringProperty           m_ofcKey{this,       "KeyOFC",        "LArOFC",   "Output key non-pileup OFCs"}; 
  StringProperty           m_ofcKeyV2{this,     "KeyOFCV2",      "LArOFCV2", "Output key pileup OFCs"}; 
  StringProperty           m_shapeKey{this,     "KeyShape",      "LArShape", "Output key Shape object"}; 
  BooleanProperty          m_storeMaxPhase{this,"StoreMaxPhase", false,      "Store phase of input wave max.?"};
  StringProperty           m_ofcBinKey{this,    "LArOFCBinKey",  "LArOFCPhase","Key for storing OFCBin object for MAx phase"};
 
  StringProperty           m_groupingType{this,  "GroupingType",  "SubDetector","Which grouping type to use"};
  StringProperty           m_larPhysWaveBinKey{this,"LArPhysWaveBinKey", "",  "Key for object to choose bin"};
 
  IntegerProperty          m_useDelta{this,      "UseDelta",      0,          "0= not use Delta, 1=only EMECIW/HEC/FCAL, 2=all , 3 = only EMECIW/HEC/FCAL1+high eta FCAL2-3"};
  IntegerProperty          m_useDeltaV2{this,    "UseDeltaV2",    0,          "Same af before for Delta"};
  BooleanProperty          m_computeV2{this,     "ComputeOFCV2",  false,      "Compute pileup OFCs?"};
  BooleanProperty          m_computePed{this,    "ComputeOFCPed", false,      "Compute OFCs with additional constraint to pedestal?"};
  IntegerProperty          m_nThreads{this,      "nThreads",      -1,         "-1: No TBB, 0: Let TBB decide, >0 number of threads"};
 
  BooleanProperty          m_readDSPConfig{this, "ReadDSPConfig", false,      "Read DSPConfig object ?"};
  StringProperty           m_DSPConfigFolder{this,"DSPConfigFolder","/LAR/Configuration/DSPConfiguration", "Folder for DSPConfig object"};
  std::unique_ptr<LArDSPConfig>  m_DSPConfig;
 
  BooleanProperty          m_forceShift{this,     "ForceShift",   false,       "Forcing shift of input wave ?"};
 
  BooleanProperty m_isSC{this, "isSC", false, "Running on cells or supercells?"};
 
  Eigen::VectorXd getDelta(std::vector<float>& samples, const HWIdentifier chid, unsigned nSamples) const;
 
 
 
  bool useDelta(const HWIdentifier chid, const int jobOFlag, const LArOnOffIdMapping* cabling) const;
 
  static const float m_fcal3Delta[5];
  static const float m_fcal2Delta[5];
  static const float m_fcal1Delta[5];
 
 
  //Functor for processing with TBB
  class  ATLAS_NOT_THREAD_SAFE Looper {
    //The way this class gets used is actually thread-safe
  public:
    Looper(std::vector<perChannelData_t>* p, const LArOnOffIdMapping* cabling, const LArOFCAlg* a) : m_perChanData(p), m_cabling(cabling), m_ofcAlg(a) {};
    void operator() (tbb::blocked_range<size_t>& r) const {
      for (size_t i=r.begin();i!=r.end();++i) {
    m_ofcAlg->process(m_perChanData->at(i),m_cabling);
      }
    }
  private:
    std::vector<perChannelData_t>* m_perChanData;
    const LArOnOffIdMapping* m_cabling;
    const LArOFCAlg* m_ofcAlg;
  };
};
 
 
#endif
 

m_fillShape

BooleanProperty LArOFCAlg::m_fillShape {this, "FillShape", false, "Fill also shape object"}

private

Definition at line 150 of file LArOFCAlg.h.

{this,    "FillShape",     false,      "Fill also shape object"};

m_forceShift

BooleanProperty LArOFCAlg::m_forceShift {this, "ForceShift", false, "Forcing shift of input wave ?"}

private

Definition at line 170 of file LArOFCAlg.h.

{this,     "ForceShift",   false,       "Forcing shift of input wave ?"};

m_groupingType

StringProperty LArOFCAlg::m_groupingType {this, "GroupingType", "SubDetector","Which grouping type to use"}

private

Definition at line 157 of file LArOFCAlg.h.

{this,  "GroupingType",  "SubDetector","Which grouping type to use"};

m_isSC

BooleanProperty LArOFCAlg::m_isSC {this, "isSC", false, "Running on cells or supercells?"}

private

Definition at line 172 of file LArOFCAlg.h.

{this, "isSC", false, "Running on cells or supercells?"};

m_keylist

StringArrayProperty LArOFCAlg::m_keylist {this, "KeyList", {}, "List of keys to process"}

private

Definition at line 124 of file LArOFCAlg.h.

{this, "KeyList", {}, "List of keys to process"};

m_larPhysWaveBin

const LArOFCBinComplete* LArOFCAlg::m_larPhysWaveBin {}

private

Definition at line 144 of file LArOFCAlg.h.

{};

m_larPhysWaveBinKey

StringProperty LArOFCAlg::m_larPhysWaveBinKey {this,"LArPhysWaveBinKey", "", "Key for object to choose bin"}

private

Definition at line 158 of file LArOFCAlg.h.

{this,"LArPhysWaveBinKey", "",  "Key for object to choose bin"};

m_nDelays

UnsignedIntegerProperty LArOFCAlg::m_nDelays {this, "Ndelay", 24, "Number of delays in one clock"}

private

Definition at line 136 of file LArOFCAlg.h.

{this, "Ndelay", 24, "Number of delays in one clock"};

m_normalize

BooleanProperty LArOFCAlg::m_normalize {this, "Normalize", false, "Normalize input wave"}

private

Definition at line 126 of file LArOFCAlg.h.

{this, "Normalize", false, "Normalize input wave"};

m_nPhases

UnsignedIntegerProperty LArOFCAlg::m_nPhases {this, "Nphase", 50, "How many sphases to compute"}

private

Definition at line 134 of file LArOFCAlg.h.

{this, "Nphase", 50, "How many sphases to compute"};

m_nPoints

unsigned int LArOFCAlg::m_nPoints {0}

private

Definition at line 121 of file LArOFCAlg.h.

{0};

m_nSamples

UnsignedIntegerProperty LArOFCAlg::m_nSamples {this, "Nsample", 5, "How many sample to compute"}

private

Definition at line 133 of file LArOFCAlg.h.

{this, "Nsample", 5, "How many sample to compute"};

m_nThreads

IntegerProperty LArOFCAlg::m_nThreads {this, "nThreads", -1, "-1: No TBB, 0: Let TBB decide, >0 number of threads"}

private

Definition at line 164 of file LArOFCAlg.h.

{this,      "nThreads",      -1,         "-1: No TBB, 0: Let TBB decide, >0 number of threads"};

m_ofcBinKey

StringProperty LArOFCAlg::m_ofcBinKey {this, "LArOFCBinKey", "LArOFCPhase","Key for storing OFCBin object for MAx phase"}

private

Definition at line 155 of file LArOFCAlg.h.

{this,    "LArOFCBinKey",  "LArOFCPhase","Key for storing OFCBin object for MAx phase"};

m_ofcKey

StringProperty LArOFCAlg::m_ofcKey {this, "KeyOFC", "LArOFC", "Output key non-pileup OFCs"}

private

Definition at line 151 of file LArOFCAlg.h.

{this,       "KeyOFC",        "LArOFC",   "Output key non-pileup OFCs"}; 

m_ofcKeyV2

StringProperty LArOFCAlg::m_ofcKeyV2 {this, "KeyOFCV2", "LArOFCV2", "Output key pileup OFCs"}

private

Definition at line 152 of file LArOFCAlg.h.

{this,     "KeyOFCV2",      "LArOFCV2", "Output key pileup OFCs"}; 

m_onlineID

const LArOnlineID_Base* LArOFCAlg::m_onlineID {}

private

Definition at line 143 of file LArOFCAlg.h.

{};

m_readCaliWave

BooleanProperty LArOFCAlg::m_readCaliWave {this, "ReadCaliWave", true, "If false PhysWave is input"}

private

Definition at line 149 of file LArOFCAlg.h.

{this, "ReadCaliWave",  true,       "If false PhysWave is input"};

m_readDSPConfig

BooleanProperty LArOFCAlg::m_readDSPConfig {this, "ReadDSPConfig", false, "Read DSPConfig object ?"}

private

Definition at line 166 of file LArOFCAlg.h.

{this, "ReadDSPConfig", false,      "Read DSPConfig object ?"};

m_shapeKey

StringProperty LArOFCAlg::m_shapeKey {this, "KeyShape", "LArShape", "Output key Shape object"}

private

Definition at line 153 of file LArOFCAlg.h.

{this,     "KeyShape",      "LArShape", "Output key Shape object"}; 

m_storeMaxPhase

BooleanProperty LArOFCAlg::m_storeMaxPhase {this,"StoreMaxPhase", false, "Store phase of input wave max.?"}

private

Definition at line 154 of file LArOFCAlg.h.

{this,"StoreMaxPhase", false,      "Store phase of input wave max.?"};

m_timeShift

BooleanProperty LArOFCAlg::m_timeShift {this, "TimeShift", false, "Shifting input wave"}

private

Definition at line 127 of file LArOFCAlg.h.

{this, "TimeShift", false, "Shifting input wave"};

m_timeShiftByIndex

IntegerProperty LArOFCAlg::m_timeShiftByIndex {this, "TimeShiftByIndex", -1, "shifting by n bins input wave"}

private

Definition at line 128 of file LArOFCAlg.h.

{this, "TimeShiftByIndex", -1, "shifting by n bins input wave"} ;

m_useDelta

IntegerProperty LArOFCAlg::m_useDelta {this, "UseDelta", 0, "0= not use Delta, 1=only EMECIW/HEC/FCAL, 2=all , 3 = only EMECIW/HEC/FCAL1+high eta FCAL2-3"}

private

Definition at line 160 of file LArOFCAlg.h.

{this,      "UseDelta",      0,          "0= not use Delta, 1=only EMECIW/HEC/FCAL, 2=all , 3 = only EMECIW/HEC/FCAL1+high eta FCAL2-3"};

m_useDeltaV2

IntegerProperty LArOFCAlg::m_useDeltaV2 {this, "UseDeltaV2", 0, "Same af before for Delta"}

private

Definition at line 161 of file LArOFCAlg.h.

{this,    "UseDeltaV2",    0,          "Same af before for Delta"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_verify

BooleanProperty LArOFCAlg::m_verify {this, "Verify", true, "Verufy OFCs after computation"}

private

Definition at line 125 of file LArOFCAlg.h.

{this, "Verify", true, "Verufy OFCs after computation"}; 

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_waveCnt_nc

LArCaliWaveContainer* LArOFCAlg::m_waveCnt_nc =nullptr

private

Definition at line 131 of file LArOFCAlg.h.

---

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

• LArOFCAlg.h
• LArOFCAlg.cxx