l1t::L1GT3BodyCut Class Reference

#include <L1GT3BodyCut.h>

Public Member Functions
bool	checkObjects (const P2GTCandidate &obj1, const P2GTCandidate &obj2, const P2GTCandidate &obj3, InvariantMassErrorCollection &massErrors) const
	L1GT3BodyCut (const edm::ParameterSet &config, const edm::ParameterSet &lutConfig, const L1GTScales &scales, bool inv_mass_checks=false)

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &desc)

Private Member Functions
int64_t	calc2BodyInvMass (const P2GTCandidate &obj1, const P2GTCandidate &obj2, InvariantMassErrorCollection &massErrors) const
int64_t	calc2BodyTransMass (const P2GTCandidate &obj1, const P2GTCandidate &obj2) const

Private Attributes
const L1GTSingleInOutLUT	coshEtaLUT2_
const L1GTSingleInOutLUT	coshEtaLUT_
const L1GTSingleInOutLUT	cosPhiLUT_
const bool	inv_mass_checks_
const int	invMassResolutionReduceShift_
const std::optional< int64_t >	maxInvMassSqrDiv2_
const std::optional< int64_t >	maxTransMassSqrDiv2_
const std::optional< int64_t >	minInvMassSqrDiv2_
const std::optional< int64_t >	minTransMassSqrDiv2_
const int	scaleNormalShift_
const L1GTScales &	scales_
const int	transMassResolutionReduceShift_

Static Private Attributes
static constexpr int	HW_PI = 1 << (P2GTCandidate::hwPhi_t::width - 1)

Detailed Description

Definition at line 20 of file L1GT3BodyCut.h.

Constructor & Destructor Documentation

L1GT3BodyCut()

l1t::L1GT3BodyCut::L1GT3BodyCut ( const edm::ParameterSet &  config, const edm::ParameterSet &  lutConfig, const L1GTScales &  scales, bool  inv_mass_checks = false  )

inline

Definition at line 22 of file L1GT3BodyCut.h.

References cosPhiLUT_, l1t::L1GTSingleInOutLUT::output_scale(), and l1tGTDoubleObjectCond_cfi::scales.

        : scales_(scales),
          coshEtaLUT_(lutConfig.getParameterSet("cosh_eta_lut")),
          coshEtaLUT2_(lutConfig.getParameterSet("cosh_eta_lut2")),
          cosPhiLUT_(lutConfig.getParameterSet("cos_phi_lut")),
          minInvMassSqrDiv2_(getOptionalParam<int64_t, double>("minInvMass",
                                                               config,
                                                               [&](double value) {
                                                                 return std::round(scales.to_hw_InvMassSqrDiv2(value) *
                                                                                   cosPhiLUT_.output_scale());
                                                               })),
          maxInvMassSqrDiv2_(getOptionalParam<int64_t, double>("maxInvMass",
                                                               config,
                                                               [&](double value) {
                                                                 return std::round(scales.to_hw_InvMassSqrDiv2(value) *
                                                                                   cosPhiLUT_.output_scale());
                                                               })),
          minTransMassSqrDiv2_(getOptionalParam<int64_t, double>(
              "minTransMass",
              config,
              [&](double value) {
                return std::round(scales.to_hw_TransMassSqrDiv2(value) * cosPhiLUT_.output_scale());
              })),
          maxTransMassSqrDiv2_(getOptionalParam<int64_t, double>(
              "maxTransMass",
              config,
              [&](double value) {
                return std::round(scales.to_hw_TransMassSqrDiv2(value) * cosPhiLUT_.output_scale());
              })),
          scaleNormalShift_(std::round(std::log2(std::ceil(coshEtaLUT_.output_scale() / coshEtaLUT2_.output_scale())))),
          invMassResolutionReduceShift_([&]() {
            if (minInvMassSqrDiv2_) {
              return std::max<int>(
                  std::ceil(std::log2(minInvMassSqrDiv2_.value() * cosPhiLUT_.output_scale() + 1.0)) - 16, 0);
            } else if (maxInvMassSqrDiv2_) {
              return std::max<int>(std::ceil(std::log2(maxInvMassSqrDiv2_.value() * cosPhiLUT_.output_scale())) - 16,
                                   0);
            } else {
              return 0;
            }
          }()),
          transMassResolutionReduceShift_([&]() {
            if (minTransMassSqrDiv2_) {
              return std::max<int>(
                  std::ceil(std::log2(minTransMassSqrDiv2_.value() * cosPhiLUT_.output_scale() + 1.0)) - 16, 0);
            } else if (maxTransMassSqrDiv2_) {
              return std::max<int>(std::ceil(std::log2(maxTransMassSqrDiv2_.value() * cosPhiLUT_.output_scale())) - 16,
                                   0);
            } else {
              return 0;
            }
          }()),
          inv_mass_checks_(inv_mass_checks) {}

Member Function Documentation

calc2BodyInvMass()

int64_t l1t::L1GT3BodyCut::calc2BodyInvMass ( const P2GTCandidate &  obj1, const P2GTCandidate &  obj2, InvariantMassErrorCollection &  massErrors  ) const

inlineprivate

Definition at line 118 of file L1GT3BodyCut.h.

References funct::abs(), funct::cos(), coshEtaLUT2_, coshEtaLUT_, cosPhiLUT_, HLT_2024v14_cff::dEta, l1t::L1GTSingleInOutLUT::DETA_LUT_SPLIT, relativeConstraints::error, l1t::L1GTScales::eta_lsb(), HW_PI, l1t::P2GTCandidate::hwEta(), l1t::P2GTCandidate::hwPhi(), l1t::P2GTCandidate::hwPT(), inv_mass_checks_, l1t::L1GTSingleInOutLUT::output_scale(), l1t::L1GTScales::phi_lsb(), l1t::L1GTScales::pT_lsb(), scaleNormalShift_, scales_, and mathSSE::sqrt().

Referenced by checkObjects().

                                                                             {
      uint32_t dEta = (obj1.hwEta() > obj2.hwEta()) ? obj1.hwEta().to_int() - obj2.hwEta().to_int()
                                                    : obj2.hwEta().to_int() - obj1.hwEta().to_int();
      int32_t lutCoshDEta = dEta < L1GTSingleInOutLUT::DETA_LUT_SPLIT
                                ? coshEtaLUT_[dEta]
                                : coshEtaLUT2_[dEta - L1GTSingleInOutLUT::DETA_LUT_SPLIT];

      // Ensure dPhi is always the smaller angle, i.e. always between [0, pi]
      uint32_t dPhi = HW_PI - abs(abs(obj1.hwPhi().to_int() - obj2.hwPhi().to_int()) - HW_PI);

      // Optimization: (cos(x + pi) = -cos(x), x in [0, pi))
      int32_t lutCosDPhi = dPhi >= HW_PI ? -cosPhiLUT_[dPhi] : cosPhiLUT_[dPhi];

      int64_t invMassSqrDiv2;

      if (dEta < L1GTSingleInOutLUT::DETA_LUT_SPLIT) {
        // dEta [0, 2pi)
        invMassSqrDiv2 = obj1.hwPT().to_int64() * obj2.hwPT().to_int64() * (lutCoshDEta - lutCosDPhi);
      } else {
        // dEta [2pi, 4pi), ignore cos
        invMassSqrDiv2 = obj1.hwPT().to_int64() * obj2.hwPT().to_int64() * lutCoshDEta;
      }

      if (inv_mass_checks_) {
        double precInvMass =
            scales_.pT_lsb() * std::sqrt(2 * obj1.hwPT().to_double() * obj2.hwPT().to_double() *
                                         (std::cosh(dEta * scales_.eta_lsb()) - std::cos(dPhi * scales_.phi_lsb())));

        double lutInvMass =
            scales_.pT_lsb() * std::sqrt(2 * static_cast<double>(invMassSqrDiv2) /
                                         (dEta < L1GTSingleInOutLUT::DETA_LUT_SPLIT ? coshEtaLUT_.output_scale()
                                                                                    : coshEtaLUT2_.output_scale()));

        double error = std::abs(precInvMass - lutInvMass);
        massErrors.emplace_back(InvariantMassError{error, error / precInvMass, precInvMass});
      }

      // Normalize scales required due to LUT split in dEta with different scale factors.
      return dEta < L1GTSingleInOutLUT::DETA_LUT_SPLIT ? invMassSqrDiv2 : invMassSqrDiv2 << scaleNormalShift_;
    }

calc2BodyTransMass()

int64_t l1t::L1GT3BodyCut::calc2BodyTransMass ( const P2GTCandidate &  obj1, const P2GTCandidate &  obj2  ) const

inlineprivate

Definition at line 161 of file L1GT3BodyCut.h.

References funct::abs(), cosPhiLUT_, HW_PI, l1t::P2GTCandidate::hwPhi(), l1t::P2GTCandidate::hwPT(), and l1t::L1GTSingleInOutLUT::output_scale().

Referenced by checkObjects().

                                                                                           {
      // Ensure dPhi is always the smaller angle, i.e. always between [0, pi]
      uint32_t dPhi = HW_PI - abs(abs(obj1.hwPhi().to_int() - obj2.hwPhi().to_int()) - HW_PI);

      // Optimization: (cos(x + pi) = -cos(x), x in [0, pi))
      int32_t lutCosDPhi = dPhi >= HW_PI ? -cosPhiLUT_[dPhi] : cosPhiLUT_[dPhi];

      return obj1.hwPT().to_int64() * obj2.hwPT().to_int64() *
             (static_cast<int64_t>(std::round(cosPhiLUT_.output_scale())) - lutCosDPhi);
    }

checkObjects()

bool l1t::L1GT3BodyCut::checkObjects ( const P2GTCandidate &  obj1, const P2GTCandidate &  obj2, const P2GTCandidate &  obj3, InvariantMassErrorCollection &  massErrors  ) const

inline

Definition at line 79 of file L1GT3BodyCut.h.

References calc2BodyInvMass(), calc2BodyTransMass(), invMassResolutionReduceShift_, maxInvMassSqrDiv2_, maxTransMassSqrDiv2_, minInvMassSqrDiv2_, minTransMassSqrDiv2_, and transMassResolutionReduceShift_.

Referenced by L1GTTripleObjectCond::filter(), and L1GTQuadObjectCond::filter().

                                                                      {
      bool res = true;

      if (minInvMassSqrDiv2_ || maxInvMassSqrDiv2_) {
        int64_t invMassSqrDiv2 = (calc2BodyInvMass(obj1, obj2, massErrors) >> invMassResolutionReduceShift_) +
                                 (calc2BodyInvMass(obj1, obj3, massErrors) >> invMassResolutionReduceShift_) +
                                 (calc2BodyInvMass(obj2, obj3, massErrors) >> invMassResolutionReduceShift_);

        res &= minInvMassSqrDiv2_ ? invMassSqrDiv2 > minInvMassSqrDiv2_.value() >> invMassResolutionReduceShift_ : true;
        res &= maxInvMassSqrDiv2_ ? invMassSqrDiv2 < maxInvMassSqrDiv2_.value() >> invMassResolutionReduceShift_ : true;
      }

      if (minTransMassSqrDiv2_ || maxTransMassSqrDiv2_) {
        int64_t transMassDiv2 = (calc2BodyTransMass(obj1, obj2) >> transMassResolutionReduceShift_) +
                                (calc2BodyTransMass(obj1, obj3) >> transMassResolutionReduceShift_) +
                                (calc2BodyTransMass(obj2, obj3) >> transMassResolutionReduceShift_);

        res &= minTransMassSqrDiv2_ ? transMassDiv2 > minTransMassSqrDiv2_.value() >> transMassResolutionReduceShift_
                                    : true;
        res &= maxTransMassSqrDiv2_ ? transMassDiv2 < maxTransMassSqrDiv2_.value() >> transMassResolutionReduceShift_
                                    : true;
      }

      return res;
    }

fillPSetDescription()

static void l1t::L1GT3BodyCut::fillPSetDescription ( edm::ParameterSetDescription &  desc )

inlinestatic

Definition at line 108 of file L1GT3BodyCut.h.

References submitPVResolutionJobs::desc.

                                                                      {
      desc.addOptional<double>("minInvMass");
      desc.addOptional<double>("maxInvMass");
      desc.addOptional<double>("minTransMass");
      desc.addOptional<double>("maxTransMass");
    }

Member Data Documentation

coshEtaLUT2_

const L1GTSingleInOutLUT l1t::L1GT3BodyCut::coshEtaLUT2_

private

Definition at line 175 of file L1GT3BodyCut.h.

Referenced by calc2BodyInvMass().

coshEtaLUT_

const L1GTSingleInOutLUT l1t::L1GT3BodyCut::coshEtaLUT_

private

Definition at line 174 of file L1GT3BodyCut.h.

Referenced by calc2BodyInvMass().

cosPhiLUT_

const L1GTSingleInOutLUT l1t::L1GT3BodyCut::cosPhiLUT_

private

Definition at line 176 of file L1GT3BodyCut.h.

Referenced by calc2BodyInvMass(), calc2BodyTransMass(), and L1GT3BodyCut().

HW_PI

constexpr int l1t::L1GT3BodyCut::HW_PI = 1 << (P2GTCandidate::hwPhi_t::width - 1)

staticprivate

Definition at line 116 of file L1GT3BodyCut.h.

Referenced by calc2BodyInvMass(), and calc2BodyTransMass().

inv_mass_checks_

const bool l1t::L1GT3BodyCut::inv_mass_checks_

private

Definition at line 187 of file L1GT3BodyCut.h.

Referenced by calc2BodyInvMass().

invMassResolutionReduceShift_

const int l1t::L1GT3BodyCut::invMassResolutionReduceShift_

private

Definition at line 184 of file L1GT3BodyCut.h.

Referenced by checkObjects().

maxInvMassSqrDiv2_

const std::optional<int64_t> l1t::L1GT3BodyCut::maxInvMassSqrDiv2_

private

Definition at line 179 of file L1GT3BodyCut.h.

Referenced by checkObjects().

maxTransMassSqrDiv2_

const std::optional<int64_t> l1t::L1GT3BodyCut::maxTransMassSqrDiv2_

private

Definition at line 181 of file L1GT3BodyCut.h.

Referenced by checkObjects().

minInvMassSqrDiv2_

const std::optional<int64_t> l1t::L1GT3BodyCut::minInvMassSqrDiv2_

private

Definition at line 178 of file L1GT3BodyCut.h.

Referenced by checkObjects().

minTransMassSqrDiv2_

const std::optional<int64_t> l1t::L1GT3BodyCut::minTransMassSqrDiv2_

private

Definition at line 180 of file L1GT3BodyCut.h.

Referenced by checkObjects().

scaleNormalShift_

const int l1t::L1GT3BodyCut::scaleNormalShift_

private

Definition at line 183 of file L1GT3BodyCut.h.

Referenced by calc2BodyInvMass().

scales_

const L1GTScales& l1t::L1GT3BodyCut::scales_

private

Definition at line 172 of file L1GT3BodyCut.h.

Referenced by calc2BodyInvMass().

transMassResolutionReduceShift_

const int l1t::L1GT3BodyCut::transMassResolutionReduceShift_

private

Definition at line 185 of file L1GT3BodyCut.h.

Referenced by checkObjects().