#include <TileDigiNoiseCalibAlg.h>

Inheritance diagram for TileDigiNoiseCalibAlg:

Public Member Functions
	TileDigiNoiseCalibAlg (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TileDigiNoiseCalibAlg ()
virtual StatusCode	initialize () override
	Only array initialization is done here All the helpers initialization is done at the first event.
virtual StatusCode	execute () override
	Main method.
virtual StatusCode	finalize () override
	The output ntuple is created in finalize method.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
enum	trigtype { Unknown = 0 , Phys = 1 , Las = 2 , Ped = 4 , Cis = 8 }
using	Tile = TileCalibUtils
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	FirstEvt_initialize ()
	Initialization done at the first event.
StatusCode	fillDigits (const TileDQstatus *theDQstatus)
	fillDigits is called at every events.
void	finalDigits ()
	finalDigits is called during finalize Here the average Ped, m_lfn, m_hfn and covariance are calculated.
void	StoreRunInfo (const TileDQstatus *dqStatus)
	StoreRunInfo is called only during the first event.
int	digiChannel2PMT (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
bool	m_calibMode
bool	m_usePMT
bool	m_doAvgCorr
bool	m_doRobustCov
SG::ReadHandleKey< TileDQstatus >	m_dqStatusKey
SG::ReadHandleKey< TileDigitsContainer >	m_digitsContainerKey
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey
ToolHandle< TileRawChannelBuilderFlatFilter >	m_adderFilterAlgTool
TileBeamElemContByteStreamCnv *	m_beamCnv
const TileCablingService *	m_cabling
TileOFCorrelation *	m_tileOFCorrelation
const TileID *	m_tileID
const TileHWID *	m_tileHWID
const uint32_t *	m_cispar
std::string	m_ntupleID
std::string	m_file
int64_t	m_treeSize
int	m_nSamples
std::string	m_digitsContainer
std::string	m_beamElemContainer
std::string	m_dspRawChannelContainer
double(*	m_sumPed2 )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
double(*	m_sumRms2 )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
double(*	m_meanAmp )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
double(*	m_meanAmp_ij )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN]
int	m_evtNr
int(*	m_evt )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
int	m_time
int	m_year
int	m_month
int	m_day
int	m_yday
int	m_hour
int	m_min
int	m_run
int	m_trigType
uint8_t(*	m_ros )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
uint8_t(*	m_drawer )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
uint8_t(*	m_channel )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
bool(*	m_gain )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_ped )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_lfn )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_hfn )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
float(*	m_noise_cov )[Tile::MAX_DRAWER][Tile::MAX_GAIN]
float(*	m_auto_corr )[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS]
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 46 of file TileDigiNoiseCalibAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ Tile

using TileDigiNoiseCalibAlg::Tile = TileCalibUtils

private

Definition at line 124 of file TileDigiNoiseCalibAlg.h.

Member Enumeration Documentation

◆ trigtype

enum TileDigiNoiseCalibAlg::trigtype

private

Enumerator
Unknown
Phys
Las
Ped
Cis

Definition at line 58 of file TileDigiNoiseCalibAlg.h.

                  {
      Unknown = 0
      , Phys = 1
      , Las = 2
      , Ped = 4
      , Cis = 8
    };

Constructor & Destructor Documentation

◆ TileDigiNoiseCalibAlg()

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

Definition at line 43 of file TileDigiNoiseCalibAlg.cxx.

    : AthAlgorithm(name, pSvcLocator)
  , m_beamCnv(nullptr)
  , m_cabling(nullptr)
  , m_tileOFCorrelation(nullptr)
  , m_tileID(nullptr)
  , m_tileHWID(nullptr)
  , m_cispar(nullptr)
//  , m_nDrawers(0)
  , m_time(0)
  , m_year(0)
  , m_month(0)
  , m_day(0)
  , m_yday(0)
  , m_hour(0)
  , m_min(0)
  , m_trigType(0)
{
  declareProperty("TileBeamElemContainer", m_beamElemContainer = "TileBeamElemCnt");
  /*  declareProperty("TileRawChannelContainerFlat", m_flatRawChannelContainer = "TileRawChannelFlat");
   declareProperty("TileRawChannelContainerFit", m_fitRawChannelContainer = ""); // don't create
   declareProperty("TileRawChannelContainerOpt", m_optRawChannelContainer = ""); // by default */
  declareProperty("TileRawChannelContainerDsp", m_dspRawChannelContainer = "TileRawChannelCnt");
  declareProperty("CalibMode", m_calibMode = true);
  declareProperty("usePMT", m_usePMT = false);
  declareProperty("RunNumber", m_run = 0);
  declareProperty("FileNamePrefix", m_file = "Digi_NoiseCalib");
  declareProperty("NtupleID", m_ntupleID = "Digi_NoiseCalib");
  declareProperty("TreeSize", m_treeSize = 16000000000LL);
  declareProperty("NSamples", m_nSamples = 7);
  declareProperty("DoAvgCorr", m_doAvgCorr = false);
  declareProperty("DoRobustCov", m_doRobustCov = false);
  declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
 
  m_run = 0;
  m_evtNr = -1;
 
  m_sumPed2 = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_sumRms2 = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_meanAmp = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_meanAmp_ij = new double[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_evt = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_ros = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_drawer = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_channel = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_gain = new bool[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_ped = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_lfn = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_hfn = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
  m_noise_cov = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_GAIN]();
  m_auto_corr = new float[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS]();
}

◆ ~TileDigiNoiseCalibAlg()

TileDigiNoiseCalibAlg::~TileDigiNoiseCalibAlg ( )

virtual

Definition at line 96 of file TileDigiNoiseCalibAlg.cxx.

                                              {
 
  delete[] m_sumPed2;
  delete[] m_sumRms2;
  delete[] m_meanAmp;
  delete[] m_meanAmp_ij;
  delete[] m_evt;
  delete[] m_ros;
  delete[] m_drawer;
  delete[] m_channel;
  delete[] m_gain;
  delete[] m_ped;
  delete[] m_lfn;
  delete[] m_hfn;
  delete[] m_noise_cov;
  delete[] m_auto_corr;
}

Member Function Documentation

◆ declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

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

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ digiChannel2PMT()

int TileDigiNoiseCalibAlg::digiChannel2PMT	(	int	ros,
		int	chan )

inlineprivate

Definition at line 72 of file TileDigiNoiseCalibAlg.h.

                                                  {
      return (abs(m_cabling->channel2hole(ros, chan)) - 1);
    }

◆ evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode TileDigiNoiseCalibAlg::execute ( )

overridevirtual

Main method.

Definition at line 195 of file TileDigiNoiseCalibAlg.cxx.

                                          {
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
  const TileDQstatus * dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
 
  StatusCode sc;
  bool empty(false);
 
  if (m_evtNr < 0) {
 
    if (FirstEvt_initialize().isFailure()) {
      ATH_MSG_ERROR( "FirstEvt_initialize failed" );
    }
 
    bool calibMode = (dqStatus->calibMode() == 1);
    if (calibMode != m_calibMode) {
      ATH_MSG_INFO( "Calib mode from data is " );
      ATH_MSG_INFO( "  Overwriting calib mode " );
      m_calibMode = calibMode;
    }
 
    m_cispar = dqStatus->cispar();
    StoreRunInfo(dqStatus); // done only once
  }
 
  m_cispar = dqStatus->cispar();
  if (m_evtNr % 1000 == 0)
    ATH_MSG_WARNING( m_evtNr << " events processed so far" );
 
  // store TileDigits
  if (m_nSamples > 0) sc = fillDigits (dqStatus);
  empty &= (sc.isFailure());
 
  if (empty) {
    ATH_MSG_WARNING( "Error in execute "  );
  }
  ++m_evtNr;
  return StatusCode::SUCCESS;
}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

◆ fillDigits()

StatusCode TileDigiNoiseCalibAlg::fillDigits ( const TileDQstatus * theDQstatus )

private

fillDigits is called at every events.

Statistics is summed for Average, RMS and covariance calculations

Definition at line 378 of file TileDigiNoiseCalibAlg.cxx.

                                                                             {
/*---------------------------------------------------------*/
 
  SG::ReadHandle<TileDigitsContainer> digitsCnt(m_digitsContainerKey);
  ATH_CHECK( digitsCnt.isValid() );
 
  TileDigitsContainer::const_iterator collItr = digitsCnt->begin();
  TileDigitsContainer::const_iterator lastColl = digitsCnt->end();
 
  for (; collItr != lastColl; ++collItr) {
 
    TileDigitsCollection::const_iterator digitsItr = (*collItr)->begin();
    TileDigitsCollection::const_iterator lastDigits = (*collItr)->end();
 
    if (digitsItr != lastDigits) { //loop over all the drawers in the data
 
      HWIdentifier adc_id = (*digitsItr)->adc_HWID();
      int ros = m_tileHWID->ros(adc_id);
      // IMPORTANT! ros for TileCal partitions goes like LBA=1  LBC=2  EBA=3  EBC=4
 
      int drawer = m_tileHWID->drawer(adc_id);
      // IMPORTANT! Drawers are from 0 to 63!
 
      //coverity[STACK_USE]
      double mean_tmp[48][16][2] = {};
 
 
      for (; digitsItr != lastDigits; ++digitsItr) { // loop over all channels in the drawer
 
        adc_id = (*digitsItr)->adc_HWID();
        int chan = m_tileHWID->channel(adc_id);
        if (m_usePMT) {
          chan = digiChannel2PMT(ros, chan);   // IMPORTANT: 0-47 PMT format!
          // by default we use CHANNELS.
          // PMTs usage is possible by switching on m_usePMT
        }
        int gain = m_tileHWID->adc(adc_id);
 
        std::vector<float> vdigits = (*digitsItr)->samples();
 
        // Needed to calculate the AutoCorrealtion matrix at end of run
        //m_tileOFCorrelation->RunningCorrelation(vdigits,ros-1,drawer,chan,gain,msg(),false,m_nSamples,100);
 
        // if (theDQstatus->isChEmpty(ros, drawer, chan)) {
        //   ATH_MSG_DEBUG( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
        //                 << " channel: " << chan
        //                 << " ADC: " << gain
        //                 << " because empty" );
        //   continue;
        // }
 
        // If DQ problem, do not fill calib ntuple
        if (m_calibMode == 1) {// Bigain: check indivual adc's
           if (!(theDQstatus->isAdcDQgood(ros, drawer, chan, gain))) {
             ATH_MSG_DEBUG( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
                           << " channel: " << chan
                           << " ADC: " << gain
                           << " due to DQ error found." );
            continue;
          }
        } else {// monogain, just check channel
 
          if (!(theDQstatus->isChanDQgood(ros, drawer, chan))) {
            ATH_MSG_DEBUG( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
                          << " channel: " << chan
                          << " due to DQ error found." );
            continue;
          }
        }
 
        double meansamp = 0.0;
        double rmssamp = 0.0;
        unsigned int dsize = vdigits.size();
 
        if (dsize > 16) {
          ATH_MSG_ERROR( "length of digits vector " << dsize << " - greater than 16 !" );
          dsize = 16;
        }
 
        for (unsigned int i = 0; i < dsize; ++i) {
          double dig = vdigits[i];
          meansamp += dig;
          rmssamp += dig * dig;
          mean_tmp[chan][i][gain] = dig;
        }
        if (dsize > 0) {
          m_ped[ros][drawer][chan][gain] += vdigits[0];
          m_sumPed2[ros][drawer][chan][gain] += vdigits[0] * vdigits[0];
 
          if (dsize > 1) {
            m_evt[ros][drawer][chan][gain]++;
            meansamp /= dsize;
            rmssamp = rmssamp / dsize - meansamp * meansamp;
            rmssamp = (rmssamp > 0.0) ? sqrt(rmssamp * dsize / (dsize - 1)) : 0.0;
            m_hfn[ros][drawer][chan][gain] += rmssamp;
            m_sumRms2[ros][drawer][chan][gain] += rmssamp * rmssamp;
          }
        }
 
        // Fill event-by-event correlation values
        if (m_doAvgCorr)
          m_tileOFCorrelation->RunningCorrelation(vdigits, ros - 1, drawer, chan, gain, msg(), false, m_nSamples, 100);
        else
          m_tileOFCorrelation->Sum(vdigits, ros - 1, drawer, chan, gain, msg(), false, m_nSamples, m_doRobustCov);
 
      } // loop over channels
 
      //For cor&cov
      for (int sample = 0; sample < m_nSamples; ++sample) {
        for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
          for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
            m_meanAmp[ros][drawer][chan_i][gain] += mean_tmp[chan_i][sample][gain];
            for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j)
              m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] += mean_tmp[chan_i][sample][gain] * mean_tmp[chan_j][sample][gain];
          }
        }
      }
    } //check if Digits in module
  } //loop over drawers
 
  return StatusCode::SUCCESS;
}

◆ finalDigits()

void TileDigiNoiseCalibAlg::finalDigits ( )

private

finalDigits is called during finalize Here the average Ped, m_lfn, m_hfn and covariance are calculated.

Definition at line 504 of file TileDigiNoiseCalibAlg.cxx.

                                        {
/*---------------------------------------------------------*/
 
 
  // Calculate AutoCorrealtion matrix
  // --Average calculation (Assumes matrix is Toeplitz)
  if (m_doAvgCorr)
    m_tileOFCorrelation->CalcRunningCorrelation(msg(), m_nSamples, 100, false);
  // --Rigorous calculation
  else
    m_tileOFCorrelation->CalcCorrelation(msg(), m_nSamples, false, m_doRobustCov);
 
  // Needed to store autoCorrelation matrix
  float tmpCorr[9][9] = {};
 
 
  for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
    for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
      for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
        for (unsigned int chan = 0; chan < TileCalibUtils::MAX_CHAN; ++chan) {
 
          m_ros[ros][drawer][chan][gain] = ros;
          m_drawer[ros][drawer][chan][gain] = drawer;
          m_channel[ros][drawer][chan][gain] = chan;
          m_gain[ros][drawer][chan][gain] = gain;
 
          if (m_evt[ros][drawer][chan][gain] > 0) {
            int nev = m_evt[ros][drawer][chan][gain];
            m_ped[ros][drawer][chan][gain] /= nev;
            double Ped = m_ped[ros][drawer][chan][gain];
            m_hfn[ros][drawer][chan][gain] /= nev;
 
            if (nev > 1) {
              double PedRMS = m_sumPed2[ros][drawer][chan][gain] / nev - Ped * Ped;
              PedRMS = m_sumPed2[ros][drawer][chan][gain] / nev - Ped * Ped;
              PedRMS = (PedRMS > 0.0) ? sqrt(PedRMS * nev / (nev - 1)) : 0.0;
              m_lfn[ros][drawer][chan][gain] = PedRMS;
            }
          }
 
          // Get values from AutoCorrelation matrix
          // matrix is symmetric, so only half-retrieved and stored
          m_tileOFCorrelation->GetCorrelation(m_nSamples, tmpCorr, ros - 1, drawer, chan, gain);
          //std::cout << "Printing AutoCorr values: " << std::endl;
          int nVals = 0;
      if (m_doRobustCov){ //save 28 elements for robust method
            for (int i = 0; i < m_nSamples; i++) {
              for (int j = i; j < m_nSamples; j++) {
                //std::cout << "Auto Corr [" << i << "][" << j << "]:" << tmpCorr[i][j] << std::endl;
                //std::cout << "Auto CorrSym [" << j << "][" << i << "]:" << tmpCorr[j][i] << std::endl;
                m_auto_corr[ros][drawer][chan][gain][nVals] = tmpCorr[i][j];
                nVals++;
              }
            }
      } else {
            for (int i = 0; i < m_nSamples; i++) {
              for (int j = i+1; j < m_nSamples; j++) {
                //std::cout << "Auto Corr [" << i << "][" << j << "]:" << tmpCorr[i][j] << std::endl;
                //std::cout << "Auto CorrSym [" << j << "][" << i << "]:" << tmpCorr[j][i] << std::endl;
                m_auto_corr[ros][drawer][chan][gain][nVals] = tmpCorr[i][j];
                nVals++;
              }
            }
      }
 
        } // end chan loop
 
        //Calculate covariance loop over chan_i, chan_j
        if (m_evtNr * m_nSamples > 0) {
          //replace m_evtNr with sqrt(m_evt[ch_i]*m_evt[ch_j])
 
          for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
            m_meanAmp[ros][drawer][chan_i][gain] /= m_evtNr * m_nSamples;
            for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j)
              m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] /= m_evtNr * m_nSamples;
          }
 
          //coverity[STACK_USE]
          double covar[48][48];
          double mean_cov_ii = 0.; // mean values of covar in diag terms
          double mean_cov_ij = 0.;  // mean values of covar in off diag terms
 
          for (unsigned int chan_i = 0; chan_i < TileCalibUtils::MAX_CHAN; ++chan_i) {
            for (unsigned int chan_j = 0; chan_j < TileCalibUtils::MAX_CHAN; ++chan_j) {
              covar[chan_i][chan_j] = m_meanAmp_ij[ros][drawer][chan_i][chan_j][gain] - m_meanAmp[ros][drawer][chan_i][gain] * m_meanAmp[ros][drawer][chan_j][gain];
 
              if (chan_j < chan_i) {
                mean_cov_ij += covar[chan_i][chan_j]; //LF: we take C_ij with its sign
              }
            }
            mean_cov_ii += covar[chan_i][chan_i];
          }
 
          if (mean_cov_ii != 0.) {
            m_noise_cov[ros][drawer][gain] = (2. * mean_cov_ij) / (mean_cov_ii * 47.); //(2*cov_ij/(48*47))/(cov_ii/48)
 
          } else {
            m_noise_cov[ros][drawer][gain] = 0.;
          }
 
        }
      }
    }
  }
}

◆ finalize()

StatusCode TileDigiNoiseCalibAlg::finalize ( )

overridevirtual

The output ntuple is created in finalize method.

Definition at line 236 of file TileDigiNoiseCalibAlg.cxx.

                                           {
 
  ATH_MSG_INFO( "Finalizing TileDigiNoiseCalibAlg" );
 
  finalDigits();
 
  std::ostringstream sStr;
  std::string trig_str;
 
  if (m_trigType == Phys) trig_str = "Phys";
  else if (m_trigType == Las) trig_str = "Las";
  else if (m_trigType == Ped) trig_str = "Ped";
  else if (m_trigType == Cis) trig_str = "Cis";
  else {
    ATH_MSG_WARNING( "Unknown trigger type " << m_trigType );
    trig_str = "Unk";
  }
  sStr << m_file << "_" << m_run << "_" << trig_str << ".root";
  m_file = sStr.str();
  ATH_MSG_INFO( "Writing calibrations to file " << m_file );
 
  // Create output file: for now creating file for just this
  // algorithm; want to add to ntuple file eventually??
  TFile* fout = new TFile(m_file.c_str(), "recreate");
 
  // Create tree with branches
  TTree* t = new TTree(m_ntupleID.c_str(), "TileCalib-Ntuple");
 
  t->Branch("RunNumber", &m_run, "RunNumber/I");
  t->Branch("TrigType", &m_trigType, "TrigType/I");
  t->Branch("Time", &m_time, "Time/I");
  t->Branch("Year", &m_year, "Year/I");
  t->Branch("Month", &m_month, "Month/I");
  t->Branch("Day", &m_day, "Day/I");
  t->Branch("YDay", &m_yday, "YDay/I");
  t->Branch("Hour", &m_hour, "Hour/I");
  t->Branch("Min", &m_min, "Min/I");
  t->Branch("nSamples", &m_nSamples, "nSamples/I");
  t->Branch("nEvt", &m_evtNr, "nEvt/I"); // events processed
  t->Branch("ros", *m_ros, "ros[5][64][48][2]/b");
  t->Branch("drawer", *m_drawer, "drawer[5][64][48][2]/b");
  t->Branch("channel", *m_channel, "channel[5][64][48][2]/b");
  t->Branch("gain", *m_gain, "gain[5][64][48][2]/O");
  t->Branch("EvtGood", *m_evt, "Evt[5][64][48][2]/I"); // events used in the noise calculation for every channel
  t->Branch("ped", *m_ped, "ped[5][64][48][2]/F");
  t->Branch("lfn", *m_lfn, "lfn[5][64][48][2]/F");
  t->Branch("hfn", *m_hfn, "hfn[5][64][48][2]/F");
  t->Branch("noise_cov", *m_noise_cov, "noise_cov[5][64][2]/F");
  // AutoCorrelation Matrix: Store only non-diagonal half of symmetric matrix
  t->Branch("auto_corr", *m_auto_corr, "auto_corr[5][64][48][2][36]/F");
 
  // Fill with current values (i.e. tree will have only one entry for this whole run)
 
  t->Fill();
  t->Write();
 
  fout->Close();
 
  return StatusCode::SUCCESS;
}

◆ FirstEvt_initialize()

StatusCode TileDigiNoiseCalibAlg::FirstEvt_initialize ( )

private

Initialization done at the first event.

All the helpers and data dependent variables are initialized here

Definition at line 131 of file TileDigiNoiseCalibAlg.cxx.

                                                      {
 
  // find TileCablingService
  m_cabling = TileCablingService::getInstance();
 
  // retrieve TileID helper from det store
  CHECK( detStore()->retrieve(m_tileID) );
 
  CHECK( detStore()->retrieve(m_tileHWID) );
 
  CHECK( m_adderFilterAlgTool.retrieve() );
 
  StatusCode sc;
  sc &= m_adderFilterAlgTool->setProperty("TileRawChannelContainer", "TileAdderFlat");
  sc &= m_adderFilterAlgTool->setProperty("calibrateEnergy", "true");
  sc &= m_adderFilterAlgTool->setProperty("PedStart", "0");
  sc &= m_adderFilterAlgTool->setProperty("PedLength", "1");
  sc &= m_adderFilterAlgTool->setProperty("PedOffset", "0");
  sc &= m_adderFilterAlgTool->setProperty("SignalStart", "1");
  sc &= m_adderFilterAlgTool->setProperty("SignalLength", "15");
  sc &= m_adderFilterAlgTool->setProperty("FilterLength", "5");
  sc &= m_adderFilterAlgTool->setProperty("FrameLength", "16");
  sc &= m_adderFilterAlgTool->setProperty("DeltaCutLo", "9.5");
  sc &= m_adderFilterAlgTool->setProperty("DeltaCutHi", "9.5");
  sc &= m_adderFilterAlgTool->setProperty("RMSCutLo", "1.0");
  sc &= m_adderFilterAlgTool->setProperty("RMSCutHi", "1.0");
 
  if (sc.isFailure()) {
    ATH_MSG_ERROR("Failure setting properties of " << m_adderFilterAlgTool);
    return StatusCode::FAILURE;
  }
 
  m_tileOFCorrelation = new TileOFCorrelation();
  m_tileOFCorrelation->SetCorrelationZero(msg(), m_nSamples);
 
  ATH_MSG_INFO( "calibMode " << m_calibMode );
  ATH_MSG_INFO( "number of samples " << m_nSamples );
 
  // set event number to 0 before first event
  m_evtNr = 0;
 
  if (m_evtNr == 0) {
    if (m_beamElemContainer.length() > 0) {
      ServiceHandle<IConversionSvc> cnvSvc("ByteStreamCnvSvc", "");
      if (cnvSvc.retrieve().isFailure()) {
        ATH_MSG_ERROR( " Can't get ByteStreamCnvSvc " );
        m_beamCnv = nullptr;
      } else {
        m_beamCnv = dynamic_cast<TileBeamElemContByteStreamCnv *>(cnvSvc->converter(ClassID_traits<TileBeamElemContainer>::ID()));
        if (m_beamCnv == nullptr) {
          ATH_MSG_ERROR( " Can't get TileBeamElemContByteStreamCnv " );
        }
      }
 
    } else {
      m_beamCnv = nullptr;
    }
  }
 
  ATH_MSG_INFO( "initialization completed" );
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode TileDigiNoiseCalibAlg::initialize ( )

overridevirtual

Only array initialization is done here All the helpers initialization is done at the first event.

Definition at line 116 of file TileDigiNoiseCalibAlg.cxx.

                                             {
 
  CHECK( m_dqStatusKey.initialize() );
 
  if (!m_eventInfoKey.key().empty()) {
    ATH_CHECK( m_eventInfoKey.initialize() );
  }
  // TileDigitsContainer initialization
  ATH_CHECK( m_digitsContainerKey.initialize() );
 
  return StatusCode::SUCCESS;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ StoreRunInfo()

void TileDigiNoiseCalibAlg::StoreRunInfo ( const TileDQstatus * dqStatus )

private

StoreRunInfo is called only during the first event.

Definition at line 298 of file TileDigiNoiseCalibAlg.cxx.

                                                                      {
  if (not dqStatus){
    m_time = 0;
    m_year = 0;
    m_month = 0;
    m_day = 0;
    m_yday = 0;
    m_hour = 0;
    m_min = 0;
    m_trigType = 0;
    ATH_MSG_WARNING( "TileDigiNoiseCalibAlg::StoreRunInfo : dqStatus pointer is null" );
    return;
  }
  if (dqStatus->calibMode() == 1 && m_beamElemContainer.length() > 0) {// Bigain can use cispar
    if (m_beamCnv) {
      //    std::cout << "LUCA m_time= "<< m_time << "   bc_time_seconds= "<<  m_beamCnv->eventFragment()->bc_time_seconds() <<
      //  "   bc_time_nanoseconds= " << m_beamCnv->eventFragment()->bc_time_nanoseconds() << std::endl;
      if (m_beamCnv->validBeamFrag()) {
        m_run = m_beamCnv->robFragment()->rod_run_no();   // take it from beam ROD header
      } else {
        m_run = 0;
      }
    } else
      m_run = 0;
 
    if (m_cispar) {
      m_time = m_cispar[10]; //time in sc from 1970
      m_trigType = m_cispar[12];
    } else {
      m_time = 0;
      m_year = 0;
      m_month = 0;
      m_day = 0;
      m_yday = 0;
      m_hour = 0;
      m_min = 0;
      m_trigType = 0;
    }
  } else {// monogain can use eventinfo
 
    SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey); 
    if ( !eventInfo.isValid() ) {
      ATH_MSG_ERROR( "No EventInfo object found! Can't read run number!" );
      m_run = 0;
      m_time = 0;
      m_trigType = 0;
    } else {
      m_run = eventInfo->runNumber();
      m_time = eventInfo->timeStamp();
      if (!(eventInfo->eventType(xAOD::EventInfo::IS_CALIBRATION))) // if not calibration, physics
        m_trigType = 1;
      else
        m_trigType = 0;
    }
 
  }
 
  if (m_time != 0) {
    struct tm t;
    time_t t_time = m_time;
    localtime_r(&t_time, &t);
    m_year = t.tm_year + 1900;
    m_month = t.tm_mon + 1;
    m_day = t.tm_mday;
    m_yday = t.tm_yday + 1;
    m_hour = t.tm_hour;
    m_min = t.tm_min;
  } else {
    m_year = 0;
    m_month = 0;
    m_day = 0;
    m_yday = 0;
    m_hour = 0;
    m_min = 0;
  }
}

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_adderFilterAlgTool

ToolHandle<TileRawChannelBuilderFlatFilter> TileDigiNoiseCalibAlg::m_adderFilterAlgTool

private

Initial value:

{this,

"TileAdderFlatFilter","TileRawChannelBuilderFlatFilter/TileAdderFlatFilter","Tile adder flat filter"}

Definition at line 97 of file TileDigiNoiseCalibAlg.h.

97 {this,

98 "TileAdderFlatFilter","TileRawChannelBuilderFlatFilter/TileAdderFlatFilter","Tile adder flat filter"};

◆ m_auto_corr

float(* TileDigiNoiseCalibAlg::m_auto_corr)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NVALS]

private

Definition at line 153 of file TileDigiNoiseCalibAlg.h.

◆ m_beamCnv

TileBeamElemContByteStreamCnv* TileDigiNoiseCalibAlg::m_beamCnv

private

Definition at line 99 of file TileDigiNoiseCalibAlg.h.

◆ m_beamElemContainer

std::string TileDigiNoiseCalibAlg::m_beamElemContainer

private

Definition at line 118 of file TileDigiNoiseCalibAlg.h.

◆ m_cabling

const TileCablingService* TileDigiNoiseCalibAlg::m_cabling

private

Definition at line 100 of file TileDigiNoiseCalibAlg.h.

◆ m_calibMode

bool TileDigiNoiseCalibAlg::m_calibMode

private

Definition at line 77 of file TileDigiNoiseCalibAlg.h.

◆ m_channel

uint8_t(* TileDigiNoiseCalibAlg::m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 147 of file TileDigiNoiseCalibAlg.h.

◆ m_cispar

const uint32_t* TileDigiNoiseCalibAlg::m_cispar

private

Definition at line 107 of file TileDigiNoiseCalibAlg.h.

◆ m_day

int TileDigiNoiseCalibAlg::m_day

private

Definition at line 139 of file TileDigiNoiseCalibAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_digitsContainer

std::string TileDigiNoiseCalibAlg::m_digitsContainer

private

Definition at line 117 of file TileDigiNoiseCalibAlg.h.

◆ m_digitsContainerKey

SG::ReadHandleKey<TileDigitsContainer> TileDigiNoiseCalibAlg::m_digitsContainerKey

private

Initial value:

{this,

"TileDigitsContainer", "TileDigitsCnt", "Tile digits container"}

Definition at line 91 of file TileDigiNoiseCalibAlg.h.

91 {this,

92 "TileDigitsContainer", "TileDigitsCnt", "Tile digits container"};

◆ m_doAvgCorr

bool TileDigiNoiseCalibAlg::m_doAvgCorr

private

Definition at line 84 of file TileDigiNoiseCalibAlg.h.

◆ m_doRobustCov

bool TileDigiNoiseCalibAlg::m_doRobustCov

private

Definition at line 88 of file TileDigiNoiseCalibAlg.h.

◆ m_dqStatusKey

SG::ReadHandleKey<TileDQstatus> TileDigiNoiseCalibAlg::m_dqStatusKey

private

Definition at line 90 of file TileDigiNoiseCalibAlg.h.

◆ m_drawer

uint8_t(* TileDigiNoiseCalibAlg::m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 146 of file TileDigiNoiseCalibAlg.h.

◆ m_dspRawChannelContainer

std::string TileDigiNoiseCalibAlg::m_dspRawChannelContainer

private

Definition at line 122 of file TileDigiNoiseCalibAlg.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> TileDigiNoiseCalibAlg::m_eventInfoKey

private

Initial value:

{this,

"EventInfo", "EventInfo", "EventInfo key"}

Definition at line 93 of file TileDigiNoiseCalibAlg.h.

93 {this,

94 "EventInfo", "EventInfo", "EventInfo key"};

◆ m_evt

int(* TileDigiNoiseCalibAlg::m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 133 of file TileDigiNoiseCalibAlg.h.

◆ m_evtNr

int TileDigiNoiseCalibAlg::m_evtNr

private

Definition at line 132 of file TileDigiNoiseCalibAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_file

std::string TileDigiNoiseCalibAlg::m_file

private

Definition at line 111 of file TileDigiNoiseCalibAlg.h.

◆ m_gain

bool(* TileDigiNoiseCalibAlg::m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 148 of file TileDigiNoiseCalibAlg.h.

◆ m_hfn

float(* TileDigiNoiseCalibAlg::m_hfn)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 151 of file TileDigiNoiseCalibAlg.h.

◆ m_hour

int TileDigiNoiseCalibAlg::m_hour

private

Definition at line 141 of file TileDigiNoiseCalibAlg.h.

◆ m_lfn

float(* TileDigiNoiseCalibAlg::m_lfn)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 150 of file TileDigiNoiseCalibAlg.h.

◆ m_meanAmp

double(* TileDigiNoiseCalibAlg::m_meanAmp)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 128 of file TileDigiNoiseCalibAlg.h.

◆ m_meanAmp_ij

double(* TileDigiNoiseCalibAlg::m_meanAmp_ij)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 129 of file TileDigiNoiseCalibAlg.h.

◆ m_min

int TileDigiNoiseCalibAlg::m_min

private

Definition at line 142 of file TileDigiNoiseCalibAlg.h.

◆ m_month

int TileDigiNoiseCalibAlg::m_month

private

Definition at line 138 of file TileDigiNoiseCalibAlg.h.

◆ m_noise_cov

float(* TileDigiNoiseCalibAlg::m_noise_cov)[Tile::MAX_DRAWER][Tile::MAX_GAIN]

private

Definition at line 152 of file TileDigiNoiseCalibAlg.h.

◆ m_nSamples

int TileDigiNoiseCalibAlg::m_nSamples

private

Definition at line 113 of file TileDigiNoiseCalibAlg.h.

◆ m_ntupleID

std::string TileDigiNoiseCalibAlg::m_ntupleID

private

Definition at line 110 of file TileDigiNoiseCalibAlg.h.

◆ m_ped

float(* TileDigiNoiseCalibAlg::m_ped)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 149 of file TileDigiNoiseCalibAlg.h.

◆ m_ros

uint8_t(* TileDigiNoiseCalibAlg::m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 145 of file TileDigiNoiseCalibAlg.h.

◆ m_run

int TileDigiNoiseCalibAlg::m_run

private

Definition at line 143 of file TileDigiNoiseCalibAlg.h.

◆ m_sumPed2

double(* TileDigiNoiseCalibAlg::m_sumPed2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 126 of file TileDigiNoiseCalibAlg.h.

◆ m_sumRms2

double(* TileDigiNoiseCalibAlg::m_sumRms2)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]

private

Definition at line 127 of file TileDigiNoiseCalibAlg.h.

◆ m_tileHWID

const TileHWID* TileDigiNoiseCalibAlg::m_tileHWID

private

Definition at line 105 of file TileDigiNoiseCalibAlg.h.

◆ m_tileID

const TileID* TileDigiNoiseCalibAlg::m_tileID

private

Definition at line 104 of file TileDigiNoiseCalibAlg.h.

◆ m_tileOFCorrelation

TileOFCorrelation* TileDigiNoiseCalibAlg::m_tileOFCorrelation

private

Definition at line 101 of file TileDigiNoiseCalibAlg.h.

◆ m_time

int TileDigiNoiseCalibAlg::m_time

private

Definition at line 136 of file TileDigiNoiseCalibAlg.h.

◆ m_treeSize

int64_t TileDigiNoiseCalibAlg::m_treeSize

private

Definition at line 112 of file TileDigiNoiseCalibAlg.h.

◆ m_trigType

int TileDigiNoiseCalibAlg::m_trigType

private

Definition at line 144 of file TileDigiNoiseCalibAlg.h.

◆ m_usePMT

bool TileDigiNoiseCalibAlg::m_usePMT

private

Definition at line 80 of file TileDigiNoiseCalibAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_yday

int TileDigiNoiseCalibAlg::m_yday

private

Definition at line 140 of file TileDigiNoiseCalibAlg.h.

◆ m_year

int TileDigiNoiseCalibAlg::m_year

private

Definition at line 137 of file TileDigiNoiseCalibAlg.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ Tile

Member Enumeration Documentation

◆ trigtype

Constructor & Destructor Documentation

◆ TileDigiNoiseCalibAlg()

◆ ~TileDigiNoiseCalibAlg()

Member Function Documentation

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ digiChannel2PMT()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ fillDigits()

◆ finalDigits()

◆ finalize()

◆ FirstEvt_initialize()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ StoreRunInfo()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_adderFilterAlgTool

◆ m_auto_corr

◆ m_beamCnv

◆ m_beamElemContainer

◆ m_cabling

◆ m_calibMode

◆ m_channel

◆ m_cispar

◆ m_day

◆ m_detStore

◆ m_digitsContainer

◆ m_digitsContainerKey

◆ m_doAvgCorr

◆ m_doRobustCov

◆ m_dqStatusKey

◆ m_drawer

◆ m_dspRawChannelContainer

◆ m_eventInfoKey

◆ m_evt

◆ m_evtNr

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_file

◆ m_gain

◆ m_hfn

◆ m_hour

◆ m_lfn

◆ m_meanAmp

◆ m_meanAmp_ij

◆ m_min

◆ m_month

◆ m_noise_cov

◆ m_nSamples

◆ m_ntupleID

◆ m_ped

◆ m_ros

◆ m_run

◆ m_sumPed2

◆ m_sumRms2

◆ m_tileHWID

◆ m_tileID