l1HPSPFTauEmu Namespace Reference

Classes
class	Particle
class	Tau

Typedefs
typedef ap_uint< 5 >	count_t
typedef ap_uint< 20 >	detaphi2_t
typedef ap_int< 13 >	detaphi_t
typedef l1ct::z0_t	dz_t
typedef l1ct::glbeta_t	etaphi_t
typedef l1ct::pt_t	pt_t
typedef ap_uint< 3 >	type_t

Functions
std::vector< Tau >	emulateEvent (std::vector< Particle > &parts, std::vector< Particle > &jets, bool jEnable)
template<int W, int I, ap_q_mode _AP_Q, ap_o_mode _AP_O>
ap_ufixed< W, I >	fp_abs (ap_fixed< W, I, _AP_Q, _AP_O > x)
bool	inIsolationCone (Particle part, Particle seed)
bool	inSignalCone (Particle part, Particle seed, const int track_count, ap_uint< 20 > cone2, pt_t &iso_pt, bool &isLead)
template<int W>
ap_uint< W >	int_abs (ap_int< W > x)
template<class inP >
bool	is_charged (inP part)
Tau	makeHPSTauHW (const std::vector< Particle > &parts, const Particle seed, const pt_t total_pt)
ap_uint< 20 >	setSConeSize2 (pt_t tpt)

Variables
const detaphi_t	delta_Rclean = 0.4 * etaphi_base
constexpr float	dz_base = 0.05
const dz_t	dzCut = 0.4 / dz_base
const etaphi_t	etaCutoff = 2.4 * etaphi_base
constexpr float	etaphi_base = 720. / M_PI
const detaphi_t	isoConeSize = 0.4 * etaphi_base
const pt_t	min_leadChargedPfCand_pt = l1ct::Scales::makePtFromFloat(1.)
const detaphi_t	strip_eta = 0.05 * etaphi_base
const detaphi_t	strip_phi = 0.20 * etaphi_base

Typedef Documentation

count_t

typedef ap_uint<5> l1HPSPFTauEmu::count_t

Definition at line 25 of file L1HPSPFTauEmulator.h.

detaphi2_t

typedef ap_uint<20> l1HPSPFTauEmu::detaphi2_t

Definition at line 24 of file L1HPSPFTauEmulator.h.

detaphi_t

typedef ap_int<13> l1HPSPFTauEmu::detaphi_t

Definition at line 22 of file L1HPSPFTauEmulator.h.

dz_t

typedef l1ct::z0_t l1HPSPFTauEmu::dz_t

Definition at line 27 of file L1HPSPFTauEmulator.h.

etaphi_t

typedef l1ct::glbeta_t l1HPSPFTauEmu::etaphi_t

Definition at line 20 of file L1HPSPFTauEmulator.h.

pt_t

typedef l1ct::pt_t l1HPSPFTauEmu::pt_t

Definition at line 19 of file L1HPSPFTauEmulator.h.

type_t

typedef ap_uint<3> l1HPSPFTauEmu::type_t

Definition at line 26 of file L1HPSPFTauEmulator.h.

Function Documentation

emulateEvent()

std::vector<Tau> l1HPSPFTauEmu::emulateEvent ( std::vector< Particle > &  parts, std::vector< Particle > &  jets, bool  jEnable  )

inline

Definition at line 270 of file L1HPSPFTauEmulator.h.

References clean(), delta_Rclean, EgHLTOffHistBins_cfi::deltaE, etaCutoff, l1ct::PuppiObj::hwEta, l1ct::PuppiObj::hwPt, l1trig_cff::hwPt, mps_fire::i, inIsolationCone(), int_abs(), is_charged(), dqmiolumiharvest::j, metsig::jet, PDWG_EXODelayedJetMET_cff::jets, makeHPSTauHW(), l1ct::Scales::makePtFromFloat(), makeMuonMisalignmentScenario::matrix, fileCollector::seed, HLT_2024v10_cff::seeds, jetUpdater_cfi::sort, Tau3MuMonitor_cff::taus, l1HPSPFTauEmu::Particle::tempZ0, and HcalDetIdTransform::transform().

Referenced by L1HPSPFTauProducer::processEvent_HW().

                                                                                                          {
    using namespace l1HPSPFTauEmu;

    std::vector<Particle> parts_copy;
    parts_copy.resize(parts.size());
    std::transform(parts.begin(), parts.end(), parts_copy.begin(), [](const Particle& part) { return part; });
    //sorting by pt
    std::sort(
        parts_copy.begin(), parts_copy.end(), [](const Particle& i, const Particle& j) { return (i.hwPt > j.hwPt); });

    //sorting jets by pt
    std::vector<Particle> jets_copy;
    jets_copy.resize(jets.size());
    std::transform(jets.begin(), jets.end(), jets_copy.begin(), [](const Particle& jet) { return jet; });
    std::sort(
        jets_copy.begin(), jets_copy.end(), [](const Particle& i, const Particle& j) { return (i.hwPt > j.hwPt); });

    std::vector<Tau> taus;
    std::vector<Tau> cleaned_taus;
    taus.reserve(20);
    std::vector<Particle> preseed;
    preseed.reserve(144);

    //jet seeds reserve
    //4 for now
    int jets_index = 0;
    int jets_max = jets_copy.size();

    std::vector<Particle> jseeds;
    jseeds.reserve(4);

    int parts_index = 0;
    int parts_max = parts_copy.size();
    //first find the seeds
    while (preseed.size() < 128 && parts_index != parts_max) {
      Particle pSeed = parts_copy.at(parts_index);

      if (pSeed.hwPt > l1ct::Scales::makePtFromFloat(5.) && is_charged(pSeed) && int_abs(pSeed.hwEta) < etaCutoff) {
        preseed.push_back(pSeed);
      }

      parts_index++;
    }

    std::vector<Particle> seeds;
    seeds.reserve(16);  //up to 16 track + 4 jet seeds right now
    std::vector<int>::size_type pseed_index = 0;
    while (seeds.size() < 16 && pseed_index < preseed.size()) {
      seeds.push_back(preseed.at(pseed_index));
      pseed_index++;
    }

    //With jets
    if (jEnable) {
      while (jseeds.size() < 4 && jets_index != jets_max) {
        Particle jSeed = jets_copy.at(jets_index);

        if (jSeed.hwPt > l1ct::Scales::makePtFromFloat(20.) && int_abs(jSeed.hwEta) < etaCutoff) {
          jseeds.push_back(jSeed);
        }
        jets_index++;
      }
    }
    for (std::vector<int>::size_type i = 0; i != seeds.size(); i++) {
      Particle seed = seeds[i];

      std::vector<Particle> iso_parts;

      iso_parts.reserve(30);
      pt_t total_pt = 0;
      std::vector<int>::size_type iso_index = 0;
      while (iso_index < parts_copy.size() && iso_parts.size() < 30) {
        Particle isoCand = parts_copy.at(iso_index);
        if (inIsolationCone(isoCand, seed)) {
          iso_parts.push_back(isoCand);
          total_pt += isoCand.hwPt;
        }
        iso_index++;
      }

      taus.push_back(makeHPSTauHW(iso_parts, seed, total_pt));
    }

    //add in the jet taus
    if (jEnable) {
      for (std::vector<int>::size_type i = 0; i != jseeds.size(); i++) {
        Particle jseed = jseeds[i];
        std::vector<Particle> iso_parts;
        iso_parts.reserve(30);
        pt_t total_pt = 0;
        std::vector<int>::size_type iso_index = 0;

        pt_t max_pt_j = 0;
        while (iso_index < parts_copy.size()) {
          Particle isoCand = parts_copy.at(iso_index);

          if (inIsolationCone(isoCand, jseed)) {
            if (is_charged(isoCand) && isoCand.hwPt > max_pt_j) {
              if (isoCand.tempZ0) {
                jseed.tempZ0 = isoCand.tempZ0;
              }
              max_pt_j = isoCand.hwPt;
            }

            if (iso_parts.size() < 30) {
              iso_parts.push_back(isoCand);
              total_pt += isoCand.hwPt;
            }
          }
          iso_index++;
        }
        taus.push_back(makeHPSTauHW(iso_parts, jseed, total_pt));
      }
    }

    std::sort(taus.begin(), taus.end(), [](const Tau& i, const Tau& j) { return (i.hwPt > j.hwPt); });

    int taus_max = taus.size();

    bool matrix[380];

    for (int i = 0; i < (taus_max - 1); i++) {
      for (int j = i + 1; j < taus_max; j++) {
        etaphi_t deltaE = taus[i].hwEta - taus[j].hwEta;
        etaphi_t deltaP = taus[i].hwPhi - taus[j].hwPhi;
        if ((deltaE * deltaE + deltaP * deltaP) < (delta_Rclean * delta_Rclean)) {
          matrix[i * 19 + j] = true;
        } else {
          matrix[i * 19 + j] = false;
        }
      }
    }

    if (!taus.empty()) {
      if (taus[0].hwPt > 0) {
        cleaned_taus.push_back(taus.at(0));
      }

      bool clean[20];

      for (int i = 0; i < 20; i++) {
        clean[i] = false;
      }
      for (int i = 1; i < taus_max; i++) {
        for (int j = i - 1; j >= 0; j--) {
          clean[i] |= (matrix[j * 19 + i] && !clean[j]);
        }
        if (!clean[i] && taus[i].hwPt > 0) {
          cleaned_taus.push_back(taus.at(i));
        }
      }
    }

    return cleaned_taus;
  }

fp_abs()

template<int W, int I, ap_q_mode _AP_Q, ap_o_mode _AP_O>

ap_ufixed<W, I> l1HPSPFTauEmu::fp_abs

(

ap_fixed< W, I, _AP_Q, _AP_O >

x

)

Definition at line 55 of file L1HPSPFTauEmulator.h.

References mps_fire::result, and x.

                                                         {
    ap_ufixed<W, I> result;
    if (x < 0) {
      result = -x;
    } else {
      result = x;
    }
    return result;
  }

inIsolationCone()

bool l1HPSPFTauEmu::inIsolationCone ( Particle  part, Particle  seed  )

inline

Definition at line 120 of file L1HPSPFTauEmulator.h.

References spr::deltaEta, SiPixelRawToDigiRegional_cfi::deltaPhi, L1TauEmu::inCone(), isoConeSize, and fileCollector::seed.

Referenced by emulateEvent().

                                                            {
    bool inCone = false;
    detaphi2_t isoConeSize2 = isoConeSize * isoConeSize;

    if (part.hwPt != 0) {
      detaphi_t deltaEta = part.hwEta - seed.hwEta;
      detaphi_t deltaPhi = part.hwPhi - seed.hwPhi;
      if ((deltaEta * deltaEta + deltaPhi * deltaPhi) < isoConeSize2) {
        inCone = true;
      } else {
        inCone = false;
      }
    } else {
      inCone = false;
    }
    return inCone;
  }

inSignalCone()

bool l1HPSPFTauEmu::inSignalCone ( Particle  part, Particle  seed, const int  track_count, ap_uint< 20 >  cone2, pt_t &  iso_pt, bool &  isLead  )

inline

Definition at line 138 of file L1HPSPFTauEmulator.h.

References spr::deltaEta, SiPixelRawToDigiRegional_cfi::deltaPhi, l1tTrackerHTMiss_cfi::deltaZ, dzCut, etaCutoff, L1TauEmu::inCone(), int_abs(), is_charged(), min_leadChargedPfCand_pt, fileCollector::seed, strip_eta, and strip_phi.

Referenced by makeHPSTauHW().

                                                                                                          {
    //finds the signal cone candidates (including strip pt check

    bool isPotentialLead = false;

    isPotentialLead =
        is_charged(part) && part.pID != 4 && part.hwPt > min_leadChargedPfCand_pt && int_abs(part.hwEta) < etaCutoff;

    //calculate the deta and dphi
    bool inCone = false;

    if (part.hwPt != 0) {
      detaphi_t deltaEta = part.hwEta - seed.hwEta;
      detaphi_t deltaPhi = part.hwPhi - seed.hwPhi;
      detaphi2_t deltaEta2 = deltaEta * deltaEta;
      detaphi2_t deltaPhi2 = deltaPhi * deltaPhi;
      dz_t deltaZ = 0;
      if (part.tempZ0 && seed.tempZ0) {
        deltaZ = part.tempZ0 - seed.tempZ0;
      }

      if ((int_abs(deltaEta) < strip_eta) && (int_abs(deltaPhi) < strip_phi) && (part.pID == 3 || (part.pID == 1))) {
        if (isPotentialLead) {
          isLead = true;
        }
        inCone = true;

      } else if (((deltaEta2 + deltaPhi2) < cone2) && !((part.pID == 0) && (track_count > 3)) &&
                 !(is_charged(part) && int_abs(deltaZ) > dzCut)) {
        if (isPotentialLead) {
          isLead = true;
        }
        inCone = true;
      } else {
        if (is_charged(part) && int_abs(deltaZ) > dzCut) {
          iso_pt += part.hwPt;
          inCone = false;
        }
      }
    }
    return inCone;
  }

int_abs()

template<int W>

ap_uint<W> l1HPSPFTauEmu::int_abs ( ap_int< W >  x )

inline

Definition at line 66 of file L1HPSPFTauEmulator.h.

References mps_fire::result, and x.

Referenced by emulateEvent(), inSignalCone(), and makeHPSTauHW().

                                         {
    ap_uint<W> result;
    if (x < 0) {
      result = -x;
    } else {
      result = x;
    }
    return result;
  }

is_charged()

template<class inP >

bool l1HPSPFTauEmu::is_charged ( inP  part )

inline

Definition at line 77 of file L1HPSPFTauEmulator.h.

References ALCARECOTkAlJpsiMuMu_cff::charge.

Referenced by emulateEvent(), inSignalCone(), and makeHPSTauHW().

                                   {
    bool charge = false;
    if ((part.pID == 0) || (part.pID == 1) || (part.pID == 4)) {
      charge = true;
    } else {
      charge = false;
    }
    return charge;
  }

makeHPSTauHW()

Tau l1HPSPFTauEmu::makeHPSTauHW ( const std::vector< Particle > &  parts, const Particle  seed, const pt_t  total_pt  )

inline

Definition at line 182 of file L1HPSPFTauEmulator.h.

References etaCutoff, l1ct::PuppiObj::hwEta, l1ct::PuppiObj::hwPhi, l1ct::PuppiObj::hwPt, l1trig_cff::hwPt, mps_fire::i, inSignalCone(), int_abs(), is_charged(), reco::tau::leadCand(), l1ct::Scales::makePtFromFloat(), l1HPSPFTauEmu::Particle::pID, fileCollector::seed, setSConeSize2(), metsig::tau, runTauDisplay::tau_eta, runTauDisplay::tau_phi, and runTauDisplay::tau_pt.

Referenced by emulateEvent().

                                                 {
    using namespace l1HPSPFTauEmu;

    ap_uint<20> scone2 = setSConeSize2(total_pt);

    pt_t isocone_pt = 0;

    pt_t sum_pt = 0;

    ap_fixed<22, 20> sum_eta = 0;
    ap_fixed<22, 20> sum_phi = 0;

    pt_t tau_pt = 0;
    etaphi_t tau_eta = 0;
    etaphi_t tau_phi = 0;

    pt_t chargedIsoPileup = 0;
    std::vector<Particle> signalParts;
    std::vector<Particle> outsideParts;

    int trct = 0;
    bool leadCand = false;
    bool leadSet = false;
    Particle lead;
    for (std::vector<int>::size_type i = 0; i != parts.size(); i++) {
      bool isSignal = inSignalCone(parts.at(i), seed, trct, scone2, isocone_pt, leadCand);
      if (isSignal) {
        signalParts.push_back(parts.at(i));
        if (parts[i].pID == 0) {
          trct++;
        }
        if (leadCand) {
          if (leadSet == false) {
            lead = parts[i];
            leadCand = false;
            leadSet = true;
          } else {
            if (parts[i].hwPt > lead.hwPt) {
              lead = parts[i];
              leadCand = false;
            } else {
              leadCand = false;
            }
          }
        }
      } else {
        outsideParts.push_back(parts.at(i));
      }
    }

    for (std::vector<int>::size_type i = 0; i != signalParts.size(); i++) {
      Particle sigP = signalParts.at(i);
      if (is_charged(sigP) || (sigP.pID == 3)) {
        sum_pt += sigP.hwPt;
        sum_eta += sigP.hwPt * sigP.hwEta;
        sum_phi += sigP.hwPt * sigP.hwPhi;
      }
    }

    pt_t div_pt = 1;
    if (sum_pt == 0) {
      div_pt = 1;
    } else {
      div_pt = sum_pt;
    }

    tau_pt = sum_pt;
    tau_eta = sum_eta / div_pt;
    tau_phi = sum_phi / div_pt;

    if (tau_pt > l1ct::Scales::makePtFromFloat(20.) && int_abs(tau_eta) < etaCutoff && leadSet == true &&
        isocone_pt < tau_pt) {
      Tau tau;
      tau.hwPt = tau_pt;
      tau.hwEta = tau_eta;
      tau.hwPhi = tau_phi;
      return tau;
    } else {
      Tau tau;
      tau.hwPt = 0.;
      tau.hwEta = 0.;
      tau.hwPhi = 0.;
      return tau;
    }
  }

setSConeSize2()

ap_uint<20> l1HPSPFTauEmu::setSConeSize2 ( pt_t  tpt )

inline

Definition at line 87 of file L1HPSPFTauEmulator.h.

Referenced by makeHPSTauHW().

                                             {
    ap_ufixed<16, 14> total_pt = tpt * 4;
    ap_uint<20> SignalConeSizeSquare;
    if (total_pt < 115) {
      SignalConeSizeSquare = 23 * 23;
    } else if (total_pt < 120) {
      SignalConeSizeSquare = 22 * 22;
    } else if (total_pt < 126) {
      SignalConeSizeSquare = 21 * 21;
    } else if (total_pt < 132) {
      SignalConeSizeSquare = 20 * 20;
    } else if (total_pt < 139) {
      SignalConeSizeSquare = 19 * 19;
    } else if (total_pt < 147) {
      SignalConeSizeSquare = 18 * 18;
    } else if (total_pt < 156) {
      SignalConeSizeSquare = 17 * 17;
    } else if (total_pt < 166) {
      SignalConeSizeSquare = 16 * 16;
    } else if (total_pt < 178) {
      SignalConeSizeSquare = 15 * 15;
    } else if (total_pt < 191) {
      SignalConeSizeSquare = 14 * 14;
    } else if (total_pt < 206) {
      SignalConeSizeSquare = 13 * 13;
    } else if (total_pt < 224) {
      SignalConeSizeSquare = 12 * 12;
    } else {
      SignalConeSizeSquare = 12 * 12;
    }
    return SignalConeSizeSquare;
  }

Variable Documentation

delta_Rclean

const detaphi_t l1HPSPFTauEmu::delta_Rclean = 0.4 * etaphi_base

Definition at line 50 of file L1HPSPFTauEmulator.h.

Referenced by emulateEvent().

dz_base

constexpr float l1HPSPFTauEmu::dz_base = 0.05

Definition at line 18 of file L1HPSPFTauEmulator.h.

Referenced by L1HPSPFTauProducer::convertEDMToHW().

dzCut

const dz_t l1HPSPFTauEmu::dzCut = 0.4 / dz_base

Definition at line 51 of file L1HPSPFTauEmulator.h.

Referenced by inSignalCone().

etaCutoff

const etaphi_t l1HPSPFTauEmu::etaCutoff = 2.4 * etaphi_base

Definition at line 52 of file L1HPSPFTauEmulator.h.

Referenced by emulateEvent(), inSignalCone(), and makeHPSTauHW().

etaphi_base

constexpr float l1HPSPFTauEmu::etaphi_base = 720. / M_PI

Definition at line 17 of file L1HPSPFTauEmulator.h.

Referenced by L1HPSPFTauProducer::convertEDMToHW(), L1HPSPFTauProducer::convertHWToEDM(), L1HPSPFTauProducer::convertJetsToHW(), and L1NNTauProducer::process_HW().

isoConeSize

const detaphi_t l1HPSPFTauEmu::isoConeSize = 0.4 * etaphi_base

Definition at line 49 of file L1HPSPFTauEmulator.h.

Referenced by inIsolationCone().

min_leadChargedPfCand_pt

const pt_t l1HPSPFTauEmu::min_leadChargedPfCand_pt = l1ct::Scales::makePtFromFloat(1.)

Definition at line 48 of file L1HPSPFTauEmulator.h.

Referenced by inSignalCone().

strip_eta

const detaphi_t l1HPSPFTauEmu::strip_eta = 0.05 * etaphi_base

Definition at line 46 of file L1HPSPFTauEmulator.h.

Referenced by inSignalCone().

strip_phi

const detaphi_t l1HPSPFTauEmu::strip_phi = 0.20 * etaphi_base

Definition at line 45 of file L1HPSPFTauEmulator.h.

Referenced by CSCSectorReceiverLUT::calcGlobalPhiME(), and inSignalCone().