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 (TString pattern_file_name, int MB_number_input, int SL_shift)
void	ReCleanPatternsAndDigis ()
void	RecognisePatterns (std::vector< DTPrimitive > digisinLDown, std::vector< DTPrimitive > digisinLUp, dtbayesam::DTPatternPtrs patterns)
void	RecognisePatternsByLayerPairs (DTChamberId chamber_ID)

Private Attributes
std::vector< DTPrimitive >	alldigis_
std::unique_ptr< dtbayesam::CandidateGroupPtrs >	allMatches_
bool	allowDuplicates_
int	allowedVariance_
bool	allowUncorrelatedPatterns_
dtbayesam::DTPatternPtrs	allPatterns_ [4][3]
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_
dtbayesam::DTPatternPtrs	L0L1Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L0L2Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L0L3Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L0L4Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L0L5Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L0L6Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L0L7Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L1L2Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L1L3Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L1L4Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L1L5Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L1L6Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L1L7Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L2L3Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L2L4Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L2L5Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L2L6Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L2L7Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L3L4Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L3L5Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L3L6Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L3L7Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L4L5Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L4L6Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L4L7Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L5L6Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L5L7Patterns_ [4][3]
dtbayesam::DTPatternPtrs	L6L7Patterns_ [4][3]
uint	maxPathsPerMatch_
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 13 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");
  maxPathsPerMatch_ = pset.getUntrackedParameter<int>("maxPathsPerMatch");
  saveOnPlace_ = pset.getUntrackedParameter<bool>("saveOnPlace");
  setLateralities_ = pset.getUntrackedParameter<bool>("setLateralities");
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping:: constructor";
}

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

~PseudoBayesGrouping()

PseudoBayesGrouping::~PseudoBayesGrouping ( )

override

Definition at line 37 of file PseudoBayesGrouping.cc.

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

References debug_, and LogDebug.

Member Function Documentation

CleanDigisByLayer()

void PseudoBayesGrouping::CleanDigisByLayer ( )

private

Definition at line 590 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 505 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(), phase1PixelTopology::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 238 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 ";
 
    // Vector of all muon paths we may find
    std::vector<DTPrimitivePtrs> ptrPrimitive_vector;
 
    // We will have at least one muon path
    DTPrimitivePtrs ptrPrimitive;
    for (int i = 0; i < 8; i++)
      ptrPrimitive.push_back(std::make_shared<DTPrimitive>());
 
    ptrPrimitive_vector.push_back(ptrPrimitive);
 
    qualitybits qualityDTP;
    qualitybits qualityDTP2;
    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);
        }
      }
 
      // If one hit is already present in the current layer, for each ptrPrimitive already existing,
      // create a new with all its hits. Then, fill it with the new hit and add it to the primitives vector.
      // Do not consider more than 2 hits in the same wire or more than maxPathsPerMatch_ total muonpaths per finalMatches_
      if (qualityDTP == (qualityDTP | ref8Hit) && qualityDTP2 != (qualityDTP2 | ref8Hit) &&
          ptrPrimitive_vector.size() < maxPathsPerMatch_) {
        if (debug_)
          LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run Creating additional muon paths";
 
        qualityDTP2 = (qualityDTP2 | ref8Hit);
 
        int n_prim = ptrPrimitive_vector.size();
 
        for (int j = 0; j < n_prim; j++) {
          DTPrimitivePtrs tmpPrimitive;
          for (int i = 0; i < NUM_LAYERS_2SL; i++) {
            tmpPrimitive.push_back(ptrPrimitive_vector.at(j).at(i));
          }
          // Now save the hit in the new path
          if (saveOnPlace_) {
            //This will save the primitive in a place of the vector equal to its L position
            tmpPrimitive.at(layerHit) = std::make_shared<DTPrimitive>((*itDTP));
          }
          if (!saveOnPlace_) {
            //This will save the primitive in order
            tmpPrimitive.at(intHit) = std::make_shared<DTPrimitive>((*itDTP));
          }
          // Now add the new path to the vector of paths
          ptrPrimitive_vector.push_back(tmpPrimitive);
        }
      }
 
      // If there is not one hit already in the layer, fill the DT primitives pointers
      else {
        if (debug_)
          LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::run Adding hit to muon path";
 
        qualityDTP = (qualityDTP | ref8Hit);
 
        // for (all paths --> fill them)
        for (auto prim_it = ptrPrimitive_vector.begin(); prim_it != ptrPrimitive_vector.end(); ++prim_it) {
          if (saveOnPlace_) {
            //This will save the primitive in a place of the vector equal to its L position
            prim_it->at(layerHit) = std::make_shared<DTPrimitive>((*itDTP));
          }
          if (!saveOnPlace_) {
            //This will save the primitive in order
            intHit++;
            prim_it->at(intHit) = std::make_shared<DTPrimitive>((*itDTP));
          }
        }
      }
    }
 
    stringstream ss;
 
    int n_paths = ptrPrimitive_vector.size();
 
    for (int n_path = 0; n_path < n_paths; ++n_path) {
      mpaths.emplace_back(std::make_shared<MuonPath>(
          ptrPrimitive_vector.at(n_path), (short)(*itCand)->nLayerUp(), (short)(*itCand)->nLayerDown()));
    }
  }
}

References allowedVariance_, debug_, finalMatches_, mps_fire::i, dqmiolumiharvest::j, cmsdt::LEFT, LogDebug, maxPathsPerMatch_, NONE, cmsdt::NUM_LAYERS_2SL, funct::pow(), cmsdt::RIGHT, saveOnPlace_, setLateralities_, and contentValuesCheck::ss.

Referenced by run().

finish()

void PseudoBayesGrouping::finish ( )

overridevirtual

Reimplemented from MotherGrouping.

Definition at line 605 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 45 of file PseudoBayesGrouping.cc.

                                                                     {
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::initialiase";
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::initialiase using patterns file " << pattern_filename_;
  nPatterns_ = 0;
 
  TString patterns_folder = "L1Trigger/DTTriggerPhase2/data/";
 
  // Load all patterns
  // MB1
  LoadPattern(patterns_folder + "createdPatterns_MB1_left.root", 0, 0);
  LoadPattern(patterns_folder + "createdPatterns_MB1_right.root", 0, 2);
  // MB2
  LoadPattern(patterns_folder + "createdPatterns_MB2_left.root", 1, 0);
  LoadPattern(patterns_folder + "createdPatterns_MB2_right.root", 1, 2);
  // MB3
  LoadPattern(patterns_folder + "createdPatterns_MB3.root", 2, 1);
  // MB4
  LoadPattern(patterns_folder + "createdPatterns_MB4_left.root", 3, 0);
  LoadPattern(patterns_folder + "createdPatterns_MB4.root", 3, 1);
  LoadPattern(patterns_folder + "createdPatterns_MB4_right.root", 3, 2);
 
  prelimMatches_ = std::make_unique<CandidateGroupPtrs>();
  allMatches_ = std::make_unique<CandidateGroupPtrs>();
  finalMatches_ = std::make_unique<CandidateGroupPtrs>();
}

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

LoadPattern()

void PseudoBayesGrouping::LoadPattern ( TString  pattern_file_name, int  MB_number_input, int  SL_shift  )

private

Definition at line 73 of file PseudoBayesGrouping.cc.

                                                                                            {
  TFile* f = TFile::Open(pattern_file_name, "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) {
    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) << ", ";
 
    auto p = std::make_shared<DTPattern>();
 
    bool is_seed = true;
    for (const auto& itHits : *itPattern) {
      // First entry is the seeding information
      if (is_seed) {
        p = std::make_shared<DTPattern>(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_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 6)
        L0L6Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 5)
        L0L5Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 4)
        L0L4Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 3)
        L0L3Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 2)
        L0L2Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 1)
        L0L1Patterns_[MB_number][SL_shift].push_back(p);
    }
    if (p->sl1() == 1) {
      if (p->sl2() == 7)
        L1L7Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 6)
        L1L6Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 5)
        L1L5Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 4)
        L1L4Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 3)
        L1L3Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 2)
        L1L2Patterns_[MB_number][SL_shift].push_back(p);
    }
    if (p->sl1() == 2) {
      if (p->sl2() == 7)
        L2L7Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 6)
        L2L6Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 5)
        L2L5Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 4)
        L2L4Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 3)
        L2L3Patterns_[MB_number][SL_shift].push_back(p);
    }
    if (p->sl1() == 3) {
      if (p->sl2() == 7)
        L3L7Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 6)
        L3L6Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 5)
        L3L5Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 4)
        L3L4Patterns_[MB_number][SL_shift].push_back(p);
    }
 
    if (p->sl1() == 4) {
      if (p->sl2() == 7)
        L4L7Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 6)
        L4L6Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 5)
        L4L5Patterns_[MB_number][SL_shift].push_back(p);
    }
    if (p->sl1() == 5) {
      if (p->sl2() == 7)
        L5L7Patterns_[MB_number][SL_shift].push_back(p);
      if (p->sl2() == 6)
        L5L6Patterns_[MB_number][SL_shift].push_back(p);
    }
    if (p->sl1() == 6) {
      if (p->sl2() == 7)
        L6L7Patterns_[MB_number][SL_shift].push_back(p);
    }
 
    //Also creating a list of all patterns, needed later for deleting and avoid a memory leak
    allPatterns_[MB_number][SL_shift].push_back(p);
    nPatterns_++;
  }
  if (debug_)
    LogDebug("PseudoBayesGrouping") << "PseudoBayesGrouping::initialiase Total number of loaded patterns: "
                                    << nPatterns_;
  f->Close();
  delete f;
}

References allPatterns_, debug_, f, 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_, AlCaHLTBitMon_ParallelJobs::p, and trackerHitRTTI::vector.

Referenced by initialise().

ReCleanPatternsAndDigis()

void PseudoBayesGrouping::ReCleanPatternsAndDigis ( )

private

Definition at line 551 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()) {
        (*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_, prelimMatches_, and jetUpdater_cfi::sort.

Referenced by run().

RecognisePatterns()

void PseudoBayesGrouping::RecognisePatterns ( std::vector< DTPrimitive >  digisinLDown, std::vector< DTPrimitive >  digisinLUp, dtbayesam::DTPatternPtrs  patterns  )

private

Definition at line 454 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 << "\n"
                << "Candidate has " << cand->nhits() << " hits with quality " << cand->quality() << "\n"
                << *(*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 ( DTChamberId  chamber_ID )

private

Definition at line 345 of file PseudoBayesGrouping.cc.

                                                                              {
  // chamber_ID traslated to MB, wheel, sector
  int MB = chamber_ID.station() - 1;
  int wheel = chamber_ID.wheel();
  int sector = chamber_ID.sector();
 
  // shift of SL3 wrt SL1
  int shift = -1;
 
  // Now define DT geometry depending on its ID
 
  // MB1
  if (MB == 0) {
    if (wheel == -1 || wheel == -2)
      shift = 2;  // positive (right)
    else if (wheel == 1 || wheel == 2)
      shift = 0;  // negative (left)
    else if (wheel == 0) {
      if (sector == 1 || sector == 4 || sector == 5 || sector == 8 || sector == 9 || sector == 12)
        shift = 2;  // positive (right)
      else
        shift = 0;  // negative (left)
    }
  }
  // MB2
  else if (MB == 1) {
    if (wheel == -1 || wheel == -2)
      shift = 0;  // negative (left)
    else if (wheel == 1 || wheel == 2)
      shift = 2;  // positive (right)
    else if (wheel == 0) {
      if (sector == 1 || sector == 4 || sector == 5 || sector == 8 || sector == 9 || sector == 12)
        shift = 0;  // negative (left)
      else
        shift = 2;  // positive (right)
    }
  }
  // MB3
  else if (MB == 2) {
    shift = 1;  // shift is always 0 in MB3
  }
  // MB4
  else if (MB == 3) {
    if (wheel == -1 || wheel == -2)
      if (sector == 4 || sector == 9 || sector == 11 || sector == 13)
        shift = 1;  // no shift
      else if (sector == 5 || sector == 6 || sector == 7 || sector == 8 || sector == 14)
        shift = 2;  // positive (right)
      else
        shift = 0;  // negative (left)
    else if (wheel == 1 || wheel == 2)
      if (sector == 4 || sector == 9 || sector == 11 || sector == 13)
        shift = 1;  // no shift
      else if (sector == 1 || sector == 2 || sector == 3 || sector == 10 || sector == 12)
        shift = 2;  // positive (right)
      else
        shift = 0;  // negative (left)
    else if (wheel == 0)
      if (sector == 4 || sector == 9 || sector == 11 || sector == 13)
        shift = 1;  // no shift
      else if (sector == 2 || sector == 3 || sector == 5 || sector == 8 || sector == 10)
        shift = 2;  // positive (right)
      else
        shift = 0;  // negative (left)
    else
      return;
  }
 
  //Separated from main run function for clarity. Do all pattern recognition steps
  pidx_ = 0;
  //Compare L0-L7
  RecognisePatterns(digisinL0_, digisinL7_, L0L7Patterns_[MB][shift]);
  //Compare L0-L6 and L1-L7
  RecognisePatterns(digisinL0_, digisinL6_, L0L6Patterns_[MB][shift]);
  RecognisePatterns(digisinL1_, digisinL7_, L1L7Patterns_[MB][shift]);
  //Compare L0-L5, L1-L6, L2-L7
  RecognisePatterns(digisinL0_, digisinL5_, L0L5Patterns_[MB][shift]);
  RecognisePatterns(digisinL1_, digisinL6_, L1L6Patterns_[MB][shift]);
  RecognisePatterns(digisinL2_, digisinL7_, L2L7Patterns_[MB][shift]);
  //L0-L4, L1-L5, L2-L6, L3-L7
  RecognisePatterns(digisinL0_, digisinL4_, L0L4Patterns_[MB][shift]);
  RecognisePatterns(digisinL1_, digisinL5_, L1L5Patterns_[MB][shift]);
  RecognisePatterns(digisinL2_, digisinL6_, L2L6Patterns_[MB][shift]);
  RecognisePatterns(digisinL3_, digisinL7_, L3L7Patterns_[MB][shift]);
  //L1-L4, L2-L5, L3-L6
  RecognisePatterns(digisinL1_, digisinL4_, L1L4Patterns_[MB][shift]);
  RecognisePatterns(digisinL2_, digisinL5_, L2L5Patterns_[MB][shift]);
  RecognisePatterns(digisinL3_, digisinL6_, L3L6Patterns_[MB][shift]);
  //L2-L4, L3-L5
  RecognisePatterns(digisinL2_, digisinL4_, L2L4Patterns_[MB][shift]);
  RecognisePatterns(digisinL3_, digisinL5_, L3L5Patterns_[MB][shift]);
  //L3-L4
  RecognisePatterns(digisinL3_, digisinL4_, L3L4Patterns_[MB][shift]);
  //Uncorrelated SL1
  RecognisePatterns(digisinL0_, digisinL1_, L0L1Patterns_[MB][shift]);
  RecognisePatterns(digisinL0_, digisinL2_, L0L2Patterns_[MB][shift]);
  RecognisePatterns(digisinL0_, digisinL3_, L0L3Patterns_[MB][shift]);
  RecognisePatterns(digisinL1_, digisinL2_, L1L2Patterns_[MB][shift]);
  RecognisePatterns(digisinL1_, digisinL3_, L1L3Patterns_[MB][shift]);
  RecognisePatterns(digisinL2_, digisinL3_, L2L3Patterns_[MB][shift]);
  //Uncorrelated SL3
  RecognisePatterns(digisinL4_, digisinL5_, L4L5Patterns_[MB][shift]);
  RecognisePatterns(digisinL4_, digisinL6_, L4L6Patterns_[MB][shift]);
  RecognisePatterns(digisinL4_, digisinL7_, L4L7Patterns_[MB][shift]);
  RecognisePatterns(digisinL5_, digisinL6_, L5L6Patterns_[MB][shift]);
  RecognisePatterns(digisinL5_, digisinL7_, L5L7Patterns_[MB][shift]);
  RecognisePatterns(digisinL6_, digisinL7_, L6L7Patterns_[MB][shift]);
}

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_, RecognisePatterns(), DTChamberId::sector(), edm::shift, DTChamberId::station(), DTChamberId::wheel(), and makeMuonMisalignmentScenario::wheel.

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 193 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
  DTChamberId chamber_id;
  // We just want the chamber ID of the first digi
  // as they are all the same --> create a loop and break it
  // after the first iteration
  for (const auto& detUnitIt : digis) {
    const DTLayerId layer_Id = detUnitIt.first;
    chamber_id = layer_Id.superlayerId().chamberId();
    break;
  }
 
  RecognisePatternsByLayerPairs(chamber_id);
 
  // 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 DTSuperLayerId::chamberId(), CleanDigisByLayer(), debug_, FillDigisByLayer(), FillMuonPaths(), finalMatches_, LogDebug, prelimMatches_, ReCleanPatternsAndDigis(), RecognisePatternsByLayerPairs(), jetUpdater_cfi::sort, and DTLayerId::superlayerId().

Member Data Documentation

alldigis_

std::vector<DTPrimitive> PseudoBayesGrouping::alldigis_

private

Definition at line 65 of file PseudoBayesGrouping.h.

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

allMatches_

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

private

Definition at line 78 of file PseudoBayesGrouping.h.

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

allowDuplicates_

bool PseudoBayesGrouping::allowDuplicates_

private

Definition at line 55 of file PseudoBayesGrouping.h.

Referenced by PseudoBayesGrouping(), and ReCleanPatternsAndDigis().

allowedVariance_

int PseudoBayesGrouping::allowedVariance_

private

Definition at line 54 of file PseudoBayesGrouping.h.

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

allowUncorrelatedPatterns_

bool PseudoBayesGrouping::allowUncorrelatedPatterns_

private

Definition at line 56 of file PseudoBayesGrouping.h.

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

allPatterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::allPatterns_[4][3]

private

Definition at line 86 of file PseudoBayesGrouping.h.

Referenced by LoadPattern().

debug_

bool PseudoBayesGrouping::debug_

private

Definition at line 50 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 67 of file PseudoBayesGrouping.h.

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

digisinL1_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL1_

private

Definition at line 68 of file PseudoBayesGrouping.h.

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

digisinL2_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL2_

private

Definition at line 69 of file PseudoBayesGrouping.h.

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

digisinL3_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL3_

private

Definition at line 70 of file PseudoBayesGrouping.h.

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

digisinL4_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL4_

private

Definition at line 71 of file PseudoBayesGrouping.h.

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

digisinL5_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL5_

private

Definition at line 72 of file PseudoBayesGrouping.h.

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

digisinL6_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL6_

private

Definition at line 73 of file PseudoBayesGrouping.h.

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

digisinL7_

std::vector<DTPrimitive> PseudoBayesGrouping::digisinL7_

private

Definition at line 74 of file PseudoBayesGrouping.h.

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

finalMatches_

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

private

Definition at line 79 of file PseudoBayesGrouping.h.

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

L0L1Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L0L1Patterns_[4][3]

private

Definition at line 121 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L2Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L0L2Patterns_[4][3]

private

Definition at line 118 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L3Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L0L3Patterns_[4][3]

private

Definition at line 114 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L4Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L0L4Patterns_[4][3]

private

Definition at line 109 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L5Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L0L5Patterns_[4][3]

private

Definition at line 103 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L6Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L0L6Patterns_[4][3]

private

Definition at line 96 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L0L7Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L0L7Patterns_[4][3]

private

Definition at line 88 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L2Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L1L2Patterns_[4][3]

private

Definition at line 119 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L3Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L1L3Patterns_[4][3]

private

Definition at line 115 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L4Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L1L4Patterns_[4][3]

private

Definition at line 110 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L5Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L1L5Patterns_[4][3]

private

Definition at line 104 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L6Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L1L6Patterns_[4][3]

private

Definition at line 97 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L1L7Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L1L7Patterns_[4][3]

private

Definition at line 89 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L3Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L2L3Patterns_[4][3]

private

Definition at line 116 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L4Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L2L4Patterns_[4][3]

private

Definition at line 111 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L5Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L2L5Patterns_[4][3]

private

Definition at line 105 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L6Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L2L6Patterns_[4][3]

private

Definition at line 98 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L2L7Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L2L7Patterns_[4][3]

private

Definition at line 90 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L3L4Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L3L4Patterns_[4][3]

private

Definition at line 112 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L3L5Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L3L5Patterns_[4][3]

private

Definition at line 106 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L3L6Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L3L6Patterns_[4][3]

private

Definition at line 99 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L3L7Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L3L7Patterns_[4][3]

private

Definition at line 91 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L4L5Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L4L5Patterns_[4][3]

private

Definition at line 107 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L4L6Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L4L6Patterns_[4][3]

private

Definition at line 100 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L4L7Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L4L7Patterns_[4][3]

private

Definition at line 92 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L5L6Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L5L6Patterns_[4][3]

private

Definition at line 101 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L5L7Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L5L7Patterns_[4][3]

private

Definition at line 93 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

L6L7Patterns_

dtbayesam::DTPatternPtrs PseudoBayesGrouping::L6L7Patterns_[4][3]

private

Definition at line 94 of file PseudoBayesGrouping.h.

Referenced by LoadPattern(), and RecognisePatternsByLayerPairs().

maxPathsPerMatch_

uint PseudoBayesGrouping::maxPathsPerMatch_

private

Definition at line 62 of file PseudoBayesGrouping.h.

Referenced by FillMuonPaths(), and PseudoBayesGrouping().

minNLayerHits_

int PseudoBayesGrouping::minNLayerHits_

private

Definition at line 53 of file PseudoBayesGrouping.h.

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

minSingleSLHitsMax_

int PseudoBayesGrouping::minSingleSLHitsMax_

private

Definition at line 59 of file PseudoBayesGrouping.h.

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

minSingleSLHitsMin_

int PseudoBayesGrouping::minSingleSLHitsMin_

private

Definition at line 60 of file PseudoBayesGrouping.h.

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

minUncorrelatedHits_

int PseudoBayesGrouping::minUncorrelatedHits_

private

Definition at line 61 of file PseudoBayesGrouping.h.

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

nPatterns_

int PseudoBayesGrouping::nPatterns_

private

Definition at line 82 of file PseudoBayesGrouping.h.

Referenced by initialise(), and LoadPattern().

pattern_filename_

std::string PseudoBayesGrouping::pattern_filename_

private

Definition at line 51 of file PseudoBayesGrouping.h.

Referenced by initialise(), and PseudoBayesGrouping().

pidx_

int PseudoBayesGrouping::pidx_

private

Definition at line 52 of file PseudoBayesGrouping.h.

Referenced by RecognisePatterns(), and RecognisePatternsByLayerPairs().

prelimMatches_

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

private

Definition at line 77 of file PseudoBayesGrouping.h.

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

saveOnPlace_

bool PseudoBayesGrouping::saveOnPlace_

private

Definition at line 58 of file PseudoBayesGrouping.h.

Referenced by FillMuonPaths(), and PseudoBayesGrouping().

setLateralities_

bool PseudoBayesGrouping::setLateralities_

private

Definition at line 57 of file PseudoBayesGrouping.h.

Referenced by FillMuonPaths(), and PseudoBayesGrouping().