Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-05-15 22:44:09 

0001 // Original Author:   George Karathanasis,
0002 //                    georgios.karathanasis@cern.ch, CU Boulder
0003 //
0004 //         Created:  Tue, 05 Dec 2023 14:01:41 GMT
0005 //
0006 // Three track candidates (triplets) producer with arbitary track mass. Aimed to
0007 // run in the GTT stage. Triplets are created using the 3 most energetic tracks.
0008 // Selection cuts are applied both on each track individually and in the final
0009 // triplet. Initially created for W->3pi search.
0010 // Link https://indico.cern.ch/event/1356822/contributions/5712593/attachments/2773493/4833005/L1T_w3pi_emulator.pdf
0011 
0012 // L1T include files
0013 #include "DataFormats/L1TCorrelator/interface/TkTriplet.h"
0014 #include "DataFormats/L1TCorrelator/interface/TkTripletFwd.h"
0015 #include "DataFormats/L1Trigger/interface/TkTripletWord.h"
0016 #include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
0017 #include "DataFormats/L1TrackTrigger/interface/TTTrack.h"
0018 #include "DataFormats/L1TrackTrigger/interface/TTTrack_TrackWord.h"
0019 #include "DataFormats/L1Trigger/interface/VertexWord.h"
0020 #include "DataFormats/Math/interface/LorentzVector.h"
0021 
0022 // system include files
0023 #include "DataFormats/Common/interface/Handle.h"
0024 #include "FWCore/Framework/interface/Frameworkfwd.h"
0025 #include "FWCore/Framework/interface/stream/EDProducer.h"
0026 #include "FWCore/Framework/interface/Event.h"
0027 #include "FWCore/Framework/interface/EventSetup.h"
0028 #include "FWCore/Framework/interface/MakerMacros.h"
0029 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0030 #include "FWCore/Utilities/interface/StreamID.h"
0031 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
0032 #include "DataFormats/Common/interface/Ref.h"
0033 #include "DataFormats/Common/interface/RefVector.h"
0034 
0035 //own headers
0036 #include "L1TrackUnpacker.h"
0037 
0038 //general
0039 #include <ap_int.h>
0040 
0041 using namespace std;
0042 using namespace edm;
0043 using namespace l1t;
0044 using namespace l1trackunpacker;
0045 
0046 class L1TrackTripletEmulatorProducer : public stream::EDProducer<> {
0047 public:
0048   explicit L1TrackTripletEmulatorProducer(const ParameterSet &);
0049   ~L1TrackTripletEmulatorProducer() override = default;
0050   typedef TTTrack<Ref_Phase2TrackerDigi_> L1TTTrackType;
0051   typedef vector<L1TTTrackType> L1TTTrackCollectionType;
0052   typedef edm::RefVector<L1TTTrackCollectionType> L1TTTrackRefCollectionType;
0053   static void fillDescriptions(ConfigurationDescriptions &descriptions);
0054 
0055 private:
0056   void produce(Event &, const EventSetup &) override;
0057 
0058   // ----------member data ---------------------------
0059 
0060   std::vector<edm::Ptr<L1TTTrackType>> L1TrkPtrs_;
0061   vector<int> tdtrk_;
0062   const double trk1_pt_;
0063   const double trk1_eta_;
0064   const double trk1_mva_;
0065   const double trk1_nstub_;
0066   const double trk1_dz_;
0067   const double trk1_mass_;
0068   const double trk2_pt_;
0069   const double trk2_eta_;
0070   const double trk2_mva_;
0071   const double trk2_nstub_;
0072   const double trk2_dz_;
0073   const double trk2_mass_;
0074   const double trk3_pt_;
0075   const double trk3_eta_;
0076   const double trk3_mva_;
0077   const double trk3_nstub_;
0078   const double trk3_dz_;
0079   const double trk3_mass_;
0080   const bool displaced_;
0081   const double triplet_massMin_;
0082   const double triplet_massMax_;
0083   const double triplet_ptMin_;
0084   const double triplet_ptMax_;
0085   const double triplet_etaMin_;
0086   const double triplet_etaMax_;
0087   const int triplet_abscharge_;
0088   const double triplet_massOver_;
0089   const double pair1_massMin_;
0090   const double pair1_massMax_;
0091   const double pair2_massMin_;
0092   const double pair2_massMax_;
0093   const double pair1_dzMin_;
0094   const double pair1_dzMax_;
0095   const double pair2_dzMin_;
0096   const double pair2_dzMax_;
0097   const bool use_float_track_precision_;
0098 
0099   struct L1track {
0100     double Pt;
0101     double Eta;
0102     double Phi;
0103     int Charge;
0104     double MVA;
0105     int Nstubs;
0106     double Z0;
0107     unsigned int Index;
0108   };
0109   //    L1TTTrackType track;
0110   bool TrackSelector(L1track &, double, double, double, double, double, int);
0111   double FloatPtFromBits(const L1TTTrackType &);
0112   double FloatEtaFromBits(const L1TTTrackType &);
0113   double FloatPhiFromBits(const L1TTTrackType &);
0114   double FloatZ0FromBits(const L1TTTrackType &);
0115 
0116   const EDGetTokenT<L1TTTrackRefCollectionType> trackToken_;
0117   const EDGetTokenT<l1t::VertexWordCollection> PVtxToken_;
0118 };
0119 
0120 //constructor
0121 L1TrackTripletEmulatorProducer::L1TrackTripletEmulatorProducer(const ParameterSet &iConfig)
0122     : trk1_pt_(iConfig.getParameter<double>("trk1_ptMin")),
0123       trk1_eta_(iConfig.getParameter<double>("trk1_absEtaMax")),
0124       trk1_mva_(iConfig.getParameter<double>("trk1_mvaMin")),
0125       trk1_nstub_(iConfig.getParameter<int>("trk1_nstubMin")),
0126       trk1_dz_(iConfig.getParameter<double>("trk1_dzMax")),
0127       trk1_mass_(iConfig.getParameter<double>("trk1_mass")),
0128       trk2_pt_(iConfig.getParameter<double>("trk2_ptMin")),
0129       trk2_eta_(iConfig.getParameter<double>("trk2_absEtaMax")),
0130       trk2_mva_(iConfig.getParameter<double>("trk2_mvaMin")),
0131       trk2_nstub_(iConfig.getParameter<int>("trk2_nstubMin")),
0132       trk2_dz_(iConfig.getParameter<double>("trk2_dzMax")),
0133       trk2_mass_(iConfig.getParameter<double>("trk2_mass")),
0134       trk3_pt_(iConfig.getParameter<double>("trk3_ptMin")),
0135       trk3_eta_(iConfig.getParameter<double>("trk3_absEtaMax")),
0136       trk3_mva_(iConfig.getParameter<double>("trk3_mvaMin")),
0137       trk3_nstub_(iConfig.getParameter<int>("trk3_nstubMin")),
0138       trk3_dz_(iConfig.getParameter<double>("trk3_dzMax")),
0139       trk3_mass_(iConfig.getParameter<double>("trk3_mass")),
0140       displaced_(iConfig.getParameter<bool>("displaced")),
0141       triplet_massMin_(iConfig.getParameter<double>("triplet_massMin")),
0142       triplet_massMax_(iConfig.getParameter<double>("triplet_massMax")),
0143       triplet_ptMin_(iConfig.getParameter<double>("triplet_ptMin")),
0144       triplet_ptMax_(iConfig.getParameter<double>("triplet_ptMax")),
0145       triplet_etaMin_(iConfig.getParameter<double>("triplet_absEtaMin")),
0146       triplet_etaMax_(iConfig.getParameter<double>("triplet_absEtaMax")),
0147       triplet_abscharge_(iConfig.getParameter<int>("triplet_absCharge")),
0148       triplet_massOver_(iConfig.getParameter<double>("triplet_massOverflow")),
0149       pair1_massMin_(iConfig.getParameter<double>("pair1_massMin")),
0150       pair1_massMax_(iConfig.getParameter<double>("pair1_massMax")),
0151       pair2_massMin_(iConfig.getParameter<double>("pair2_massMin")),
0152       pair2_massMax_(iConfig.getParameter<double>("pair2_massMax")),
0153       pair1_dzMin_(iConfig.getParameter<double>("pair1_dzMin")),
0154       pair1_dzMax_(iConfig.getParameter<double>("pair1_dzMax")),
0155       pair2_dzMin_(iConfig.getParameter<double>("pair2_dzMin")),
0156       pair2_dzMax_(iConfig.getParameter<double>("pair2_dzMax")),
0157       use_float_track_precision_(iConfig.getParameter<bool>("float_precision")),
0158       trackToken_(consumes<L1TTTrackRefCollectionType>(iConfig.getParameter<InputTag>("L1TrackInputTag"))),
0159       PVtxToken_(consumes<l1t::VertexWordCollection>(iConfig.getParameter<InputTag>("L1PVertexInputTag"))) {
0160   if (displaced_) {
0161     produces<l1t::TkTripletCollection>("L1TrackTripletExtended");
0162     produces<l1t::TkTripletWordCollection>("L1TrackTripletWordExtended");
0163   } else {
0164     produces<l1t::TkTripletCollection>("L1TrackTriplet");
0165     produces<l1t::TkTripletWordCollection>("L1TrackTripletWord");
0166   }
0167 }
0168 
0169 void L1TrackTripletEmulatorProducer::produce(Event &iEvent, const EventSetup &iSetup) {
0170   unique_ptr<l1t::TkTripletCollection> L1TrackTripletContainer(new l1t::TkTripletCollection);
0171   unique_ptr<l1t::TkTripletWordCollection> L1TrackTripletWordContainer(new l1t::TkTripletWordCollection);
0172 
0173   // Read inputs
0174   edm::Handle<L1TTTrackRefCollectionType> TTTrackHandle;
0175   iEvent.getByToken(trackToken_, TTTrackHandle);
0176 
0177   edm::Handle<l1t::VertexWordCollection> PVtx;
0178   iEvent.getByToken(PVtxToken_, PVtx);
0179   double PVz = (PVtx->at(0)).z0();
0180 
0181   std::string OutputDigisName = "L1TrackTriplet";
0182   std::string OutputWordName = "L1TrackTripletWord";
0183 
0184   if (displaced_)
0185     OutputDigisName += "Extended";
0186 
0187   if (TTTrackHandle->size() < 3) {
0188     iEvent.put(std::move(L1TrackTripletContainer), OutputDigisName);
0189     iEvent.put(std::move(L1TrackTripletWordContainer), OutputWordName);
0190     return;
0191   }
0192 
0193   // Finding the 3 highest pT tracks
0194   L1track trk1{-99, -99, -99, -99, -99, -99, -99, 0};
0195   L1track trk2{-99, -99, -99, -99, -99, -99, -99, 0};
0196   L1track trk3{-99, -99, -99, -99, -99, -99, -99, 0};
0197 
0198   int current_track_idx = -1;
0199   for (auto current_track : *TTTrackHandle) {
0200     current_track_idx += 1;
0201     double current_track_pt = 0;
0202     if (use_float_track_precision_)
0203       current_track_pt = current_track->momentum().perp();
0204     else
0205       current_track_pt = FloatPtFromBits(*current_track);
0206     if (current_track_pt < trk1.Pt)
0207       continue;
0208     trk3 = trk2;
0209     trk2 = trk1;
0210     if (use_float_track_precision_) {
0211       trk1.Pt = current_track->momentum().perp();
0212       trk1.Eta = current_track->eta();
0213       trk1.Phi = current_track->phi();
0214       trk1.Charge = (int)(current_track->rInv() / fabs(current_track->rInv()));
0215       trk1.MVA = current_track->trkMVA1();
0216       trk1.Nstubs = current_track->getStubRefs().size();
0217       trk1.Z0 = current_track->z0();
0218       trk1.Index = current_track_idx;
0219     } else {
0220       trk1.Pt = FloatPtFromBits(*current_track);
0221       trk1.Eta = FloatEtaFromBits(*current_track);
0222       trk1.Phi = FloatPhiFromBits(*current_track);
0223       trk1.Charge = (int)(current_track->rInv() / fabs(current_track->rInv()));
0224       trk1.MVA = current_track->trkMVA1();
0225       trk1.Nstubs = current_track->getStubRefs().size();
0226       trk1.Z0 = FloatZ0FromBits(*current_track);
0227       trk1.Index = current_track_idx;
0228     }
0229   }
0230 
0231   // track selection
0232   bool track1_pass = TrackSelector(trk1, PVz, trk1_pt_, trk1_eta_, trk1_mva_, trk1_dz_, trk1_nstub_);
0233   bool track2_pass = TrackSelector(trk2, PVz, trk2_pt_, trk2_eta_, trk2_mva_, trk2_dz_, trk2_nstub_);
0234   bool track3_pass = TrackSelector(trk3, PVz, trk3_pt_, trk3_eta_, trk3_mva_, trk3_dz_, trk3_nstub_);
0235   if (!track1_pass || !track2_pass || !track3_pass) {
0236     iEvent.put(std::move(L1TrackTripletContainer), OutputDigisName);
0237     iEvent.put(std::move(L1TrackTripletWordContainer), OutputWordName);
0238     return;
0239   }
0240 
0241   // create Lorentz Vectors
0242   math::PtEtaPhiMLorentzVectorD pion1(trk1.Pt, trk1.Eta, trk1.Phi, trk1_mass_);
0243   math::PtEtaPhiMLorentzVectorD pion2(trk2.Pt, trk2.Eta, trk2.Phi, trk2_mass_);
0244   math::PtEtaPhiMLorentzVectorD pion3(trk3.Pt, trk3.Eta, trk3.Phi, trk3_mass_);
0245 
0246   bool event_pass = true;
0247 
0248   // create triplets
0249   double triplet_mass = (pion1 + pion2 + pion3).M();
0250   if (triplet_mass > triplet_massOver_)
0251     triplet_mass = triplet_massOver_;
0252   double triplet_eta = (pion1 + pion2 + pion3).Eta();
0253   double triplet_pt = (pion1 + pion2 + pion3).Pt();
0254   int triplet_charge = trk1.Charge + trk2.Charge + trk3.Charge;
0255   std::vector<double> pair_masses{(pion1 + pion2).M(), (pion2 + pion3).M(), (pion1 + pion3).M()};
0256   std::sort(pair_masses.begin(), pair_masses.end(), [](auto &a, auto &b) { return a > b; });
0257   std::vector<double> pair_dzs{fabs(trk1.Z0 - trk2.Z0), fabs(trk2.Z0 - trk3.Z0), fabs(trk1.Z0 - trk3.Z0)};
0258   std::sort(pair_dzs.begin(), pair_dzs.end(), [](auto &a, auto &b) { return a > b; });
0259 
0260   //triplet selection
0261   if (triplet_mass < triplet_massMin_ || triplet_mass > triplet_massMax_)
0262     event_pass = false;
0263   if (fabs(triplet_eta) < triplet_etaMin_ || fabs(triplet_eta) > triplet_etaMax_)
0264     event_pass = false;
0265   if (triplet_pt < triplet_ptMin_ || triplet_pt > triplet_ptMax_)
0266     event_pass = false;
0267   if (fabs(triplet_charge) != triplet_abscharge_ && triplet_abscharge_ > -1)
0268     event_pass = false;
0269   if (pair_masses[2] < pair2_massMin_ || pair_masses[2] > pair2_massMax_)
0270     event_pass = false;
0271   if (pair_masses[0] < pair1_massMin_ || pair_masses[0] > pair1_massMax_)
0272     event_pass = false;
0273   if (pair_dzs[2] < pair2_dzMin_ || pair_dzs[2] > pair2_dzMax_)
0274     event_pass = false;
0275   if (pair_dzs[0] < pair1_dzMin_ || pair_dzs[0] > pair1_dzMax_)
0276     event_pass = false;
0277 
0278   if (!event_pass) {
0279     iEvent.put(std::move(L1TrackTripletContainer), OutputDigisName);
0280     iEvent.put(std::move(L1TrackTripletWordContainer), OutputWordName);
0281     return;
0282   }
0283   float tripletPx = (pion1 + pion2 + pion3).Pt() * cos((pion1 + pion2 + pion3).Phi());
0284   float tripletPy = (pion1 + pion2 + pion3).Pt() * sin((pion1 + pion2 + pion3).Phi());
0285   float tripletPz = (pion1 + pion2 + pion3).Pt() * sinh((pion1 + pion2 + pion3).Eta());
0286   float tripletE =
0287       sqrt(tripletPx * tripletPx + tripletPy * tripletPy + tripletPz * tripletPz + triplet_mass * triplet_mass);
0288   TkTriplet trkTriplet(math::XYZTLorentzVector(tripletPx, tripletPy, tripletPz, tripletE),
0289                        triplet_charge,
0290                        pair_masses[0],
0291                        pair_masses[2],
0292                        pair_dzs[0],
0293                        pair_dzs[2],
0294                        {edm::Ptr<L1TTTrackType>(TTTrackHandle, trk1.Index),
0295                         edm::Ptr<L1TTTrackType>(TTTrackHandle, trk2.Index),
0296                         edm::Ptr<L1TTTrackType>(TTTrackHandle, trk3.Index)});
0297   L1TrackTripletContainer->push_back(trkTriplet);
0298 
0299   iEvent.put(std::move(L1TrackTripletContainer), OutputDigisName);
0300 
0301   // bit assignment
0302   l1t::TkTripletWord::valid_t val = 1;
0303   l1t::TkTripletWord::pt_t bitPt = pt_intern((pion1 + pion2 + pion3).Pt());
0304   l1t::TkTripletWord::glbeta_t bitEta =
0305       DoubleToBit((pion1 + pion2 + pion3).Eta(),
0306                   TkTripletWord::TkTripletBitWidths::kGlbEtaSize,
0307                   TkTripletWord::MAX_ETA / (1 << TkTripletWord::TkTripletBitWidths::kGlbEtaSize));
0308   l1t::TkTripletWord::glbphi_t bitPhi =
0309       DoubleToBit((pion1 + pion2 + pion3).Phi(),
0310                   TkTripletWord::TkTripletBitWidths::kGlbPhiSize,
0311                   (2. * std::abs(M_PI)) / (1 << TkTripletWord::TkTripletBitWidths::kGlbPhiSize));
0312   l1t::TkTripletWord::charge_t bitCharge =
0313       DoubleToBit(double(triplet_charge),
0314                   TkTripletWord::TkTripletBitWidths::kChargeSize,
0315                   TkTripletWord::MAX_CHARGE / (1 << TkTripletWord::TkTripletBitWidths::kChargeSize));
0316   l1t::TkTripletWord::mass_t bitMass =
0317       DoubleToBit((pion1 + pion2 + pion3).M(),
0318                   TkTripletWord::TkTripletBitWidths::kMassSize,
0319                   TkTripletWord::MAX_MASS / (1 << TkTripletWord::TkTripletBitWidths::kMassSize));
0320   l1t::TkTripletWord::ditrack_minmass_t bitDiTrackMinMass =
0321       DoubleToBit(pair_masses[2],
0322                   TkTripletWord::TkTripletBitWidths::kDiTrackMinMassSize,
0323                   TkTripletWord::MAX_MASS / (1 << TkTripletWord::TkTripletBitWidths::kDiTrackMinMassSize));
0324   l1t::TkTripletWord::ditrack_maxmass_t bitDiTrackMaxMass =
0325       DoubleToBit(pair_masses[0],
0326                   TkTripletWord::TkTripletBitWidths::kDiTrackMaxMassSize,
0327                   TkTripletWord::MAX_MASS / (1 << TkTripletWord::TkTripletBitWidths::kDiTrackMaxMassSize));
0328 
0329   l1t::TkTripletWord::ditrack_minz0_t bitDiTrackMinZ0 =
0330       DoubleToBit(pair_dzs[2],
0331                   TkTripletWord::TkTripletBitWidths::kDiTrackMinZ0Size,
0332                   TkTripletWord::MAX_Z0 / (1 << TkTripletWord::TkTripletBitWidths::kDiTrackMinZ0Size));
0333   l1t::TkTripletWord::ditrack_maxz0_t bitDiTrackMaxZ0 =
0334       DoubleToBit(pair_dzs[0],
0335                   TkTripletWord::TkTripletBitWidths::kDiTrackMaxZ0Size,
0336                   TkTripletWord::MAX_Z0 / (1 << TkTripletWord::TkTripletBitWidths::kDiTrackMaxZ0Size));
0337 
0338   l1t::TkTripletWord::unassigned_t unassigned = 0;
0339   l1t::TkTripletWord bitTriplet(val,
0340                                 bitPt,
0341                                 bitEta,
0342                                 bitPhi,
0343                                 bitMass,
0344                                 bitCharge,
0345                                 bitDiTrackMinZ0,
0346                                 bitDiTrackMaxMass,
0347                                 bitDiTrackMinZ0,
0348                                 bitDiTrackMaxZ0,
0349                                 unassigned);
0350 
0351   L1TrackTripletWordContainer->push_back(bitTriplet);
0352 
0353   iEvent.put(std::move(L1TrackTripletWordContainer), OutputWordName);
0354 }
0355 
0356 bool L1TrackTripletEmulatorProducer::TrackSelector(L1TrackTripletEmulatorProducer::L1track &track,
0357                                                    double PVz,
0358                                                    double pt_min_cut,
0359                                                    double eta_max_cut,
0360                                                    double mva_min_cut,
0361                                                    double dz_max_cut,
0362                                                    int nstub_min_cut) {
0363   return (track.Pt >= pt_min_cut) && (fabs(track.Eta) <= eta_max_cut) && (track.MVA >= mva_min_cut) &&
0364          (fabs(track.Z0 - PVz) <= dz_max_cut) && (track.Nstubs >= nstub_min_cut);
0365 }
0366 
0367 double L1TrackTripletEmulatorProducer::FloatPtFromBits(const L1TTTrackType &track) {
0368   ap_uint<TTTrack_TrackWord::TrackBitWidths::kRinvSize - 1> ptBits = track.getRinvWord();
0369   pt_intern digipt;
0370   digipt.V = ptBits.range();
0371   return (double)digipt;
0372 }
0373 
0374 double L1TrackTripletEmulatorProducer::FloatEtaFromBits(const L1TTTrackType &track) {
0375   TTTrack_TrackWord::tanl_t etaBits = track.getTanlWord();
0376   glbeta_intern digieta;
0377   digieta.V = etaBits.range();
0378   return (double)digieta;
0379 }
0380 
0381 double L1TrackTripletEmulatorProducer::FloatPhiFromBits(const L1TTTrackType &track) {
0382   int Sector = track.phiSector();
0383   double sector_phi_value = 0;
0384   if (Sector < 5) {
0385     sector_phi_value = 2.0 * M_PI * Sector / 9.0;
0386   } else {
0387     sector_phi_value = (-1.0 * M_PI + M_PI / 9.0 + (Sector - 5) * 2.0 * M_PI / 9.0);
0388   }
0389   glbphi_intern trkphiSector = DoubleToBit(
0390       sector_phi_value, TTTrack_TrackWord::TrackBitWidths::kPhiSize + kExtraGlobalPhiBit, TTTrack_TrackWord::stepPhi0);
0391   glbphi_intern local_phiBits = 0;
0392   local_phiBits.V = track.getPhiWord();
0393 
0394   glbphi_intern local_phi =
0395       DoubleToBit(BitToDouble(local_phiBits, TTTrack_TrackWord::TrackBitWidths::kPhiSize, TTTrack_TrackWord::stepPhi0),
0396                   TTTrack_TrackWord::TrackBitWidths::kPhiSize + kExtraGlobalPhiBit,
0397                   TTTrack_TrackWord::stepPhi0);
0398   glbphi_intern digiphi = local_phi + trkphiSector;
0399   return BitToDouble(
0400       digiphi, TTTrack_TrackWord::TrackBitWidths::kPhiSize + kExtraGlobalPhiBit, TTTrack_TrackWord::stepPhi0);
0401 }
0402 
0403 double L1TrackTripletEmulatorProducer::FloatZ0FromBits(const L1TTTrackType &track) {
0404   z0_intern trkZ = track.getZ0Word();
0405   return BitToDouble(trkZ, TTTrack_TrackWord::TrackBitWidths::kZ0Size, TTTrack_TrackWord::stepZ0);
0406 }
0407 
0408 void L1TrackTripletEmulatorProducer::fillDescriptions(ConfigurationDescriptions &descriptions) {
0409   //The following says we do not know what parameters are allowed so do no validation
0410   // Please change this to state exactly what you do use, even if it is no parameters
0411   ParameterSetDescription desc;
0412   desc.add<edm::InputTag>("L1TrackInputTag", edm::InputTag("l1tTTTracksFromTrackletEmulation", "Level1TTTracks"));
0413   desc.add<edm::InputTag>("L1PVertexInputTag", edm::InputTag("l1tVertexFinderEmulator", "L1VerticesEmulation"));
0414   desc.add<double>("trk1_ptMin", -1.0);
0415   desc.add<double>("trk1_absEtaMax", 10e7);
0416   desc.add<double>("trk1_mvaMin", -1.0);
0417   desc.add<int>("trk1_nstubMin", -1);
0418   desc.add<double>("trk1_dzMax", 10e7);
0419   desc.add<double>("trk1_mass", 0.139);
0420   desc.add<double>("trk2_ptMin", -1.0);
0421   desc.add<double>("trk2_absEtaMax", 10e7);
0422   desc.add<double>("trk2_mvaMin", -1.0);
0423   desc.add<int>("trk2_nstubMin", -1);
0424   desc.add<double>("trk2_dzMax", 10e7);
0425   desc.add<double>("trk2_mass", 0.139);
0426   desc.add<double>("trk3_ptMin", -1.0);
0427   desc.add<double>("trk3_absEtaMax", 10e7);
0428   desc.add<double>("trk3_mvaMin", -1.0);
0429   desc.add<int>("trk3_nstubMin", 0);
0430   desc.add<double>("trk3_dzMax", 10e7);
0431   desc.add<double>("trk3_mass", 0.139);
0432   desc.add<bool>("displaced", false);
0433   desc.add<double>("triplet_massMin", -1.0);
0434   desc.add<double>("triplet_massMax", 10e7);
0435   desc.add<double>("triplet_absEtaMin", -1.0);
0436   desc.add<double>("triplet_absEtaMax", 10e7);
0437   desc.add<double>("triplet_ptMin", -1.0);
0438   desc.add<double>("triplet_ptMax", 10e7);
0439   desc.add<int>("triplet_absCharge", -1);
0440   desc.add<double>("triplet_massOverflow", 1000);
0441   desc.add<double>("pair1_massMin", -1);
0442   desc.add<double>("pair1_massMax", 10e7);
0443   desc.add<double>("pair2_massMin", -1);
0444   desc.add<double>("pair2_massMax", 10e7);
0445   desc.add<double>("pair1_dzMin", -1);
0446   desc.add<double>("pair1_dzMax", 10e7);
0447   desc.add<double>("pair2_dzMin", -1);
0448   desc.add<double>("pair2_dzMax", 10e7);
0449   desc.add<bool>("float_precision", false);
0450   descriptions.add("l1tTrackTripletEmulator", desc);
0451 }
0452 
0453 //define this as a plug-in
0454 DEFINE_FWK_MODULE(L1TrackTripletEmulatorProducer);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!