CaloRec::Helpers Namespace Reference

Classes
struct	CaloClusterSignalAccumulator
	Cache for data accumulator. More...

Typedef Documentation

boolarray_t

typedef std::vector<bool> CaloRec::Helpers::boolarray_t

Vector of flags indicating sampling contribution.

Definition at line 36 of file CaloTopoClusterFromTowerHelpers.h.

valarray_t

typedef std::array<double,CaloSampling::Unknown> CaloRec::Helpers::valarray_t

Array accommodating data for samplings.

Definition at line 35 of file CaloTopoClusterFromTowerHelpers.h.

Function Documentation

calculateKine()

bool CaloRec::Helpers::calculateKine	(	xAOD::CaloCluster *	pClus,
		bool	onlyKine = false
	)

Kinematic updates.

This function updates the kinematics of a cluster e.g. after calibration

Parameters

pClus	pointer to modifiable cluster object
onlyKine	update only global cluster kinematics when true, else update all cluster variables

Definition at line 118 of file CaloTopoClusterFromTowerHelpers.cxx.

{
  // input
  if ( pClus == nullptr ) { return false; }
 
  // get cell links
  const CaloClusterCellLink* clk = pClus->getCellLinks();
  if ( clk == nullptr || clk->size() == 0 ) { return false; }
 
  // accumulator object                        ////////////////////////////////////////////////
  CaloClusterSignalAccumulator accum;          // Strict enforcement of valid cell pointers! //
  // accumulate cells                          ////////////////////////////////////////////////
  bool retflg(true); 
  auto citer(clk->begin());
  while ( citer != clk->end() && retflg ) { 
    if ( *citer != nullptr ) { retflg = cellAccumulator(**citer,accum,citer.weight(),onlyKine); } ++citer; }
  if ( !retflg ) { return false; }
 
  // set cluster kinematics: energy & mass
  pClus->setE(accum.cluster.accumE);
  pClus->setM(0.);
 
  // set cluster kinematics: directions
  if ( accum.cluster.accumAbsE != 0. ) {
    double invPosNorm(1./accum.cluster.accumAbsE);
    pClus->setEta(accum.cluster.accumEta*invPosNorm);
    pClus->setPhi(CaloPhiRange::fix(accum.cluster.accumPhi*invPosNorm));
  } else {
    pClus->setEta(0.);
    pClus->setPhi(0.);
  }
 
  // bail out if only global kinematice to be updated
  if ( onlyKine ) { return true; }
 
  // set cluster kinematics: time
  if ( accum.cluster.accumTimeNorm != 0. ) {
    pClus->setTime(accum.cluster.accumTime/accum.cluster.accumTimeNorm);
  } else {
    pClus->setTime(0.);
  }
 
  // set sampling pattern
  uint32_t samplingPattern(0);
  for ( int i(0); i<(int)CaloSampling::Unknown; ++i ) {
    if ( accum.sampling.presenceInSample[i] ) { samplingPattern |= (0x1U<<i); }
    if ( samplingPattern != pClus->samplingPattern() ) { 
      pClus->clearSamplingData();
      pClus->setSamplingPattern(samplingPattern,true);
    }
  }
 
  // set sampling variables
  for ( int i(0); i<(int)CaloSampling::Unknown; ++i ) { 
    if ( accum.sampling.presenceInSample[i] ) { 
      CaloSampling::CaloSample sam = (CaloSampling::CaloSample)i;
      pClus->setEnergy(sam,accum.sampling.energyInSample[i]);
      double enorm(accum.sampling.posNormInSample[i]);
      double eta(accum.sampling.etaInSample[i]);
      double phi(accum.sampling.phiInSample[i]);
      if ( enorm != 0. ) { 
    pClus->setEta(sam,eta/enorm);
    pClus->setPhi(sam,CaloPhiRange::fix(phi/enorm));
      } else { 
    pClus->setEta(sam,eta);
    pClus->setPhi(sam,CaloPhiRange::fix(phi));
      }
      pClus->setEmax(sam,accum.sampling.maxEnergyInSample[i]);
      pClus->setEtamax(sam,accum.sampling.etaMaxEnergyInSample[i]);
      pClus->setPhimax(sam,accum.sampling.phiMaxEnergyInSample[i]);
    } // check if sampling is in cluster
  } // loop on samplings
 
  return true;
}

cellAccumulator()

bool CaloRec::Helpers::cellAccumulator	(	const CaloCell &	rcell,
		CaloClusterSignalAccumulator &	accum,
		double	weight,
		bool	onlyKine = false
	)

Definition at line 23 of file CaloTopoClusterFromTowerHelpers.cxx.

{
  // Collecting Kinematics //
 
 
  // required info
  const CaloDetDescrElement* dde = rcell.caloDDE(); if ( dde == nullptr ) { return false; }
  // energy and weights
  accum.cluster.cellWeight    = weight;
  accum.cluster.cellAbsWeight = std::fabs(accum.cluster.cellWeight);
  accum.cluster.cellE         = accum.cluster.cellWeight*rcell.e();
  accum.cluster.cellAbsE      = accum.cluster.cellAbsWeight*std::fabs(rcell.e());
  // direction
  double celleta(dde->eta());
  double cellphi(dde->phi());
  // energy sum and normalizations
  accum.cluster.accumE    += accum.cluster.cellE;
  accum.cluster.accumAbsE += accum.cluster.cellAbsE;
  if ( accum.cluster.firstCell ) { 
    accum.cluster.phiSeed = cellphi; accum.cluster.firstCell = false; 
  } else { 
    cellphi = proxim(cellphi,accum.cluster.phiSeed); 
  }
  accum.cluster.accumPhi  += accum.cluster.cellAbsE*cellphi;
  accum.cluster.accumEta  += accum.cluster.cellAbsE*celleta;
  // kine kinmatic updates done
  if ( onlyKine ) return true;
  
  // Sampling Quantities //
 
  // check if cell has valid sampling 
  CaloSampling::CaloSample sam = dde->getSampling();
  int isam((int)sam);
  int fsam((int)CaloSampling::Unknown);
  if ( isam < 0 || isam >= fsam ) { return false; }
  
  // mark sampling in cluster
  accum.sampling.presenceInSample[isam] = true;
  
  // collecting in samples
  accum.sampling.energyInSample[isam]  += accum.cluster.cellE;
  accum.sampling.posNormInSample[isam] += accum.cluster.cellAbsE;
  accum.sampling.etaInSample[isam]     += accum.cluster.cellAbsE*celleta;
  accum.sampling.phiInSample[isam]     += accum.cluster.cellAbsE*cellphi;
  
  // maximum energies in samplings
  if ( accum.cluster.cellE > accum.sampling.maxEnergyInSample[isam] ) {
    accum.sampling.maxEnergyInSample[isam]    = accum.cluster.cellE;
    accum.sampling.etaMaxEnergyInSample[isam] = celleta;
    accum.sampling.phiMaxEnergyInSample[isam] = cellphi;
  }
  
  // counting cells in barrel and endcap
  if ( accum.cluster.cellE != 0. && accum.cluster.cellWeight != 0. ) { 
    switch (sam) {
    case CaloSampling::PreSamplerE:
    case CaloSampling::EME1:
    case CaloSampling::EME2:
    case CaloSampling::EME3:
    case CaloSampling::HEC0:
    case CaloSampling::HEC1:
    case CaloSampling::HEC2:
    case CaloSampling::HEC3:
    case CaloSampling::FCAL0:
    case CaloSampling::FCAL1:
    case CaloSampling::FCAL2:
    case CaloSampling::MINIFCAL0:
    case CaloSampling::MINIFCAL1:
    case CaloSampling::MINIFCAL2:
    case CaloSampling::MINIFCAL3:
      accum.cluster.nEndcap++;
      break;
    default:
      accum.cluster.nBarrel++;
      break;
    }
    
    // time where available
    if ( sam != CaloSampling::PreSamplerB && sam != CaloSampling::PreSamplerE ) { 
      unsigned int pmask = dde->is_tile() ? 0x8080 : 0x2000;
      // is time defined?
      if ( rcell.provenance() & pmask ) {
    double tnorm(accum.cluster.cellAbsE*accum.cluster.cellWeight*rcell.e()); // sign of weight preserved!
    accum.cluster.accumTime      += tnorm*rcell.time();
    accum.cluster.accumTimeNorm  += tnorm;
      } // cell ok for time
    } // sampling contributes to time
  } // cell has energy and weight != 0
  return true;
}

fmtMsg()

std::string CaloRec::Helpers::fmtMsg	(	const char *	fmt,
			...
	)

Definition at line 13 of file CaloTopoClusterFromTowerHelpers.cxx.

                                                    {
      char buffer[1024];
      va_list args;
      va_start(args,fmt);
      vsprintf(buffer,fmt,args);
      va_end(args);
      return std::string(buffer);
}