LArPhysWaveHECTool Class Reference

#include <LArPhysWaveHECTool.h>

Inheritance diagram for LArPhysWaveHECTool:

Collaboration diagram for LArPhysWaveHECTool:

Public Member Functions
	LArPhysWaveHECTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~LArPhysWaveHECTool ()
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
StatusCode	makeLArPhysWaveHEC (LArWFParams &wfParams, LArCaliWave &caliWave, LArPhysWave &predLArPhysWave, const LArPhysWave &LArIdealPhysWave, float &MphysMcali, const HWIdentifier &chid, const int gain, int &LArPhysWaveFlag)
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	sysInitialize () override
	Perform system initialization for an algorithm.
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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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	predict_phys_HEC (LArWFParams &wfParams, LArCaliWave &caliWave, LArPhysWave &predLArPhysWave, float &MphysMcali, const HWIdentifier &chid, const int gain)
TF1 *	CaliWave2PhysWaveHEC (TProfile *pcal, Double_t *par, double *parCL, TF1 *&deriv, Bool_t uset0, Bool_t norm, int adc, Double_t *xmax, bool gsl_flag)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const LArPhysWave *	m_gIdealPhys = nullptr
const LArOnlineID_Base *	m_onlineHelper = nullptr
bool	m_normalizeCali
bool	m_timeOriginShift
bool	m_subtractBaseline
bool	m_isSC
double	m_TcalMin
double	m_TcalMax
double	m_TcalAverage
double	m_FstepMin
double	m_FstepMax
double	m_FstepAverage
double	m_Omega0 = 0.0
double	m_Taur = 0.0
unsigned	m_Tstart = 0U
double	m_MinAmp
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 int	DEFAULT =-1

Detailed Description

Definition at line 38 of file LArPhysWaveHECTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

LArPhysWaveHECTool()

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

Definition at line 59 of file LArPhysWaveHECTool.cxx.

  : AthAlgTool(type,name,parent)
{
 
  // Declare additional interface
  declareInterface<LArPhysWaveHECTool>(this);
 
  declareProperty("NormalizeCali",    m_normalizeCali=false) ;//true?
  declareProperty("TimeOriginShift",  m_timeOriginShift=false) ;
  declareProperty("SubtractBaseline", m_subtractBaseline=true) ;
  declareProperty("isSC",             m_isSC=false) ;
  declareProperty("TcalMin",          m_TcalMin=370) ;
  declareProperty("TcalMax",          m_TcalMax=490) ;
  declareProperty("TcalAverage",      m_TcalAverage=422.2) ;
  declareProperty("FstepMin",         m_FstepMin=0.02) ;
  declareProperty("FstepMax",         m_FstepMax=0.1) ;
  declareProperty("FstepAverage",     m_FstepAverage=0.068) ;
  declareProperty("MinAmplitude",     m_MinAmp=100.);  
}

~LArPhysWaveHECTool()

LArPhysWaveHECTool::~LArPhysWaveHECTool ( )

virtual

Definition at line 79 of file LArPhysWaveHECTool.cxx.

{}

Member Function Documentation

CaliWave2PhysWaveHEC()

TF1 * LArPhysWaveHECTool::CaliWave2PhysWaveHEC ( TProfile * pcal, Double_t * par, double * parCL, TF1 *& deriv, Bool_t uset0, Bool_t norm, int adc, Double_t * xmax, bool gsl_flag )

private

Definition at line 662 of file LArPhysWaveHECTool.cxx.

                                                                                           {
 
 TF1 *fitfun{}, *fu{}; 
 Int_t i{},nbin{},nbino{},i5bin{},count{} ;
 Double_t  pampl{}, t5{}, mcut{}, rshift{}, rmult{};
 
// Cables amplitude
  a = 0.974;
// Cables poles
  tau0 = 1.5; 
// New value according to findings on Sept. 2001 run
  taup = 19.5; 
  tauz = 18.;
// Should be smaller
  taus = 0.1;
// Step amplitude
 
  al=parCL[1]; // FT: can be exchanged with m_Fstep
 
  tc=parCL[0];  // FT: can be exchanged with m_Tcal
 
// Drift time
//  tdr = 440.;
// New value:
   tdr = 449.7;
   
 nbino = nbin = pcal->GetNbinsX();
 if(nbin>NMAX) nbin = NMAX;
 if(nbino>NMAX) nbino = NMAX;
 
 if(norm) {
   normalize_prof(pcal,&pampl);
   mcut = 0.05;
 } else {
   mcut = 0.05*pcal->GetMaximum();
 } 
 
 cout<<"mcut: "<<mcut<<endl;
 i5bin = 0;
 for(i=1; i<=nbin; ++i) {
   x[i-1] = pcal->GetBinCenter(i);
   y[i-1] = pcal->GetBinContent(i);
   if(i5bin == 0 && y[i-1] > mcut) i5bin = i; 
  };
  //check access range
  if (i5bin<2) {
    printf("\n number of bins too small !\n");
    return nullptr;
  }
 t5 = (mcut-y[i5bin-2])*(x[i5bin-1]-x[i5bin-2])/(y[i5bin-1]-y[i5bin-2]);
 t5 += x[i5bin-2];
//
// t0 is app. 16.8 ns less than t5 (from reference shapes 2002)
//
 t0 = t5 - 16.8;
 
 
 if(fabs((x[1] - x[0]) - (x[3] - x[2])) > 0.000001 ) {
   cout<< x[0] << " " << x[1] << " " << x[2] << " " << x[3] << endl;
   printf("\n Nonuniform step !\n");
   return nullptr;
 }
 
 STEP = x[1] - x[0];
 
 
 if(pref) delete [] pref;
 pref = new Double_t[nbin];
 
 count = 0; 
 for(i=0; i<nbin; ++i) {
   if(x[i] < t0) {pref[i] = 0.; continue;}
   double AmplPhys      = m_gIdealPhys->getSample(count);
   pref[i]         = AmplPhys;
   ++count;
   if(count==(int)m_gIdealPhys->getSize()) break;
 } 
 if(i<nbin) nbin = i+1;
 
// Try to find the shift and mult. for reference signal
 if(splin) delete splin;
 splin = new TSpline3("sp",x,pref,nbin,"b1",0.);
 fu = new TF1("fu",P,x[15],x[nbin-15],2);
 fu->SetParName(0,"t0 shift");
 fu->SetParLimits(0,-15.,15.);
 fu->SetParName(1,"mult");
 fu->SetParLimits(1,0.,10000.);
 fu->SetParameters(5.,5.);
 
 if( pcal->Fit("fu","RQ0") == 0) {
    rshift = pcal->GetFunction("fu")->GetParameter(0);
    rmult = pcal->GetFunction("fu")->GetParameter(1);
 } else {
    rshift = 0; rmult= pcal->GetMaximum()/ (* std::max_element(m_gIdealPhys->getWave().begin(), m_gIdealPhys->getWave().end()));
 }
 
 delete fu;
// Read the reference again, shifting and multiplying:
 count = 0; 
 for(i=0; i<nbin; ++i) {
   if(x[i] < t0-rshift) {pref[i] = 0.; continue;}
   double AmplPhys      = rmult*m_gIdealPhys->getSample(count);
   pref[i]         = AmplPhys;
   ++count;
   if(count==(int)m_gIdealPhys->getSize()) break;
 } 
 if(i<nbin) nbin = i+1;
 
 if(uset0){ 
   for(i=1; i<=nbin; ++i)  x[i-1] -= t0;
   t0 = 0.;
  }
 else {
   for(i=1; i<=nbin; ++i)  x[i-1] += par[0];
   t0 += par[0];
  }
 par[0] = 0;
 Smooth_new(x, y, pref, nbin);
 if(splin) delete splin;
 splin = new TSpline3("sp",x,pref,nbin,"b1",0.);
 
 // gaus or GSL ?
 
 if(!gsl_flag)
   fitfun = new TF1("fitfun",&Tp,x[0],x[nbin-1],3);
 else
   fitfun = new TF1("fitfun",&Tp_gsl,x[0],x[nbin-1],3);
 
 fitfun->SetParName(0,"t0 shift");
 fitfun->SetParLimits(0,0.,100.);
 fitfun->SetParName(1,"mult");
 fitfun->SetParLimits(1,0.,100.);
 fitfun->SetParName(2,"Taus");
 fitfun->SetParLimits(2,0.1,10.);
 fitfun->SetNpx(nbin+1);
 fitfun->SetParameters(par[0],par[1],par[2]);
 //std::cout<<"What happens before normalize?"<<std::endl;
 if(norm) {
   if(uset0)
     normalize(fitfun,    &pampl,     0., 100., STEP);
   else 
     normalize(fitfun,     &pampl,     t0, t0+100., STEP);
 }
// Return also the derivative
 deriv = new TF1("derivfun",&DTp,x[0],x[nbin-1],3);
 deriv->SetParName(0,"t0 shift");
 deriv->SetParLimits(0,0.,100.);
 deriv->SetParName(1,"mult");
 deriv->SetParLimits(1,0.,100.);
 deriv->SetParName(2,"Taus");
 deriv->SetParLimits(2,0.1,10.);
 deriv->SetNpx(nbin+1);
 deriv->SetParameters(par[0],par[1],par[2]);
 
 if(norm) {
   normalize(deriv, &pampl, t0+par[0], t0+par[0]+100., STEP);
 }
 
 return fitfun;
}

declareGaudiProperty()

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

evtStore()

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; }

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

inlinevirtual

Definition at line 51 of file LArPhysWaveHECTool.h.

{return StatusCode::SUCCESS;}

initialize()

StatusCode LArPhysWaveHECTool::initialize ( )

virtual

Definition at line 81 of file LArPhysWaveHECTool.cxx.

{    
  if ( m_isSC ) {
    ATH_MSG_DEBUG("==== looking at SuperCells ====");
    const LArOnline_SuperCellID* ll;
    ATH_CHECK( detStore()->retrieve(ll, "LArOnline_SuperCellID") );
    m_onlineHelper = static_cast<const LArOnlineID_Base*>(ll);
  } else { // m_isSC
    const LArOnlineID* ll;
    ATH_CHECK( detStore()->retrieve(ll, "LArOnlineID") );
    m_onlineHelper = static_cast<const LArOnlineID_Base*>(ll);
  }
  return StatusCode::SUCCESS;
}

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()

const InterfaceID & LArPhysWaveHECTool::interfaceID ( )

inlinestatic

Definition at line 43 of file LArPhysWaveHECTool.h.

{ return IID_LArPhysWaveHECTool; }

makeLArPhysWaveHEC()

StatusCode LArPhysWaveHECTool::makeLArPhysWaveHEC	(	LArWFParams &	wfParams,
		LArCaliWave &	caliWave,
		LArPhysWave &	predLArPhysWave,
		const LArPhysWave &	LArIdealPhysWave,
		float &	MphysMcali,
		const HWIdentifier &	chid,
		const int	gain,
		int &	LArPhysWaveFlag )

Definition at line 97 of file LArPhysWaveHECTool.cxx.

                                                 {
  LArPhysWaveFlag=LArWave::predCali;
  Tp4_gsl_err_counter=0, Tp5_gsl_err_counter=0;
  // set input objects
  m_Omega0 = 0.;
  m_Taur   = 0.;
  m_gIdealPhys = &idealPhysWave;
 
  if(wfParam.fstep()<m_FstepMin || wfParam.fstep()>m_FstepMax){ 
    ATH_MSG_INFO (" Fstep="<< wfParam.fstep() << " out of accepted region ("<<m_FstepMin<< ","<<m_FstepMax<<") average used instead : "<<m_FstepAverage);
    wfParam.setFstep(m_FstepAverage);
  }
  if(wfParam.tcal()<m_TcalMin || wfParam.tcal()>m_TcalMax ){
    ATH_MSG_INFO (" Tcal="<< wfParam.tcal() << "out of accepted region ("<<m_TcalMin<< ","<<m_TcalMax<<") average used instead : "<<m_TcalAverage);
    wfParam.setTcal(m_TcalAverage);
  }
 
 
  ATH_MSG_DEBUG (" Tdrift="<< wfParam.tdrift() <<" Tcal="<<wfParam.tcal()<<" Fstep="<< wfParam.fstep()<<" m_Omega0="<< m_Omega0<<" m_Taur="<<m_Taur<<" LArWaveFlag="
                 << LArWaveFlag <<" LArPhysWaveFlag="<< LArPhysWaveFlag );
  predict_phys_HEC(wfParam,caliWave,predLArPhysWave, MphysMcali,chid,gain);
 
  
  return StatusCode::SUCCESS; 
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

predict_phys_HEC()

void LArPhysWaveHECTool::predict_phys_HEC ( LArWFParams & wfParams, LArCaliWave & caliWave, LArPhysWave & predLArPhysWave, float & MphysMcali, const HWIdentifier & chid, const int gain )

private

Definition at line 126 of file LArPhysWaveHECTool.cxx.

                                                                                    {
 
  // calib. signal at Mother Board :
  LArWave gCaliMB=caliWave ;//deep-copy and cast to base-class
  LArWaveHelper wHelper;
 
 
  // shift gCaliMB to start point and remove baseline
 
  m_Tstart = wHelper.getStart(gCaliMB) ;
  double baseline = wHelper.getBaseline(gCaliMB,m_Tstart) ;
  if ( m_subtractBaseline )   gCaliMB = gCaliMB+ (-baseline);
  if ( m_timeOriginShift )    gCaliMB = wHelper.translate(gCaliMB,-m_Tstart,baseline) ;
  
  // normalization of calibration pulse
  double peak_tmp=gCaliMB.getSample( wHelper.getMax(gCaliMB) ) ;
  if ( m_normalizeCali ) {
    double peak = gCaliMB.getSample( wHelper.getMax(gCaliMB) ) ;
    peak_tmp=peak;
    ATH_MSG_VERBOSE ( "*** Normalisation \t|-> YES (CaliWave peak = " << peak << ")" );
    if ( peak <=0 ) {
      ATH_MSG_WARNING ( "Peak value <=0 , cannot normalize!" );
    } else {
      gCaliMB = gCaliMB * (1./peak)  ;
    }
  } else {
    ATH_MSG_VERBOSE ( "*** Normalisation \t|-> NO" );
  }
 
  
  int FT      = m_onlineHelper->feedthrough(chid);
  int Slot    = m_onlineHelper->slot(chid);
  int Channel = m_onlineHelper->channel(chid);
  int adc = 128*(Slot-5)+ Channel+1;
 
  ATH_MSG_VERBOSE ( "*** Physics waveform\t|-> FT=" << FT   << " Slot=" << Slot << " Channel=" <<Channel<< " adc=" << adc << " gain=" << gain );
  ATH_MSG_VERBOSE ( "*** Physics waveform\t|-> m_Tdrift  = " << wfParam.tdrift() << " ns " );
  ATH_MSG_VERBOSE ( "*** Physics waveform\t|-> m_Fstep   = " << wfParam.fstep()  << " ns " );
  ATH_MSG_VERBOSE ( "*** Physics waveform\t|-> m_Tcal    = " << wfParam.tcal() << " ns " );
  
 

  unsigned int CaliWaveBins = gCaliMB.getSize();
  double const BinWidth=25.0/24;
  double const HalfBinWidth=BinWidth/2.0;
  double par[3]={0.0,1.0,0.10};
  bool uset0=false, norm=false;
 
  double const QUAL_REQ=peak_tmp*0.04; //80 ADC units is max allowed deviation of Ampl between two bins
  double const QUAL_REQ_AMPL=peak_tmp*0.3;
 
  double DIFF=0,DIFF_AMPL=0;
  unsigned short int repro_count=0;
  int idx_bad_time=-1,idx_bad_time_ampl=-1;
  TF1 *PhysWaveFunc=0;
  const unsigned short int ITER_MAX = 10;
  double Ampl_problem=-1, Time_problem=-1, Ampl_problem_ampl=-1, Time_problem_ampl=-1;
  double CALIWAVE_SHIFT=0;
  TProfile pcal("pcal","Amplitude vs Time",CaliWaveBins,0-HalfBinWidth,CaliWaveBins*BinWidth-HalfBinWidth);
  while((  (DIFF>=QUAL_REQ || DIFF_AMPL>=QUAL_REQ_AMPL) && repro_count<ITER_MAX)
       || repro_count==0){ 
 
    // if deviation is above a limit, move the CALIWAVE by 1.0 ADC counts
    if ( m_normalizeCali || peak_tmp < 1.1) {
       CALIWAVE_SHIFT=0.0005*repro_count;
    } else {
       CALIWAVE_SHIFT=1.0*repro_count;
    }
 
    if(repro_count>0){
      ATH_MSG_INFO ("FT="<<FT<<" Slot="<<Slot<<" Ch="<<Channel<<" Gain="<<gain<<" adc="<<adc);
      ATH_MSG_INFO (repro_count<<". Iteration of INTEGRATION: CALIWAVE IS MOVED UP by "<<CALIWAVE_SHIFT<<" ADC units");
      if(DIFF_AMPL>=QUAL_REQ_AMPL)
    ATH_MSG_INFO ("Problematic DIFF_AMPL bin="<<idx_bad_time_ampl<<" AmplPhysGSL="<<Ampl_problem_ampl<<" Time="<< Time_problem_ampl <<" Deviation="<<DIFF_AMPL<<" ADC units"<<" Peak="<<peak_tmp);
      if(DIFF>=QUAL_REQ)
    ATH_MSG_INFO ("Problematic DIFF bin="<<idx_bad_time<<" AmplPhysGSL="<<Ampl_problem<<" Time="<<Time_problem<<" Deviation="<<DIFF<<" ADC units"<< " Peak="<<peak_tmp);
    }
 
    pcal.Reset();
    for(unsigned tbin=1;tbin<=gCaliMB.getSize();++tbin){
      double AmplCalib = gCaliMB.getSample(tbin-1)+CALIWAVE_SHIFT;
      double Time      = gCaliMB.getTime(tbin-1);
      pcal.Fill(Time,AmplCalib,1);
    }
    bool gslflag=true;
    Double_t *xmax=0;
    double parCL[2]={wfParam.tcal(),wfParam.fstep()};
    TF1 *deriv=0;
    TF1* pwf=CaliWave2PhysWaveHEC(&pcal, par, parCL, deriv, uset0, norm, adc, xmax,gslflag);  
    if (deriv) delete deriv; 
    if (!pwf) {
      ATH_MSG_ERROR("Failed to create PhysWaveFunc");
      return;
    }
    PhysWaveFunc= (TF1*)pwf->Clone();  
    DIFF=0;DIFF_AMPL=0;Ampl_problem=-1; Time_problem=-1; Ampl_problem_ampl=-1; Time_problem_ampl=-1;
  
 
    for(int i=1;i<pcal.GetNbinsX(); ++i){
      double TimePhys1 = pcal.GetBinCenter(i+1);
      double TimePhys0 = TimePhys1-BinWidth;
      double DIFF_TMP = PhysWaveFunc->Eval(TimePhys1)-PhysWaveFunc->Eval(TimePhys0);
      if(TimePhys1>200 && DIFF<fabs(DIFF_TMP)){
    DIFF=fabs(DIFF_TMP);
    idx_bad_time=i;
    Ampl_problem=PhysWaveFunc->Eval(TimePhys1);
    Time_problem=TimePhys1;
      }
      else if(TimePhys1<=200 && DIFF_AMPL<fabs(DIFF_TMP)){
    DIFF_AMPL=fabs(DIFF_TMP);
    idx_bad_time_ampl=i;
    Ampl_problem_ampl=PhysWaveFunc->Eval(TimePhys1);
    Time_problem_ampl=TimePhys1;
      } }
    repro_count++;
  }
 
  if(repro_count>=ITER_MAX && (DIFF>=QUAL_REQ || DIFF_AMPL>=QUAL_REQ_AMPL)){
    ATH_MSG_WARNING ("FT="<<FT<<" Slot="<<Slot<<" Ch="<<Channel<<" Gain="<<gain<<" #iterations for CALIWAVE increasing reached the limit! LArWaveFlag set to -1" );
    LArWaveFlag=-1;
  }
 
  predLArPhysWave=LArPhysWave(gCaliMB.getSize(),gCaliMB.getDt()); //Assignment per value, but wave is empty at this point
 
  
  for(unsigned int i=0;i<gCaliMB.getSize(); ++i){
    const double Time  = gCaliMB.getTime(i);
    if(Time<=t0){
      predLArPhysWave.setSample(i,PhysWaveFunc->Eval(Time));
    }
    else{
      predLArPhysWave.setSample(i,PhysWaveFunc->Eval(Time)-CALIWAVE_SHIFT);
    }
  }

 
  // compute Mphys/Mcal
  if ( m_normalizeCali ) {
     // caliwave is normalized to 1 => Mcali = 1
    MphysMcali = predLArPhysWave.getSample( wHelper.getMax(predLArPhysWave) ) ;
    std::cout<<"Normalized: MphysMcali="<<MphysMcali<<std::endl;
  } else {
    MphysMcali = predLArPhysWave.getSample( wHelper.getMax(predLArPhysWave) ) /
      gCaliMB.getSample( wHelper.getMax(gCaliMB) ) ;
  }  
  ATH_MSG_VERBOSE ( "*** Physics waveform\t|-> m_MphysMcali = " << MphysMcali << " adc=" <<adc);
  
  return ;           
}

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

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

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

DEFAULT

const int LArPhysWaveHECTool::DEFAULT =-1

staticprivate

Definition at line 68 of file LArPhysWaveHECTool.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_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_FstepAverage

double LArPhysWaveHECTool::m_FstepAverage

private

Definition at line 80 of file LArPhysWaveHECTool.h.

m_FstepMax

double LArPhysWaveHECTool::m_FstepMax

private

Definition at line 80 of file LArPhysWaveHECTool.h.

m_FstepMin

double LArPhysWaveHECTool::m_FstepMin

private

Definition at line 80 of file LArPhysWaveHECTool.h.

m_gIdealPhys

const LArPhysWave* LArPhysWaveHECTool::m_gIdealPhys = nullptr

private

Definition at line 71 of file LArPhysWaveHECTool.h.

m_isSC

bool LArPhysWaveHECTool::m_isSC

private

Definition at line 77 of file LArPhysWaveHECTool.h.

m_MinAmp

double LArPhysWaveHECTool::m_MinAmp

private

Definition at line 86 of file LArPhysWaveHECTool.h.

m_normalizeCali

bool LArPhysWaveHECTool::m_normalizeCali

private

Definition at line 76 of file LArPhysWaveHECTool.h.

m_Omega0

double LArPhysWaveHECTool::m_Omega0 = 0.0

private

Definition at line 84 of file LArPhysWaveHECTool.h.

m_onlineHelper

const LArOnlineID_Base* LArPhysWaveHECTool::m_onlineHelper = nullptr

private

Definition at line 73 of file LArPhysWaveHECTool.h.

m_subtractBaseline

bool LArPhysWaveHECTool::m_subtractBaseline

private

Definition at line 76 of file LArPhysWaveHECTool.h.

m_Taur

double LArPhysWaveHECTool::m_Taur = 0.0

private

Definition at line 84 of file LArPhysWaveHECTool.h.

m_TcalAverage

double LArPhysWaveHECTool::m_TcalAverage

private

Definition at line 79 of file LArPhysWaveHECTool.h.

m_TcalMax

double LArPhysWaveHECTool::m_TcalMax

private

Definition at line 79 of file LArPhysWaveHECTool.h.

m_TcalMin

double LArPhysWaveHECTool::m_TcalMin

private

Definition at line 79 of file LArPhysWaveHECTool.h.

m_timeOriginShift

bool LArPhysWaveHECTool::m_timeOriginShift

private

Definition at line 76 of file LArPhysWaveHECTool.h.

m_Tstart

unsigned LArPhysWaveHECTool::m_Tstart = 0U

private

Definition at line 85 of file LArPhysWaveHECTool.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.

---

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

• LArPhysWaveHECTool.h
• LArPhysWaveHECTool.cxx