#include <TileLaserLinearityCalibTool.h>

Inheritance diagram for TileLaserLinearityCalibTool:

Collaboration diagram for TileLaserLinearityCalibTool:

Public Member Functions
	TileLaserLinearityCalibTool (const std::string &type, const std::string &name, const IInterface *pParent)
virtual	~TileLaserLinearityCalibTool ()
virtual StatusCode	initialize () override
virtual StatusCode	initNtuple (int runNumber, int runType, TFile *rootfile) override
virtual StatusCode	execute () override
virtual StatusCode	finalizeCalculations () override
virtual StatusCode	writeNtuple (int runNumber, int runType, TFile *rootfile) override
virtual StatusCode	finalize () override
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
int	chanIsConnected (int ros, int chan)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::string	m_toolNtuple
std::string	m_rawChannelContainerName
std::string	m_laserContainerName
SG::ReadHandleKey< TileDQstatus >	m_dqStatusKey
SG::ReadHandleKey< TileRawChannelContainer >	m_rawChannelContainerKey
SG::ReadHandleKey< TileLaserObject >	m_laserContainerKey
const TileHWID *	m_tileHWID
const TileCablingService *	m_cabling
ToolHandle< TileCondToolEmscale >	m_tileToolEmscale
int	m_toolRunNo
int	m_ADC_problem
int	m_las_filter
double	m_las_requ_amp
double	m_hrate
double	m_flow
double	m_head_temp
double	m_las_time
double(*	m_LG_PMT )[NPMTS]
double(*	m_LG_PMT_S )[NPMTS]
double(*	m_LG_diode )[NDIODES]
double(*	m_LG_diode_S )[NDIODES]
double(*	m_HG_PMT )[NPMTS]
double(*	m_HG_PMT_S )[NPMTS]
double(*	m_HG_diode )[NDIODES]
double(*	m_HG_diode_S )[NDIODES]
double(*	m_mean )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_mean_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_LG_ratio )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_LG_ratio_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_LG_ratio2 )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_LG_ratio2_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_HG_ratio )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_HG_ratio_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_HG_ratio2 )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
double(*	m_HG_ratio2_S )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
int(*	m_entries )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
int	m_PMT1_ADC_prev [2]
int	m_PMT2_ADC_prev [2]
int	m_first_filter
int	m_last_evt_filter
int	m_n_same_filt_evts
bool	m_complete_turn
RunningStat (	m_HG_diode_signal )[NDIODES]
RunningStat (	m_HG_PMT_signal )[NPMTS]
RunningStat (	m_LG_diode_signal )[NDIODES]
RunningStat (	m_LG_PMT_signal )[NPMTS]
RunningStat (	m_signal )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
RunningStat (	m_LG_ratio_stat )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
RunningStat (	m_LG_ratio2_stat )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
RunningStat (	m_HG_ratio_stat )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
RunningStat (	m_HG_ratio2_stat )[NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 42 of file TileLaserLinearityCalibTool.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

◆ TileLaserLinearityCalibTool()

TileLaserLinearityCalibTool::TileLaserLinearityCalibTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pParent )

Definition at line 34 of file TileLaserLinearityCalibTool.cxx.

                                                                                                                              :
  AthAlgTool(type, name, pParent),
  m_tileHWID (nullptr),
  m_cabling (nullptr),
  m_toolRunNo(0),
  m_ADC_problem(0),
  m_las_filter(0),
  m_las_requ_amp(0),
  m_hrate(0),
  m_flow(0),
  m_head_temp(0),
  m_las_time(0),
  m_PMT1_ADC_prev(),
  m_PMT2_ADC_prev(),
  m_first_filter(0),
  m_last_evt_filter(0),
  m_n_same_filt_evts(0),
  m_complete_turn(0)
{
  declareInterface<ITileCalibTool>( this );
  declareProperty("toolNtuple", m_toolNtuple="h3000");
  declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
 
// creating multi-dim arrays on the heap and initialize all elements to zeros
  m_LG_PMT = new double[NFILTERS][NPMTS]();
  m_LG_PMT_S = new double[NFILTERS][NPMTS]();
  m_LG_diode = new double[NFILTERS][NDIODES]();
  m_LG_diode_S = new double[NFILTERS][NDIODES]();
  m_HG_PMT = new double[NFILTERS][NPMTS]();
  m_HG_PMT_S = new double[NFILTERS][NPMTS]();
  m_HG_diode = new double[NFILTERS][NDIODES]();
  m_HG_diode_S = new double[NFILTERS][NDIODES]();
  m_mean = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_mean_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_LG_ratio = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_LG_ratio_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_LG_ratio2 = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_LG_ratio2_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_HG_ratio = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_HG_ratio_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_HG_ratio2 = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_HG_ratio2_S = new double[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_entries = new int[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_HG_diode_signal = new RunningStat*[NFILTERS][NDIODES]();
  m_HG_PMT_signal = new RunningStat*[NFILTERS][NGAINS]();
  m_LG_diode_signal = new RunningStat*[NFILTERS][NDIODES]();
  m_LG_PMT_signal = new RunningStat*[NFILTERS][NGAINS]();
  m_signal = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_LG_ratio_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_LG_ratio2_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_HG_ratio_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
  m_HG_ratio2_stat = new RunningStat*[NFILTERS][NPARTITIONS][NDRAWERS][NCHANNELS][NGAINS]();
}

◆ ~TileLaserLinearityCalibTool()

TileLaserLinearityCalibTool::~TileLaserLinearityCalibTool ( )

virtual

Definition at line 88 of file TileLaserLinearityCalibTool.cxx.

{
 
  delete[] m_LG_PMT;
  delete[] m_LG_PMT_S;
  delete[] m_LG_diode;
  delete[] m_LG_diode_S;
  delete[] m_HG_PMT;
  delete[] m_HG_PMT_S;
  delete[] m_HG_diode;
  delete[] m_HG_diode_S;
  delete[] m_mean;
  delete[] m_mean_S;
  delete[] m_LG_ratio;
  delete[] m_LG_ratio_S;
  delete[] m_LG_ratio2;
  delete[] m_LG_ratio2_S;
  delete[] m_HG_ratio;
  delete[] m_HG_ratio_S;
  delete[] m_HG_ratio2;
  delete[] m_HG_ratio2_S;
  delete[] m_entries;
  delete[] m_HG_diode_signal;
  delete[] m_HG_PMT_signal;
  delete[] m_LG_diode_signal;
  delete[] m_LG_PMT_signal;
  delete[] m_signal;
  delete[] m_LG_ratio_stat;
  delete[] m_LG_ratio2_stat;
  delete[] m_HG_ratio_stat;
  delete[] m_HG_ratio2_stat;
 
}

Member Function Documentation

◆ chanIsConnected()

int TileLaserLinearityCalibTool::chanIsConnected	(	int	ros,
		int	chan )

inlineprivate

Definition at line 136 of file TileLaserLinearityCalibTool.h.

                                                {
    if(m_cabling->channel2hole(ros,chan)<0) return 0; //negative means not connected
    return 1;
  }

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

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode TileLaserLinearityCalibTool::execute ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 229 of file TileLaserLinearityCalibTool.cxx.

{
  ATH_MSG_INFO ( "execute()" );
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
 
  //
  // Here we analyze a run with filter wheel moving
  // we just keep the information from the first turn of the wheel
  //
 
  if (m_complete_turn)
  {
    ATH_MSG_INFO ( "Filter wheel turn completed: stop here" );
    return StatusCode::SUCCESS;
  }
 
  ATH_MSG_DEBUG ( "Retrieving the LASER object and RawChannel" );
 
  SG::ReadHandle<TileRawChannelContainer> rawCnt(m_rawChannelContainerKey);
  SG::ReadHandle<TileLaserObject> laserObj(m_laserContainerKey);
  
  ATH_CHECK( rawCnt.isValid() );
  ATH_CHECK( laserObj.isValid() );
 
  // First we got event time (From 1/1/70)
 
  const uint32_t *cispar = dqStatus->cispar();
  
  m_las_time = static_cast<double>(cispar[10])+static_cast<double>(cispar[11])/1000000;
 
  //
  // Then we could start getting the LASER informations 
  // 
 
 
  if (laserObj->getDiodeCurrOrd() == 0 || laserObj->getFiltNumber() == 0)   // Sanity check
  {
    ATH_MSG_VERBOSE ( "Filter wheel moving: skip event !!" );
    return StatusCode::SUCCESS; // This is expected for some events 
  }
 
  //
  // Filter number is different from 0
  // But we have to check few points in order to be sure 
  // that the wheel is stabilized 
  //
 
  m_las_filter = laserObj->getFiltNumber()-1; // Corrected filter position
 
  if (m_last_evt_filter == m_las_filter)  // If the position the same as before??
  {
    m_n_same_filt_evts +=1;
  }
  else
  {
    m_n_same_filt_evts = 0;
  }
  
  m_last_evt_filter = m_las_filter;
 
 
  //
  // As long as we don't have a suffecient number of consecutive events 
  // with the same filter (200), we consider that we are not stable and thus
  // we reject the entire event
  //
 
  if (m_n_same_filt_evts < 200)   // Sanity check
  {
    ATH_MSG_WARNING ( "Still in a non stable area, wait a bit !!" );
    return StatusCode::SUCCESS; // This is expected for some events 
  }
 
  // 
  // Then we get the diodes signals and store them
  //
 
  double LG_diode[10];
  double HG_diode[10];
    
  for(int i=0; i<10; ++i) 
  {
    LG_diode[i] = static_cast<double>(laserObj->getDiodeADC(i,0)-laserObj->getDiodePedestal(i,0));
    HG_diode[i] = static_cast<double>(laserObj->getDiodeADC(i,1)-laserObj->getDiodePedestal(i,1));
  } // FOR
 
  for(int i=0; i<10; ++i){ 
    m_LG_diode_signal[m_las_filter][i]->Push(LG_diode[i]);
    m_HG_diode_signal[m_las_filter][i]->Push(HG_diode[i]);
  } // FOR
 
  for(int i=0; i<2; ++i){
    m_LG_PMT_signal[m_las_filter][i]->Push(laserObj->getPMADC(i,0)-laserObj->getPMPedestal(i,0));
    m_HG_PMT_signal[m_las_filter][i]->Push(laserObj->getPMADC(i,1)-laserObj->getPMPedestal(i,1));
  } // FOR
 
  // Check that the ADC has really sent a new information 
 
  if (laserObj->getPMADC(0,0) == m_PMT1_ADC_prev[0] && 
      laserObj->getPMADC(1,0) == m_PMT2_ADC_prev[0])
  {
    m_ADC_problem = 1;
    ATH_MSG_WARNING ( "There is perhaps an ADC problem with this event" );
  }
  if (laserObj->getPMADC(0,1) == m_PMT1_ADC_prev[1] && 
      laserObj->getPMADC(1,1) == m_PMT2_ADC_prev[1])
  {
    m_ADC_problem = 1;
    ATH_MSG_WARNING ( "There is perhaps an ADC problem with this event" );
  }
 
  m_PMT1_ADC_prev[0] = laserObj->getPMADC(0,0);
  m_PMT2_ADC_prev[0] = laserObj->getPMADC(1,0);
  m_PMT1_ADC_prev[1] = laserObj->getPMADC(0,1);
  m_PMT2_ADC_prev[1] = laserObj->getPMADC(1,1);
 
  // Next parameters are constants, don't need to update them more than once
 
  if (m_hrate == 0) 
  {
    m_first_filter   = laserObj->getFiltNumber()-1; // The first filter position
    m_hrate        = laserObj->getHumidity(); 
    m_flow         = laserObj->getGasFlux(); 
    m_head_temp    = laserObj->getPumpDiodeTemp();
    m_las_requ_amp = laserObj->getDiodeCurrOrd();
  }
 
  //
  // Are we back to the first wheel position??
  // If so we stop here because otherwise
  // we have systematic shifts with filter wheel position
  //
 
  if (m_las_filter==m_first_filter) 
  {
    int previous_filter = (m_first_filter+7)%8;
    if (m_HG_PMT_signal[previous_filter][0]->NumDataValues()>400 || m_LG_PMT_signal[previous_filter][0]->NumDataValues()>400) 
    {
      m_complete_turn=true; // Yes, stop here 
      ATH_MSG_INFO ( "Filter wheel turn completed: stop here" );
      return StatusCode::SUCCESS;
    }
  }
 
  //
  // Then we could loop over all the channels, and get the correction factor
  //
 
 
  // Create iterator over RawChannelContainer 
  TileRawChannelUnit::UNIT RChUnit = rawCnt->get_unit();
  TileRawChannelContainer::const_iterator itColl = rawCnt->begin();
  TileRawChannelContainer::const_iterator itCollEnd = rawCnt->end();
  
  // Go through all TileRawChannelCollections
  for(; itColl != itCollEnd; ++itColl) 
  {
       
    // go through all TileRawChannels in collection
    TileRawChannelCollection::const_iterator it = (*itColl)->begin();
    for(; it != (*itColl)->end(); ++it) 
    {
 
      // get adcHash
      HWIdentifier hwid=(*it)->adc_HWID();
      int ros    = m_tileHWID->ros(hwid)-1;    // LBA=0  LBC=1  EBA=2  EBC=3 
      int drawer = m_tileHWID->drawer(hwid);   // 0 to 63
      int chan   = m_tileHWID->channel(hwid);  // 0 to 47 channel not PMT
      int gain   = m_tileHWID->adc(hwid);      // low=0 high=1
 
      // amp has to be in PicoCoulombs, here we are mixing gains 
      float amp = (*it)->amplitude();
      unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros+1,drawer);
 
 
 
      // check if channel is connected
      if( !chanIsConnected(ros+1,chan) ) continue;
     
      // Don't enable negative or null energies
      if ( amp <= 0.) continue;
  
      float ampInPicoCoulombs = m_tileToolEmscale->channelCalib(drawerIdx, chan, gain, amp, RChUnit, TileRawChannelUnit::PicoCoulombs);
 
      //
      // Here we do an outlier removal when enough events have been collected
      // (Mean and RMS are computed in the same pass
      //)
      // Useful when the filter wheel is moving again (the signal could become bad again)
      //
 
      if (m_signal[m_las_filter][ros][drawer][chan][gain]->NumDataValues()>400) 
      {                                                                 
    double current_mean = m_signal[m_las_filter][ros][drawer][chan][gain]->Mean();
    double current_RMS  = m_signal[m_las_filter][ros][drawer][chan][gain]->StandardDeviation();
 
    if (fabs(ampInPicoCoulombs-current_mean)>5*current_RMS) // 5 sigmas away, not normal
    {
      ATH_MSG_VERBOSE ( "Rejecting an outlier. If there are a lot this means filter wheel will soon move again!" );
    }
    else
    {
      m_signal[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs);
      
      if (HG_diode[0] != 0)
      {
        m_HG_ratio_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/HG_diode[0]);
        m_HG_ratio2_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/(laserObj->getPMADC(0,1)-laserObj->getPMPedestal(0,1)));
      }
 
      if (LG_diode[0] != 0)
      {
        m_LG_ratio_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/LG_diode[0]);
        m_LG_ratio2_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/(laserObj->getPMADC(0,0)-laserObj->getPMPedestal(0,0)));
      }
 
    }
      }
      else
      {
    if (ros == 2 && drawer == 0 && chan == 1)   
      ATH_MSG_VERBOSE ( m_las_filter+1 <<" / " << gain <<" / " << ampInPicoCoulombs <<" / " 
                            << m_signal[m_las_filter][ros][drawer][chan][gain]->Mean() 
                            << " / " << m_signal[m_las_filter][ros][drawer][chan][gain]->StandardDeviation() );
 
    m_signal[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs);
 
    if (HG_diode[0] != 0)
    {
      m_HG_ratio_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/HG_diode[0]);
      m_HG_ratio2_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/(laserObj->getPMADC(0,1)-laserObj->getPMPedestal(0,1)));
    }
 
    if (LG_diode[0] != 0)
    {
      m_LG_ratio_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/LG_diode[0]);
      m_LG_ratio2_stat[m_las_filter][ros][drawer][chan][gain]->Push(ampInPicoCoulombs/(laserObj->getPMADC(0,0)-laserObj->getPMPedestal(0,0)));
    }
 
      }     
    } // End of the loop over the TileRawChannelCollection
  } // End of the loop over the TileRawChannelContainer
  
  return StatusCode::SUCCESS;  
}       

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

StatusCode TileLaserLinearityCalibTool::finalize ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 639 of file TileLaserLinearityCalibTool.cxx.

{
  ATH_MSG_INFO ( "finalize()" );
  return StatusCode::SUCCESS;  
}  

◆ finalizeCalculations()

StatusCode TileLaserLinearityCalibTool::finalizeCalculations ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 484 of file TileLaserLinearityCalibTool.cxx.

{
  ATH_MSG_INFO ( "execute()" );
 
  for(int f=0; f<NFILTERS; ++f) 
  {
    for(int d=0; d<NPMTS; ++d) 
    {
      m_LG_PMT[f][d]      = m_LG_PMT_signal[f][d]->Mean();    
      m_LG_PMT_S[f][d]    = m_LG_PMT_signal[f][d]->StandardDeviation();  
 
      m_HG_PMT[f][d]      = m_HG_PMT_signal[f][d]->Mean();    
      m_HG_PMT_S[f][d]    = m_HG_PMT_signal[f][d]->StandardDeviation();  
    }
  }
 
  for(int f=0; f<NFILTERS; ++f) 
  {
    for(int d=0; d<NPARTITIONS; ++d) 
    {
      m_LG_diode[f][d]       = m_LG_diode_signal[f][d]->Mean();    
      m_LG_diode_S[f][d]     = m_LG_diode_signal[f][d]->StandardDeviation();    
 
      m_HG_diode[f][d]       = m_HG_diode_signal[f][d]->Mean();    
      m_HG_diode_S[f][d]     = m_HG_diode_signal[f][d]->StandardDeviation();    
    }
  }
 
  for(int f=0; f<NFILTERS; ++f) 
  {
    for(int i=0; i<NPARTITIONS; ++i) 
    {
      for(int j=0; j<NDRAWERS; ++j) 
      {
    for(int k=0; k<NCHANNELS; ++k) 
    { 
      for(int l=0; l<NGAINS; ++l) 
      { 
        m_mean[f][i][j][k][l]    = m_signal[f][i][j][k][l]->Mean();
        m_mean_S[f][i][j][k][l]  = m_signal[f][i][j][k][l]->StandardDeviation();
        
        m_LG_ratio[f][i][j][k][l]   = m_LG_ratio_stat[f][i][j][k][l]->Mean();
        m_LG_ratio_S[f][i][j][k][l] = m_LG_ratio_stat[f][i][j][k][l]->StandardDeviation();
        m_LG_ratio2[f][i][j][k][l]   = m_LG_ratio2_stat[f][i][j][k][l]->Mean();
        m_LG_ratio2_S[f][i][j][k][l] = m_LG_ratio2_stat[f][i][j][k][l]->StandardDeviation();
        m_HG_ratio[f][i][j][k][l]   = m_HG_ratio_stat[f][i][j][k][l]->Mean();
        m_HG_ratio_S[f][i][j][k][l] = m_HG_ratio_stat[f][i][j][k][l]->StandardDeviation();
        m_HG_ratio2[f][i][j][k][l]   = m_HG_ratio2_stat[f][i][j][k][l]->Mean();
        m_HG_ratio2_S[f][i][j][k][l] = m_HG_ratio2_stat[f][i][j][k][l]->StandardDeviation();
        m_entries[f][i][j][k][l] = m_signal[f][i][j][k][l]->NumDataValues();
      }
    }
      }
    }
  } 
 
  // remove all RunningStat objects from memory
 
  for(int f=0; f<NFILTERS; ++f)
  {
    for(int d=0; d<NPMTS; ++d)
    {
      delete m_LG_PMT_signal[f][d];
      delete m_HG_PMT_signal[f][d];
    }
  }
 
  for(int f=0; f<NFILTERS; ++f)
  {
    for(int d=0; d<NPARTITIONS; ++d)
    {
      delete m_LG_diode_signal[f][d];
      delete m_HG_diode_signal[f][d];
    }
  }
 
  for(int f=0; f<NFILTERS; ++f)        // Filter
  {
    for(int i=0; i<NPARTITIONS; ++i)      // Partition
    {
      for(int j=0; j<NDRAWERS; ++j)   // Module
      {
    for(int k=0; k<NCHANNELS; ++k) // Channel
    {
      for(int l=0; l<NGAINS; ++l) // Gain
      {
        delete m_signal[f][i][j][k][l];
        delete m_HG_ratio_stat[f][i][j][k][l];
        delete m_HG_ratio2_stat[f][i][j][k][l];
        delete m_LG_ratio_stat[f][i][j][k][l];
        delete m_LG_ratio2_stat[f][i][j][k][l];
      }
    }
      }
    }
  }
 
  return StatusCode::SUCCESS;  
}       

◆ initialize()

StatusCode TileLaserLinearityCalibTool::initialize ( )

overridevirtual

Implements ITileCalibTool.

Definition at line 131 of file TileLaserLinearityCalibTool.cxx.

{
  
  ATH_MSG_INFO ( "initialize()" );
 
  // Reset local parameters
  // For parameter definition, see the header file
  //
 
  m_complete_turn = false;
 
  m_toolRunNo    = 0;
  m_ADC_problem  = 0;
  m_las_filter   = 0;
  m_las_requ_amp = 0;
  m_hrate        = 0; 
  m_flow         = 0; 
  m_head_temp    = 0;
  m_las_time     = 0;
  m_PMT1_ADC_prev[0]= 0;
  m_PMT2_ADC_prev[0]= 0;
  m_PMT1_ADC_prev[1]= 0;
  m_PMT2_ADC_prev[1]= 0;
 
  m_last_evt_filter  = 0; 
  m_n_same_filt_evts = 0; 
 
  for(int f=0; f<NFILTERS; ++f) 
  {
    for(int d=0; d<NPMTS; ++d) 
    {
      m_LG_PMT_signal[f][d] = new RunningStat();
      m_HG_PMT_signal[f][d] = new RunningStat();
    }
  }
 
  for(int f=0; f<NFILTERS; ++f) 
  {
    for(int d=0; d<NPARTITIONS; ++d) 
    {
      m_LG_diode_signal[f][d]  = new RunningStat();
      m_HG_diode_signal[f][d]  = new RunningStat();
    }
  }
 
  for(int f=0; f<NFILTERS; ++f)        // Filter 
  {
    for(int i=0; i<NPARTITIONS; ++i)      // Partition
    {
      for(int j=0; j<NDRAWERS; ++j)   // Module
      {
    for(int k=0; k<NCHANNELS; ++k) // Channel
    { 
      for(int l=0; l<NGAINS; ++l) // Gain
      { 
        m_signal[f][i][j][k][l]    = new RunningStat();
        m_HG_ratio_stat[f][i][j][k][l]     = new RunningStat();
        m_HG_ratio2_stat[f][i][j][k][l]    = new RunningStat();
        m_LG_ratio_stat[f][i][j][k][l]     = new RunningStat();
        m_LG_ratio2_stat[f][i][j][k][l]    = new RunningStat();
      }
    }
      }
    }
  } 
 
 
  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
  ATH_CHECK( m_tileToolEmscale.retrieve() );
 
  ATH_CHECK( m_rawChannelContainerKey.initialize() );
  ATH_CHECK( m_laserContainerKey.initialize() );
 
  m_cabling = TileCablingService::getInstance();
 
  CHECK( m_dqStatusKey.initialize() );
 
  return StatusCode::SUCCESS;  
}       

◆ initNtuple()

StatusCode TileLaserLinearityCalibTool::initNtuple	(	int	runNumber,
		int	runType,
		TFile *	rootfile )

overridevirtual

Implements ITileCalibTool.

Definition at line 211 of file TileLaserLinearityCalibTool.cxx.

{
  ATH_MSG_INFO ( "initialize(" << runNumber << "," << runType << "," << rootFile << ")" );
  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 & ITileCalibTool::interfaceID ( )

inlinestaticinherited

Definition at line 21 of file ITileCalibTool.h.

21{ return IID_ITileCalibTool; }

IID_ITileCalibTool

static const InterfaceID IID_ITileCalibTool("ITileCalibTool", 1, 0)

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

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

◆ writeNtuple()

StatusCode TileLaserLinearityCalibTool::writeNtuple	(	int	runNumber,
		int	runType,
		TFile *	rootfile )

overridevirtual

Implements ITileCalibTool.

Definition at line 593 of file TileLaserLinearityCalibTool.cxx.

{
  ATH_MSG_INFO ( "finalize(" << runNumber << "," << runType << "," << rootFile << ")" );
 
  // Create output tree
 
  m_toolRunNo = runNumber;
 
  TTree *t = new TTree(m_toolNtuple.c_str(), "TileLaserCalib-Ntuple");
  t->Branch("RunNumber",&m_toolRunNo, "runNo/I");
  t->Branch("ADC_status",&m_ADC_problem, "ADC/I");
  t->Branch("RequestedAmp",&m_las_requ_amp, "requamp/D");
  t->Branch("Humidity",&m_hrate,"humid/D"); 
  t->Branch("AirFlow",&m_flow,"flow/D"); 
  t->Branch("HeadTemp",&m_head_temp,"htemp/D");
  t->Branch("Time",&m_las_time, "timeofrun/D");
  t->Branch("LG_PMT_Signal",m_LG_PMT, "LG_PMT1[8][2]/D");
  t->Branch("LG_PMT_Sigma_Signal",m_LG_PMT_S, "LG_PMT1_s[8][2]/D");
  t->Branch("HG_PMT_Signal",m_HG_PMT, "HG_PMT1[8][2]/D");
  t->Branch("HG_PMT_Sigma_Signal",m_HG_PMT_S, "HG_PMT1_s[8][2]/D");
 
  t->Branch("LG_Diode_Signal",m_LG_diode, "LG_diode[8][10]/D");
  t->Branch("LG_Diode_Sigma_Signal",m_LG_diode_S, "LG_diode_s[8][10]/D");
  t->Branch("HG_Diode_Signal",m_HG_diode, "HG_diode[8][10]/D");
  t->Branch("HG_Diode_Sigma_Signal",m_HG_diode_S, "HG_diode_s[8][10]/D");
 
  t->Branch("Signal",*m_mean,"signal[8][4][64][48][2]/D");
  t->Branch("Sigma_Signal",*m_mean_S,"signal_s[8][4][64][48][2]/D");
  t->Branch("LG_Ratio",*m_LG_ratio,"LG_signal_cor[8][4][64][48][2]/D");
  t->Branch("LG_Sigma_Ratio",*m_LG_ratio_S,"LG_signal_cor_s[8][4][64][48][2]/D");
  t->Branch("LG_Ratio2",*m_LG_ratio2,"LG_signal_cor2[8][4][64][48][2]/D");
  t->Branch("LG_Sigma_Ratio2",*m_LG_ratio2_S,"LG_signal_cor2_s[8][4][64][48][2]/D");
  t->Branch("HG_Ratio",*m_HG_ratio,"HG_signal_cor[8][4][64][48][2]/D");
  t->Branch("HG_Sigma_Ratio",*m_HG_ratio_S,"HG_signal_cor_s[8][4][64][48][2]/D");
  t->Branch("HG_Ratio2",*m_HG_ratio2,"HG_signal_cor2[8][4][64][48][2]/D");
  t->Branch("HG_Sigma_Ratio2",*m_HG_ratio2_S,"HG_signal_cor2_s[8][4][64][48][2]/D");
  t->Branch("Entries",*m_entries,"n_LASER_entries[8][4][64][48][2]/I");  
 
     
  // Fill with current values (i.e. tree will have only one entry for this whole run)
  t->Fill();
  t->Write();
  
  return StatusCode::SUCCESS;  
}