trklet::Sector Class Reference

#include <Sector.h>

Public Member Functions
void	addMem (std::string memType, std::string memName)
template<typename TV , typename... Args>
void	addMemToVec (std::vector< std::unique_ptr< TV > > &memvec, const std::string &memName, Args &...args)
void	addProc (std::string procType, std::string procName)
template<typename TV , typename... Args>
void	addProcToVec (std::vector< std::unique_ptr< TV > > &procvec, const std::string &procName, Args &...args)
bool	addStub (L1TStub stub, std::string dtc)
void	addWire (std::string mem, std::string procinfull, std::string procoutfull)
void	clean ()
void	executeFT ()
void	executeIR ()
void	executeMC ()
void	executeME ()
void	executeMP ()
void	executePD (std::vector< Track > &tracks)
void	executePR ()
void	executeTC ()
void	executeTCD ()
void	executeTE ()
void	executeTED ()
void	executeTP ()
void	executeTRE ()
void	executeVMR ()
std::vector< Tracklet * >	getAllTracklets () const
MemoryBase *	getMem (std::string memName)
ProcessBase *	getProc (std::string procName)
std::vector< const Stub * >	getStubs () const
double	phimax () const
double	phimin () const
	Sector (Settings const &settings, Globals *globals)
std::unordered_set< int >	seedMatch (int itp) const
void	setSector (unsigned int isector)
void	writeAIS (bool first)
void	writeAP (bool first)
void	writeAS (bool first)
void	writeCM (bool first)
void	writeCT (bool first)
void	writeDTCStubs (bool first)
void	writeIRStubs (bool first)
void	writeMC (bool first)
void	writeSP (bool first)
void	writeST (bool first)
void	writeTF (bool first)
void	writeTPAR (bool first)
void	writeTPROJ (bool first)
void	writeVMPROJ (bool first)
void	writeVMSME (bool first)
void	writeVMSTE (bool first)
	~Sector ()

Private Attributes
std::vector< std::unique_ptr < AllInnerStubsMemory > >	AIS_
std::vector< std::unique_ptr < AllProjectionsMemory > >	AP_
std::vector< std::unique_ptr < AllStubsMemory > >	AS_
std::vector< std::unique_ptr < CandidateMatchMemory > >	CM_
std::vector< std::unique_ptr < CleanTrackMemory > >	CT_
std::vector< std::unique_ptr < DTCLinkMemory > >	DL_
std::vector< std::unique_ptr < FullMatchMemory > >	FM_
std::vector< std::unique_ptr < FitTrack > >	FT_
Globals *	globals_
std::vector< std::unique_ptr < InputLinkMemory > >	IL_
std::vector< std::unique_ptr < InputRouter > >	IR_
int	isector_
std::vector< std::unique_ptr < MatchCalculator > >	MC_
std::vector< std::unique_ptr < MatchEngine > >	ME_
std::map< std::string, MemoryBase * >	Memories_
std::vector< MemoryBase * >	MemoriesV_
std::vector< std::unique_ptr < MatchProcessor > >	MP_
std::vector< std::unique_ptr < PurgeDuplicate > >	PD_
double	phimax_
double	phimin_
std::vector< std::unique_ptr < ProjectionRouter > >	PR_
std::map< std::string, ProcessBase * >	Processes_
Settings const &	settings_
std::vector< std::unique_ptr < StubPairsMemory > >	SP_
std::vector< std::unique_ptr < StubTripletsMemory > >	ST_
std::vector< std::unique_ptr < TrackletCalculator > >	TC_
std::vector< std::unique_ptr < TrackletCalculatorDisplaced > >	TCD_
std::vector< std::unique_ptr < TrackletEngine > >	TE_
std::vector< std::unique_ptr < TrackletEngineDisplaced > >	TED_
std::vector< std::unique_ptr < TrackFitMemory > >	TF_
std::vector< std::unique_ptr < TrackletProcessor > >	TP_
std::vector< std::unique_ptr < TrackletParametersMemory > >	TPAR_
std::vector< std::unique_ptr < TrackletProjectionsMemory > >	TPROJ_
std::vector< std::unique_ptr < TripletEngine > >	TRE_
std::vector< std::unique_ptr < VMProjectionsMemory > >	VMPROJ_
std::vector< std::unique_ptr < VMRouter > >	VMR_
std::vector< std::unique_ptr < VMRouterCM > >	VMRCM_
std::vector< std::unique_ptr < VMStubsMEMemory > >	VMSME_
std::vector< std::unique_ptr < VMStubsTEMemory > >	VMSTE_

Detailed Description

Definition at line 61 of file Sector.h.

Constructor & Destructor Documentation

Sector::Sector	(	Settings const &	settings,
		Globals *	globals
	)

Definition at line 48 of file Sector.cc.

: isector_(-1), settings_(settings), globals_(globals) {}

Sector::~Sector ( )

default

Member Function Documentation

void Sector::addMem	(	std::string	memType,
		std::string	memName
	)

Definition at line 101 of file Sector.cc.

References addMemToVec(), AIS_, AP_, AS_, CM_, CT_, DL_, beamvalidation::exit(), FM_, IL_, phimax_, phimin_, settings_, SP_, ST_, TF_, TPAR_, TPROJ_, VMPROJ_, VMSME_, and VMSTE_.

                                                  {
  if (memType == "DTCLink:") {
    addMemToVec(DL_, memName, settings_, phimin_, phimax_);
  } else if (memType == "InputLink:") {
    addMemToVec(IL_, memName, settings_, phimin_, phimax_);
  } else if (memType == "AllStubs:") {
    addMemToVec(AS_, memName, settings_);
  } else if (memType == "AllInnerStubs:") {
    addMemToVec(AIS_, memName, settings_);
  } else if (memType == "VMStubsTE:") {
    addMemToVec(VMSTE_, memName, settings_);
  } else if (memType == "VMStubsME:") {
    addMemToVec(VMSME_, memName, settings_);
  } else if (memType == "StubPairs:" || memType == "StubPairsDisplaced:") {
    addMemToVec(SP_, memName, settings_);
  } else if (memType == "StubTriplets:") {
    addMemToVec(ST_, memName, settings_);
  } else if (memType == "TrackletParameters:") {
    addMemToVec(TPAR_, memName, settings_);
  } else if (memType == "TrackletProjections:") {
    addMemToVec(TPROJ_, memName, settings_);
  } else if (memType == "AllProj:") {
    addMemToVec(AP_, memName, settings_);
  } else if (memType == "VMProjections:") {
    addMemToVec(VMPROJ_, memName, settings_);
  } else if (memType == "CandidateMatch:") {
    addMemToVec(CM_, memName, settings_);
  } else if (memType == "FullMatch:") {
    addMemToVec(FM_, memName, settings_);
  } else if (memType == "TrackFit:") {
    addMemToVec(TF_, memName, settings_, phimin_, phimax_);
  } else if (memType == "CleanTrack:") {
    addMemToVec(CT_, memName, settings_, phimin_, phimax_);
  } else {
    edm::LogPrint("Tracklet") << "Don't know of memory type: " << memType;
    exit(0);
  }
}

template<typename TV , typename... Args>

void trklet::Sector::addMemToVec ( std::vector< std::unique_ptr< TV > > &  memvec, const std::string &  memName, Args &...  args  )

inline

Definition at line 129 of file Sector.h.

References Memories_, and MemoriesV_.

Referenced by addMem().

                                                                                                     {
      memvec.push_back(std::make_unique<TV>(memName, std::forward<Args>(args)...));
      Memories_[memName] = memvec.back().get();
      MemoriesV_.push_back(memvec.back().get());
    }

void Sector::addProc	(	std::string	procType,
		std::string	procName
	)

Definition at line 140 of file Sector.cc.

References addProcToVec(), beamvalidation::exit(), FT_, globals_, IR_, MC_, ME_, MP_, PD_, PR_, settings_, TC_, TCD_, TE_, TED_, TP_, TRE_, VMR_, and VMRCM_.

                                                     {
  if (procType == "InputRouter:") {
    addProcToVec(IR_, procName, settings_, globals_);
  } else if (procType == "VMRouter:") {
    addProcToVec(VMR_, procName, settings_, globals_);
  } else if (procType == "VMRouterCM:") {
    addProcToVec(VMRCM_, procName, settings_, globals_);
  } else if (procType == "TrackletEngine:") {
    addProcToVec(TE_, procName, settings_, globals_);
  } else if (procType == "TrackletEngineDisplaced:") {
    addProcToVec(TED_, procName, settings_, globals_);
  } else if (procType == "TripletEngine:") {
    addProcToVec(TRE_, procName, settings_, globals_);
  } else if (procType == "TrackletCalculator:") {
    addProcToVec(TC_, procName, settings_, globals_);
  } else if (procType == "TrackletProcessor:") {
    addProcToVec(TP_, procName, settings_, globals_);
  } else if (procType == "TrackletCalculatorDisplaced:") {
    addProcToVec(TCD_, procName, settings_, globals_);
  } else if (procType == "ProjectionRouter:") {
    addProcToVec(PR_, procName, settings_, globals_);
  } else if (procType == "MatchEngine:") {
    addProcToVec(ME_, procName, settings_, globals_);
  } else if (procType == "MatchCalculator:" ||
             procType == "DiskMatchCalculator:") {  //TODO should not be used in configurations
    addProcToVec(MC_, procName, settings_, globals_);
  } else if (procType == "MatchProcessor:") {
    addProcToVec(MP_, procName, settings_, globals_);
  } else if (procType == "FitTrack:") {
    addProcToVec(FT_, procName, settings_, globals_);
  } else if (procType == "PurgeDuplicate:") {
    addProcToVec(PD_, procName, settings_, globals_);
  } else {
    edm::LogPrint("Tracklet") << "Don't know of processing type: " << procType;
    exit(0);
  }
}

template<typename TV , typename... Args>

void trklet::Sector::addProcToVec ( std::vector< std::unique_ptr< TV > > &  procvec, const std::string &  procName, Args &...  args  )

inline

Definition at line 136 of file Sector.h.

References Processes_.

Referenced by addProc().

                                                                                                        {
      procvec.push_back(std::make_unique<TV>(procName, std::forward<Args>(args)...));
      Processes_[procName] = procvec.back().get();
    }

bool Sector::addStub	(	L1TStub	stub,
		std::string	dtc
	)

Definition at line 68 of file Sector.cc.

References cms::cuda::assert(), trklet::Stub::bend(), DL_, globals_, mps_fire::i, trklet::TrackletLUT::initPhiCorrTable(), trklet::L1TStub::layerdisk(), trklet::TrackletLUT::lookup(), trklet::N_LAYER, mergeVDriftHistosByStation::name, trklet::FPGAWord::nbits(), trklet::Globals::phiCorr(), trklet::Stub::r(), alignCSCRings::r, trklet::Stub::setPhiCorr(), settings_, and trklet::FPGAWord::value().

                                             {
  unsigned int layerdisk = stub.layerdisk();

  if (layerdisk < N_LAYER && globals_->phiCorr(layerdisk) == nullptr) {
    globals_->phiCorr(layerdisk) = new TrackletLUT(settings_);
    globals_->phiCorr(layerdisk)->initPhiCorrTable(layerdisk, 3);
  }

  Stub fpgastub(stub, settings_, *globals_);

  if (layerdisk < N_LAYER) {
    FPGAWord r = fpgastub.r();
    int bendbin = fpgastub.bend().value();
    int rbin = (r.value() + (1 << (r.nbits() - 1))) >> (r.nbits() - 3);
    const TrackletLUT& phiCorrTable = *globals_->phiCorr(layerdisk);
    int iphicorr = phiCorrTable.lookup(bendbin * (1 << 3) + rbin);
    fpgastub.setPhiCorr(iphicorr);
  }

  int nadd = 0;
  for (unsigned int i = 0; i < DL_.size(); i++) {
    const string& name = DL_[i]->getName();
    if (name.find("_" + dtc) == string::npos)
      continue;
    DL_[i]->addStub(stub, fpgastub);
    nadd++;
  }

  assert(nadd == 1);

  return true;
}

void Sector::addWire	(	std::string	mem,
		std::string	procinfull,
		std::string	procoutfull
	)

Definition at line 178 of file Sector.cc.

References trklet::ProcessBase::addInput(), trklet::ProcessBase::addOutput(), getMem(), getProc(), input, and convertSQLitetoXML_cfg::output.

                                                                      {
  stringstream ss1(procinfull);
  string procin, output;
  getline(ss1, procin, '.');
  getline(ss1, output);

  stringstream ss2(procoutfull);
  string procout, input;
  getline(ss2, procout, '.');
  getline(ss2, input);

  MemoryBase* memory = getMem(mem);

  if (!procin.empty()) {
    ProcessBase* inProc = getProc(procin);
    inProc->addOutput(memory, output);
  }

  if (!procout.empty()) {
    ProcessBase* outProc = getProc(procout);
    outProc->addInput(memory, input);
  }
}

void Sector::clean

(

)

Definition at line 318 of file Sector.cc.

References mem, and MemoriesV_.

                   {
  for (auto& mem : MemoriesV_) {
    mem->clean();
  }
}

void Sector::executeFT

(

)

Definition at line 412 of file Sector.cc.

References FT_, mps_fire::i, and isector_.

                       {
  for (auto& i : FT_) {
    i->execute(isector_);
  }
}

void Sector::executeIR

(

)

Definition at line 324 of file Sector.cc.

References mps_fire::i, and IR_.

                       {
  for (auto& i : IR_) {
    i->execute();
  }
}

void Sector::executeMC

(

)

Definition at line 400 of file Sector.cc.

References mps_fire::i, MC_, and phimin_.

                       {
  for (auto& i : MC_) {
    i->execute(phimin_);
  }
}

void Sector::executeME

(

)

Definition at line 394 of file Sector.cc.

References mps_fire::i, and ME_.

                       {
  for (auto& i : ME_) {
    i->execute();
  }
}

void Sector::executeMP

(

)

Definition at line 406 of file Sector.cc.

References mps_fire::i, isector_, MP_, and phimin_.

                       {
  for (auto& i : MP_) {
    i->execute(isector_, phimin_);
  }
}

void Sector::executePD

(

std::vector< Track > &

tracks

)

Definition at line 418 of file Sector.cc.

References mps_fire::i, isector_, and PD_.

                                               {
  for (auto& i : PD_) {
    i->execute(tracks, isector_);
  }
}

void Sector::executePR

(

)

Definition at line 388 of file Sector.cc.

References mps_fire::i, and PR_.

                       {
  for (auto& i : PR_) {
    i->execute();
  }
}

void Sector::executeTC

(

)

Definition at line 369 of file Sector.cc.

References globals_, mps_fire::i, isector_, trklet::Globals::ofstream(), submitPVResolutionJobs::out, phimax_, phimin_, settings_, TC_, TPROJ_, and trklet::Settings::writeMonitorData().

                       {
  for (auto& i : TC_) {
    i->execute(isector_, phimin_, phimax_);
  }

  if (settings_.writeMonitorData("TrackProjOcc")) {
    ofstream& out = globals_->ofstream("trackprojocc.txt");
    for (auto& i : TPROJ_) {
      out << i->getName() << " " << i->nTracklets() << endl;
    }
  }
}

void Sector::executeTCD

(

)

Definition at line 382 of file Sector.cc.

References mps_fire::i, isector_, phimax_, phimin_, and TCD_.

                        {
  for (auto& i : TCD_) {
    i->execute(isector_, phimin_, phimax_);
  }
}

void Sector::executeTE

(

)

Definition at line 345 of file Sector.cc.

References mps_fire::i, and TE_.

                       {
  for (auto& i : TE_) {
    i->execute();
  }
}

void Sector::executeTED

(

)

Definition at line 351 of file Sector.cc.

References mps_fire::i, and TED_.

                        {
  for (auto& i : TED_) {
    i->execute();
  }
}

void Sector::executeTP

(

)

Definition at line 363 of file Sector.cc.

References mps_fire::i, isector_, phimax_, phimin_, and TP_.

                       {
  for (auto& i : TP_) {
    i->execute(isector_, phimin_, phimax_);
  }
}

void Sector::executeTRE

(

)

Definition at line 357 of file Sector.cc.

References mps_fire::i, and TRE_.

                        {
  for (auto& i : TRE_) {
    i->execute();
  }
}

void Sector::executeVMR

(

)

Definition at line 330 of file Sector.cc.

References globals_, mps_fire::i, IL_, trklet::Globals::ofstream(), submitPVResolutionJobs::out, settings_, VMR_, VMRCM_, and trklet::Settings::writeMonitorData().

                        {
  if (settings_.writeMonitorData("IL")) {
    ofstream& out = globals_->ofstream("inputlink.txt");
    for (auto& i : IL_) {
      out << i->getName() << " " << i->nStubs() << endl;
    }
  }
  for (auto& i : VMR_) {
    i->execute();
  }
  for (auto& i : VMRCM_) {
    i->execute();
  }
}

std::vector< Tracklet * > Sector::getAllTracklets

(

)

const

Definition at line 424 of file Sector.cc.

References dqmiolumiharvest::j, createJobs::tmp, and TPAR_.

                                                   {
  std::vector<Tracklet*> tmp;
  for (auto& tpar : TPAR_) {
    for (unsigned int j = 0; j < tpar->nTracklets(); j++) {
      tmp.push_back(tpar->getTracklet(j));
    }
  }
  return tmp;
}

MemoryBase * Sector::getMem

(

std::string

memName

)

Definition at line 212 of file Sector.cc.

References Exception, and Memories_.

Referenced by addWire().

                                         {
  auto it = Memories_.find(memName);

  if (it != Memories_.end()) {
    return it->second;
  }
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find memory : " << memName;
  return nullptr;
}

ProcessBase * Sector::getProc

(

std::string

procName

)

Definition at line 202 of file Sector.cc.

References Exception, and Processes_.

Referenced by addWire().

                                            {
  auto it = Processes_.find(procName);

  if (it != Processes_.end()) {
    return it->second;
  }
  throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find process : " << procName << endl;
  return nullptr;
}

std::vector< const Stub * > Sector::getStubs

(

)

const

Definition at line 434 of file Sector.cc.

References IL_, and createJobs::tmp.

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

  for (auto& imem : IL_) {
    for (unsigned int istub = 0; istub < imem->nStubs(); istub++) {
      tmp.push_back(imem->getStub(istub));
    }
  }

  return tmp;
}

double trklet::Sector::phimax ( ) const

inline

Definition at line 126 of file Sector.h.

References phimax_.

{ return phimax_; }

double trklet::Sector::phimin ( ) const

inline

Definition at line 125 of file Sector.h.

References phimin_.

{ return phimin_; }

std::unordered_set< int > Sector::seedMatch

(

int

itp

)

const

Definition at line 446 of file Sector.cc.

References mps_fire::i, dqmiolumiharvest::j, and TPAR_.

                                                     {
  std::unordered_set<int> tmpSeeds;
  for (auto& i : TPAR_) {
    unsigned int nTracklet = i->nTracklets();
    for (unsigned int j = 0; j < nTracklet; j++) {
      if (i->getTracklet(j)->tpseed() == itp) {
        tmpSeeds.insert(i->getTracklet(j)->getISeed());
      }
    }
  }
  return tmpSeeds;
}

void Sector::setSector

(

unsigned int

isector

)

Definition at line 52 of file Sector.cc.

References cms::cuda::assert(), trklet::Settings::dphisectorHG(), isector_, M_PI, trklet::N_SECTOR, phimax_, phimin_, reco::reduceRange(), and settings_.

                                           {
  assert(isector < N_SECTOR);
  isector_ = isector;
  double dphi = 2 * M_PI / N_SECTOR;
  double dphiHG = 0.5 * settings_.dphisectorHG() - M_PI / N_SECTOR;
  phimin_ = isector_ * dphi - dphiHG;
  phimax_ = phimin_ + dphi + 2 * dphiHG;
  phimin_ -= M_PI / N_SECTOR;
  phimax_ -= M_PI / N_SECTOR;
  phimin_ = reco::reduceRange(phimin_);
  phimax_ = reco::reduceRange(phimax_);
  if (phimin_ > phimax_) {
    phimin_ -= 2 * M_PI;
  }
}

void Sector::writeAIS

(

bool

first

)

Definition at line 252 of file Sector.cc.

References AIS_, mps_fire::i, and isector_.

                                {
  for (auto& i : AIS_) {
    i->writeStubs(first, isector_);
  }
}

void Sector::writeAP

(

bool

first

)

Definition at line 282 of file Sector.cc.

References AP_, mps_fire::i, and isector_.

                               {
  for (auto& i : AP_) {
    i->writeAP(first, isector_);
  }
}

void Sector::writeAS

(

bool

first

)

Definition at line 246 of file Sector.cc.

References AS_, mps_fire::i, and isector_.

                               {
  for (auto& i : AS_) {
    i->writeStubs(first, isector_);
  }
}

void Sector::writeCM

(

bool

first

)

Definition at line 294 of file Sector.cc.

References CM_, mps_fire::i, and isector_.

                               {
  for (auto& i : CM_) {
    i->writeCM(first, isector_);
  }
}

void Sector::writeCT

(

bool

first

)

Definition at line 312 of file Sector.cc.

References CT_, mps_fire::i, and isector_.

                               {
  for (auto& i : CT_) {
    i->writeCT(first, isector_);
  }
}

void Sector::writeDTCStubs

(

bool

first

)

Definition at line 222 of file Sector.cc.

References DL_, mps_fire::i, and isector_.

                                     {
  for (auto& i : DL_) {
    i->writeStubs(first, isector_);
  }
}

void Sector::writeIRStubs

(

bool

first

)

Definition at line 228 of file Sector.cc.

References mps_fire::i, IL_, and isector_.

                                    {
  for (auto& i : IL_) {
    i->writeStubs(first, isector_);
  }
}

void Sector::writeMC

(

bool

first

)

Definition at line 300 of file Sector.cc.

References FM_, mps_fire::i, and isector_.

                               {
  for (auto& i : FM_) {
    i->writeMC(first, isector_);
  }
}

void Sector::writeSP

(

bool

first

)

Definition at line 258 of file Sector.cc.

References mps_fire::i, isector_, and SP_.

                               {
  for (auto& i : SP_) {
    i->writeSP(first, isector_);
  }
}

void Sector::writeST

(

bool

first

)

Definition at line 264 of file Sector.cc.

References mps_fire::i, isector_, and ST_.

                               {
  for (auto& i : ST_) {
    i->writeST(first, isector_);
  }
}

void Sector::writeTF

(

bool

first

)

Definition at line 306 of file Sector.cc.

References mps_fire::i, isector_, and TF_.

                               {
  for (auto& i : TF_) {
    i->writeTF(first, isector_);
  }
}

void Sector::writeTPAR

(

bool

first

)

Definition at line 270 of file Sector.cc.

References mps_fire::i, isector_, and TPAR_.

                                 {
  for (auto& i : TPAR_) {
    i->writeTPAR(first, isector_);
  }
}

void Sector::writeTPROJ

(

bool

first

)

Definition at line 276 of file Sector.cc.

References mps_fire::i, isector_, and TPROJ_.

                                  {
  for (auto& i : TPROJ_) {
    i->writeTPROJ(first, isector_);
  }
}

void Sector::writeVMPROJ

(

bool

first

)

Definition at line 288 of file Sector.cc.

References mps_fire::i, isector_, and VMPROJ_.

                                   {
  for (auto& i : VMPROJ_) {
    i->writeVMPROJ(first, isector_);
  }
}

void Sector::writeVMSME

(

bool

first

)

Definition at line 240 of file Sector.cc.

References mps_fire::i, isector_, and VMSME_.

                                  {
  for (auto& i : VMSME_) {
    i->writeStubs(first, isector_);
  }
}

void Sector::writeVMSTE

(

bool

first

)

Definition at line 234 of file Sector.cc.

References mps_fire::i, isector_, and VMSTE_.

                                  {
  for (auto& i : VMSTE_) {
    i->writeStubs(first, isector_);
  }
}

Member Data Documentation

std::vector<std::unique_ptr<AllInnerStubsMemory> > trklet::Sector::AIS_

private

Definition at line 153 of file Sector.h.

Referenced by addMem(), and writeAIS().

std::vector<std::unique_ptr<AllProjectionsMemory> > trklet::Sector::AP_

private

Definition at line 160 of file Sector.h.

Referenced by addMem(), and writeAP().

std::vector<std::unique_ptr<AllStubsMemory> > trklet::Sector::AS_

private

Definition at line 152 of file Sector.h.

Referenced by addMem(), and writeAS().

std::vector<std::unique_ptr<CandidateMatchMemory> > trklet::Sector::CM_

private

Definition at line 162 of file Sector.h.

Referenced by addMem(), and writeCM().

std::vector<std::unique_ptr<CleanTrackMemory> > trklet::Sector::CT_

private

Definition at line 165 of file Sector.h.

Referenced by addMem(), and writeCT().

std::vector<std::unique_ptr<DTCLinkMemory> > trklet::Sector::DL_

private

Definition at line 150 of file Sector.h.

Referenced by addMem(), addStub(), and writeDTCStubs().

std::vector<std::unique_ptr<FullMatchMemory> > trklet::Sector::FM_

private

Definition at line 163 of file Sector.h.

Referenced by addMem(), and writeMC().

std::vector<std::unique_ptr<FitTrack> > trklet::Sector::FT_

private

Definition at line 181 of file Sector.h.

Referenced by addProc(), and executeFT().

Globals* trklet::Sector::globals_

private

Definition at line 144 of file Sector.h.

Referenced by addProc(), addStub(), executeTC(), and executeVMR().

std::vector<std::unique_ptr<InputLinkMemory> > trklet::Sector::IL_

private

Definition at line 151 of file Sector.h.

Referenced by addMem(), executeVMR(), getStubs(), and writeIRStubs().

std::vector<std::unique_ptr<InputRouter> > trklet::Sector::IR_

private

Definition at line 168 of file Sector.h.

Referenced by addProc(), and executeIR().

int trklet::Sector::isector_

private

Definition at line 142 of file Sector.h.

Referenced by executeFT(), executeMP(), executePD(), executeTC(), executeTCD(), executeTP(), setSector(), writeAIS(), writeAP(), writeAS(), writeCM(), writeCT(), writeDTCStubs(), writeIRStubs(), writeMC(), writeSP(), writeST(), writeTF(), writeTPAR(), writeTPROJ(), writeVMPROJ(), writeVMSME(), and writeVMSTE().

std::vector<std::unique_ptr<MatchCalculator> > trklet::Sector::MC_

private

Definition at line 179 of file Sector.h.

Referenced by addProc(), and executeMC().

std::vector<std::unique_ptr<MatchEngine> > trklet::Sector::ME_

private

Definition at line 178 of file Sector.h.

Referenced by addProc(), and executeME().

std::map<std::string, MemoryBase*> trklet::Sector::Memories_

private

Definition at line 148 of file Sector.h.

Referenced by addMemToVec(), and getMem().

std::vector<MemoryBase*> trklet::Sector::MemoriesV_

private

Definition at line 149 of file Sector.h.

Referenced by addMemToVec(), and clean().

std::vector<std::unique_ptr<MatchProcessor> > trklet::Sector::MP_

private

Definition at line 180 of file Sector.h.

Referenced by addProc(), and executeMP().

std::vector<std::unique_ptr<PurgeDuplicate> > trklet::Sector::PD_

private

Definition at line 182 of file Sector.h.

Referenced by addProc(), and executePD().

double trklet::Sector::phimax_

private

Definition at line 146 of file Sector.h.

Referenced by addMem(), executeTC(), executeTCD(), executeTP(), phimax(), and setSector().

double trklet::Sector::phimin_

private

Definition at line 145 of file Sector.h.

Referenced by addMem(), executeMC(), executeMP(), executeTC(), executeTCD(), executeTP(), phimin(), and setSector().

std::vector<std::unique_ptr<ProjectionRouter> > trklet::Sector::PR_

private

Definition at line 177 of file Sector.h.

Referenced by addProc(), and executePR().

std::map<std::string, ProcessBase*> trklet::Sector::Processes_

private

Definition at line 167 of file Sector.h.

Referenced by addProcToVec(), and getProc().

Settings const& trklet::Sector::settings_

private

Definition at line 143 of file Sector.h.

Referenced by addMem(), addProc(), addStub(), executeTC(), executeVMR(), and setSector().

std::vector<std::unique_ptr<StubPairsMemory> > trklet::Sector::SP_

private

Definition at line 156 of file Sector.h.

Referenced by addMem(), and writeSP().

std::vector<std::unique_ptr<StubTripletsMemory> > trklet::Sector::ST_

private

Definition at line 157 of file Sector.h.

Referenced by addMem(), and writeST().

std::vector<std::unique_ptr<TrackletCalculator> > trklet::Sector::TC_

private

Definition at line 175 of file Sector.h.

Referenced by addProc(), and executeTC().

std::vector<std::unique_ptr<TrackletCalculatorDisplaced> > trklet::Sector::TCD_

private

Definition at line 176 of file Sector.h.

Referenced by addProc(), and executeTCD().

std::vector<std::unique_ptr<TrackletEngine> > trklet::Sector::TE_

private

Definition at line 171 of file Sector.h.

Referenced by addProc(), and executeTE().

std::vector<std::unique_ptr<TrackletEngineDisplaced> > trklet::Sector::TED_

private

Definition at line 172 of file Sector.h.

Referenced by addProc(), and executeTED().

std::vector<std::unique_ptr<TrackFitMemory> > trklet::Sector::TF_

private

Definition at line 164 of file Sector.h.

Referenced by addMem(), and writeTF().

std::vector<std::unique_ptr<TrackletProcessor> > trklet::Sector::TP_

private

Definition at line 174 of file Sector.h.

Referenced by addProc(), and executeTP().

std::vector<std::unique_ptr<TrackletParametersMemory> > trklet::Sector::TPAR_

private

Definition at line 158 of file Sector.h.

Referenced by addMem(), getAllTracklets(), seedMatch(), and writeTPAR().

std::vector<std::unique_ptr<TrackletProjectionsMemory> > trklet::Sector::TPROJ_

private

Definition at line 159 of file Sector.h.

Referenced by addMem(), executeTC(), and writeTPROJ().

std::vector<std::unique_ptr<TripletEngine> > trklet::Sector::TRE_

private

Definition at line 173 of file Sector.h.

Referenced by addProc(), and executeTRE().

std::vector<std::unique_ptr<VMProjectionsMemory> > trklet::Sector::VMPROJ_

private

Definition at line 161 of file Sector.h.

Referenced by addMem(), and writeVMPROJ().

std::vector<std::unique_ptr<VMRouter> > trklet::Sector::VMR_

private

Definition at line 169 of file Sector.h.

Referenced by addProc(), and executeVMR().

std::vector<std::unique_ptr<VMRouterCM> > trklet::Sector::VMRCM_

private

Definition at line 170 of file Sector.h.

Referenced by addProc(), and executeVMR().

std::vector<std::unique_ptr<VMStubsMEMemory> > trklet::Sector::VMSME_

private

Definition at line 155 of file Sector.h.

Referenced by addMem(), and writeVMSME().

std::vector<std::unique_ptr<VMStubsTEMemory> > trklet::Sector::VMSTE_

private

Definition at line 154 of file Sector.h.

Referenced by addMem(), and writeVMSTE().