PseudoBayesGrouping Class Reference

#include <PseudoBayesGrouping.h>

Inheritance diagram for PseudoBayesGrouping:

Classes
struct	CandPointGreat

Public Member Functions
void	finish () override
void	initialise (const edm::EventSetup &iEventSetup) override
	PseudoBayesGrouping (const edm::ParameterSet &pset, edm::ConsumesCollector &iC)
void	run (edm::Event &iEvent, const edm::EventSetup &iEventSetup, const DTDigiCollection &digis, MuonPathPtrs &outMpath) override
	~PseudoBayesGrouping () override
Public Member Functions inherited from MotherGrouping
	MotherGrouping (const edm::ParameterSet &pset, edm::ConsumesCollector &iC)
virtual	~MotherGrouping ()

Private Member Functions
void	CleanDigisByLayer ()
void	FillDigisByLayer (const DTDigiCollection *digis)
void	FillMuonPaths (MuonPathPtrs &mpaths)
void	LoadPattern (std::vector< std::vector< std::vector< int >>>::iterator itPattern)
void	ReCleanPatternsAndDigis ()
void	RecognisePatterns (std::vector< DTPrimitive > digisinLDown, std::vector< DTPrimitive > digisinLUp, std::vector< DTPattern * > patterns)
void	RecognisePatternsByLayerPairs ()

Private Attributes
std::vector< DTPrimitive >	alldigis_
std::unique_ptr< dtbayesam::CandidateGroupPtrs >	allMatches_
bool	allowDuplicates_
int	allowedVariance_
bool	allowUncorrelatedPatterns_
std::vector< DTPattern * >	allPatterns_
bool	debug_
std::vector< DTPrimitive >	digisinL0_
std::vector< DTPrimitive >	digisinL1_
std::vector< DTPrimitive >	digisinL2_
std::vector< DTPrimitive >	digisinL3_
std::vector< DTPrimitive >	digisinL4_
std::vector< DTPrimitive >	digisinL5_
std::vector< DTPrimitive >	digisinL6_
std::vector< DTPrimitive >	digisinL7_
std::unique_ptr< dtbayesam::CandidateGroupPtrs >	finalMatches_
std::vector< DTPattern * >	L0L1Patterns_
std::vector< DTPattern * >	L0L2Patterns_
std::vector< DTPattern * >	L0L3Patterns_
std::vector< DTPattern * >	L0L4Patterns_
std::vector< DTPattern * >	L0L5Patterns_
std::vector< DTPattern * >	L0L6Patterns_
std::vector< DTPattern * >	L0L7Patterns_
std::vector< DTPattern * >	L1L2Patterns_
std::vector< DTPattern * >	L1L3Patterns_
std::vector< DTPattern * >	L1L4Patterns_
std::vector< DTPattern * >	L1L5Patterns_
std::vector< DTPattern * >	L1L6Patterns_
std::vector< DTPattern * >	L1L7Patterns_
std::vector< DTPattern * >	L2L3Patterns_
std::vector< DTPattern * >	L2L4Patterns_
std::vector< DTPattern * >	L2L5Patterns_
std::vector< DTPattern * >	L2L6Patterns_
std::vector< DTPattern * >	L2L7Patterns_
std::vector< DTPattern * >	L3L4Patterns_
std::vector< DTPattern * >	L3L5Patterns_
std::vector< DTPattern * >	L3L6Patterns_
std::vector< DTPattern * >	L3L7Patterns_
std::vector< DTPattern * >	L4L5Patterns_
std::vector< DTPattern * >	L4L6Patterns_
std::vector< DTPattern * >	L4L7Patterns_
std::vector< DTPattern * >	L5L6Patterns_
std::vector< DTPattern * >	L5L7Patterns_
std::vector< DTPattern * >	L6L7Patterns_
int	minNLayerHits_
int	minSingleSLHitsMax_
int	minSingleSLHitsMin_
int	minUncorrelatedHits_
int	nPatterns_
std::string	pattern_filename_
int	pidx_
std::unique_ptr< dtbayesam::CandidateGroupPtrs >	prelimMatches_
bool	saveOnPlace_
bool	setLateralities_

Detailed Description

Definition at line 11 of file PseudoBayesGrouping.h.

Constructor & Destructor Documentation

PseudoBayesGrouping()

PseudoBayesGrouping::PseudoBayesGrouping	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector &	iC
	)

Definition at line 18 of file PseudoBayesGrouping.cc.

    : MotherGrouping(pset, iC) {
  // Obtention of parameters
  debug_ = pset.getUntrackedParameter<bool>("debug");
  pattern_filename_ = pset.getUntrackedParameter<edm::FileInPath>("pattern_filename").fullPath();
  minNLayerHits_ = pset.getUntrackedParameter<int>("minNLayerHits");
  minSingleSLHitsMax_ = pset.getUntrackedParameter<int>("minSingleSLHitsMax");
  minSingleSLHitsMin_ = pset.getUntrackedParameter<int>("minSingleSLHitsMin");
  allowedVariance_ = pset.getUntrackedParameter<int>("allowedVariance");
  allowDuplicates_ = pset.getUntrackedParameter<bool>("allowDuplicates");
  allowUncorrelatedPatterns_ = pset.getUntrackedParameter<bool>("allowUncorrelatedPatterns");
  minUncorrelatedHits_ = pset.getUntrackedParameter<int>("minUncorrelatedHits");
  saveOnPlace_ = pset.getUntrackedParameter<bool>("saveOnPlace");
  setLateralities_ = pset.getUntrackedParameter<bool>("setLateralities");
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping:: constructor";
}

References allowDuplicates_, allowedVariance_, allowUncorrelatedPatterns_, debug_, contentValuesFiles::fullPath, LogDebug, minNLayerHits_, minSingleSLHitsMax_, minSingleSLHitsMin_, minUncorrelatedHits_, pattern_filename_, muonDTDigis_cfi::pset, saveOnPlace_, and setLateralities_.

~PseudoBayesGrouping()

PseudoBayesGrouping::~PseudoBayesGrouping ( )

override

Definition at line 36 of file PseudoBayesGrouping.cc.

                                          {
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping:: destructor";
  for (std::vector<DTPattern*>::iterator pat_it = allPatterns_.begin(); pat_it != allPatterns_.end(); pat_it++) {
    delete (*pat_it);
  }
}

References allPatterns_, debug_, and LogDebug.

Member Function Documentation

CleanDigisByLayer()

void PseudoBayesGrouping::CleanDigisByLayer ( )

private

Definition at line 453 of file PseudoBayesGrouping.cc.

                                            {
  digisinL0_.clear();
  digisinL1_.clear();
  digisinL2_.clear();
  digisinL3_.clear();
  digisinL4_.clear();
  digisinL5_.clear();
  digisinL6_.clear();
  digisinL7_.clear();
  alldigis_.clear();
  allMatches_->clear();
  prelimMatches_->clear();
  finalMatches_->clear();
}

References alldigis_, allMatches_, digisinL0_, digisinL1_, digisinL2_, digisinL3_, digisinL4_, digisinL5_, digisinL6_, digisinL7_, finalMatches_, and prelimMatches_.

Referenced by run().

FillDigisByLayer()

void PseudoBayesGrouping::FillDigisByLayer ( const DTDigiCollection *  digis )

private

Definition at line 368 of file PseudoBayesGrouping.cc.

                                                                        {
  //First we need to have separated lists of digis by layer
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::FillDigisByLayer Classifying digis by layer";
  //  for (auto dtDigi_It = digis->begin(); dtDigi_It != digis->end(); dtDigi_It++) {
  for (const auto& dtDigi_It : *digis) {
    const DTLayerId dtLId = dtDigi_It.first;
    //Skip digis in SL theta which we are not interested on for the grouping
    for (auto digiIt = (dtDigi_It.second).first; digiIt != (dtDigi_It.second).second; digiIt++) {
      //Need to change notation slightly here
      if (dtLId.superlayer() == 2)
        continue;
      int layer = dtLId.layer() - 1;
      if (dtLId.superlayer() == 3)
        layer += 4;
      //Use the same format as for InitialGrouping to avoid tons of replicating classes, we will have some not used variables
      DTPrimitive dtpAux = DTPrimitive();
      dtpAux.setTDCTimeStamp(digiIt->time());
      dtpAux.setChannelId(digiIt->wire() - 1);
      dtpAux.setLayerId(layer);
      dtpAux.setSuperLayerId(dtLId.superlayer());
      dtpAux.setCameraId(dtLId.rawId());
      if (debug_)
        LogDebug("PseudoBayesGrouping") << "Hit in L " << layer << " SL " << dtLId.superlayer() << " WIRE "
                                        << digiIt->wire() - 1;
      if (layer == 0)
        digisinL0_.push_back(dtpAux);
      else if (layer == 1)
        digisinL1_.push_back(dtpAux);
      else if (layer == 2)
        digisinL2_.push_back(dtpAux);
      else if (layer == 3)
        digisinL3_.push_back(dtpAux);
      else if (layer == 4)
        digisinL4_.push_back(dtpAux);
      else if (layer == 5)
        digisinL5_.push_back(dtpAux);
      else if (layer == 6)
        digisinL6_.push_back(dtpAux);
      else if (layer == 7)
        digisinL7_.push_back(dtpAux);
      alldigis_.push_back(dtpAux);
    }
  }
}

References alldigis_, debug_, digisinL0_, digisinL1_, digisinL2_, digisinL3_, digisinL4_, digisinL5_, digisinL6_, digisinL7_, DTLayerId::layer(), LogDebug, DetId::rawId(), DTPrimitive::setCameraId(), DTPrimitive::setChannelId(), DTPrimitive::setLayerId(), DTPrimitive::setSuperLayerId(), DTPrimitive::setTDCTimeStamp(), and DTSuperLayerId::superlayer().

Referenced by run().

FillMuonPaths()

void PseudoBayesGrouping::FillMuonPaths ( MuonPathPtrs &  mpaths )

private

Definition at line 212 of file PseudoBayesGrouping.cc.

                                                            {
  //Loop over all selected candidates
  for (auto itCand = finalMatches_->begin(); itCand != finalMatches_->end(); itCand++) {
    if (debug_)
      LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run Create pointers ";
    DTPrimitivePtrs ptrPrimitive;
    for (int i = 0; i < 8; i++)
      ptrPrimitive.push_back(std::make_shared<DTPrimitive>());
 
    qualitybits qualityDTP;
    int intHit = 0;
    //And for each candidate loop over all grouped hits
    for (auto& itDTP : (*itCand)->candHits()) {
      if (debug_)
        LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run loop over dt hits to fill pointer";
 
      int layerHit = (*itDTP).layerId();
      //Back to the usual basis for SL
      if (layerHit >= 4) {
        (*itDTP).setLayerId(layerHit - 4);
      }
      qualitybits ref8Hit(std::pow(2, layerHit));
      //Get the predicted laterality
      if (setLateralities_) {
        int predLat = (*itCand)->pattern()->latHitIn(layerHit, (*itDTP).channelId(), allowedVariance_);
        if (predLat == -10 || predLat == 0) {
          (*itDTP).setLaterality(NONE);
        } else if (predLat == -1) {
          (*itDTP).setLaterality(LEFT);
        } else if (predLat == +1) {
          (*itDTP).setLaterality(RIGHT);
        }
      }
      //Only fill the DT primitives pointer if there is not one hit already in the layer
      if (qualityDTP != (qualityDTP | ref8Hit)) {
        if (debug_)
          LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run Adding hit to muon path";
        qualityDTP = (qualityDTP | ref8Hit);
        if (saveOnPlace_) {
          //This will save the primitive in a place of the vector equal to its L position
          ptrPrimitive.at(layerHit) = std::make_shared<DTPrimitive>((*itDTP));
        }
        if (!saveOnPlace_) {
          //This will save the primitive in order
          intHit++;
          ptrPrimitive.at(intHit) = std::make_shared<DTPrimitive>((*itDTP));
        }
      }
    }
    //Now, if there are empty spaces in the vector fill them full of daylight
    int ipow = 1;
    for (int i = 0; i <= 7; i++) {
      ipow *= 2;
      if (qualityDTP != (qualityDTP | qualitybits(1 << i))) {
        ptrPrimitive.at(i) = std::make_shared<DTPrimitive>();
      }
    }
 
    mpaths.emplace_back(
        std::make_shared<MuonPath>(ptrPrimitive, (short)(*itCand)->nLayerUp(), (short)(*itCand)->nLayerDown()));
  }
}

References allowedVariance_, debug_, finalMatches_, mps_fire::i, cmsdt::LEFT, LogDebug, NONE, funct::pow(), cmsdt::RIGHT, saveOnPlace_, and setLateralities_.

Referenced by run().

finish()

void PseudoBayesGrouping::finish ( )

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 468 of file PseudoBayesGrouping.cc.

                                 {
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping: finish";
};

References debug_, and LogDebug.

Referenced by progressbar.ProgressBar::__next__().

initialise()

void PseudoBayesGrouping::initialise ( const edm::EventSetup &  iEventSetup )

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 47 of file PseudoBayesGrouping.cc.

                                                                     {
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::initialiase";
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::initialiase using patterns file " << pattern_filename_;
  nPatterns_ = 0;
  //Load patterns from pattern root file with expected hits information
  TFile* f = TFile::Open(TString(pattern_filename_), "READ");
  std::vector<std::vector<std::vector<int>>>* pattern_reader =
      (std::vector<std::vector<std::vector<int>>>*)f->Get("allPatterns");
  for (std::vector<std::vector<std::vector<int>>>::iterator itPattern = (*pattern_reader).begin();
       itPattern != (*pattern_reader).end();
       ++itPattern) {
    //Loops over all patterns in the loop and constructs the Pattern object for each one
    LoadPattern(itPattern);
  }
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::initialiase Total number of loaded patterns: "
                                    << nPatterns_;
  f->Close();
  delete f;
 
  prelimMatches_ = std::make_unique<CandidateGroupPtrs>();
  allMatches_ = std::make_unique<CandidateGroupPtrs>();
  finalMatches_ = std::make_unique<CandidateGroupPtrs>();
}

References allMatches_, debug_, f, finalMatches_, LoadPattern(), LogDebug, nPatterns_, pattern_filename_, and prelimMatches_.

LoadPattern()

void PseudoBayesGrouping::LoadPattern ( std::vector< std::vector< std::vector< int >>>::iterator  itPattern )

private

Definition at line 74 of file PseudoBayesGrouping.cc.

                                                                                            {
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::LoadPattern Loading patterns seeded by: "
                                    << itPattern->at(0).at(0) << ", " << itPattern->at(0).at(1) << ", "
                                    << itPattern->at(0).at(2) << ", ";
 
  DTPattern p;
  //  for (auto itHits = itPattern->begin(); itHits != itPattern->end(); ++itHits) {
  bool is_seed = true;
  for (const auto& itHits : *itPattern) {
    //First entry is the seeding information
    if (is_seed) {
      p = DTPattern(itHits.at(0), itHits.at(1), itHits.at(2));
      is_seed = false;
    }
    //Other entries are the hits information
    else {
      if (itHits.begin() == itHits.end())
        continue;
      //We need to correct the geometry from pattern generation to reconstruction as they use slightly displaced basis
      else if (itHits.at(0) % 2 == 0) {
        p.addHit(std::make_tuple(itHits.at(0), itHits.at(1), itHits.at(2)));
      } else if (itHits.at(0) % 2 == 1) {
        p.addHit(std::make_tuple(itHits.at(0), itHits.at(1) - 1, itHits.at(2)));
      }
    }
  }
  //Classified by seeding layers for optimized search later
  //TODO::This can be vastly improved using std::bitset<8>, for example
  if (p.sl1() == 0) {
    if (p.sl2() == 7)
      L0L7Patterns_.push_back(&p);
    if (p.sl2() == 6)
      L0L6Patterns_.push_back(&p);
    if (p.sl2() == 5)
      L0L5Patterns_.push_back(&p);
    if (p.sl2() == 4)
      L0L4Patterns_.push_back(&p);
    if (p.sl2() == 3)
      L0L3Patterns_.push_back(&p);
    if (p.sl2() == 2)
      L0L2Patterns_.push_back(&p);
    if (p.sl2() == 1)
      L0L1Patterns_.push_back(&p);
  }
  if (p.sl1() == 1) {
    if (p.sl2() == 7)
      L1L7Patterns_.push_back(&p);
    if (p.sl2() == 6)
      L1L6Patterns_.push_back(&p);
    if (p.sl2() == 5)
      L1L5Patterns_.push_back(&p);
    if (p.sl2() == 4)
      L1L4Patterns_.push_back(&p);
    if (p.sl2() == 3)
      L1L3Patterns_.push_back(&p);
    if (p.sl2() == 2)
      L1L2Patterns_.push_back(&p);
  }
  if (p.sl1() == 2) {
    if (p.sl2() == 7)
      L2L7Patterns_.push_back(&p);
    if (p.sl2() == 6)
      L2L6Patterns_.push_back(&p);
    if (p.sl2() == 5)
      L2L5Patterns_.push_back(&p);
    if (p.sl2() == 4)
      L2L4Patterns_.push_back(&p);
    if (p.sl2() == 3)
      L2L3Patterns_.push_back(&p);
  }
  if (p.sl1() == 3) {
    if (p.sl2() == 7)
      L3L7Patterns_.push_back(&p);
    if (p.sl2() == 6)
      L3L6Patterns_.push_back(&p);
    if (p.sl2() == 5)
      L3L5Patterns_.push_back(&p);
    if (p.sl2() == 4)
      L3L4Patterns_.push_back(&p);
  }
 
  if (p.sl1() == 4) {
    if (p.sl2() == 7)
      L4L7Patterns_.push_back(&p);
    if (p.sl2() == 6)
      L4L6Patterns_.push_back(&p);
    if (p.sl2() == 5)
      L4L5Patterns_.push_back(&p);
  }
  if (p.sl1() == 5) {
    if (p.sl2() == 7)
      L5L7Patterns_.push_back(&p);
    if (p.sl2() == 6)
      L5L6Patterns_.push_back(&p);
  }
  if (p.sl1() == 6) {
    if (p.sl2() == 7)
      L6L7Patterns_.push_back(&p);
  }
  //Also creating a list of all patterns, needed later for deleting and avoid a memory leak
  allPatterns_.push_back(&p);
  nPatterns_++;
}

References allPatterns_, debug_, L0L1Patterns_, L0L2Patterns_, L0L3Patterns_, L0L4Patterns_, L0L5Patterns_, L0L6Patterns_, L0L7Patterns_, L1L2Patterns_, L1L3Patterns_, L1L4Patterns_, L1L5Patterns_, L1L6Patterns_, L1L7Patterns_, L2L3Patterns_, L2L4Patterns_, L2L5Patterns_, L2L6Patterns_, L2L7Patterns_, L3L4Patterns_, L3L5Patterns_, L3L6Patterns_, L3L7Patterns_, L4L5Patterns_, L4L6Patterns_, L4L7Patterns_, L5L6Patterns_, L5L7Patterns_, L6L7Patterns_, LogDebug, nPatterns_, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by initialise().

ReCleanPatternsAndDigis()

void PseudoBayesGrouping::ReCleanPatternsAndDigis ( )

private

Definition at line 414 of file PseudoBayesGrouping.cc.

                                                  {
  //GhostbustPatterns that share hits and are of lower quality
  if (prelimMatches_->empty()) {
    return;
  };
  while ((prelimMatches_->at(0)->nLayerhits() >= minNLayerHits_ &&
          (prelimMatches_->at(0)->nLayerUp() >= minSingleSLHitsMax_ ||
           prelimMatches_->at(0)->nLayerDown() >= minSingleSLHitsMax_) &&
          (prelimMatches_->at(0)->nLayerUp() >= minSingleSLHitsMin_ &&
           prelimMatches_->at(0)->nLayerDown() >= minSingleSLHitsMin_)) ||
         (allowUncorrelatedPatterns_ &&
          ((prelimMatches_->at(0)->nLayerUp() >= minUncorrelatedHits_ && prelimMatches_->at(0)->nLayerDown() == 0) ||
           (prelimMatches_->at(0)->nLayerDown() >= minUncorrelatedHits_ && prelimMatches_->at(0)->nLayerUp() == 0)))) {
    finalMatches_->push_back(prelimMatches_->at(0));
    auto itSel = finalMatches_->end() - 1;
    prelimMatches_->erase(prelimMatches_->begin());
    if (prelimMatches_->empty()) {
      return;
    };
    for (auto cand_it = prelimMatches_->begin(); cand_it != prelimMatches_->end(); cand_it++) {
      if (*(*cand_it) == *(*itSel) && allowDuplicates_)
        continue;
      for (const auto& dt_it : (*itSel)->candHits()) {  //.begin(); dt_it != (*itSel)->candHits().end(); dt_it++) {
        (*cand_it)->removeHit((*dt_it));
      }
    }
 
    std::sort(prelimMatches_->begin(), prelimMatches_->end(), CandPointGreat());
    if (debug_) {
      LogDebug("PseudoBayesGrouping") << "Pattern qualities: ";
      for (const auto& cand_it : *prelimMatches_) {
        LogDebug("PseudoBayesGrouping") << cand_it->nLayerhits() << ", " << cand_it->nisGood() << ", "
                                        << cand_it->nhits() << ", " << cand_it->quality() << ", " << cand_it->candId()
                                        << "\n";
      }
    }
  }
}

References allowDuplicates_, allowUncorrelatedPatterns_, debug_, finalMatches_, LogDebug, minNLayerHits_, minSingleSLHitsMax_, minSingleSLHitsMin_, minUncorrelatedHits_, and prelimMatches_.

Referenced by run().

RecognisePatterns()

void PseudoBayesGrouping::RecognisePatterns ( std::vector< DTPrimitive >  digisinLDown, std::vector< DTPrimitive >  digisinLUp, std::vector< DTPattern * >  patterns  )

private

Definition at line 317 of file PseudoBayesGrouping.cc.

                                                                            {
  //Loop over all hits and search for matching patterns (there will be four
  // amongst ~60, accounting for possible lateralities)
  for (auto dtPD_it = digisinLDown.begin(); dtPD_it != digisinLDown.end(); dtPD_it++) {
    int LDown = dtPD_it->layerId();
    int wireDown = dtPD_it->channelId();
    for (auto dtPU_it = digisinLUp.begin(); dtPU_it != digisinLUp.end(); dtPU_it++) {
      int LUp = dtPU_it->layerId();
      int wireUp = dtPU_it->channelId();
      int diff = wireUp - wireDown;
      for (auto pat_it = patterns.begin(); pat_it != patterns.end(); pat_it++) {
        //For each pair of hits in the layers search for the seeded patterns
        if ((*pat_it)->sl1() != (LDown) || (*pat_it)->sl2() != (LUp) || (*pat_it)->diff() != diff)
          continue;
        //If we are here a pattern was found and we can start comparing
        (*pat_it)->setHitDown(wireDown);
        auto cand = std::make_shared<CandidateGroup>(*pat_it);
        for (auto dtTest_it = alldigis_.begin(); dtTest_it != alldigis_.end(); dtTest_it++) {
          //Find hits matching to the pattern
          if (((*pat_it)->latHitIn(dtTest_it->layerId(), dtTest_it->channelId(), allowedVariance_)) != -999) {
            if (((*pat_it)->latHitIn(dtTest_it->layerId(), dtTest_it->channelId(), allowedVariance_)) == -10)
              cand->addHit((*dtTest_it), dtTest_it->layerId(), false);
            else
              cand->addHit((*dtTest_it), dtTest_it->layerId(), true);
          }
        }
        if ((cand->nhits() >= minNLayerHits_ &&
             (cand->nLayerUp() >= minSingleSLHitsMax_ || cand->nLayerDown() >= minSingleSLHitsMax_) &&
             (cand->nLayerUp() >= minSingleSLHitsMin_ && cand->nLayerDown() >= minSingleSLHitsMin_)) ||
            (allowUncorrelatedPatterns_ && ((cand->nLayerUp() >= minUncorrelatedHits_ && cand->nLayerDown() == 0) ||
                                            (cand->nLayerDown() >= minUncorrelatedHits_ && cand->nLayerUp() == 0)))) {
          if (debug_) {
            LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::RecognisePatterns Pattern found for pair in "
                                            << LDown << " ," << wireDown << " ," << LUp << " ," << wireUp;
            LogDebug("PseudoBayesGrouping")
                << "Candidate has " << cand->nhits() << " hits with quality " << cand->quality();
            LogDebug("PseudoBayesGrouping") << *(*pat_it);
          }
          //We currently save everything at this level, might want to be more restrictive
          pidx_++;
          cand->setCandId(pidx_);
          prelimMatches_->push_back(std::move(cand));
          allMatches_->push_back(std::move(cand));
        }
      }
    }
  }
}

References alldigis_, allMatches_, allowedVariance_, allowUncorrelatedPatterns_, debug_, change_name::diff, LogDebug, minNLayerHits_, minSingleSLHitsMax_, minSingleSLHitsMin_, minUncorrelatedHits_, eostools::move(), pidx_, and prelimMatches_.

Referenced by RecognisePatternsByLayerPairs().

RecognisePatternsByLayerPairs()

void PseudoBayesGrouping::RecognisePatternsByLayerPairs ( )

private

Definition at line 275 of file PseudoBayesGrouping.cc.

                                                        {
  //Separated from main run function for clarity. Do all pattern recognition steps
  pidx_ = 0;
  //Compare L0-L7
  RecognisePatterns(digisinL0_, digisinL7_, L0L7Patterns_);
  //Compare L0-L6 and L1-L7
  RecognisePatterns(digisinL0_, digisinL6_, L0L6Patterns_);
  RecognisePatterns(digisinL1_, digisinL7_, L1L7Patterns_);
  //Compare L0-L5, L1-L6, L2-L7
  RecognisePatterns(digisinL0_, digisinL5_, L0L5Patterns_);
  RecognisePatterns(digisinL1_, digisinL6_, L1L6Patterns_);
  RecognisePatterns(digisinL2_, digisinL7_, L2L7Patterns_);
  //L0-L4, L1-L5, L2-L6, L3-L7
  RecognisePatterns(digisinL0_, digisinL4_, L0L4Patterns_);
  RecognisePatterns(digisinL1_, digisinL5_, L1L5Patterns_);
  RecognisePatterns(digisinL2_, digisinL6_, L2L6Patterns_);
  RecognisePatterns(digisinL3_, digisinL7_, L3L7Patterns_);
  //L1-L4, L2-L5, L3-L6
  RecognisePatterns(digisinL1_, digisinL4_, L1L4Patterns_);
  RecognisePatterns(digisinL2_, digisinL5_, L2L5Patterns_);
  RecognisePatterns(digisinL3_, digisinL6_, L3L6Patterns_);
  //L2-L4, L3-L5
  RecognisePatterns(digisinL2_, digisinL4_, L2L4Patterns_);
  RecognisePatterns(digisinL3_, digisinL5_, L3L5Patterns_);
  //L3-L4
  RecognisePatterns(digisinL3_, digisinL4_, L3L4Patterns_);
  //Uncorrelated SL1
  RecognisePatterns(digisinL0_, digisinL1_, L0L1Patterns_);
  RecognisePatterns(digisinL0_, digisinL2_, L0L2Patterns_);
  RecognisePatterns(digisinL0_, digisinL3_, L0L3Patterns_);
  RecognisePatterns(digisinL1_, digisinL2_, L1L2Patterns_);
  RecognisePatterns(digisinL1_, digisinL3_, L1L3Patterns_);
  RecognisePatterns(digisinL2_, digisinL3_, L2L3Patterns_);
  //Uncorrelated SL3
  RecognisePatterns(digisinL4_, digisinL5_, L4L5Patterns_);
  RecognisePatterns(digisinL4_, digisinL6_, L4L6Patterns_);
  RecognisePatterns(digisinL4_, digisinL7_, L4L7Patterns_);
  RecognisePatterns(digisinL5_, digisinL6_, L5L6Patterns_);
  RecognisePatterns(digisinL5_, digisinL7_, L5L7Patterns_);
  RecognisePatterns(digisinL6_, digisinL7_, L6L7Patterns_);
}

References digisinL0_, digisinL1_, digisinL2_, digisinL3_, digisinL4_, digisinL5_, digisinL6_, digisinL7_, L0L1Patterns_, L0L2Patterns_, L0L3Patterns_, L0L4Patterns_, L0L5Patterns_, L0L6Patterns_, L0L7Patterns_, L1L2Patterns_, L1L3Patterns_, L1L4Patterns_, L1L5Patterns_, L1L6Patterns_, L1L7Patterns_, L2L3Patterns_, L2L4Patterns_, L2L5Patterns_, L2L6Patterns_, L2L7Patterns_, L3L4Patterns_, L3L5Patterns_, L3L6Patterns_, L3L7Patterns_, L4L5Patterns_, L4L6Patterns_, L4L7Patterns_, L5L6Patterns_, L5L7Patterns_, L6L7Patterns_, pidx_, and RecognisePatterns().

Referenced by run().

run()

void PseudoBayesGrouping::run ( edm::Event &  iEvent, const edm::EventSetup &  iEventSetup, const DTDigiCollection &  digis, MuonPathPtrs &  outMpath  )

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 179 of file PseudoBayesGrouping.cc.

                                                    {
  //Takes dt digis collection and does the grouping for correlated hits, it is saved in a vector of up to 8 (or 4) correlated hits
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run";
  //Do initial cleaning
  CleanDigisByLayer();
  //Sort digis by layer
  FillDigisByLayer(&digis);
  //Sarch for patterns
  RecognisePatternsByLayerPairs();
  //Now sort patterns by qualities
  std::sort(prelimMatches_->begin(), prelimMatches_->end(), CandPointGreat());
  if (debug_ && !prelimMatches_->empty()) {
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run Pattern qualities before cleaning: ";
    for (const auto& cand_it : *prelimMatches_) {
      LogDebug("PseudoBayesGrouping") << cand_it->nLayerhits() << ", " << cand_it->nisGood() << ", " << cand_it->nhits()
                                      << ", " << cand_it->quality() << ", " << cand_it->candId();
    }
  }
  //And ghostbust patterns to retain higher quality ones
  ReCleanPatternsAndDigis();
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run Number of found patterns: " << finalMatches_->size();
 
  //Last organize candidates information into muonpaths to finalize the grouping
  FillMuonPaths(mpaths);
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run ended run";
}

References CleanDigisByLayer(), debug_, FillDigisByLayer(), FillMuonPaths(), finalMatches_, LogDebug, prelimMatches_, ReCleanPatternsAndDigis(), and RecognisePatternsByLayerPairs().

Member Data Documentation

alldigis_

std::vector<DTPrimitive> PseudoBayesGrouping::alldigis_

private

Definition at line 62 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatterns().

allMatches_

std::unique_ptr<dtbayesam::CandidateGroupPtrs> PseudoBayesGrouping::allMatches_

private

Definition at line 75 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), initialise(), and RecognisePatterns().

allowDuplicates_

bool PseudoBayesGrouping::allowDuplicates_

private

Definition at line 53 of file PseudoBayesGrouping.h.

Referenced by PseudoBayesGrouping(), and ReCleanPatternsAndDigis().

allowedVariance_

int PseudoBayesGrouping::allowedVariance_

private

Definition at line 52 of file PseudoBayesGrouping.h.

Referenced by FillMuonPaths(), PseudoBayesGrouping(), and RecognisePatterns().

allowUncorrelatedPatterns_

bool PseudoBayesGrouping::allowUncorrelatedPatterns_

private

Definition at line 54 of file PseudoBayesGrouping.h.

Referenced by PseudoBayesGrouping(), ReCleanPatternsAndDigis(), and RecognisePatterns().

allPatterns_

std::vector<DTPattern*> PseudoBayesGrouping::allPatterns_

private

Definition at line 80 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and ~PseudoBayesGrouping().

debug_

bool PseudoBayesGrouping::debug_

private

Definition at line 48 of file PseudoBayesGrouping.h.

Referenced by FillDigisByLayer(), FillMuonPaths(), finish(), initialise(), LoadPattern(), PseudoBayesGrouping(), ReCleanPatternsAndDigis(), RecognisePatterns(), run(), and ~PseudoBayesGrouping().

digisinL0_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL0_

private

Definition at line 64 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatternsByLayerPairs().

digisinL1_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL1_

private

Definition at line 65 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatternsByLayerPairs().

digisinL2_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL2_

private

Definition at line 66 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatternsByLayerPairs().

digisinL3_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL3_

private

Definition at line 67 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatternsByLayerPairs().

digisinL4_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL4_

private

Definition at line 68 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatternsByLayerPairs().

digisinL5_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL5_

private

Definition at line 69 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatternsByLayerPairs().

digisinL6_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL6_

private

Definition at line 70 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatternsByLayerPairs().

digisinL7_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL7_

private

Definition at line 71 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillDigisByLayer(), and RecognisePatternsByLayerPairs().

finalMatches_

std::unique_ptr<dtbayesam::CandidateGroupPtrs> PseudoBayesGrouping::finalMatches_

private

Definition at line 76 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), FillMuonPaths(), initialise(), ReCleanPatternsAndDigis(), and run().

L0L1Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L0L1Patterns_

private

Definition at line 115 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L2Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L0L2Patterns_

private

Definition at line 112 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L3Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L0L3Patterns_

private

Definition at line 108 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L4Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L0L4Patterns_

private

Definition at line 103 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L5Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L0L5Patterns_

private

Definition at line 97 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L6Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L0L6Patterns_

private

Definition at line 90 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L7Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L0L7Patterns_

private

Definition at line 82 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L2Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L1L2Patterns_

private

Definition at line 113 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L3Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L1L3Patterns_

private

Definition at line 109 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L4Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L1L4Patterns_

private

Definition at line 104 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L5Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L1L5Patterns_

private

Definition at line 98 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L6Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L1L6Patterns_

private

Definition at line 91 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L7Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L1L7Patterns_

private

Definition at line 83 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L3Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L2L3Patterns_

private

Definition at line 110 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L4Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L2L4Patterns_

private

Definition at line 105 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L5Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L2L5Patterns_

private

Definition at line 99 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L6Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L2L6Patterns_

private

Definition at line 92 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L7Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L2L7Patterns_

private

Definition at line 84 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L3L4Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L3L4Patterns_

private

Definition at line 106 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L3L5Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L3L5Patterns_

private

Definition at line 100 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L3L6Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L3L6Patterns_

private

Definition at line 93 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L3L7Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L3L7Patterns_

private

Definition at line 85 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L4L5Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L4L5Patterns_

private

Definition at line 101 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L4L6Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L4L6Patterns_

private

Definition at line 94 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L4L7Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L4L7Patterns_

private

Definition at line 86 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L5L6Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L5L6Patterns_

private

Definition at line 95 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L5L7Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L5L7Patterns_

private

Definition at line 87 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L6L7Patterns_

std::vector<DTPattern*> PseudoBayesGrouping::L6L7Patterns_

private

Definition at line 88 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

minNLayerHits_

int PseudoBayesGrouping::minNLayerHits_

private

Definition at line 51 of file PseudoBayesGrouping.h.

Referenced by PseudoBayesGrouping(), ReCleanPatternsAndDigis(), and RecognisePatterns().

minSingleSLHitsMax_

int PseudoBayesGrouping::minSingleSLHitsMax_

private

Definition at line 57 of file PseudoBayesGrouping.h.

Referenced by PseudoBayesGrouping(), ReCleanPatternsAndDigis(), and RecognisePatterns().

minSingleSLHitsMin_

int PseudoBayesGrouping::minSingleSLHitsMin_

private

Definition at line 58 of file PseudoBayesGrouping.h.

Referenced by PseudoBayesGrouping(), ReCleanPatternsAndDigis(), and RecognisePatterns().

minUncorrelatedHits_

int PseudoBayesGrouping::minUncorrelatedHits_

private

Definition at line 59 of file PseudoBayesGrouping.h.

Referenced by PseudoBayesGrouping(), ReCleanPatternsAndDigis(), and RecognisePatterns().

nPatterns_

int PseudoBayesGrouping::nPatterns_

private

Definition at line 79 of file PseudoBayesGrouping.h.

Referenced by initialise(), and LoadPattern().

pattern_filename_

std::string PseudoBayesGrouping::pattern_filename_

private

Definition at line 49 of file PseudoBayesGrouping.h.

Referenced by initialise(), and PseudoBayesGrouping().

pidx_

int PseudoBayesGrouping::pidx_

private

Definition at line 50 of file PseudoBayesGrouping.h.

Referenced by RecognisePatterns(), and RecognisePatternsByLayerPairs().

prelimMatches_

std::unique_ptr<dtbayesam::CandidateGroupPtrs> PseudoBayesGrouping::prelimMatches_

private

Definition at line 74 of file PseudoBayesGrouping.h.

Referenced by CleanDigisByLayer(), initialise(), ReCleanPatternsAndDigis(), RecognisePatterns(), and run().

saveOnPlace_

bool PseudoBayesGrouping::saveOnPlace_

private

Definition at line 56 of file PseudoBayesGrouping.h.

Referenced by FillMuonPaths(), and PseudoBayesGrouping().

setLateralities_

bool PseudoBayesGrouping::setLateralities_

private

Definition at line 55 of file PseudoBayesGrouping.h.

Referenced by FillMuonPaths(), and PseudoBayesGrouping().