Sampling calculator helper class. More...

Inheritance diagram for CaloClusterCorr::SamplingHelper:

Collaboration diagram for CaloClusterCorr::SamplingHelper:

Public Member Functions
	SamplingHelper (const CaloClusterCorrection &parent, const CaloFillRectangularCluster::WindowArray_t &windows, CaloCluster *cluster)
	Constructor.
virtual	~SamplingHelper ()=default
	Destructor — just to get a vtable.
virtual void	calculate (double eta, double phi, double deta, double dphi, CaloSampling::CaloSample sampling, bool dofill=false)=0
	Calculate layer variables — abstract method.
virtual const CaloCell *	max_et_cell () const =0
	Return the cell with the maximum energy — abstract method.
virtual bool	empty () const =0
	Test for empty candidate cell list — abstract method.
void	calculate_cluster (double eta, double phi, double deta, double dphi, CaloSampling::CaloSample sampling)
	Calculate layer variables for cells in the cluster.
void	calculate_and_set (double eta, double phi, int layer, int fallback_layer, const CaloSampling::CaloSample samplings[4], bool allow_badpos=false)
	Calculate layer variables and update cluster.
CaloCluster *	cluster ()
	Return the cluster we're updating.
double	etam () const
	Return the \(\eta\) position from the last calculation.
double	phim () const
	Return the \(\phi\) position from the last calculation.
double	etamax () const
	Return the \(\eta\) maximum position from the last calculation.
double	phimax () const
	Return the \(\phi\) maximum position from the last calculation.
double	etareal () const
double	deta (int layer) const
double	dphi (int layer) const

Protected Attributes
CaloLayerCalculator	m_calc
	The calculator object.
const CaloClusterCorrection &	m_parent
	The correction object using us.
CaloCluster *	m_cluster
	The cluster we're updating.
CaloFillRectangularCluster::WindowArray_t	m_windows
	Window size, per layer.
double	m_etam
	\(\eta\) position from last calculation.
double	m_phim
	\(\phi\) position from last calculation.

Detailed Description

Sampling calculator helper class.

This helper class is used to decouple the layer calculations from the decision of the origin of the cells (a StoreGate container or the existing cluster cells).

This is an abstract base class; there are concrete implementations of this for the two cases of cells coming from StoreGate and cells coming from the clusters.

Definition at line 185 of file CaloFillRectangularCluster.cxx.

Constructor & Destructor Documentation

◆ SamplingHelper()

CaloClusterCorr::SamplingHelper::SamplingHelper	(	const CaloClusterCorrection &	parent,
		const CaloFillRectangularCluster::WindowArray_t &	windows,
		CaloCluster *	cluster )

Constructor.

Parameters

parent	The parent correction class.
windows	Per-layer array of window eta,phi sizes.
cluster	The cluster being operated on.

Definition at line 344 of file CaloFillRectangularCluster.cxx.

  : m_parent (parent),
    m_cluster (cluster),
    m_windows (windows),
    m_etam(0),
    m_phim(0)
{
}

◆ ~SamplingHelper()

virtual CaloClusterCorr::SamplingHelper::~SamplingHelper ( )

virtualdefault

Destructor — just to get a vtable.

Member Function Documentation

◆ calculate()

virtual void CaloClusterCorr::SamplingHelper::calculate	(	double	eta,
		double	phi,
		double	deta,
		double	dphi,
		CaloSampling::CaloSample	sampling,
		bool	dofill = false )

pure virtual

Calculate layer variables — abstract method.

Parameters

eta	Center of the cluster in \(\eta\).
phi	Center of the cluster in \(\phi\).
deta	Full width of the cluster in \(\eta\).
dphi	Full width of the cluster in \(\phi\).
sampling	The sampling for which to do the calculation.
dofill	If true, add selected cells to the cluster (if possible).

This virtual method should select the cells within the specified window in the specified sampling from the list of candidate cells and calculate the layer variables. If dofill is true, then the selected cells will also be added to the cluster, provided that this makes sense (it will not be done if the cluster is the source of the cells).

The result of the calculation will be held in internal variables.

Implemented in CaloClusterCorr::SamplingHelper_CaloCellList, and CaloClusterCorr::SamplingHelper_Cluster.

◆ calculate_and_set()

void CaloClusterCorr::SamplingHelper::calculate_and_set	(	double	eta,
		double	phi,
		int	layer,
		int	fallback_layer,
		const CaloSampling::CaloSample	samplings[4],
		bool	allow_badpos = false )

Calculate layer variables and update cluster.

Parameters

eta	Center of the cluster in \(\eta\).
phi	Center of the cluster in \(\phi\).
layer	Calorimeter layer being calculated (0-3).
fallback_layer	Layer for fallback values (see below).
samplings	List of samplings for this region.
allow_badpos	Should error flags be allowed into the cluster?

This method selects the cells within the specified window for the sampling for the specified layer from the current list of cells in the cluster and calculates the layer variables.

The result of the calculation will be held in internal variables. In addition, the cluster variables for this sampling will be updated with the result.

In some cases, the calculation of the cluster position may yield an error (for example, if there are no selected cells). In this case, we use the cluster eta/phi from the layer given by fallback_layer instead of the calculated result. (If fallback_layer is < 0, then we use the eta, phi arguments instead.) If allow_badpos is true, then the error flags are used to update the cluster variables; otherwise, the fallback position is used when updating the cluster.

Definition at line 383 of file CaloFillRectangularCluster.cxx.

{
  calculate (eta, phi, deta(layer), dphi(layer), samplings[layer], true);
 
  double seteta = m_calc.etam();
  double setphi = m_calc.phim();
 
  double fallback_eta = eta;
  double fallback_phi = phi;
  if ((seteta == -999 || setphi == -999) && fallback_layer >= 0 && fallback_layer < 4) {
    // In the calo frame
    fallback_eta = m_cluster->etaSample (samplings[fallback_layer]);
    fallback_phi = m_cluster->phiSample (samplings[fallback_layer]);
  }
 
  if (!allow_badpos) {
    //if (m_etam == -999) m_etam = fallback_eta;
    //if (m_phim == -999) m_phim = fallback_phi;
    if (seteta == -999) seteta = fallback_eta;
    if (setphi == -999) setphi = fallback_phi;
  }
 
  //FIXME: Sampling pattern not yet set! 
  m_parent.setsample (m_cluster,
                      samplings[layer],
                      m_calc.em(),
              seteta,
              setphi,
                      m_calc.emax(),
                      m_calc.etamax(),
                      m_calc.phimax(),
                      m_calc.etas(),
                      m_calc.phis());
  if (allow_badpos) {
    if (m_etam == -999) m_etam = fallback_eta;
    if (m_phim == -999) m_phim = fallback_phi;
  }
}

◆ calculate_cluster()

void CaloClusterCorr::SamplingHelper::calculate_cluster	(	double	eta,
		double	phi,
		double	deta,
		double	dphi,
		CaloSampling::CaloSample	sampling )

Calculate layer variables for cells in the cluster.

Parameters

eta	Center of the cluster in \(\eta\).
phi	Center of the cluster in \(\phi\).
deta	Full width of the cluster in \(\eta\).
dphi	Full width of the cluster in \(\phi\).
sampling	The sampling for which to do the calculation.

This method selects the cells within the specified window in the specified sampling from the current list of cells in the cluster and calculates the layer variables.

The result of the calculation will be held in internal variables.

Definition at line 444 of file CaloFillRectangularCluster.cxx.

{
  m_calc.fill (m_cluster->cell_begin(), m_cluster->cell_end(),
               eta, phi, deta, dphi, sampling);
  m_etam = m_calc.etamr();
  m_phim = m_calc.phimr();
}