LArWFParamTool Class Reference

#include <LArWFParamTool.h>

Inheritance diagram for LArWFParamTool:

Collaboration diagram for LArWFParamTool:

Classes
struct	omegaScanParams_t
struct	waveRange_t
struct	WaveTiming_t

Public Types
enum	{ FailExtract = -999, DoExtract, DefaultNotSet = 0 }
enum	{   OK = 0, TooShort = 1, NotFilled = 2, LowStat = 3,   Noisy = 4, Oscillating = 5 }

Public Member Functions
	LArWFParamTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~LArWFParamTool ()
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
StatusCode	getLArWaveParams (const LArCaliWave &larCaliWave, const HWIdentifier chid, const CaloGain::CaloGain gain, LArWFParams &wfParams, const LArOnOffIdMapping *cabling, std::optional< LArCaliWave > &omegaScan, std::optional< LArCaliWave > &resOscill0, std::optional< LArCaliWave > &resOscill1) const
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	sysInitialize () override
	Perform system initialization for an algorithm. 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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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
WaveTiming_t	timeExtr (LArWave &gCali) const
double	expTail (const LArWave &gCali, const WaveTiming_t &wt) const
StatusCode	GetFstep (const LArWave &gCali, LArWFParams &wfParams, const WaveTiming_t &wt) const
double	fstepMin (const LArWave &gCali, double fstep, const double Tc, const unsigned Ttail) const
double	dFstep (const LArWave &gCali, const double fstep, const double Tc, const unsigned Ttail) const
LArWave	dstepRespDfstep (const LArWave &gCali, const double &fstep, const double &Tc) const
StatusCode	RTM_Omega0 (const LArWave &gCali, const HWIdentifier chid, LArWFParams &wfParams, const WaveTiming_t &wt, const LArOnOffIdMapping *cabling, std::optional< LArCaliWave > &omegaScan) const
StatusCode	RTM_Taur (const LArWave &gCali, LArWFParams &wfParams, const WaveTiming_t &wt) const
double	logChi2CosRespShaper (const double omega, const LArWave &gCali, const LArWFParams &wf, const waveRange_t &range) const
double	logChi2InjRespRes (const double taur, const LArWave &gCali, const LArWFParams &wf, const waveRange_t &range) const
LArWave	cosRespShaper (const LArWave &gCali, const double &fstep, const double &tcal, const double &w, const double &tsh) const
double	omega0MinNum (double omegaMin, double omegaMax, const double tol, const LArWave &gCali, const LArWFParams &wf, const waveRange_t &) const
double	taurMinNum (const double taurmin, const double taurmax, const double tol, const LArWave &gCali, const LArWFParams &wf, const waveRange_t &) const
double	fminbr (double a, double b, const double tol, double(LArWFParamTool::*f)(double, const LArWave &, const LArWFParams &, const waveRange_t &) const, const LArWave &gCali, const LArWFParams &wf, const waveRange_t &range) const
unsigned	checkStatus (const LArCaliWave &larCaliWave) const
omegaScanParams_t	OmegaScanHelper (const Identifier id, const WaveTiming_t &wt) const
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...

Static Private Member Functions
static LArWave	stepResp (const LArWave &gCali, const double fstep, const double Tc)
static LArWave	stepCorr (const LArWave &gCali, const double &fstep, const double &Tc)
static double	dstepCorrDfstep (const double t, const double &fstep, const double &Tc)
static LArWave	dstepCorrDfstep (const LArWave &gCali, const double &fstep, const double &Tcal)
static LArWave	cosResp (const LArWave &gCali, const double &fstep, const double &tcal, const double &omega)
static LArWave	injRespRes (const LArWave &w, const double omega0, const double taur)
static LArWave	injCorr (const unsigned N, const double dt, const double omega0, const double taur)
static LArWave	cosCorr (const unsigned N, const double dt, const double fstep, const double tcal, const double omega)

Private Attributes
const LArEM_Base_ID *	m_emId = nullptr
const LArOnlineID_Base *	m_onlineHelper = nullptr
LArWaveHelper	m_wHelper
double	m_Tshaper
std::vector< bool >	m_cosRespScan
std::vector< double >	m_omegamin
std::vector< double >	m_omegamax
std::vector< unsigned >	m_npoints
std::vector< bool >	m_storeResOscill
unsigned int	m_NBaseline
bool	m_ShiftToStart
bool	m_SubtractBaseline
bool	m_UseOmegaScanHelper
bool	m_isSC
std::vector< int >	m_TtailMin
std::vector< int >	m_TtailMax
std::vector< int >	m_DeltaTtail
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

Static Private Attributes
static const double	m_DEFAULT = -1
static const double	m_TINY =2.22045e-16
static const double	m_SQRT_EPSILON =1.49012e-08
static const double	m_EPSILON =2.22045e-16

Detailed Description

Definition at line 28 of file LArWFParamTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
FailExtract
DoExtract
DefaultNotSet

Definition at line 33 of file LArWFParamTool.h.

       {
    FailExtract = -999 ,
    DoExtract ,
    DefaultNotSet = 0
  } ;

anonymous enum

anonymous enum

Enumerator
OK
TooShort
NotFilled
LowStat
Noisy
Oscillating

Definition at line 68 of file LArWFParamTool.h.

       { OK           = 0 ,
     TooShort     = 1 ,
     NotFilled    = 2 ,
     LowStat      = 3 , 
     Noisy        = 4 ,
     Oscillating  = 5 
  } ;

Constructor & Destructor Documentation

LArWFParamTool()

LArWFParamTool::LArWFParamTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 36 of file LArWFParamTool.cxx.

  : AthAlgTool(type,name,parent),
    m_NBaseline(0),
    m_ShiftToStart(false),
    m_SubtractBaseline(false),
    m_UseOmegaScanHelper(false)
{
 
  // Declare additional interface
  declareInterface<LArWFParamTool>(this);
 
  declareProperty("NBaseline",        m_NBaseline);
  declareProperty("ShiftToStart",     m_ShiftToStart);
  declareProperty("SubtractBaseline", m_SubtractBaseline);
  declareProperty("isSC", m_isSC = false);
 
  m_DeltaTtail.resize(3);
  int default_deltattail[3] = { 100, 50, 0 } ;
  for ( unsigned i=0; i<3; ++i )
    m_DeltaTtail[i] = default_deltattail[i] ;
  declareProperty("DeltaTtail", m_DeltaTtail);
 
  m_TtailMin.resize(4);
  m_TtailMax.resize(4); 
  int default_ttailmin[4] = { 0, 0, 0, 0 };
  int default_ttailmax[4] = { 0, 0, 0, 0 };
  for ( unsigned i=0; i<4; ++i ) {
    m_TtailMin[i] = default_ttailmin[i];
    m_TtailMax[i] = default_ttailmax[i];    
  }
  declareProperty("TtailMin", m_TtailMin);
  declareProperty("TtailMax", m_TtailMax);
  
  // flags to force cos resp scan:
  m_cosRespScan.resize(4) ;
  bool defaults[4] = { false , true , false , true } ;
  for ( unsigned i=0 ; i<4 ; ++i ) 
    m_cosRespScan[i] = defaults[i] ;
  declareProperty("CosRespScan", m_cosRespScan ) ;
 
 
  // omega0 intervals and granularities:
  //float    default_omegamin[4] = { 0.01 , 0.47 , 0.10 , 0.30 } ;
  //float    default_omegamax[4] = { 1.00 , 0.48 , 0.30 , 0.60 } ;
  //unsigned default_npoints[4]  = { 100 , 50 , 100 , 100 } ;
  float    default_omegamin[4] = { 0.01 , 0.10 , 0.10 , 0.10 };
  float    default_omegamax[4] = { 1.00 , 0.33 , 0.20 , 0.33 };
  unsigned default_npoints[4]  = {  100 ,  100 ,  100 ,  100 };
  m_omegamin.resize(4) ;
  m_omegamax.resize(4) ;
  m_npoints.resize(4) ;
  for ( unsigned i=0 ; i<4 ; ++i ) {
    m_omegamin[i] = default_omegamin[i] ;
    m_omegamax[i] = default_omegamax[i] ;
    m_npoints[i]  = default_npoints[i] ;
  }
  declareProperty("Omega0Min",  m_omegamin);
  declareProperty("Omega0Max",  m_omegamax);
  declareProperty("NpointScan", m_npoints );
  declareProperty("UseOmegaScanHelper", m_UseOmegaScanHelper );
 
  // flags to save residual oscillation
  m_storeResOscill.resize(4,false) ;
  declareProperty("StoreResOscill", m_storeResOscill) ;
  
  declareProperty("TShaper",    m_Tshaper=15.) ;
}

~LArWFParamTool()

LArWFParamTool::~LArWFParamTool ( )

virtualdefault

Member Function Documentation

checkStatus()

unsigned LArWFParamTool::checkStatus ( const LArCaliWave &  larCaliWave ) const

private

Definition at line 979 of file LArWFParamTool.cxx.

{
  // this is supposed to be a quick test on cali waves, to flags those 
  // clearly problematic. but cuts must be tuned, so for the time being 
  // don't call this method!
 
  //MsgStream log(msgSvc(), name());
 
  unsigned length ;
  if ( (length=larCaliWave.getSize()) < 750 ) {
   ATH_MSG_WARNING( "Calibration wave is too short!" ) ;
    return TooShort ;
  }
 
  const unsigned range = 2 ;
  unsigned nMax = 0 ;
  double tremble = 0 ;
  double maxSample = -9.E+10 ;
  for ( unsigned i=0 ; i<length ; i++ ) {
    if ( larCaliWave.getError(i) < 0 || larCaliWave.getTrigger(i) < 0 ) {
      ATH_MSG_WARNING( "Calibration wave probably not completely filled" ) ;
      return NotFilled ;
    }
    if ( larCaliWave.getTrigger(i) < 50 ) {
      ATH_MSG_WARNING( "Calibration wave with low statistics" ) ;
      return LowStat ;
    }
    double thisSample = larCaliWave.getTrigger(i) ;
    if ( thisSample > maxSample ) maxSample = thisSample ;
    if ( i>=range && i<length-range ) {
      bool max = true ;
      double loc_tremble = 0 ;
      for ( unsigned k=i-range ; k<=i+range ; k++ ) {
    double delta = thisSample - larCaliWave.getSample(k) ;
    loc_tremble += delta*delta;//  pow(delta,2) ;
    if ( delta < 0 ) max = false ;
      }
      if ( max ) nMax ++ ;
      tremble += loc_tremble / (2*range) ; 
    }
  }
  if ( sqrt(tremble/length)/maxSample > 0.1 ) {
    ATH_MSG_WARNING( "Calibration wave is noisy " << sqrt(tremble/length)/maxSample ) ;
    return Noisy ;
  }
  if ( nMax > 1 ) {
    ATH_MSG_WARNING( "Calibration wave oscillates" ) ;
    return Oscillating ;
  }
 
  return OK ;
}

cosCorr()

LArWave LArWFParamTool::cosCorr ( const unsigned  N, const double  dt, const double  fstep, const double  tcal, const double  omega  )

staticprivate

Definition at line 737 of file LArWFParamTool.cxx.

                                                                                                                          {
  LArWave w(N,dt);
  const double C1=(fstep*fstep-fstep*fstep*fstep)/Tc;
  const double C2=(fstep+omega*omega*Tc*Tc);
  const double C3=(fstep-1.)*omega*Tc;
  const double C4=( fstep*fstep+omega*omega*Tc*Tc );
  for ( unsigned i=0 ; i<N ; i++ ) {
    const double t=i*dt;
    //const double p=((fstep*fstep-fstep*fstep*fstep)/Tc*exp(-fstep*t/Tc) - omega*((fstep+omega*omega*Tc*Tc)*sin(omega*t)+(fstep-1.)*omega*Tc*cos(omega*t)) ) / ( fstep*fstep+omega*omega*Tc*Tc ) ;
    const double p=(C1*exp(-fstep*t/Tc) - omega*(C2*sin(omega*t) + C3*cos(omega*t))) / C4 ;
    w.setSample(i,p);
  }
  return w ;
}

cosResp()

LArWave LArWFParamTool::cosResp ( const LArWave &  gCali, const double &  fstep, const double &  tcal, const double &  omega  )

staticprivate

Definition at line 727 of file LArWFParamTool.cxx.

                                                                                                                   {
  
  LArWave result=gCali % cosCorr(gCali.getSize(),gCali.getDt(),fstep, tcal, omega);
  result+=gCali;
  return result;
}

cosRespShaper()

LArWave LArWFParamTool::cosRespShaper ( const LArWave &  gCali, const double &  fstep, const double &  tcal, const double &  w, const double &  tsh  ) const

private

Definition at line 720 of file LArWFParamTool.cxx.

                                                                                                                                               {
  return cosResp(gCali,fstep,tcal, w) * ( pow((1.+ w*w*tsh*tsh),1.5)/(w*tsh));
}

declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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; }

dFstep()

double LArWFParamTool::dFstep ( const LArWave &  gCali, const double  fstep, const double  Tc, const unsigned  Ttail  ) const

private

Definition at line 376 of file LArWFParamTool.cxx.

                                                                                                                    {
  LArWave stepResp1        = stepResp(gCali, fstep, Tc) ; 
  LArWave dstepRespDfstep1 = dstepRespDfstep(gCali,fstep,Tc)  ; 
  //LArWaveHelper wHelper;
  double a,b;
  if ( m_TtailMin[1]!=0 && m_TtailMax[1]!=0 && m_TtailMin[1]<m_TtailMax[1] ) {
    b = m_wHelper.getSumRegion( stepResp1 * dstepRespDfstep1,m_TtailMin[1],m_TtailMax[1]);
    a = m_wHelper.getSumSquareRegion( dstepRespDfstep1,m_TtailMin[1],m_TtailMax[1]);
  } else {
    b = m_wHelper.getSumTail( stepResp1 * dstepRespDfstep1,Ttail);
    a = m_wHelper.getSumSquareTail( dstepRespDfstep1,Ttail);
  }
  return -b/a ;
}

dstepCorrDfstep() [1/2]

double LArWFParamTool::dstepCorrDfstep ( const double  t, const double &  fstep, const double &  Tc  )

staticprivate

Definition at line 414 of file LArWFParamTool.cxx.

                                                                                              {
  return (-1./Tc)*(1.+((1.-fstep)/Tc)*t)*exp(-fstep*t/Tc);
}

dstepCorrDfstep() [2/2]

LArWave LArWFParamTool::dstepCorrDfstep ( const LArWave &  gCali, const double &  fstep, const double &  Tcal  )

staticprivate

Definition at line 418 of file LArWFParamTool.cxx.

                                                                                                      {
  const unsigned N = gCali.getSize() ;
  const double dt = gCali.getDt() ;
  LArWave w(N,dt);
  for ( unsigned i=0 ; i<N ; i++ ) w.setSample(i,dstepCorrDfstep(i*dt,fstep,Tcal)) ;
  return w ;
}

dstepRespDfstep()

LArWave LArWFParamTool::dstepRespDfstep ( const LArWave &  gCali, const double &  fstep, const double &  Tc  ) const

private

Definition at line 410 of file LArWFParamTool.cxx.

                                                                                                          {
  return gCali % dstepCorrDfstep(gCali,fstep,Tc);
}

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

expTail()

double LArWFParamTool::expTail ( const LArWave &  gCali, const WaveTiming_t &  wt  ) const

private

Definition at line 315 of file LArWFParamTool.cxx.

{
  unsigned int t1; 
  unsigned int t2; 
  if ( m_TtailMin[0]!=0 && m_TtailMax[0]!=0 && m_TtailMin[0]<m_TtailMax[0] ) {
    t1 = m_TtailMin[0];
    t2 = m_TtailMax[0];
  } else {
    const unsigned nAfterMin  = 150;
    const unsigned nBeforeEnd = 125;
    t1 = wt.Tmin + nAfterMin;
    t2 = gCali.getSize() - nBeforeEnd ;  // last points rejected because sometimes are crazy!
  }
  ATH_MSG_VERBOSE( "exp-fitting between " << t1 << " and " << t2 ) ;
  
  double A, rho  ;
  std::vector<double> fitPars = m_wHelper.expfit(gCali,t1,t2,rho) ; // fit to B*exp(A*t) function
  if (fitPars.size() == 2 ) {
    A = fitPars[1];
    //B = fitPars[0];
  } else {
    return -1;
  }
 
  const double Tcal = -1./A ;
  if ( Tcal < 0 ) {
    ATH_MSG_WARNING( "Exponential fit yielded negative Tcal " << Tcal );
  }
  ATH_MSG_VERBOSE( "*** Exponential fit\t--> m_Tcal    = " << Tcal ) ;
 
  return Tcal;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

finalize()

virtual StatusCode LArWFParamTool::finalize ( )

inlinevirtual

Definition at line 49 of file LArWFParamTool.h.

{return StatusCode::SUCCESS;}

fminbr()

double LArWFParamTool::fminbr ( double  a, double  b, const double  tol, double(LArWFParamTool::*)(double, const LArWave &, const LArWFParams &, const waveRange_t &) const  f, const LArWave &  gCali, const LArWFParams &  wf, const waveRange_t &  range  ) const

private

Definition at line 868 of file LArWFParamTool.cxx.

{
  double x,v,w;             /* Abscissae, descr. see above  */
  double fx;                /* f(x)             */
  double fv;                /* f(v)             */
  double fw;                /* f(w)             */
  const double r = (3.-sqrt(5.0))/2;    /* Gold section ratio       */
 
  assert( tol > 0 && b > a );
 
  v = a + r*(b-a);  fv = (this->*f)(v,gCali,wf,waverange);       /* First step - always gold section*/
  x = v;  w = v;
  fx=fv;  fw=fv;
 
  for(;;)       /* Main iteration loop  */
  {
    double range = b-a;         /* Range over which the minimum */
                    /* is seeked for        */
    double middle_range = (a+b)/2;
    double tol_act =            /* Actual tolerance     */
        m_SQRT_EPSILON*fabs(x) + tol/3;
    double new_step;            /* Step at this iteration       */
 
    if( fabs(x-middle_range) + range/2 <= 2*tol_act )
      return x;             /* Acceptable approx. is found  */
 
                    /* Obtain the gold section step */
    new_step = r * ( x<middle_range ? b-x : a-x );
 
 
                /* Decide if the interpolation can be tried */
    if( fabs(x-w) >= tol_act  )     /* If x and w are distinct      */
    {                   /* interpolatiom may be tried   */
        double p;                   /* Interpolation step is calcula-*/
    double q;                       /* ted as p/q; division operation*/
                                        /* is delayed until last moment */
    double t;
 
    t = (x-w) * (fx-fv);
    q = (x-v) * (fx-fw);
    p = (x-v)*q - (x-w)*t;
    q = 2*(q-t);
 
    if( q>(double)0 )       /* q was calculated with the op-*/
      p = -p;           /* posite sign; make q positive */
    else                /* and assign possible minus to */
      q = -q;           /* p                */
 
    if( fabs(p) < fabs(new_step*q) &&   /* If x+p/q falls in [a,b]*/
        p > q*(a-x+2*tol_act) &&        /* not too close to a and */
        p < q*(b-x-2*tol_act)  )            /* b, and isn't too large */
      new_step = p/q;           /* it is accepted         */
                    /* If p/q is too large then the */
                    /* gold section procedure can   */
                    /* reduce [a,b] range to more   */
                    /* extent           */
    }
 
    if( fabs(new_step) < tol_act ) {    /* Adjust the step to be not less*/
      if( new_step > (double)0 )    /* than tolerance       */
    new_step = tol_act;
      else
    new_step = -tol_act;
    }
 
                /* Obtain the next approximation to min */
    {               /* and reduce the enveloping range  */
      double t = x + new_step;  /* Tentative point for the min  */
      double ft = (this->*f)(t,gCali,wf,waverange);
      if( ft <= fx )
      {                                 /* t is a better approximation  */
    if( t < x )         /* Reduce the range so that */
      b = x;                        /* t would fall within it   */
    else
      a = x;
      
    v = w;  w = x;  x = t;      /* Assign the best approx to x  */
    fv=fw;  fw=fx;  fx=ft;
      }
      else                              /* x remains the better approx  */
      {                          
    if( t < x )         /* Reduce the range enclosing x */
      a = t;                   
    else
      b = t;
      
        if( ft <= fw || w==x )
        {
           v = w;  w = t;
       fv=fw;  fw=ft;
        }
        else if( ft<=fv || v==x || v==w )
        {
           v = t;
       fv=ft;
        }
      }
    }           /* ----- end-of-block ----- */
  }     /* ===== End of loop ===== */   
}

fstepMin()

double LArWFParamTool::fstepMin ( const LArWave &  gCali, double  fstep, const double  Tc, const unsigned  Ttail  ) const

private

Definition at line 360 of file LArWFParamTool.cxx.

                                                                                                                {
  int niter = 0;
  //double dfstep;
  while (1) {
    niter++ ;
    const double dfstep = dFstep(gCali,fstep,Tc,Ttail) ;
    fstep += dfstep ;
    if ( niter > 50 || fstep < 0. ) {
      fstep = 0.;
      break;
    }
    if ( fabs( dfstep ) <= m_TINY ) break;
  }
  return fstep;
}

GetFstep()

StatusCode LArWFParamTool::GetFstep ( const LArWave &  gCali, LArWFParams &  wfParams, const WaveTiming_t &  wt  ) const

private

Definition at line 348 of file LArWFParamTool.cxx.

{
  // step response
  const unsigned Ttail = wt.Tmin + m_DeltaTtail[0]; 
  //m_Fstep = 0.; // starting point for iterations
  const double fstep1=0.0;
  const double Tcal=wfParams.tcal();
  wfParams.setFstep(fstepMin(gCali,fstep1,Tcal,Ttail) );
  //ATH_MSG_VERBOSE( "*** Step response\t--> m_Fstep   = " << m_Fstep ) ;
  return StatusCode::SUCCESS ;
}

getLArWaveParams()

StatusCode LArWFParamTool::getLArWaveParams	(	const LArCaliWave &	larCaliWave,
		const HWIdentifier	chid,
		const CaloGain::CaloGain	gain,
		LArWFParams &	wfParams,
		const LArOnOffIdMapping *	cabling,
		std::optional< LArCaliWave > &	omegaScan,
		std::optional< LArCaliWave > &	resOscill0,
		std::optional< LArCaliWave > &	resOscill1
	)		const

Definition at line 197 of file LArWFParamTool.cxx.

{
 
 
  wfParams.setTshaper(m_Tshaper);    
  LArCaliWave gCali=larCaliWave; //down-cast to LArWave + deep copy (we'll modify the wave)
 
  // find m_Tstart, m_Tpeak, m_Tcross, m_Tmin, m_Amplitude
  WaveTiming_t waveTiming=timeExtr(gCali);
 
  // find m_Tcal   
  if ( wfParams.tcal() == DoExtract ) {
    const double Tcal = expTail(gCali,waveTiming) ;
    if ( Tcal < 0 ) {
      ATH_MSG_WARNING( "Could not extract Tcal for " << m_onlineHelper->channel_name(chid) 
            << " gain=" << (int)gain ) ;
      wfParams.setTcal(FailExtract);
      return StatusCode::FAILURE;
    }
    else {
      wfParams.setTcal(Tcal);
    }
    ATH_MSG_VERBOSE( "set Tcal = " << wfParams.tcal()) ;
  }
    
  // find m_Fstep
  if ( wfParams.fstep() == DoExtract ) {
    StatusCode sc = GetFstep(gCali,wfParams,waveTiming);
    if ( sc.isFailure() ) {
      ATH_MSG_WARNING( "Could not extract Fstep for " << m_onlineHelper->channel_name(chid) 
            << " gain=" << (int)gain );
      wfParams.setFstep(FailExtract);
      return sc ;
    }
  } else {
    ATH_MSG_VERBOSE( "set Fstep = " <<wfParams.fstep() );  
  }
 
  // find m_Omega0 using RTM
  if ( wfParams.omega0() == DoExtract ) {
    StatusCode sc = RTM_Omega0(gCali,chid,wfParams,waveTiming,cabling,omegaScanWave);
    if ( sc.isFailure() ) {
      ATH_MSG_WARNING( "Could not extract Omega0 for " << m_onlineHelper->channel_name(chid)  
            << " gain=" << (int)gain ); 
      wfParams.setOmega0(FailExtract) ;
      return sc ;
    }
  } else {
    ATH_MSG_VERBOSE( "set Omega0 = " << wfParams.omega0());
  }
 
 
  const Identifier id = cabling->cnvToIdentifier(chid);
  const unsigned layer=m_emId->sampling(id);
  if ( m_storeResOscill[ layer ] && resOscill0) {
    LArWave injres0 = injRespRes(gCali,wfParams.omega0(),0);
    *resOscill0 = LArCaliWave(injres0.getWave(),gCali.getDt(),gCali.getDAC(), 0x1,LArWave::unknown);
  }
 
  // find m_Taur using RTM
  if ( wfParams.taur() == DoExtract ) { 
    StatusCode sc = RTM_Taur(gCali, wfParams,waveTiming ) ;
    if ( sc.isFailure() ) {
      ATH_MSG_WARNING( "Could not extract Taur for ChID=" << chid.get_compact() 
            << " gain=" << (int)gain ) ;
      wfParams.setTaur(FailExtract);
      return sc ;
    }
    ATH_MSG_VERBOSE( "set Taur = " << wfParams.taur() );
  }
 
  wfParams.setFlag( 0 ) ;  // this should contain the method used to find parameters and the gain
 
  if ( m_storeResOscill[ layer ] && resOscill1) {
    LArWave injres1 = injRespRes(gCali,wfParams.omega0(),wfParams.taur());
    *resOscill1 = LArCaliWave(injres1.getWave(),gCali.getDt(),gCali.getDAC(), 0x1, LArWave::unknown);  
  }
 
  return( StatusCode::SUCCESS );
}

initialize()

StatusCode LArWFParamTool::initialize ( )

virtual

Definition at line 112 of file LArWFParamTool.cxx.

{
  std::string layerName[4] = { "PS" , "Strips" , "Middle" , "Back" } ;
  
  ATH_MSG_INFO( "TShaper set to " << m_Tshaper << " ns" ) ;
 
  ATH_MSG_INFO( "Step response (Fstep)        -> Ttail = Tmin + " << m_DeltaTtail[0] << " steps" ) ;
 
  if (!m_UseOmegaScanHelper)
    ATH_MSG_INFO( "Cosine response (Omega0)     -> Ttail = Tmin + " << m_DeltaTtail[1] << " steps" ) ;
  else
    ATH_MSG_INFO( "Cosine response (Omega0)     -> Will use OmegaScanHelper() to dynamically select settings" );
 
  ATH_MSG_INFO( "Residual oscillations (Taur) -> Ttail = Tmin + " << m_DeltaTtail[2] << " steps" ) ;
  
  for ( unsigned layer=0 ; layer<4 ; ++layer ) {
    ATH_MSG_INFO( "options for Layer " << layer << " (" << layerName[layer] << ")" ) ;
 
    ATH_MSG_INFO( "      perform cos resp scan: " );
    if ( m_cosRespScan[layer] && !m_UseOmegaScanHelper ) 
      ATH_MSG_INFO( "YES (" << m_npoints[layer] << " points)" ) ;
    if ( !m_cosRespScan[layer] && !m_UseOmegaScanHelper ) 
      ATH_MSG_INFO( "NO" ) ;
    if ( m_UseOmegaScanHelper )
      ATH_MSG_INFO( "Will use OmegaScanHelper() to dynamically select settings" ) ;
 
    if (!m_UseOmegaScanHelper) {
      ATH_MSG_INFO( "      search interval: [ " << m_omegamin[layer] << " ; " << m_omegamax[layer] << " ]" ) ;
      if ( m_omegamin[layer] >= m_omegamax[layer] ) {
    ATH_MSG_ERROR( "Omega0Min >= Omega0Max in layer " << layer << " -- exit!" ) ;
    return StatusCode::FAILURE ;
      }
    }
 
    ATH_MSG_INFO( "      store residual oscillation wave:" );
    if ( m_storeResOscill[layer] ) {
      ATH_MSG_INFO( "YES" ) ;
    } else {
      ATH_MSG_INFO( "NO" ) ;
    }
 
  }
 
  
  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");
    
  } 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. ");
    
  }
  
  /*sc = detStore()->retrieve(m_emId, "LArEM_ID");
  if (sc.isFailure()) {
    msg(MSG::ERROR) << "Could not get LArOnlineID helper" << endmsg;
    return sc;
  }*/
  const CaloIdManager *caloIdMgr=nullptr;
  ATH_CHECK( detStore()->retrieve(caloIdMgr));
  if(!caloIdMgr){
    ATH_MSG_ERROR( "Could not access CaloIdManager" );
    return StatusCode::FAILURE;
  }
  if ( m_isSC ) {
    m_emId=caloIdMgr->getEM_SuperCell_ID();
  } else {
    m_emId=caloIdMgr->getEM_ID();
  }
  if (!m_emId) {
    ATH_MSG_ERROR( "Could not access lar EM ID helper" );
    return StatusCode::FAILURE;
  }
 
 
  return StatusCode::SUCCESS;
}

injCorr()

LArWave LArWFParamTool::injCorr ( const unsigned  N, const double  dt, const double  omega0, const double  taur  )

staticprivate

Definition at line 765 of file LArWFParamTool.cxx.

                                                                                                        {
 
  LArWave w(N,dt);
 
  const double tau0 = 1./omega0;
  const double Delta = taur*taur - 4*tau0*tau0;
  if ( Delta > 0 ) {
    const double sqrtDelta = sqrt(Delta) ;
    const double taup = 0.5*( taur + sqrtDelta ) ;
    const double taum = 0.5*( taur - sqrtDelta ) ;
    for ( unsigned i=0 ; i<N ; i++ ) {
      const double t=i*dt;
      w.setSample(i, (exp(-t/taup) - exp(-t/taum) ) / (taup - taum));
    }
    //return ( exp(-t/taup) - exp(-t/taum) ) / ( taup - taum ) ;
  } else if ( Delta < 0 ) {
    const double T = sqrt(-Delta) ;
    const double A = 2 * taur / ( (taur*taur) - Delta ) ;
    const double B = 2 * T / ( (taur*taur) - Delta ); 
    for ( unsigned i=0 ; i<N ; i++ ) {
      const double t=i*dt;
      w.setSample(i, 2 * exp(-A*t) * sin(B*t) / T);
    }
    //return 2 * exp(-A*t) * sin(B*t) / T ;
  } else { //Delta==0
    const double tau = 0.5 * taur ;
    //    return exp(-t/tau) * t / pow(tau,2) ;
    for ( unsigned i=0 ; i<N ; i++ ) {
      const double t=i*dt;
      w.setSample(i,exp(-t/tau) * t / (tau*tau)) ;
    }
    //return exp(-t/tau) * t / (tau*tau) ;
  } //end else
  return w;
}

injRespRes()

LArWave LArWFParamTool::injRespRes ( const LArWave &  w, const double  omega0, const double  taur  )

staticprivate

Definition at line 761 of file LArWFParamTool.cxx.

                                                                                            {
  return w - ( w % injCorr(w.getSize(),w.getDt(),omega0,taur) );
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

static const InterfaceID& LArWFParamTool::interfaceID ( )

inlinestatic

Definition at line 40 of file LArWFParamTool.h.

{ return IID_LArWFParamTool; }

logChi2CosRespShaper()

double LArWFParamTool::logChi2CosRespShaper ( const double  omega, const LArWave &  gCali, const LArWFParams &  wf, const waveRange_t &  range  ) const

private

Definition at line 716 of file LArWFParamTool.cxx.

                                                                                                                                                  {
  return log(m_wHelper.getSumSquareRegion(cosRespShaper(gCali,wfParams.fstep(),wfParams.tcal(),omega,wfParams.tshaper()),range.min,range.max)) ; 
}

logChi2InjRespRes()

double LArWFParamTool::logChi2InjRespRes ( const double  taur, const LArWave &  gCali, const LArWFParams &  wf, const waveRange_t &  range  ) const

private

Definition at line 757 of file LArWFParamTool.cxx.

                                                                                                                                        {
  return m_wHelper.getSumSquareRegion(injRespRes(gCali,wf.omega0(),taur), range.min, range.max);
}

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

omega0MinNum()

double LArWFParamTool::omega0MinNum ( double  omegaMin, double  omegaMax, const double  tol, const LArWave &  gCali, const LArWFParams &  wf, const waveRange_t &  range  ) const

private

Definition at line 801 of file LArWFParamTool.cxx.

                                                                                                                                                                    {
  return fminbr ( omegaMin, omegaMax, tol, &LArWFParamTool::logChi2CosRespShaper, gCali, wf, range);
}

OmegaScanHelper()

LArWFParamTool::omegaScanParams_t LArWFParamTool::OmegaScanHelper ( const Identifier  id, const WaveTiming_t &  wt  ) const

private

Definition at line 498 of file LArWFParamTool.cxx.

                                                                                                                  {
 
  omegaScanParams_t ret{};
 
  // this is a skeleton of the final function: use at your own risk! M.D. & C.G.
  // EMEC part modified by L. March - 7 April 2011
 
  const unsigned layer=m_emId->sampling(id);
  
  ret.range.min   = m_TtailMin[2];
  ret.range.max   = m_TtailMax[2];
  ret.cosRespScan = m_cosRespScan[ (unsigned)layer ] ;
  ret.omegamin    = m_omegamin[ (unsigned)layer ] ;
  ret.omegamax    = m_omegamax[ (unsigned)layer ] ;
  ret.Npoint      = m_npoints[ (unsigned)layer ] ;
  ret.DeltaOmega  = 0.02 ;
  //DeltaOmega  = 0.001 ;
 
  //if ( m_BarrelEC==0 ) { // Barrel
  if (m_emId->is_em_barrel(id)) {
 
    if ( layer==0 ) { // PS
      ret.range.min   = wt.Tstart;
      ret.range.max   = wt.Tcross;
      ret.cosRespScan = m_cosRespScan[ (unsigned)layer ];
      ret.omegamin    = 0.240;
      ret.omegamax    = 0.330;
      ret.Npoint      = 900;
    }
 
    if ( layer==1 ) { // Strips
      ret.range.min = wt.Tstart;
      ret.range.max = wt.Tcross;
      ret.cosRespScan = true;
      // Strips interval 1
      //ret.omegamin    = 0.150;
      //ret.omegamax    = 0.220;
      //ret.Npoint      = 700;
      // Strips interval 2
      ret.omegamin    = 0.220;
      ret.omegamax    = 0.310;
      ret.Npoint      = 900;
      // Strips interval 3
      //omegamin    = 0.310;
      //omegamax    = 0.390;
      //Npoint      = 1400;
    }
 
    if ( layer==2 ) { // Middle
      ret.range.min = wt.Tstart;
      ret.range.max = wt.Tmin + m_DeltaTtail[1];
      ret.cosRespScan = false;
      ret.omegamin    = 0.060;
      ret.omegamax    = 0.215;
      //Npoint      = 315;
    }
 
    if ( layer==3 ) { // Back     
      ret.range.min   = wt.Tstart;
      ret.range.max   = wt.Tcross;
      ret.cosRespScan = false;
      ret.omegamin    = 0.100;
      ret.omegamax    = 0.700;  
      ret.Npoint      = 120;
    }
 
  } 
  else {
    //if ( m_BarrelEC==1 ) { // EndCap
 
    // use pulse peak to perform cosine response tranformation minimization
    //ret.range.min = m_Tstart;
    //ret.range.max = m_Tcross;
    ret.range.min = 0.;
    ret.range.max = 0.;
 
    ret.DeltaOmega  = 0.001 ;
 
    //(*m_log) << MSG::WARNING << " m_Tstart= " << m_Tstart << " m_Tcross=" << m_Tcross ) ;
 
    const bool IsEMECInnerWheel = m_emId->is_em_endcap_inner(id);//m_onlineHelper->isEMECinHECchannel(m_chID);
    const int eta=m_emId->eta(id); 
    if ( IsEMECInnerWheel ) { // EMEC Inner Wheel
      
      if ( layer==1 ) {
    //omegamin    = 0.10 ;
    //omegamax    = 0.20 ;
    ret.omegamin    = 0.12 ;
    if(eta>=0 && eta<=3) 
      {
        ret.omegamin    = 0.12 ;
        //omegamax = 0.165 ;
        ret.omegamax = 0.16 ;
        ret.Npoint=100;
      }
    if(eta>=4 && eta<=6) 
      {
        ret.omegamin    = 0.14 ;
        ret.omegamax = 0.18 ;
        ret.Npoint=100;
      }
      } else
      if ( layer == 2 ) { // don't extract Omega0   
    /*
    cosRespScan = false;
    omegamin    = 0.;
    omegamax    = 0.;
    Npoint      = 0;
    DeltaOmega  = 0.; 
    */
    ret.cosRespScan = true;
    ret.omegamin    = 0.12;
    ret.omegamax    = 0.35;
    ret.Npoint      = 100;
      } else { // don't extract Omega0   
    ret.cosRespScan = false;
    ret.omegamin    = 0.;
    ret.omegamax    = 0.;
    ret.Npoint      = 0;
    ret.DeltaOmega  = 0.; 
      }
 
    } else { // EMEC Outer Whell
 
      if ( layer==1 ) { // don't extract Omega0
    ret.cosRespScan = false;
    ret.omegamin    = 0.;
    ret.omegamax    = 0.;
    ret.Npoint      = 0;
    ret.DeltaOmega  = 0.;
      } else
      if ( layer == 2 ) { 
        ret.cosRespScan = true;
    ret.Npoint  =100;
    ret.omegamin=0.1;
    if(eta==0) {
      ret.omegamax    = 0.140 ;
    } 
    if(eta==1) {
      ret.omegamax    = 0.135 ;
    }
    if(eta==2) {
      ret.omegamax    = 0.15 ;
    } 
    if(eta==3) {
      ret.omegamin    = 0.10;
          ret.omegamax    = 0.16;
        }
    if(eta>=4 &&  eta<11 ) {
      ret.omegamin    = 0.12 ;
      ret.omegamax    = 0.20 ;
    } 
    if(eta==11) {
      ret.omegamin    = 0.12 ;
      ret.omegamax    = 0.22 ;
    } 
    if(eta>=12 && eta<28) {
      ret.omegamin    = 0.12 ;
      ret.omegamax    = 0.24 ;
    } 
    if(eta>=28 && eta<39) {
      ret.omegamin    = 0.12 ;
      ret.omegamax    = 0.245 ;
    } 
    if(eta>=39 && eta<43) {
      //ret.omegamin    = 0.12 ;
          ret.omegamin    = 0.24 ; 
      ret.omegamax    = 0.32 ;
    }
      } else { // don't extract Omega0
    ret.cosRespScan = false;
    ret.omegamin    = 0.;
    ret.omegamax    = 0.;
    ret.Npoint      = 0;
    ret.DeltaOmega  = 0.;
      }
 
    } // end of EMEC Outer Wheel
 
  } // end of EMEC
 
  return ret;
}

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

RTM_Omega0()

StatusCode LArWFParamTool::RTM_Omega0 ( const LArWave &  gCali, const HWIdentifier  chid, LArWFParams &  wfParams, const WaveTiming_t &  wt, const LArOnOffIdMapping *  cabling, std::optional< LArCaliWave > &  omegaScan  ) const

private

Definition at line 426 of file LArWFParamTool.cxx.

{
  /*  begin of the COSINE RESPONSE analysis */
   
  const Identifier id = cabling->cnvToIdentifier(chid);
  // Define the (raw) minimum research interval (if the Layer card is not set,
  // uses the wider interval, and default value for the first minimum scan)
 
  omegaScanParams_t OSParams{};  
 
  // defaults (e.g. to be used in case cosRespScan=true)
  OSParams.cosRespScan  = true ;
  OSParams.omegamin   = 0.01 ;
  OSParams.omegamax   = 1.   ;
  OSParams.Npoint        = 100  ;
  OSParams.DeltaOmega = 0.01 ; // GHz
  OSParams.range.min=m_TtailMin[2];
  OSParams.range.max=m_TtailMax[2];
 
  if ( !m_UseOmegaScanHelper) {
    const unsigned layer=m_emId->sampling(id);    
    OSParams.cosRespScan = m_cosRespScan[ layer ] ;
    OSParams.omegamin    = m_omegamin[ layer ] ;
    OSParams.omegamax    = m_omegamax[ layer ] ;
    OSParams.Npoint      = m_npoints[ layer ] ;
    OSParams.DeltaOmega  = 0.02 ;
    //DeltaOmega  = 0.001 ;
  } else {
    OSParams=OmegaScanHelper(id,wt);
  }
 
  waveRange_t range=OSParams.range;
//if (m_TtailMin[2]==0 || m_TtailMax[2]==0 || m_TtailMin[2]>=m_TtailMax[2]) {
  if (range.min==0 || range.max==0 || range.min>=range.max) {
    range.min=wt.Tmin + m_DeltaTtail[1];
    range.max=gCali.getSize();
  }
 
  if ( OSParams.cosRespScan ){   
    // makes a raw scan of the cosresp chi2 logarithm
    const double dOmega = (OSParams.omegamax-OSParams.omegamin)/OSParams.Npoint;
    const unsigned vectSize = (unsigned) ceil ( OSParams.omegamax/dOmega );
    const unsigned indexmin = (unsigned) floor( OSParams.omegamin/dOmega );
    if (omegaScanWave) omegaScanWave->setSize(vectSize);
    double chi2min = LAR_MAX_DOUBLE, omega0raw = LAR_MAX_DOUBLE;  
    for (int i=0;i<OSParams.Npoint;i++) {
      const double omega = OSParams.omegamin+dOmega*i ;
      const double chi2 = logChi2CosRespShaper(omega, gCali, wfParams, range);
      if (omegaScanWave) omegaScanWave->setSample(i+indexmin,chi2);
      if ( chi2 < chi2min ) { 
    chi2min   = chi2;
    omega0raw = omega;
      }
    }
 
    OSParams.omegamin = omega0raw - OSParams.DeltaOmega ;
    OSParams.omegamax = omega0raw + OSParams.DeltaOmega ;
  }
 
  if ( OSParams.omegamin == OSParams.omegamax ) { // skip cosine response calculation
    wfParams.setOmega0(0.); // this will force no injection point correction in LArPhysWavePredictor
    ATH_MSG_VERBOSE( "*** Cosine response skipped\t--> m_Omega0  = " << wfParams.omega0() ) ;  
  } else { // numerical (Brent) log(chi2) minimization
    wfParams.setOmega0(omega0MinNum ( OSParams.omegamin, OSParams.omegamax, m_EPSILON, gCali, wfParams, range)  );
    ATH_MSG_VERBOSE( "*** Cosine response\t--> m_Omega0  = " <<wfParams.omega0() ) ;
  }
 
  /* end of the COSINE RESPONSE analysis */
  return StatusCode::SUCCESS ;
}

RTM_Taur()

StatusCode LArWFParamTool::RTM_Taur ( const LArWave &  gCali, LArWFParams &  wfParams, const WaveTiming_t &  wt  ) const

private

Definition at line 683 of file LArWFParamTool.cxx.

{
  /* begin of the INJECTION POINT CORRECTION RESIDUAL OSCILLATION analysis */
    
  // m_Taur minimum search interval... 
  double taurmin = 0.; // ns
  //double taurmax = 4.; // ns
  double taurmax = 100.; // ns
 
  if ( wf.omega0()==0) {
    wf.setTaur(0);
    ATH_MSG_VERBOSE( "*** Injection point skipped\t--> m_Taur    = " << wf.taur() ) ;
  } else {
    // numerical (Brent) log(chi2) minimization
    waveRange_t range{};
    if ( m_TtailMin[3]!=0 && m_TtailMax[3]!=0 && m_TtailMin[3]<m_TtailMax[3]) {
      range.min=m_TtailMin[3];
      range.max=m_TtailMax[3];
    }
    else {
      range.min= wt.Tmin + m_DeltaTtail[2];
      range.max=gCali.getSize();
    }
 
    wf.setTaur(taurMinNum ( taurmin, taurmax, m_EPSILON, gCali, wf, range));
    ATH_MSG_VERBOSE( "*** Injection point\t--> m_Taur    = " << wf.taur()) ;
  }
 
  /* end of the INJECTION POINT CORRECTION RESIDUAL OSCILLATION analysis */
 
  return StatusCode::SUCCESS ;
}

stepCorr()

LArWave LArWFParamTool::stepCorr ( const LArWave &  gCali, const double &  fstep, const double &  Tc  )

staticprivate

Definition at line 398 of file LArWFParamTool.cxx.

                                                                                            {
  const unsigned N = gCali.getSize() ;
  const double dt = gCali.getDt() ;
 
  LArWave w(N,dt);
  const double A=(1.-fstep)/Tc;
  for ( unsigned i=0 ; i<N ; i++ ) {
    w.setSample(i,A*exp(-fstep*i*dt/Tc));
  }
  return w ;
}

stepResp()

LArWave LArWFParamTool::stepResp ( const LArWave &  gCali, const double  fstep, const double  Tc  )

staticprivate

Definition at line 391 of file LArWFParamTool.cxx.

                                                                                           {
  //return m_gCali + m_gCali % stepCorr() ;
  LArWave result = gCali % stepCorr(gCali, fstep, Tc);
  result+=gCali;
  return result;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

taurMinNum()

double LArWFParamTool::taurMinNum ( const double  taurmin, const double  taurmax, const double  tol, const LArWave &  gCali, const LArWFParams &  wf, const waveRange_t &  range  ) const

private

Definition at line 810 of file LArWFParamTool.cxx.

                                                                                                                                                                             {
  return fminbr ( taurmin, taurmax, tol, &LArWFParamTool::logChi2InjRespRes, gCali, wf, range );
}

timeExtr()

LArWFParamTool::WaveTiming_t LArWFParamTool::timeExtr ( LArWave &  gCali ) const

private

Definition at line 287 of file LArWFParamTool.cxx.

{
  WaveTiming_t wt{}; //return object
 
  wt.Tstart = m_wHelper.getStart(gCali);
  
  const unsigned NBaseline= m_NBaseline==0 ? wt.Tstart :  m_NBaseline ;
 
  const double baseline = m_wHelper.getBaseline(gCali,NBaseline);
  
  if ( m_ShiftToStart ) // move the wave to the start
    gCali = m_wHelper.translate(gCali, -wt.Tstart, baseline); 
  
  if ( m_SubtractBaseline ) // remove the baseline
    gCali = gCali + (-baseline);
  
  wt.Tpeak = m_wHelper.getMax(gCali);
 
  wt.Amplitude = gCali.getSample(wt.Tpeak);
   
  wt.Tmin  = m_wHelper.getMin(gCali);
 
  wt.Tcross = m_wHelper.getZeroCross(gCali);
 
  return wt;
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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_cosRespScan

std::vector<bool> LArWFParamTool::m_cosRespScan

private

Definition at line 101 of file LArWFParamTool.h.

m_DEFAULT

const double LArWFParamTool::m_DEFAULT = -1

staticprivate

Definition at line 78 of file LArWFParamTool.h.

m_DeltaTtail

std::vector<int> LArWFParamTool::m_DeltaTtail

private

Definition at line 115 of file LArWFParamTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_emId

const LArEM_Base_ID* LArWFParamTool::m_emId = nullptr

private

Definition at line 93 of file LArWFParamTool.h.

m_EPSILON

const double LArWFParamTool::m_EPSILON =2.22045e-16

staticprivate

Definition at line 81 of file LArWFParamTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_isSC

bool LArWFParamTool::m_isSC

private

Definition at line 112 of file LArWFParamTool.h.

m_NBaseline

unsigned int LArWFParamTool::m_NBaseline

private

Definition at line 108 of file LArWFParamTool.h.

m_npoints

std::vector<unsigned> LArWFParamTool::m_npoints

private

Definition at line 104 of file LArWFParamTool.h.

m_omegamax

std::vector<double> LArWFParamTool::m_omegamax

private

Definition at line 103 of file LArWFParamTool.h.

m_omegamin

std::vector<double> LArWFParamTool::m_omegamin

private

Definition at line 102 of file LArWFParamTool.h.

m_onlineHelper

const LArOnlineID_Base* LArWFParamTool::m_onlineHelper = nullptr

private

Definition at line 94 of file LArWFParamTool.h.

m_ShiftToStart

bool LArWFParamTool::m_ShiftToStart

private

Definition at line 109 of file LArWFParamTool.h.

m_SQRT_EPSILON

const double LArWFParamTool::m_SQRT_EPSILON =1.49012e-08

staticprivate

Definition at line 80 of file LArWFParamTool.h.

m_storeResOscill

std::vector<bool> LArWFParamTool::m_storeResOscill

private

Definition at line 107 of file LArWFParamTool.h.

m_SubtractBaseline

bool LArWFParamTool::m_SubtractBaseline

private

Definition at line 110 of file LArWFParamTool.h.

m_TINY

const double LArWFParamTool::m_TINY =2.22045e-16

staticprivate

Definition at line 79 of file LArWFParamTool.h.

m_Tshaper

double LArWFParamTool::m_Tshaper

private

Definition at line 99 of file LArWFParamTool.h.

m_TtailMax

std::vector<int> LArWFParamTool::m_TtailMax

private

Definition at line 114 of file LArWFParamTool.h.

m_TtailMin

std::vector<int> LArWFParamTool::m_TtailMin

private

Definition at line 113 of file LArWFParamTool.h.

m_UseOmegaScanHelper

bool LArWFParamTool::m_UseOmegaScanHelper

private

Definition at line 111 of file LArWFParamTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_wHelper

LArWaveHelper LArWFParamTool::m_wHelper

private

Definition at line 96 of file LArWFParamTool.h.

---

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

• LArWFParamTool.h
• LArWFParamTool.cxx