trklet::PurgeDuplicate Class Reference

#include <PurgeDuplicate.h>

Inheritance diagram for trklet::PurgeDuplicate:

Public Member Functions
void	addInput (MemoryBase *memory, std::string input) override
void	addOutput (MemoryBase *memory, std::string output) override
void	execute (std::vector< Track > &outputtracks, unsigned int iSector)
	PurgeDuplicate (std::string name, Settings const &settings, Globals *global)
	~PurgeDuplicate () override=default
Public Member Functions inherited from trklet::ProcessBase
unsigned int	getISeed (const std::string &name)
std::string const &	getName () const
void	initLayerDisk (unsigned int pos, int &layer, int &disk)
void	initLayerDisk (unsigned int pos, int &layer, int &disk, int &layerdisk)
unsigned int	initLayerDisk (unsigned int pos)
void	initLayerDisksandISeed (unsigned int &layerdisk1, unsigned int &layerdisk2, unsigned int &iSeed)
unsigned int	nbits (unsigned int power)
	ProcessBase (std::string name, Settings const &settings, Globals *global)
virtual	~ProcessBase ()=default

Private Member Functions
std::pair< int, int >	findLayerDisk (const Stub *) const
std::vector< unsigned int >	findOverlapPhiBins (const Tracklet *trk) const
std::vector< unsigned int >	findOverlapRinvBins (const Tracklet *trk) const
unsigned int	findPhiBin (const Tracklet *trk) const
unsigned int	findRinvBin (const Tracklet *trk) const
std::vector< double >	getInventedCoords (unsigned int, const Stub *, const Tracklet *) const
std::vector< double >	getInventedCoordsExtended (unsigned int, const Stub *, const Tracklet *) const
std::vector< const Stub * >	getInventedSeedingStub (unsigned int, const Tracklet *, const std::vector< const Stub *> &) const
double	getPhiRes (Tracklet *curTracklet, const Stub *curStub) const
bool	isSeedingStub (int, int, int) const
bool	isTrackInBin (const std::vector< unsigned int > &vec, unsigned int num) const
std::string	l1tinfo (const L1TStub *, std::string) const

Private Attributes
std::vector< std::vector< std::pair< int, int > > >	inputstubidslists_
std::vector< std::vector< const Stub * > >	inputstublists_
std::vector< TrackFitMemory * >	inputtrackfits_
std::vector< Tracklet * >	inputtracklets_
std::vector< Track * >	inputtracks_
std::vector< std::vector< std::pair< int, int > > >	mergedstubidslists_
std::vector< CleanTrackMemory * >	outputtracklets_

Additional Inherited Members
Protected Attributes inherited from trklet::ProcessBase
Globals *	globals_
std::string	name_
Settings const &	settings_

Detailed Description

Definition at line 27 of file PurgeDuplicate.h.

Constructor & Destructor Documentation

PurgeDuplicate()

PurgeDuplicate::PurgeDuplicate	(	std::string	name,
		Settings const &	settings,
		Globals *	global
	)

Definition at line 25 of file PurgeDuplicate.cc.

    : ProcessBase(name, settings, global) {}

~PurgeDuplicate()

trklet::PurgeDuplicate::~PurgeDuplicate ( )

overridedefault

Member Function Documentation

addInput()

void PurgeDuplicate::addInput ( MemoryBase *  memory, std::string  input  )

overridevirtual

Implements trklet::ProcessBase.

Definition at line 54 of file PurgeDuplicate.cc.

References cms::cuda::assert(), Exception, input, PixelMapPlotter::inputs, inputtrackfits_, mps_setup::memory, trklet::ProcessBase::name_, trklet::ProcessBase::settings_, createJobs::tmp, and trklet::Settings::writetrace().

                                                                 {
  if (settings_.writetrace()) {
    edm::LogVerbatim("Tracklet") << "In " << name_ << " adding input from " << memory->getName() << " to input "
                                 << input;
  }
  unordered_set<string> inputs = {"trackin",
                                  "trackin1",
                                  "trackin2",
                                  "trackin3",
                                  "trackin4",
                                  "trackin5",
                                  "trackin6",
                                  "trackin7",
                                  "trackin8",
                                  "trackin9",
                                  "trackin10",
                                  "trackin11",
                                  "trackin12"};
  if (inputs.find(input) != inputs.end()) {
    auto* tmp = dynamic_cast<TrackFitMemory*>(memory);
    assert(tmp != nullptr);
    inputtrackfits_.push_back(tmp);
    return;
  }
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " could not find input: " << input;
}

addOutput()

void PurgeDuplicate::addOutput ( MemoryBase *  memory, std::string  output  )

overridevirtual

Implements trklet::ProcessBase.

Definition at line 28 of file PurgeDuplicate.cc.

References cms::cuda::assert(), Exception, mps_setup::memory, trklet::ProcessBase::name_, convertSQLitetoXML_cfg::output, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, outputtracklets_, trklet::ProcessBase::settings_, createJobs::tmp, and trklet::Settings::writetrace().

                                                                   {
  if (settings_.writetrace()) {
    edm::LogVerbatim("Tracklet") << "In " << name_ << " adding output to " << memory->getName() << " to output "
                                 << output;
  }
  unordered_set<string> outputs = {"trackout",
                                   "trackout1",
                                   "trackout2",
                                   "trackout3",
                                   "trackout4",
                                   "trackout5",
                                   "trackout6",
                                   "trackout7",
                                   "trackout8",
                                   "trackout9",
                                   "trackout10",
                                   "trackout11"};
  if (outputs.find(output) != outputs.end()) {
    auto* tmp = dynamic_cast<CleanTrackMemory*>(memory);
    assert(tmp != nullptr);
    outputtracklets_.push_back(tmp);
    return;
  }
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " could not find output: " << output;
}

execute()

void PurgeDuplicate::execute	(	std::vector< Track > &	outputtracks,
		unsigned int	iSector
	)

Definition at line 81 of file PurgeDuplicate.cc.

References Reference_intrackfit_cff::barrel, newFWLiteAna::bin, trklet::Settings::extended(), spr::find(), findOverlapPhiBins(), findOverlapRinvBins(), findPhiBin(), findRinvBin(), dqmdumpme::first, trklet::HybridFit::Fit(), trklet::Tracklet::fit(), groupFilesInBlocks::fout, getInventedSeedingStub(), getPhiRes(), getTrack(), trklet::Tracklet::getTrack(), trklet::ProcessBase::globals_, getRunAppsInfo::grid, mps_fire::i, trklet::Track::ichisq(), inputstubidslists_, inputstublists_, inputtrackfits_, inputtracklets_, inputtracks_, createfilelist::int, trklet::Settings::inventStubs(), isTrackInBin(), dqmiolumiharvest::j, M_PI, SiStripPI::max, trklet::Settings::maxStep(), trklet::Settings::mergeComparison(), mergedstubidslists_, SiStripPI::min, trklet::Settings::minIndStubs(), trklet::ProcessBase::name_, trklet::Settings::numTracksComparedPerBin(), outputtracklets_, BeamMonitor_cff::phiBin, trklet::Settings::phiBins(), muonRecoAnalyzer_cfi::ptBin, trklet::Settings::removalType(), trklet::Settings::rinvBins(), edm::second(), trklet::Tracklet::seedIndex(), trklet::Track::setSector(), trklet::Track::setStubIDprefit(), trklet::Track::setStubIDpremerge(), trklet::ProcessBase::settings_, jetUpdater_cfi::sort, trklet::Track::stubID(), ecalIM::uniqueIndex(), and trklet::Settings::writeMonitorData().

                                                                                 {
  inputtracklets_.clear();
  inputtracks_.clear();

  inputstubidslists_.clear();
  inputstublists_.clear();
  mergedstubidslists_.clear();

  if (settings_.removalType() != "merge") {
    for (auto& inputtrackfit : inputtrackfits_) {
      if (inputtrackfit->nTracks() == 0)
        continue;
      for (unsigned int j = 0; j < inputtrackfit->nTracks(); j++) {
        Track* aTrack = inputtrackfit->getTrack(j)->getTrack();
        aTrack->setSector(iSector);
        inputtracks_.push_back(aTrack);
      }
    }
    if (inputtracks_.empty())
      return;
  }

  unsigned int numTrk = inputtracks_.size();

  // Hybrid Removal //
#ifdef USEHYBRID

  if (settings_.removalType() == "merge") {
    // Track seed & duplicate flag
    std::vector<std::pair<int, bool>> trackInfo;
    // Flag for tracks in multiple bins that get merged but are not in the correct bin
    std::vector<bool> trackBinInfo;
    // Vector to store the relative rank of the track candidate for merging, based on seed type
    std::vector<int> seedRank;

    // Stubs on every track
    std::vector<std::vector<const Stub*>> inputstublistsall;
    // (layer, unique stub index within layer) of each stub on every track
    std::vector<std::vector<std::pair<int, int>>> mergedstubidslistsall;
    std::vector<std::vector<std::pair<int, int>>> inputstubidslistsall;
    std::vector<Tracklet*> inputtrackletsall;

    std::vector<unsigned int> prefTracks;  // Stores all the tracks that are sent to the KF from each bin
    std::vector<int> prefTrackFit;  // Stores the track seed that corresponds to the associated track in prefTracks

    for (unsigned int bin = 0; bin < settings_.rinvBins().size() - 1; bin++) {
      for (unsigned int phiBin = 0; phiBin < settings_.phiBins().size() - 1; phiBin++) {
        // Get vectors from TrackFit and save them
        // inputtracklets: Tracklet objects from the FitTrack (not actually fit yet)
        // inputstublists: L1Stubs for that track
        // inputstubidslists: Stub stubIDs for that 3rack
        // mergedstubidslists: the same as inputstubidslists, but will be used during duplicate removal
        for (unsigned int i = 0; i < inputtrackfits_.size(); i++) {
          if (inputtrackfits_[i]->nStublists() == 0)
            continue;
          if (inputtrackfits_[i]->nStublists() != inputtrackfits_[i]->nTracks())
            throw cms::Exception("LogicError")
                << __FILE__ << " " << __LINE__ << " Number of stublists and tracks don't match up! ";
          for (unsigned int j = 0; j < inputtrackfits_[i]->nStublists(); j++) {
            if (isTrackInBin(findOverlapRinvBins(inputtrackfits_[i]->getTrack(j)), bin)) {
              if (!isTrackInBin(findOverlapPhiBins(inputtrackfits_[i]->getTrack(j)), phiBin))
                continue;
              if (inputtracklets_.size() >= settings_.maxStep("DR"))
                continue;
              Tracklet* aTrack = inputtrackfits_[i]->getTrack(j);
              inputtracklets_.push_back(inputtrackfits_[i]->getTrack(j));
              std::vector<const Stub*> stublist = inputtrackfits_[i]->getStublist(j);
              inputstublists_.push_back(stublist);
              std::vector<std::pair<int, int>> stubidslist = inputtrackfits_[i]->getStubidslist(j);
              inputstubidslists_.push_back(stubidslist);
              mergedstubidslists_.push_back(stubidslist);

              // Encoding: L1L2=0, L2L3=1, L3L4=2, L5L6=3, D1D2=4, D3D4=5, L1D1=6, L2D1=7
              // Best Guess:          L1L2 > L1D1 > L2L3 > L2D1 > D1D2 > L3L4 > L5L6 > D3D4
              // Best Rank:           L1L2 > L3L4 > D3D4 > D1D2 > L2L3 > L2D1 > L5L6 > L1D1
              // Rank-Informed Guess: L1L2 > L3L4 > L1D1 > L2L3 > L2D1 > D1D2 > L5L6 > D3D4
              unsigned int curSeed = aTrack->seedIndex();
              std::vector<int> ranks{1, 5, 2, 7, 4, 3, 8, 6};
              if (settings_.extended())
                seedRank.push_back(9);
              else
                seedRank.push_back(ranks[curSeed]);

              if (stublist.size() != stubidslist.size())
                throw cms::Exception("LogicError")
                    << __FILE__ << " " << __LINE__ << " Number of stubs and stubids don't match up! ";

              trackInfo.emplace_back(i, false);
              trackBinInfo.emplace_back(false);
            } else
              continue;
          }
        }

        if (inputtracklets_.empty())
          continue;
        const unsigned int numStublists = inputstublists_.size();

        if (settings_.inventStubs()) {
          for (unsigned int itrk = 0; itrk < numStublists; itrk++) {
            inputstublists_[itrk] = getInventedSeedingStub(iSector, inputtracklets_[itrk], inputstublists_[itrk]);
          }
        }

        // Initialize all-false 2D array of tracks being duplicates to other tracks
        bool dupMap[numStublists][numStublists];  // Ends up symmetric
        for (unsigned int itrk = 0; itrk < numStublists; itrk++) {
          for (unsigned int jtrk = 0; jtrk < numStublists; jtrk++) {
            dupMap[itrk][jtrk] = false;
          }
        }

        // Used to check if a track is in two bins, is not a duplicate in either bin, so is sent out twice
        bool noMerge[numStublists];
        for (unsigned int itrk = 0; itrk < numStublists; itrk++) {
          noMerge[itrk] = false;
        }

        // Find duplicates; Fill dupMap by looping over all pairs of "tracks"
        // numStublists-1 since last track has no other to compare to
        for (unsigned int itrk = 0; itrk < numStublists - 1; itrk++) {
          for (unsigned int jtrk = itrk + 1; jtrk < numStublists; jtrk++) {
            if (itrk >= settings_.numTracksComparedPerBin())
              continue;
            // Get primary track stubids = (layer, unique stub index within layer)
            const std::vector<std::pair<int, int>>& stubsTrk1 = inputstubidslists_[itrk];

            // Get and count secondary track stubids
            const std::vector<std::pair<int, int>>& stubsTrk2 = inputstubidslists_[jtrk];

            // Count number of layers that share stubs, and the number of UR that each track hits
            unsigned int nShareLay = 0;
            if (settings_.mergeComparison() == "CompareAll") {
              bool layerArr[16];
              for (auto& i : layerArr) {
                i = false;
              };
              for (const auto& st1 : stubsTrk1) {
                for (const auto& st2 : stubsTrk2) {
                  if (st1.first == st2.first && st1.second == st2.second) {  // tracks share stub
                    // Converts layer/disk encoded in st1->first to an index in the layer array
                    int i = st1.first;  // layer/disk
                    bool barrel = (i > 0 && i < 10);
                    bool endcapA = (i > 10);
                    bool endcapB = (i < 0);
                    int lay = barrel * (i - 1) + endcapA * (i - 5) - endcapB * i;  // encode in range 0-15
                    if (!layerArr[lay]) {
                      nShareLay++;
                      layerArr[lay] = true;
                    }
                  }
                }
              }
            } else if (settings_.mergeComparison() == "CompareBest") {
              std::vector<const Stub*> fullStubslistsTrk1 = inputstublists_[itrk];
              std::vector<const Stub*> fullStubslistsTrk2 = inputstublists_[jtrk];

              // Arrays to store the index of the best stub in each layer
              int layStubidsTrk1[16];
              int layStubidsTrk2[16];
              for (int i = 0; i < 16; i++) {
                layStubidsTrk1[i] = -1;
                layStubidsTrk2[i] = -1;
              }
              // For each stub on the first track, find the stub with the best residual and store its index in the layStubidsTrk1 array
              for (unsigned int stcount = 0; stcount < stubsTrk1.size(); stcount++) {
                int i = stubsTrk1[stcount].first;  // layer/disk
                bool barrel = (i > 0 && i < 10);
                bool endcapA = (i > 10);
                bool endcapB = (i < 0);
                int lay = barrel * (i - 1) + endcapA * (i - 5) - endcapB * i;  // encode in range 0-15
                double nres = getPhiRes(inputtracklets_[itrk], fullStubslistsTrk1[stcount]);
                double ores = 0;
                if (layStubidsTrk1[lay] != -1)
                  ores = getPhiRes(inputtracklets_[itrk], fullStubslistsTrk1[layStubidsTrk1[lay]]);
                if (layStubidsTrk1[lay] == -1 || nres < ores) {
                  layStubidsTrk1[lay] = stcount;
                }
              }
              // For each stub on the second track, find the stub with the best residual and store its index in the layStubidsTrk1 array
              for (unsigned int stcount = 0; stcount < stubsTrk2.size(); stcount++) {
                int i = stubsTrk2[stcount].first;  // layer/disk
                bool barrel = (i > 0 && i < 10);
                bool endcapA = (i > 10);
                bool endcapB = (i < 0);
                int lay = barrel * (i - 1) + endcapA * (i - 5) - endcapB * i;  // encode in range 0-15
                double nres = getPhiRes(inputtracklets_[jtrk], fullStubslistsTrk2[stcount]);
                double ores = 0;
                if (layStubidsTrk2[lay] != -1)
                  ores = getPhiRes(inputtracklets_[jtrk], fullStubslistsTrk2[layStubidsTrk2[lay]]);
                if (layStubidsTrk2[lay] == -1 || nres < ores) {
                  layStubidsTrk2[lay] = stcount;
                }
              }
              // For all 16 layers (6 layers and 10 disks), count the number of layers who's best stub on both tracks are the same
              for (int i = 0; i < 16; i++) {
                int t1i = layStubidsTrk1[i];
                int t2i = layStubidsTrk2[i];
                if (t1i != -1 && t2i != -1 && stubsTrk1[t1i].first == stubsTrk2[t2i].first &&
                    stubsTrk1[t1i].second == stubsTrk2[t2i].second)
                  nShareLay++;
              }
            }

            // Fill duplicate map
            if (nShareLay >= settings_.minIndStubs()) {  // For number of shared stub merge condition
              dupMap[itrk][jtrk] = true;
              dupMap[jtrk][itrk] = true;
            }
          }
        }

        // Check to see if the track is a duplicate
        for (unsigned int itrk = 0; itrk < numStublists; itrk++) {
          for (unsigned int jtrk = 0; jtrk < numStublists; jtrk++) {
            if (dupMap[itrk][jtrk]) {
              noMerge[itrk] = true;
            }
          }
        }

        // If the track isn't a duplicate, and if it's in more than one bin, and it is not in the proper rinv or phi bin, then mark it so it won't be sent to output
        for (unsigned int itrk = 0; itrk < numStublists; itrk++) {
          if (noMerge[itrk] == false) {
            if (((findOverlapRinvBins(inputtracklets_[itrk]).size() > 1) &&
                 (findRinvBin(inputtracklets_[itrk]) != bin)) ||
                ((findOverlapPhiBins(inputtracklets_[itrk]).size() > 1) &&
                 findPhiBin(inputtracklets_[itrk]) != phiBin)) {
              trackInfo[itrk].second = true;
            }
          }
        }
        // Merge duplicate tracks
        for (unsigned int itrk = 0; itrk < numStublists - 1; itrk++) {
          for (unsigned int jtrk = itrk + 1; jtrk < numStublists; jtrk++) {
            // Merge a track with its first duplicate found.
            if (dupMap[itrk][jtrk]) {
              // Set preferred track based on seed rank
              int preftrk;
              int rejetrk;
              if (seedRank[itrk] < seedRank[jtrk]) {
                preftrk = itrk;
                rejetrk = jtrk;
              } else {
                preftrk = jtrk;
                rejetrk = itrk;
              }

              // If the preffered track is in more than one bin, but not in the proper rinv or phi bin, then mark as true
              if (((findOverlapRinvBins(inputtracklets_[preftrk]).size() > 1) &&
                   (findRinvBin(inputtracklets_[preftrk]) != bin)) ||
                  ((findOverlapPhiBins(inputtracklets_[preftrk]).size() > 1) &&
                   (findPhiBin(inputtracklets_[preftrk]) != phiBin))) {
                trackBinInfo[preftrk] = true;
                trackBinInfo[rejetrk] = true;
              } else {
                // Get a merged stub list
                std::vector<const Stub*> newStubList;
                std::vector<const Stub*> stubsTrk1 = inputstublists_[preftrk];
                std::vector<const Stub*> stubsTrk2 = inputstublists_[rejetrk];
                std::vector<unsigned int> stubsTrk1indices;
                std::vector<unsigned int> stubsTrk2indices;
                for (unsigned int stub1it = 0; stub1it < stubsTrk1.size(); stub1it++) {
                  stubsTrk1indices.push_back(stubsTrk1[stub1it]->l1tstub()->uniqueIndex());
                }
                for (unsigned int stub2it = 0; stub2it < stubsTrk2.size(); stub2it++) {
                  stubsTrk2indices.push_back(stubsTrk2[stub2it]->l1tstub()->uniqueIndex());
                }
                newStubList = stubsTrk1;
                for (unsigned int stub2it = 0; stub2it < stubsTrk2.size(); stub2it++) {
                  if (find(stubsTrk1indices.begin(), stubsTrk1indices.end(), stubsTrk2indices[stub2it]) ==
                      stubsTrk1indices.end()) {
                    newStubList.push_back(stubsTrk2[stub2it]);
                  }
                }
                //   Overwrite stublist of preferred track with merged list
                inputstublists_[preftrk] = newStubList;

                std::vector<std::pair<int, int>> newStubidsList;
                std::vector<std::pair<int, int>> stubidsTrk1 = mergedstubidslists_[preftrk];
                std::vector<std::pair<int, int>> stubidsTrk2 = mergedstubidslists_[rejetrk];
                newStubidsList = stubidsTrk1;

                for (unsigned int stub2it = 0; stub2it < stubsTrk2.size(); stub2it++) {
                  if (find(stubsTrk1indices.begin(), stubsTrk1indices.end(), stubsTrk2indices[stub2it]) ==
                      stubsTrk1indices.end()) {
                    newStubidsList.push_back(stubidsTrk2[stub2it]);
                  }
                }
                // Overwrite stubidslist of preferred track with merged list
                mergedstubidslists_[preftrk] = newStubidsList;

                // Mark that rejected track has been merged into another track
                trackInfo[rejetrk].second = true;
              }
            }
          }
        }

        for (unsigned int ktrk = 0; ktrk < numStublists; ktrk++) {
          if ((trackInfo[ktrk].second != true) && (trackBinInfo[ktrk] != true)) {
            prefTracks.push_back(ktrk);
            prefTrackFit.push_back(trackInfo[ktrk].first);
            inputtrackletsall.push_back(inputtracklets_[ktrk]);
            inputstublistsall.push_back(inputstublists_[ktrk]);
            inputstubidslistsall.push_back(inputstubidslists_[ktrk]);
            mergedstubidslistsall.push_back(mergedstubidslists_[ktrk]);
          }
        }

        // Need to clear all the vectors which will be used in the next bin
        seedRank.clear();
        trackInfo.clear();
        trackBinInfo.clear();
        inputtracklets_.clear();
        inputstublists_.clear();
        inputstubidslists_.clear();
        mergedstubidslists_.clear();
      }
    }

    // Make the final track objects, fit with KF, and send to output
    for (unsigned int itrk = 0; itrk < prefTracks.size(); itrk++) {
      Tracklet* tracklet = inputtrackletsall[itrk];
      std::vector<const Stub*> trackstublist = inputstublistsall[itrk];

      // Run KF track fit
      HybridFit hybridFitter(iSector, settings_, globals_);
      hybridFitter.Fit(tracklet, trackstublist);

      // If the track was accepted (and thus fit), add to output
      if (tracklet->fit()) {
        // Add fitted Track to output (later converted to TTTrack)
        Track* outtrack = tracklet->getTrack();
        outtrack->setSector(iSector);
        // Also store fitted track as more detailed Tracklet object.
        outputtracklets_[prefTrackFit[itrk]]->addTrack(tracklet);

        // Add all tracks to standalone root file output
        outtrack->setStubIDpremerge(inputstubidslistsall[itrk]);
        outtrack->setStubIDprefit(mergedstubidslistsall[itrk]);
        outputtracks.push_back(*outtrack);
      }
    }
  }

#endif

  // Grid removal //
  if (settings_.removalType() == "grid") {
    // Sort tracks by ichisq/DoF so that removal will keep the lower ichisq/DoF track
    std::sort(inputtracks_.begin(), inputtracks_.end(), [](const Track* lhs, const Track* rhs) {
      return lhs->ichisq() / lhs->stubID().size() < rhs->ichisq() / rhs->stubID().size();
    });
    bool grid[35][40] = {{false}};

    for (unsigned int itrk = 0; itrk < numTrk; itrk++) {
      if (inputtracks_[itrk]->duplicate())
        edm::LogPrint("Tracklet") << "WARNING: Track already tagged as duplicate!!";

      double phiBin = (inputtracks_[itrk]->phi0(settings_) - 2 * M_PI / 27 * iSector) / (2 * M_PI / 9 / 50) + 9;
      phiBin = std::max(phiBin, 0.);
      phiBin = std::min(phiBin, 34.);

      double ptBin = 1 / inputtracks_[itrk]->pt(settings_) * 40 + 20;
      ptBin = std::max(ptBin, 0.);
      ptBin = std::min(ptBin, 39.);

      if (grid[(int)phiBin][(int)ptBin])
        inputtracks_[itrk]->setDuplicate(true);
      grid[(int)phiBin][(int)ptBin] = true;

      double phiTest = inputtracks_[itrk]->phi0(settings_) - 2 * M_PI / 27 * iSector;
      if (phiTest < -2 * M_PI / 27)
        edm::LogVerbatim("Tracklet") << "track phi too small!";
      if (phiTest > 2 * 2 * M_PI / 27)
        edm::LogVerbatim("Tracklet") << "track phi too big!";
    }
  }  // end grid removal

  // ichi + nstub removal //
  if (settings_.removalType() == "ichi" || settings_.removalType() == "nstub") {
    for (unsigned int itrk = 0; itrk < numTrk - 1; itrk++) {  // numTrk-1 since last track has no other to compare to

      // If primary track is a duplicate, it cannot veto any...move on
      if (inputtracks_[itrk]->duplicate() == 1)
        continue;

      unsigned int nStubP = 0;
      vector<unsigned int> nStubS(numTrk);
      vector<unsigned int> nShare(numTrk);
      // Get and count primary stubs
      std::map<int, int> stubsTrk1 = inputtracks_[itrk]->stubID();
      nStubP = stubsTrk1.size();

      for (unsigned int jtrk = itrk + 1; jtrk < numTrk; jtrk++) {
        // Skip duplicate tracks
        if (inputtracks_[jtrk]->duplicate() == 1)
          continue;

        // Get and count secondary stubs
        std::map<int, int> stubsTrk2 = inputtracks_[jtrk]->stubID();
        nStubS[jtrk] = stubsTrk2.size();

        // Count shared stubs
        for (auto& st : stubsTrk1) {
          if (stubsTrk2.find(st.first) != stubsTrk2.end()) {
            if (st.second == stubsTrk2[st.first])
              nShare[jtrk]++;
          }
        }
      }

      // Tag duplicates
      for (unsigned int jtrk = itrk + 1; jtrk < numTrk; jtrk++) {
        // Skip duplicate tracks
        if (inputtracks_[jtrk]->duplicate() == 1)
          continue;

        // Chi2 duplicate removal
        if (settings_.removalType() == "ichi") {
          if ((nStubP - nShare[jtrk] < settings_.minIndStubs()) ||
              (nStubS[jtrk] - nShare[jtrk] < settings_.minIndStubs())) {
            if ((int)inputtracks_[itrk]->ichisq() / (2 * inputtracks_[itrk]->stubID().size() - 4) >
                (int)inputtracks_[jtrk]->ichisq() / (2 * inputtracks_[itrk]->stubID().size() - 4)) {
              inputtracks_[itrk]->setDuplicate(true);
            } else if ((int)inputtracks_[itrk]->ichisq() / (2 * inputtracks_[itrk]->stubID().size() - 4) <=
                       (int)inputtracks_[jtrk]->ichisq() / (2 * inputtracks_[itrk]->stubID().size() - 4)) {
              inputtracks_[jtrk]->setDuplicate(true);
            } else {
              edm::LogVerbatim("Tracklet") << "Error: Didn't tag either track in duplicate pair.";
            }
          }
        }  // end ichi removal

        // nStub duplicate removal
        if (settings_.removalType() == "nstub") {
          if ((nStubP - nShare[jtrk] < settings_.minIndStubs()) && (nStubP < nStubS[jtrk])) {
            inputtracks_[itrk]->setDuplicate(true);
          } else if ((nStubS[jtrk] - nShare[jtrk] < settings_.minIndStubs()) && (nStubS[jtrk] <= nStubP)) {
            inputtracks_[jtrk]->setDuplicate(true);
          } else {
            edm::LogVerbatim("Tracklet") << "Error: Didn't tag either track in duplicate pair.";
          }
        }  // end nstub removal

      }  // end tag duplicates

    }  // end loop over primary track

  }  // end ichi + nstub removal

  //Add tracks to output
  if (settings_.removalType() != "merge") {
    for (unsigned int i = 0; i < inputtrackfits_.size(); i++) {
      for (unsigned int j = 0; j < inputtrackfits_[i]->nTracks(); j++) {
        if (inputtrackfits_[i]->getTrack(j)->getTrack()->duplicate() == 0) {
          if (settings_.writeMonitorData("Seeds")) {
            ofstream fout("seeds.txt", ofstream::app);
            fout << __FILE__ << ":" << __LINE__ << " " << name_ << "_" << iSector << " "
                 << inputtrackfits_[i]->getTrack(j)->getISeed() << endl;
            fout.close();
          }
          outputtracklets_[i]->addTrack(inputtrackfits_[i]->getTrack(j));
        }
        //For root file:
        outputtracks.push_back(*inputtrackfits_[i]->getTrack(j)->getTrack());
      }
    }
  }
}

findLayerDisk()

std::pair< int, int > PurgeDuplicate::findLayerDisk ( const Stub *  st ) const

private

Definition at line 603 of file PurgeDuplicate.cc.

References trklet::Stub::layerdisk(), and trklet::N_LAYER.

Referenced by getInventedCoords(), getInventedCoordsExtended(), and getInventedSeedingStub().

                                                                    {
  std::pair<int, int> layer_disk;
  layer_disk.first = st->layerdisk() + 1;
  if (layer_disk.first > N_LAYER) {
    layer_disk.first = 0;
  }
  layer_disk.second = st->layerdisk() - (N_LAYER - 1);
  if (layer_disk.second < 0) {
    layer_disk.second = 0;
  }
  return layer_disk;
}

findOverlapPhiBins()

std::vector< unsigned int > PurgeDuplicate::findOverlapPhiBins ( const Tracklet *  trk ) const

private

Definition at line 806 of file PurgeDuplicate.cc.

References mps_fire::i, trklet::Tracklet::phi0(), l1tTrackJets_cfi::phiBins, trklet::Settings::phiBins(), trklet::Settings::phiOverlapSize(), trklet::Settings::rcrit(), trklet::rinv(), trklet::Tracklet::rinv(), and trklet::ProcessBase::settings_.

Referenced by execute().

                                                                                    {
  double phi0 = trk->phi0();
  double rcrit = settings_.rcrit();
  double rinv = trk->rinv();
  double phi = phi0 - asin(0.5 * rinv * rcrit);

  const double phiOverlapSize = settings_.phiOverlapSize();
  const std::vector<double>& phiBins = settings_.phiBins();

  std::vector<unsigned int> chosenBins;
  for (long unsigned int i = 0; i < phiBins.size() - 1; i++) {
    if ((phi < phiBins[i + 1] + phiOverlapSize) && (phi > phiBins[i] - phiOverlapSize)) {
      chosenBins.push_back(i);
    }
  }
  return chosenBins;
}

findOverlapRinvBins()

std::vector< unsigned int > PurgeDuplicate::findOverlapRinvBins ( const Tracklet *  trk ) const

private

Definition at line 790 of file PurgeDuplicate.cc.

References mps_fire::i, trklet::rinv(), trklet::Tracklet::rinv(), trklet::Settings::rinvBins(), trklet::Settings::rinvOverlapSize(), and trklet::ProcessBase::settings_.

Referenced by execute().

                                                                                     {
  double rinv = trk->rinv();

  const double rinvOverlapSize = settings_.rinvOverlapSize();
  const std::vector<double>& rinvBins = settings_.rinvBins();

  std::vector<unsigned int> chosenBins;
  for (long unsigned int i = 0; i < rinvBins.size() - 1; i++) {
    if ((rinv < rinvBins[i + 1] + rinvOverlapSize) && (rinv > rinvBins[i] - rinvOverlapSize)) {
      chosenBins.push_back(i);
    }
  }
  return chosenBins;
}

findPhiBin()

unsigned int PurgeDuplicate::findPhiBin ( const Tracklet *  trk ) const

private

Definition at line 767 of file PurgeDuplicate.cc.

References trigObjTnPSource_cfi::bins, HLT_2023v12_cff::distance, trklet::Tracklet::phi0(), l1tTrackJets_cfi::phiBins, trklet::Settings::phiBins(), trklet::Settings::rcrit(), trklet::rinv(), trklet::Tracklet::rinv(), trklet::ProcessBase::settings_, and pfDeepBoostedJetPreprocessParams_cfi::upper_bound.

Referenced by execute().

                                                                 {
  std::vector<double> phiBins = settings_.phiBins();

  //Get phi of track at rcrit
  double phi0 = trk->phi0();
  double rcrit = settings_.rcrit();
  double rinv = trk->rinv();
  double phi = phi0 - asin(0.5 * rinv * rcrit);

  //Check between what 2 values in phibins phi is between
  auto bins = std::upper_bound(phiBins.begin(), phiBins.end(), phi);

  //return integer for bin index
  unsigned int phiIndx = std::distance(phiBins.begin(), bins);
  if (phiIndx == std::distance(phiBins.end(), bins))
    return phiBins.size() - 2;
  else if (bins == phiBins.begin())
    return std::distance(phiBins.begin(), bins);
  else
    return phiIndx - 1;
}

findRinvBin()

unsigned int PurgeDuplicate::findRinvBin ( const Tracklet *  trk ) const

private

Definition at line 747 of file PurgeDuplicate.cc.

References trigObjTnPSource_cfi::bins, HLT_2023v12_cff::distance, trklet::rinv(), trklet::Tracklet::rinv(), trklet::Settings::rinvBins(), trklet::ProcessBase::settings_, and pfDeepBoostedJetPreprocessParams_cfi::upper_bound.

Referenced by execute().

                                                                  {
  std::vector<double> rinvBins = settings_.rinvBins();

  //Get rinverse of track
  double rinv = trk->rinv();

  //Check between what 2 values in rinvbins rinv is between
  auto bins = std::upper_bound(rinvBins.begin(), rinvBins.end(), rinv);

  //return integer for bin index
  unsigned int rIndx = std::distance(rinvBins.begin(), bins);
  if (rIndx == std::distance(rinvBins.end(), bins))
    return rinvBins.size() - 2;
  else if (bins == rinvBins.begin())
    return std::distance(rinvBins.begin(), bins);
  else
    return rIndx - 1;
}

getInventedCoords()

std::vector< double > PurgeDuplicate::getInventedCoords ( unsigned int  iSector, const Stub *  st, const Tracklet *  tracklet  ) const

private

Definition at line 628 of file PurgeDuplicate.cc.

References funct::abs(), trklet::Tracklet::disk(), trklet::Settings::dphisector(), trklet::Settings::dphisectorHG(), findLayerDisk(), dqmdumpme::first, trklet::Stub::isBarrel(), trklet::Tracklet::phi0(), reco::reduceRange(), trklet::Tracklet::rinv(), trklet::Settings::rmean(), edm::second(), trklet::ProcessBase::settings_, funct::sin(), trklet::Tracklet::t(), trklet::Tracklet::z0(), and trklet::Settings::zmean().

Referenced by getInventedSeedingStub().

                                                                                      {
  int stubLayer = (findLayerDisk(st)).first;
  int stubDisk = (findLayerDisk(st)).second;

  double stub_phi = -99;
  double stub_z = -99;
  double stub_r = -99;

  double tracklet_rinv = tracklet->rinv();

  if (st->isBarrel()) {
    stub_r = settings_.rmean(stubLayer - 1);
    stub_phi = tracklet->phi0() - std::asin(stub_r * tracklet_rinv / 2);
    stub_phi = stub_phi + iSector * settings_.dphisector() - 0.5 * settings_.dphisectorHG();
    stub_phi = reco::reduceRange(stub_phi);
    stub_z = tracklet->z0() + 2 * tracklet->t() * 1 / tracklet_rinv * std::asin(stub_r * tracklet_rinv / 2);
  } else {
    stub_z = settings_.zmean(stubDisk - 1) * tracklet->disk() / abs(tracklet->disk());
    stub_phi = tracklet->phi0() - (stub_z - tracklet->z0()) * tracklet_rinv / 2 / tracklet->t();
    stub_phi = stub_phi + iSector * settings_.dphisector() - 0.5 * settings_.dphisectorHG();
    stub_phi = reco::reduceRange(stub_phi);
    stub_r = 2 / tracklet_rinv * std::sin((stub_z - tracklet->z0()) * tracklet_rinv / 2 / tracklet->t());
  }

  std::vector<double> invented_coords{stub_r, stub_z, stub_phi};
  return invented_coords;
}

getInventedCoordsExtended()

std::vector< double > PurgeDuplicate::getInventedCoordsExtended ( unsigned int  iSector, const Stub *  st, const Tracklet *  tracklet  ) const

private

Definition at line 658 of file PurgeDuplicate.cc.

References funct::abs(), HLT_2023v12_cff::beta, funct::cos(), trklet::Tracklet::d0(), trklet::Tracklet::disk(), trklet::Settings::dphisector(), trklet::Settings::dphisectorHG(), findLayerDisk(), dqmdumpme::first, trklet::Stub::isBarrel(), trklet::Stub::l1tstub(), trklet::L1TStub::phi(), trklet::Tracklet::phi0(), trklet::L1TStub::r(), reco::reduceRange(), trklet::Tracklet::rinv(), trklet::Settings::rmean(), edm::second(), fileCollector::seed, trklet::Tracklet::seedIndex(), trklet::ProcessBase::settings_, mathSSE::sqrt(), trklet::Tracklet::t(), trklet::L1TStub::z(), trklet::Tracklet::z0(), and trklet::Settings::zmean().

Referenced by getInventedSeedingStub().

                                                                                              {
  int stubLayer = (findLayerDisk(st)).first;
  int stubDisk = (findLayerDisk(st)).second;

  double stub_phi = -99;
  double stub_z = -99;
  double stub_r = -99;

  double rho = 1 / tracklet->rinv();
  double rho_minus_d0 = rho + tracklet->d0();  // should be -, but otherwise does not work

  // exact helix
  if (st->isBarrel()) {
    stub_r = settings_.rmean(stubLayer - 1);

    double sin_val = (stub_r * stub_r + rho_minus_d0 * rho_minus_d0 - rho * rho) / (2 * stub_r * rho_minus_d0);
    stub_phi = tracklet->phi0() - std::asin(sin_val);
    stub_phi = stub_phi + iSector * settings_.dphisector() - 0.5 * settings_.dphisectorHG();
    stub_phi = reco::reduceRange(stub_phi);

    double beta = std::acos((rho * rho + rho_minus_d0 * rho_minus_d0 - stub_r * stub_r) / (2 * rho * rho_minus_d0));
    stub_z = tracklet->z0() + tracklet->t() * std::abs(rho * beta);
  } else {
    stub_z = settings_.zmean(stubDisk - 1) * tracklet->disk() / abs(tracklet->disk());

    double beta = (stub_z - tracklet->z0()) / (tracklet->t() * std::abs(rho));  // maybe rho should be abs value
    double r_square = -2 * rho * rho_minus_d0 * std::cos(beta) + rho * rho + rho_minus_d0 * rho_minus_d0;
    stub_r = sqrt(r_square);

    double sin_val = (stub_r * stub_r + rho_minus_d0 * rho_minus_d0 - rho * rho) / (2 * stub_r * rho_minus_d0);
    stub_phi = tracklet->phi0() - std::asin(sin_val);
    stub_phi = stub_phi + iSector * settings_.dphisector() - 0.5 * settings_.dphisectorHG();
    stub_phi = reco::reduceRange(stub_phi);
  }

  // TMP: for displaced tracking, exclude one of the 3 seeding stubs
  // to be discussed
  int seed = tracklet->seedIndex();
  if ((seed == 8 && stubLayer == 4) || (seed == 9 && stubLayer == 5) || (seed == 10 && stubLayer == 3) ||
      (seed == 11 && abs(stubDisk) == 1)) {
    stub_phi = st->l1tstub()->phi();
    stub_z = st->l1tstub()->z();
    stub_r = st->l1tstub()->r();
  }

  std::vector<double> invented_coords{stub_r, stub_z, stub_phi};
  return invented_coords;
}

getInventedSeedingStub()

std::vector< const Stub * > PurgeDuplicate::getInventedSeedingStub ( unsigned int  iSector, const Tracklet *  tracklet, const std::vector< const Stub *> &  originalStubsList  ) const

private

Definition at line 709 of file PurgeDuplicate.cc.

References trklet::L1TStub::allStubIndex(), funct::cos(), trklet::Settings::extended(), findLayerDisk(), dqmdumpme::first, getInventedCoords(), getInventedCoordsExtended(), isSeedingStub(), trklet::Stub::l1tstub(), edm::second(), trklet::Tracklet::seedIndex(), trklet::L1TStub::setAllStubIndex(), trklet::L1TStub::setCoords(), trklet::Stub::setl1tstub(), trklet::ProcessBase::settings_, trklet::L1TStub::setUniqueIndex(), funct::sin(), and trklet::L1TStub::uniqueIndex().

Referenced by execute().

                                                                                                           {
  std::vector<const Stub*> newStubList;

  for (unsigned int stubit = 0; stubit < originalStubsList.size(); stubit++) {
    const Stub* thisStub = originalStubsList[stubit];

    if (isSeedingStub(tracklet->seedIndex(), (findLayerDisk(thisStub)).first, (findLayerDisk(thisStub)).second)) {
      // get a vector containing r, z, phi
      std::vector<double> inv_r_z_phi;
      if (!settings_.extended())
        inv_r_z_phi = getInventedCoords(iSector, thisStub, tracklet);
      else {
        inv_r_z_phi = getInventedCoordsExtended(iSector, thisStub, tracklet);
      }
      double stub_x_invent = inv_r_z_phi[0] * std::cos(inv_r_z_phi[2]);
      double stub_y_invent = inv_r_z_phi[0] * std::sin(inv_r_z_phi[2]);
      double stub_z_invent = inv_r_z_phi[1];

      Stub* invent_stub_ptr = new Stub(*thisStub);
      const L1TStub* l1stub = thisStub->l1tstub();
      L1TStub invent_l1stub = *l1stub;
      invent_l1stub.setCoords(stub_x_invent, stub_y_invent, stub_z_invent);

      invent_stub_ptr->setl1tstub(new L1TStub(invent_l1stub));
      invent_stub_ptr->l1tstub()->setAllStubIndex(l1stub->allStubIndex());
      invent_stub_ptr->l1tstub()->setUniqueIndex(l1stub->uniqueIndex());

      newStubList.push_back(invent_stub_ptr);

    } else {
      newStubList.push_back(thisStub);
    }
  }
  return newStubList;
}

getPhiRes()

double PurgeDuplicate::getPhiRes ( Tracklet *  curTracklet, const Stub *  curStub  ) const

private

Definition at line 559 of file PurgeDuplicate.cc.

References funct::abs(), isSeedingStub(), trklet::Stub::l1tstub(), trklet::Stub::layerdisk(), trklet::N_LAYER, trklet::L1TStub::phi(), trklet::Tracklet::proj(), and trklet::Tracklet::seedIndex().

Referenced by execute().

                                                                                 {
  double phiproj;
  double stubphi;
  double phires;
  // Get phi position of stub
  stubphi = curStub->l1tstub()->phi();
  // Get layer that the stub is in (Layer 1->6, Disk 1->5)
  int Layer = curStub->layerdisk() + 1;
  if (Layer > N_LAYER) {
    Layer = 0;
  }
  int Disk = curStub->layerdisk() - (N_LAYER - 1);
  if (Disk < 0) {
    Disk = 0;
  }
  // Get phi projection of tracklet
  int seedindex = curTracklet->seedIndex();
  // If this stub is a seed stub, set projection=phi, so that res=0
  if (isSeedingStub(seedindex, Layer, Disk)) {
    phiproj = stubphi;
    // Otherwise, get projection of tracklet
  } else {
    phiproj = curTracklet->proj(curStub->layerdisk()).phiproj();
  }
  // Calculate residual
  phires = std::abs(stubphi - phiproj);
  return phires;
}

isSeedingStub()

bool PurgeDuplicate::isSeedingStub ( int  seedindex, int  Layer, int  Disk  ) const

private

Definition at line 588 of file PurgeDuplicate.cc.

References funct::abs().

Referenced by getInventedSeedingStub(), and getPhiRes().

                                                                           {
  if ((seedindex == 0 && (Layer == 1 || Layer == 2)) || (seedindex == 1 && (Layer == 2 || Layer == 3)) ||
      (seedindex == 2 && (Layer == 3 || Layer == 4)) || (seedindex == 3 && (Layer == 5 || Layer == 6)) ||
      (seedindex == 4 && (abs(Disk) == 1 || abs(Disk) == 2)) ||
      (seedindex == 5 && (abs(Disk) == 3 || abs(Disk) == 4)) || (seedindex == 6 && (Layer == 1 || abs(Disk) == 1)) ||
      (seedindex == 7 && (Layer == 2 || abs(Disk) == 1)) ||
      (seedindex == 8 && (Layer == 2 || Layer == 3 || Layer == 4)) ||
      (seedindex == 9 && (Layer == 4 || Layer == 5 || Layer == 6)) ||
      (seedindex == 10 && (Layer == 2 || Layer == 3 || abs(Disk) == 1)) ||
      (seedindex == 11 && (Layer == 2 || abs(Disk) == 1 || abs(Disk) == 2)))
    return true;

  return false;
}

isTrackInBin()

bool PurgeDuplicate::isTrackInBin ( const std::vector< unsigned int > &  vec, unsigned int  num  ) const

private

Definition at line 825 of file PurgeDuplicate.cc.

References spr::find(), newFWLiteAna::found, EgammaValidation_cff::num, and mps_fire::result.

Referenced by execute().

                                                                                            {
  auto result = std::find(vec.begin(), vec.end(), num);
  bool found = (result != vec.end());
  return found;
}

l1tinfo()

std::string PurgeDuplicate::l1tinfo ( const L1TStub *  l1stub, std::string  str = ""  ) const

private

Definition at line 616 of file PurgeDuplicate.cc.

References trklet::L1TStub::bend(), trklet::L1TStub::iphi(), trklet::L1TStub::layerdisk(), trklet::L1TStub::phi(), trklet::L1TStub::r(), str, AlCaHLTBitMon_QueryRunRegistry::string, and trklet::L1TStub::z().

                                                                                 {
  std::string thestr = Form("\t %s stub info:  r/z/phi:\t%f\t%f\t%f\t%d\t%f\t%d",
                            str.c_str(),
                            l1stub->r(),
                            l1stub->z(),
                            l1stub->phi(),
                            l1stub->iphi(),
                            l1stub->bend(),
                            l1stub->layerdisk());
  return thestr;
}

Member Data Documentation

inputstubidslists_

std::vector<std::vector<std::pair<int, int> > > trklet::PurgeDuplicate::inputstubidslists_

private

Definition at line 64 of file PurgeDuplicate.h.

Referenced by execute().

inputstublists_

std::vector<std::vector<const Stub*> > trklet::PurgeDuplicate::inputstublists_

private

Definition at line 63 of file PurgeDuplicate.h.

Referenced by execute().

inputtrackfits_

std::vector<TrackFitMemory*> trklet::PurgeDuplicate::inputtrackfits_

private

Definition at line 66 of file PurgeDuplicate.h.

Referenced by addInput(), and execute().

inputtracklets_

std::vector<Tracklet*> trklet::PurgeDuplicate::inputtracklets_

private

Definition at line 67 of file PurgeDuplicate.h.

Referenced by execute().

inputtracks_

std::vector<Track*> trklet::PurgeDuplicate::inputtracks_

private

Definition at line 62 of file PurgeDuplicate.h.

Referenced by execute().

mergedstubidslists_

std::vector<std::vector<std::pair<int, int> > > trklet::PurgeDuplicate::mergedstubidslists_

private

Definition at line 65 of file PurgeDuplicate.h.

Referenced by execute().

outputtracklets_

std::vector<CleanTrackMemory*> trklet::PurgeDuplicate::outputtracklets_

private

Definition at line 68 of file PurgeDuplicate.h.

Referenced by addOutput(), and execute().