HLT::MET::PufitUtils Namespace Reference

Classes
struct	CovarianceSum
	Helper struct to hold the sum over pileup objects and its covariance. More...

Functions
void	trimmedMeanAndVariance (const std::vector< double > &sorted, double trimFraction, double &mean, double &variance)
	Calculate the trimmed mean and variance for a vector of tower sumEts.
void	trimmedMeanAndVariance (const PufitGrid &grid, double trimFraction, double &mean, double &variance)
	Calculate the trimmed mean and variance for a vector of tower sumEts.
void	unmaskedMeanAndVariance (const PufitGrid &grid, double &mean, double &variance)
	Calculate the mean and variance of unmasked towers.
GridDisplacement	selectGrid (const PufitGridSet &grids)
	Select the grid with the highest masked sumEt.
Eigen::VectorXd	pufit (const Eigen::Vector2d &pileupSum, const Eigen::Matrix2d &pileupCovariance, const Eigen::VectorXd &towerExpectations, const Eigen::VectorXd &towerVariances, const Eigen::VectorXd &correctionDirections, double constraintImportance=1)
	Perform the pile-up fit.
Eigen::VectorXd	pufit (const Eigen::Vector2d &pileupSum, const Eigen::Matrix2d &pileupCovariance, double towerMean, double towerVariance, const Eigen::VectorXd &correctionDirections, double constraintImportance=1)
	Perform the pile-up fit.
Eigen::VectorXd	pufit (const Eigen::Vector2d &pileupSum, const Eigen::Matrix2d &pileupCovariance, const Eigen::VectorXd &towerExpectations, const Eigen::VectorXd &towerVariances, const Eigen::Matrix< double, 2, Eigen::Dynamic > &cosSin, double constraintImportance=1)
	Perform the pile-up fit.
Eigen::VectorXd	pufit (const Eigen::Vector2d &pileupSum, const Eigen::Matrix2d &pileupCovariance, double towerMean, double towerVariance, const Eigen::Matrix< double, 2, Eigen::Dynamic > &cosSin, double constraintImportance=1)
	Perform the pile-up fit.
std::vector< SignedKinematics >	pufit (const Eigen::Vector2d &pileupSum, const Eigen::Matrix2d &pileupCovariance, const std::vector< double > &towerExpectations, const std::vector< double > &towerVariances, const std::vector< SignedKinematics > &toCorrect, double constraintImportance=1)
	Perform the pile-up fit.
std::vector< SignedKinematics >	pufit (const Eigen::Vector2d &pileupSum, const Eigen::Matrix2d &pileupCovariance, double towerMean, double towerVariance, const std::vector< SignedKinematics > &toCorrect, double constraintImportance=1)
	Perform the pile-up fit.
template<std::size_t N>
void	trimmedMeanAndVariance (const PufitMultiGrid< N > &grid, std::size_t type, double trimFraction, double &mean, double &variance)
	Calculate the trimmed mean and variance for a vector of tower sumEts.
template<std::size_t N>
void	unmaskedMeanAndVariance (const PufitMultiGrid< N > &grid, int type, double &mean, double &variance)
	Calculate the mean and variance of unmasked towers.
template<typename Grid>
GridDisplacement	selectGrid (const PufitMultiGridSet< Grid > &grids, std::size_t type)
	Select the grid with the highest masked sumEt.

Function Documentation

pufit() [1/6]

Eigen::VectorXd HLT::MET::PufitUtils::pufit	(	const Eigen::Vector2d &	pileupSum,
		const Eigen::Matrix2d &	pileupCovariance,
		const Eigen::VectorXd &	towerExpectations,
		const Eigen::VectorXd &	towerVariances,
		const Eigen::Matrix< double, 2, Eigen::Dynamic > &	cosSin,
		double	constraintImportance = 1 )

Perform the pile-up fit.

Parameters

pileupSum	2-vector sum over the pileup contributions
pileupCovariance	Covariance matrix of the pileup sum
towerExpectations	Expected values for each tower based on the pileup energy density
towerVariances	Expected values for the variances of each tower based on variances of background towers
cosSin	The cosines and sines of the objects to correct
The	relative importance of the constraints.

Returns

A vector containing the magnitudes of the corrections

This variant directly provides the cos-sin matrix for the correction, potentially allowing many cos/sin calls to be avoided. This variant provides individual estimates of the expected energy in each tower and the corresponding variances - these are for cases where the areas of each object are different.

Definition at line 158 of file PufitUtils.cxx.

      {
        // Keep track of the number of corrections to derive
        std::size_t nCorr = cosSin.cols();
        if (nCorr == 0)
          // No need to do anything to derive corrections to nothing
          return {};
        // Eigen internally uses somewhat complicated 'expression templates' to hold
        // the mathematics of a matrix calculation without actually doing the loop.
        // This allows it to avoid doing more loops than it actually needs to. It
        // will do this by default unless you force it to evaluate an expression by
        // binding it to a vector matrix type. Therefore we use 'auto' to store the
        // individual expression pieces, rather than forcing an early evaluation.
        if (pileupCovariance.determinant() == 0)
        {
          // In very rare circumstances the pileup covariance can be 0. This essentially means that
          // there is nothing interpreted as pileup. The calculation will fail in this case so we
          // cannot run the fit. Just return the expectations
          return towerExpectations;
        }
        auto constants =
            // Constant part derived from the uniformity constraint
            towerExpectations.cwiseQuotient(towerVariances) -
            // Constant part derived from the pileup balance constraint
            constraintImportance * cosSin.transpose() * pileupCovariance.inverse() * pileupSum;
        Eigen::MatrixXd diagonal = towerVariances.cwiseInverse().asDiagonal();
        auto coeffMatrix =
            // Matrix part derived from the uniformity constraint
            diagonal +
            // Matrix part derived from the pileup balance constraint
            constraintImportance * (cosSin.transpose() * pileupCovariance.inverse() * cosSin);
        // Now return the actual corrections
        return coeffMatrix.inverse() * constants;
      }

pufit() [2/6]

Eigen::VectorXd HLT::MET::PufitUtils::pufit	(	const Eigen::Vector2d &	pileupSum,
		const Eigen::Matrix2d &	pileupCovariance,
		const Eigen::VectorXd &	towerExpectations,
		const Eigen::VectorXd &	towerVariances,
		const Eigen::VectorXd &	correctionDirections,
		double	constraintImportance = 1 )

Perform the pile-up fit.

Parameters

pileupSum	2-vector sum over the pileup contributions
pileupCovariance	Covariance matrix of the pileup sum
towerExpectations	Expected values for each tower based on the pileup energy density
towerVariances	Expected values for the variances of each tower based on variances of background towers
correctionDirections	The directions of the objects to correct
The	relative importance of the constraints.

Returns

A vector containing the magnitudes of the corrections

This variant provides individual estimates of the expected energy in each tower and the corresponding variances - these are for cases where the areas of each object are different.

Definition at line 114 of file PufitUtils.cxx.

      {
        // Keep track of the number of corrections to derive
        std::size_t nCorr = correctionDirections.size();
        if (nCorr == 0)
          // No need to do anything to derive corrections to nothing
          return {};
        // Turn the directions into cos/sin pairs
        Eigen::Matrix<double, 2, Eigen::Dynamic> cosSin(2, nCorr);
        cosSin.row(0) = correctionDirections.array().cos();
        cosSin.row(1) = correctionDirections.array().sin();
        return pufit(
            pileupSum,
            pileupCovariance,
            towerExpectations,
            towerVariances,
            cosSin,
            constraintImportance);
      }

pufit() [3/6]

std::vector< SignedKinematics > HLT::MET::PufitUtils::pufit	(	const Eigen::Vector2d &	pileupSum,
		const Eigen::Matrix2d &	pileupCovariance,
		const std::vector< double > &	towerExpectations,
		const std::vector< double > &	towerVariances,
		const std::vector< SignedKinematics > &	toCorrect,
		double	constraintImportance = 1 )

Perform the pile-up fit.

Parameters

pileupSum	2-vector sum over the pileup contributions
pileupCovariance	Covariance matrix of the pileup sum
towerExpectations	Expected values for each tower based on the pileup energy density
towerVariances	Expected values for the variances of each tower based on variances of background towers
toCorrect	Kinematics of the objects to correct
The	relative importance of the constraints.

Returns

The corrections to apply

Note that this version still returns the corrections that should be applied, not the corrected objects. The corrections are returned using the negatives of the value calculated by the fit - i.e. you should add the returned objects and let them act as negative energy objects (unless the sign of the correction was negative in which case it will act as a positive energy object). This variant provides individual estimates of the expected energy in each tower and the corresponding variances - these are for cases where the areas of each object are different.

Definition at line 217 of file PufitUtils.cxx.

      {
        // Keep track of the number of corrections to derive
        std::size_t nCorr = toCorrect.size();
        if (nCorr == 0)
          // No need to do anything to derive corrections to nothing
          return {};
 
        // Get the cos-sin matrix
        Eigen::Matrix<double, 2, Eigen::Dynamic> cosSin(2, nCorr);
        Eigen::VectorXd vecTowerExpectations(nCorr);
        Eigen::VectorXd vecTowerVariances(nCorr);
        for (std::size_t ii = 0; ii < nCorr; ++ii)
        {
          cosSin(0, ii) = toCorrect.at(ii).cosPhi();
          cosSin(1, ii) = toCorrect.at(ii).sinPhi();
          vecTowerExpectations(ii) = towerExpectations.at(ii);
          vecTowerVariances(ii) = towerVariances.at(ii);
        }
        Eigen::VectorXd corrections = pufit(
            pileupSum,
            pileupCovariance,
            vecTowerExpectations,
            vecTowerVariances,
            cosSin,
            constraintImportance);
        // Now convert these into kinematics
        std::vector<SignedKinematics> kinCorrections;
        kinCorrections.reserve(nCorr);
        for (std::size_t ii = 0; ii < nCorr; ++ii)
          kinCorrections.push_back(SignedKinematics::fromEtEtaPhi(
              -corrections.coeff(ii),
              toCorrect.at(ii).eta(),
              toCorrect.at(ii).phi()));
        return kinCorrections;
      }

pufit() [4/6]

Eigen::VectorXd HLT::MET::PufitUtils::pufit	(	const Eigen::Vector2d &	pileupSum,
		const Eigen::Matrix2d &	pileupCovariance,
		double	towerMean,
		double	towerVariance,
		const Eigen::Matrix< double, 2, Eigen::Dynamic > &	cosSin,
		double	constraintImportance = 1 )

Perform the pile-up fit.

Parameters

pileupSum	2-vector sum over the pileup contributions
pileupCovariance	Covariance matrix of the pileup sum
towerMean	Estimate of the mean pileup tower transverse energy
towerVariance	Estimate of the variance of pileup tower transverse energies
cosSin	The cosines and sines of the objects to correct
The	relative importance of the constraints.

Returns

A vector containing the magnitudes of the corrections

This variant directly provides the cos-sin matrix for the correction, potentially allowing many cos/sin calls to be avoided.

Definition at line 199 of file PufitUtils.cxx.

      {
        std::size_t nCorr = cosSin.cols();
        return pufit(
            pileupSum,
            pileupCovariance,
            Eigen::VectorXd::Constant(nCorr, towerMean),
            Eigen::VectorXd::Constant(nCorr, towerVariance),
            cosSin,
            constraintImportance);
      }

pufit() [5/6]

Eigen::VectorXd HLT::MET::PufitUtils::pufit	(	const Eigen::Vector2d &	pileupSum,
		const Eigen::Matrix2d &	pileupCovariance,
		double	towerMean,
		double	towerVariance,
		const Eigen::VectorXd &	correctionDirections,
		double	constraintImportance = 1 )

Perform the pile-up fit.

Parameters

pileupSum	2-vector sum over the pileup contributions
pileupCovariance	Covariance matrix of the pileup sum
towerMean	Estimate of the mean pileup tower transverse energy
towerVariance	Estimate of the variance of pileup tower transverse energies
correctionDirections	The directions of the objects to correct
The	relative importance of the constraints.

Returns

A vector containing the magnitudes of the corrections

Definition at line 140 of file PufitUtils.cxx.

      {
        std::size_t nCorr = correctionDirections.size();
        return pufit(
            pileupSum,
            pileupCovariance,
            Eigen::VectorXd::Constant(nCorr, towerMean),
            Eigen::VectorXd::Constant(nCorr, towerVariance),
            correctionDirections,
            constraintImportance);
      }

pufit() [6/6]

std::vector< SignedKinematics > HLT::MET::PufitUtils::pufit	(	const Eigen::Vector2d &	pileupSum,
		const Eigen::Matrix2d &	pileupCovariance,
		double	towerMean,
		double	towerVariance,
		const std::vector< SignedKinematics > &	toCorrect,
		double	constraintImportance = 1 )

Perform the pile-up fit.

Parameters

pileupSum	2-vector sum over the pileup contributions
pileupCovariance	Covariance matrix of the pileup sum
towerMean	Estimate of the mean pileup tower transverse energy
towerVariance	Estimate of the variance of pileup tower transverse energies
toCorrect	Kinematics of the objects to correct
The	relative importance of the constraints.

Returns

The corrections to apply

Note that this version still returns the corrections that should be applied, not the corrected objects. The corrections are returned using the negatives of the value calculated by the fit - i.e. you should add the returned objects and let them act as negative energy objects (unless the sign of the correction was negative in which case it will act as a positive energy object).

Definition at line 259 of file PufitUtils.cxx.

      {
        // Keep track of the number of corrections to derive
        std::size_t nCorr = toCorrect.size();
        if (nCorr == 0)
          // No need to do anything to derive corrections to nothing
          return {};
 
        return pufit(
            pileupSum,
            pileupCovariance,
            std::vector<double>(nCorr, towerMean),
            std::vector<double>(nCorr, towerVariance),
            toCorrect,
            constraintImportance);
      }

selectGrid() [1/2]

GridDisplacement HLT::MET::PufitUtils::selectGrid

(

const PufitGridSet &

grids

)

Select the grid with the highest masked sumEt.

Definition at line 95 of file PufitUtils.cxx.

      {
        GridDisplacement maximum = NoDisplacement;
        double maxSum = 0;
        for (std::size_t d = 0; d < 4; ++d)
        {
          double sum = 0;
          for (const PufitGrid::Tower &tower : grids[GridDisplacement(d)])
            if (tower.masked())
              sum += tower.sumEt();
          if (sum > maxSum)
          {
            maximum = GridDisplacement(d);
            maxSum = sum;
          }
        }
        return maximum;
      }

selectGrid() [2/2]

template<typename Grid>

GridDisplacement HLT::MET::PufitUtils::selectGrid	(	const PufitMultiGridSet< Grid > &	grids,
		std::size_t	type )

Select the grid with the highest masked sumEt.

trimmedMeanAndVariance() [1/3]

void HLT::MET::PufitUtils::trimmedMeanAndVariance	(	const PufitGrid &	grid,
		double	trimFraction,
		double &	mean,
		double &	variance )

Calculate the trimmed mean and variance for a vector of tower sumEts.

Parameters

	grid	The grid to calculate
	trimFraction	The fraction of towers to use in the calculation
[out]	mean	The calculated mean
[out]	variance	The calculated variance

Definition at line 57 of file PufitUtils.cxx.

      {
        std::vector<double> sorted;
        sorted.reserve(grid.nTowers());
        for (const PufitGrid::Tower &tower : grid)
          sorted.insert(
              std::lower_bound(sorted.begin(), sorted.end(), tower.sumEt()),
              tower.sumEt());
        trimmedMeanAndVariance(sorted, trimFraction, mean, variance);
      }

trimmedMeanAndVariance() [2/3]

template<std::size_t N>

void HLT::MET::PufitUtils::trimmedMeanAndVariance	(	const PufitMultiGrid< N > &	grid,
		std::size_t	type,
		double	trimFraction,
		double &	mean,
		double &	variance )

Calculate the trimmed mean and variance for a vector of tower sumEts.

Parameters

	grid	The grid to calculate
	type	The int mask of subgrid types
	trimFraction	The fraction of twoers to use in the calculation
[out]	mean	The calculated mean
[out]	variance	The calculated variance

trimmedMeanAndVariance() [3/3]

void HLT::MET::PufitUtils::trimmedMeanAndVariance	(	const std::vector< double > &	sorted,
		double	trimFraction,
		double &	mean,
		double &	variance )

Calculate the trimmed mean and variance for a vector of tower sumEts.

Parameters

	sorted	The sumEts for all towers, sorted in ascending order
	trimFraction	The fraction of towers to use in the calculation
[out]	mean	The calculated mean
[out]	variance	The calculated variance

Definition at line 35 of file PufitUtils.cxx.

      {
        // The number to trim from each side
        std::size_t nTrim = sorted.size() * (1 - trimFraction) / 2;
 
        mean = std::accumulate(sorted.begin() + nTrim, sorted.end() - nTrim, 0.);
        mean /= (sorted.size() - 2 * nTrim);
 
        // Now get the variance
        variance = 0;
        for (std::size_t ii = 0; ii < sorted.size() - nTrim; ++ii)
        {
          double val = sorted.at(ii) - mean;
          variance += val * val * (ii < nTrim ? 2 : 1);
        }
        variance /= sorted.size();
      }

unmaskedMeanAndVariance() [1/2]

void HLT::MET::PufitUtils::unmaskedMeanAndVariance	(	const PufitGrid &	grid,
		double &	mean,
		double &	variance )

Calculate the mean and variance of unmasked towers.

Parameters

	grid	The grid to calculate
[out]	mean	The calculated mean
[out]	variance	The calculated variance

Definition at line 72 of file PufitUtils.cxx.

      {
        double sum = 0;
        double squaredSum = 0;
        std::size_t n = 0;
        for (const PufitGrid::Tower &tower : grid)
        {
          if (tower.masked())
            continue;
          ++n;
          sum += tower.sumEt();
          squaredSum += tower.sumEt() * tower.sumEt();
        }
        mean = sum / n;
        // Note that this could result in catastrophic cancellation in some cases.
        // However the amount of precision present in a double is around 10^15 so we
        // can afford to lose some significant figures
        variance = squaredSum / n - mean * mean;
      }

unmaskedMeanAndVariance() [2/2]

template<std::size_t N>

void HLT::MET::PufitUtils::unmaskedMeanAndVariance	(	const PufitMultiGrid< N > &	grid,
		int	type,
		double &	mean,
		double &	variance )

Calculate the mean and variance of unmasked towers.

Parameters

	grid	The grid to calculate
	type	The int mask of subgrid types
[out]	mean	The calculated mean
[out]	variance	The calculated variance