trklet::Sector Class Reference

#include <Sector.h>

Public Member Functions
void	addMem (std::string memType, std::string memName)
template<typename TV >
void	addMemToVec (std::vector< TV * > &memvec, TV *mem, const std::string &memName)
void	addProc (std::string procType, std::string procName)
template<typename TV >
void	addProcToVec (std::vector< TV * > &procvec, TV *proc, const std::string &procName)
bool	addStub (L1TStub stub, std::string dtc)
void	addWire (std::string mem, std::string procinfull, std::string procoutfull)
void	clean ()
void	executeFT ()
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 (unsigned int i, Settings const &settings, Globals *globals)
std::unordered_set< int >	seedMatch (int itp) const
void	writeAP (bool first)
void	writeAS (bool first)
void	writeCM (bool first)
void	writeCT (bool first)
void	writeInputStubs (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< AllProjectionsMemory * >	AP_
std::vector< AllStubsMemory * >	AS_
std::vector< CandidateMatchMemory * >	CM_
std::vector< CleanTrackMemory * >	CT_
std::vector< FullMatchMemory * >	FM_
std::vector< FitTrack * >	FT_
Globals *	globals_
std::vector< InputLinkMemory * >	IL_
int	isector_
std::vector< MatchCalculator * >	MC_
std::vector< MatchEngine * >	ME_
std::map< std::string, std::unique_ptr< MemoryBase > >	Memories_
std::vector< MemoryBase * >	MemoriesV_
std::vector< MatchProcessor * >	MP_
std::vector< PurgeDuplicate * >	PD_
double	phimax_
double	phimin_
std::vector< ProjectionRouter * >	PR_
std::map< std::string, std::unique_ptr< ProcessBase > >	Processes_
Settings const &	settings_
std::vector< StubPairsMemory * >	SP_
std::vector< StubTripletsMemory * >	ST_
std::vector< TrackletCalculator * >	TC_
std::vector< TrackletCalculatorDisplaced * >	TCD_
std::vector< TrackletEngine * >	TE_
std::vector< TrackletEngineDisplaced * >	TED_
std::vector< TrackFitMemory * >	TF_
std::vector< TrackletProcessor * >	TP_
std::vector< TrackletParametersMemory * >	TPAR_
std::vector< TrackletProjectionsMemory * >	TPROJ_
std::vector< TripletEngine * >	TRE_
std::vector< VMProjectionsMemory * >	VMPROJ_
std::vector< VMRouter * >	VMR_
std::vector< VMStubsMEMemory * >	VMSME_
std::vector< VMStubsTEMemory * >	VMSTE_

Detailed Description

Definition at line 56 of file Sector.h.

Constructor & Destructor Documentation

Sector()

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

Definition at line 43 of file Sector.cc.

                                                                         : settings_(settings), globals_(globals) {
  isector_ = i;
  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;
}

References trklet::Settings::dphisectorHG(), mps_fire::i, isector_, M_PI, trklet::N_SECTOR, phimax_, phimin_, reco::reduceRange(), and settings_.

~Sector()

Sector::~Sector

(

)

Definition at line 57 of file Sector.cc.

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

References mem, and MemoriesV_.

Member Function Documentation

addMem()

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

Definition at line 93 of file Sector.cc.

                                                  {
  if (memType == "InputLink:") {
    addMemToVec(IL_, new InputLinkMemory(memName, settings_, isector_, phimin_, phimax_), memName);
  } else if (memType == "AllStubs:") {
    addMemToVec(AS_, new AllStubsMemory(memName, settings_, isector_), memName);
  } else if (memType == "VMStubsTE:") {
    addMemToVec(VMSTE_, new VMStubsTEMemory(memName, settings_, isector_), memName);
  } else if (memType == "VMStubsME:") {
    addMemToVec(VMSME_, new VMStubsMEMemory(memName, settings_, isector_), memName);
  } else if (memType == "StubPairs:" || memType == "StubPairsDisplaced:") {
    addMemToVec(SP_, new StubPairsMemory(memName, settings_, isector_), memName);
  } else if (memType == "StubTriplets:") {
    addMemToVec(ST_, new StubTripletsMemory(memName, settings_, isector_), memName);
  } else if (memType == "TrackletParameters:") {
    addMemToVec(TPAR_, new TrackletParametersMemory(memName, settings_, isector_), memName);
  } else if (memType == "TrackletProjections:") {
    addMemToVec(TPROJ_, new TrackletProjectionsMemory(memName, settings_, isector_), memName);
  } else if (memType == "AllProj:") {
    addMemToVec(AP_, new AllProjectionsMemory(memName, settings_, isector_), memName);
  } else if (memType == "VMProjections:") {
    addMemToVec(VMPROJ_, new VMProjectionsMemory(memName, settings_, isector_), memName);
  } else if (memType == "CandidateMatch:") {
    addMemToVec(CM_, new CandidateMatchMemory(memName, settings_, isector_), memName);
  } else if (memType == "FullMatch:") {
    addMemToVec(FM_, new FullMatchMemory(memName, settings_, isector_), memName);
  } else if (memType == "TrackFit:") {
    addMemToVec(TF_, new TrackFitMemory(memName, settings_, isector_, phimin_, phimax_), memName);
  } else if (memType == "CleanTrack:") {
    addMemToVec(CT_, new CleanTrackMemory(memName, settings_, isector_, phimin_, phimax_), memName);
  } else {
    edm::LogPrint("Tracklet") << "Don't know of memory type: " << memType;
    exit(0);
  }
}

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

addMemToVec()

template<typename TV >

void trklet::Sector::addMemToVec ( std::vector< TV * > &  memvec, TV *  mem, const std::string &  memName  )

inline

Definition at line 118 of file Sector.h.

                                                                                {
      memvec.push_back(mem);
      Memories_[memName].reset(mem);
      MemoriesV_.push_back(mem);
    }

References mem, Memories_, and MemoriesV_.

Referenced by addMem().

addProc()

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

Definition at line 128 of file Sector.cc.

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

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

addProcToVec()

template<typename TV >

void trklet::Sector::addProcToVec ( std::vector< TV * > &  procvec, TV *  proc, const std::string &  procName  )

inline

Definition at line 125 of file Sector.h.

                                                                                    {
      procvec.push_back(proc);
      Processes_[procName].reset(proc);
    }

References ValidateTausOnZEEFastSim_cff::proc, and Processes_.

Referenced by addProc().

addStub()

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

Definition at line 63 of file Sector.cc.

                                             {
  bool add = false;
 
  double phi = stub.phi();
  double dphi = 0.5 * settings_.dphisectorHG() - M_PI / N_SECTOR;
 
  std::map<string, std::vector<int> >& ILindex = globals_->ILindex();
  std::vector<int>& tmp = ILindex[dtc];
  if (tmp.empty()) {
    for (unsigned int i = 0; i < IL_.size(); i++) {
      if (IL_[i]->getName().find("_" + dtc) != string::npos) {
        tmp.push_back(i);
      }
    }
  }
 
  if (((phi > phimin_ - dphi) && (phi < phimax_ + dphi)) ||
      ((phi > 2 * M_PI + phimin_ - dphi) && (phi < 2 * M_PI + phimax_ + dphi))) {
    Stub fpgastub(stub, settings_, phimin_, phimax_);
    std::vector<int>& tmp = ILindex[dtc];
    assert(!tmp.empty());
    for (int i : tmp) {
      if (IL_[i]->addStub(settings_, globals_, stub, fpgastub, dtc))
        add = true;
    }
  }
 
  return add;
}

References PVValHelper::add(), cms::cuda::assert(), trklet::Settings::dphisectorHG(), getName(), globals_, mps_fire::i, IL_, trklet::Globals::ILindex(), M_PI, trklet::N_SECTOR, trklet::L1TStub::phi(), phimax_, phimin_, settings_, and createJobs::tmp.

addWire()

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

Definition at line 162 of file Sector.cc.

                                                                      {
  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);
  }
}

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

clean()

void Sector::clean

(

)

Definition at line 290 of file Sector.cc.

                   {
  if (settings_.writeMonitorData("NMatches")) {
    int matchesL1 = 0;
    int matchesL3 = 0;
    int matchesL5 = 0;
    for (auto& i : TPAR_) {
      i->writeMatches(globals_, matchesL1, matchesL3, matchesL5);
    }
    globals_->ofstream("nmatchessector.txt") << matchesL1 << " " << matchesL3 << " " << matchesL5 << endl;
  }
 
  for (auto& mem : MemoriesV_) {
    mem->clean();
  }
}

References globals_, mps_fire::i, mem, MemoriesV_, trklet::Globals::ofstream(), settings_, TPAR_, and trklet::Settings::writeMonitorData().

executeFT()

void Sector::executeFT

(

)

Definition at line 385 of file Sector.cc.

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

References FT_, and mps_fire::i.

executeMC()

void Sector::executeMC

(

)

Definition at line 373 of file Sector.cc.

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

References mps_fire::i, and MC_.

executeME()

void Sector::executeME

(

)

Definition at line 367 of file Sector.cc.

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

References mps_fire::i, and ME_.

executeMP()

void Sector::executeMP

(

)

Definition at line 379 of file Sector.cc.

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

References mps_fire::i, and MP_.

executePD()

void Sector::executePD

(

std::vector< Track * > &

tracks

)

Definition at line 391 of file Sector.cc.

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

References mps_fire::i, PD_, and PDWG_EXOHSCP_cff::tracks.

executePR()

void Sector::executePR

(

)

Definition at line 361 of file Sector.cc.

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

References mps_fire::i, and PR_.

executeTC()

void Sector::executeTC

(

)

Definition at line 342 of file Sector.cc.

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

References globals_, mps_fire::i, trklet::Globals::ofstream(), MillePedeFileConverter_cfg::out, settings_, TC_, TPROJ_, and trklet::Settings::writeMonitorData().

executeTCD()

void Sector::executeTCD

(

)

Definition at line 355 of file Sector.cc.

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

References mps_fire::i, and TCD_.

executeTE()

void Sector::executeTE

(

)

Definition at line 318 of file Sector.cc.

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

References mps_fire::i, and TE_.

executeTED()

void Sector::executeTED

(

)

Definition at line 324 of file Sector.cc.

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

References mps_fire::i, and TED_.

executeTP()

void Sector::executeTP

(

)

Definition at line 336 of file Sector.cc.

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

References mps_fire::i, and TP_.

executeTRE()

void Sector::executeTRE

(

)

Definition at line 330 of file Sector.cc.

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

References mps_fire::i, and TRE_.

executeVMR()

void Sector::executeVMR

(

)

Definition at line 306 of file Sector.cc.

                        {
  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();
  }
}

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

getAllTracklets()

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

(

)

const

Definition at line 397 of file Sector.cc.

                                                   {
  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;
}

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

getMem()

MemoryBase * Sector::getMem

(

std::string

memName

)

Definition at line 196 of file Sector.cc.

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

References Exception, and Memories_.

Referenced by addWire().

getProc()

ProcessBase * Sector::getProc

(

std::string

procName

)

Definition at line 186 of file Sector.cc.

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

References Exception, and Processes_.

Referenced by addWire().

getStubs()

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

(

)

const

Definition at line 407 of file Sector.cc.

                                              {
  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;
}

References IL_, and createJobs::tmp.

phimax()

double trklet::Sector::phimax ( ) const

inline

Definition at line 115 of file Sector.h.

{ return phimax_; }

References phimax_.

phimin()

double trklet::Sector::phimin ( ) const

inline

Definition at line 114 of file Sector.h.

{ return phimin_; }

References phimin_.

seedMatch()

std::unordered_set< int > Sector::seedMatch

(

int

itp

)

const

Definition at line 419 of file Sector.cc.

                                                     {
  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;
}

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

writeAP()

void Sector::writeAP

(

bool

first

)

Definition at line 254 of file Sector.cc.

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

References AP_, dqmdumpme::first, and mps_fire::i.

writeAS()

void Sector::writeAS

(

bool

first

)

Definition at line 224 of file Sector.cc.

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

References AS_, dqmdumpme::first, and mps_fire::i.

writeCM()

void Sector::writeCM

(

bool

first

)

Definition at line 266 of file Sector.cc.

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

References CM_, dqmdumpme::first, and mps_fire::i.

writeCT()

void Sector::writeCT

(

bool

first

)

Definition at line 284 of file Sector.cc.

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

References CT_, dqmdumpme::first, and mps_fire::i.

writeInputStubs()

void Sector::writeInputStubs

(

bool

first

)

Definition at line 206 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and IL_.

writeMC()

void Sector::writeMC

(

bool

first

)

Definition at line 272 of file Sector.cc.

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

References dqmdumpme::first, FM_, and mps_fire::i.

writeSP()

void Sector::writeSP

(

bool

first

)

Definition at line 230 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and SP_.

writeST()

void Sector::writeST

(

bool

first

)

Definition at line 236 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and ST_.

writeTF()

void Sector::writeTF

(

bool

first

)

Definition at line 278 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and TF_.

writeTPAR()

void Sector::writeTPAR

(

bool

first

)

Definition at line 242 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and TPAR_.

writeTPROJ()

void Sector::writeTPROJ

(

bool

first

)

Definition at line 248 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and TPROJ_.

writeVMPROJ()

void Sector::writeVMPROJ

(

bool

first

)

Definition at line 260 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and VMPROJ_.

writeVMSME()

void Sector::writeVMSME

(

bool

first

)

Definition at line 218 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and VMSME_.

writeVMSTE()

void Sector::writeVMSTE

(

bool

first

)

Definition at line 212 of file Sector.cc.

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

References dqmdumpme::first, mps_fire::i, and VMSTE_.

Member Data Documentation

AP_

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

private

Definition at line 147 of file Sector.h.

Referenced by addMem(), and writeAP().

AS_

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

private

Definition at line 140 of file Sector.h.

Referenced by addMem(), and writeAS().

CM_

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

private

Definition at line 149 of file Sector.h.

Referenced by addMem(), and writeCM().

CT_

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

private

Definition at line 152 of file Sector.h.

Referenced by addMem(), and writeCT().

FM_

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

private

Definition at line 150 of file Sector.h.

Referenced by addMem(), and writeMC().

FT_

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

private

Definition at line 166 of file Sector.h.

Referenced by addProc(), and executeFT().

globals_

Globals* trklet::Sector::globals_

private

Definition at line 133 of file Sector.h.

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

IL_

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

private

Definition at line 139 of file Sector.h.

Referenced by addMem(), addStub(), executeVMR(), getStubs(), and writeInputStubs().

isector_

int trklet::Sector::isector_

private

Definition at line 131 of file Sector.h.

Referenced by addMem(), addProc(), and Sector().

MC_

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

private

Definition at line 164 of file Sector.h.

Referenced by addProc(), and executeMC().

ME_

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

private

Definition at line 163 of file Sector.h.

Referenced by addProc(), and executeME().

Memories_

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

private

Definition at line 137 of file Sector.h.

Referenced by addMemToVec(), and getMem().

MemoriesV_

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

private

Definition at line 138 of file Sector.h.

Referenced by addMemToVec(), clean(), and ~Sector().

MP_

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

private

Definition at line 165 of file Sector.h.

Referenced by addProc(), and executeMP().

PD_

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

private

Definition at line 167 of file Sector.h.

Referenced by addProc(), and executePD().

phimax_

double trklet::Sector::phimax_

private

Definition at line 135 of file Sector.h.

Referenced by addMem(), addStub(), phimax(), and Sector().

phimin_

double trklet::Sector::phimin_

private

Definition at line 134 of file Sector.h.

Referenced by addMem(), addStub(), phimin(), and Sector().

PR_

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

private

Definition at line 162 of file Sector.h.

Referenced by addProc(), and executePR().

Processes_

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

private

Definition at line 154 of file Sector.h.

Referenced by addProcToVec(), and getProc().

settings_

Settings const& trklet::Sector::settings_

private

Definition at line 132 of file Sector.h.

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

SP_

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

private

Definition at line 143 of file Sector.h.

Referenced by addMem(), and writeSP().

ST_

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

private

Definition at line 144 of file Sector.h.

Referenced by addMem(), and writeST().

TC_

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

private

Definition at line 160 of file Sector.h.

Referenced by addProc(), and executeTC().

TCD_

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

private

Definition at line 161 of file Sector.h.

Referenced by addProc(), and executeTCD().

TE_

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

private

Definition at line 156 of file Sector.h.

Referenced by addProc(), and executeTE().

TED_

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

private

Definition at line 157 of file Sector.h.

Referenced by addProc(), and executeTED().

TF_

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

private

Definition at line 151 of file Sector.h.

Referenced by addMem(), and writeTF().

TP_

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

private

Definition at line 159 of file Sector.h.

Referenced by addProc(), and executeTP().

TPAR_

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

private

Definition at line 145 of file Sector.h.

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

TPROJ_

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

private

Definition at line 146 of file Sector.h.

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

TRE_

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

private

Definition at line 158 of file Sector.h.

Referenced by addProc(), and executeTRE().

VMPROJ_

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

private

Definition at line 148 of file Sector.h.

Referenced by addMem(), and writeVMPROJ().

VMR_

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

private

Definition at line 155 of file Sector.h.

Referenced by addProc(), and executeVMR().

VMSME_

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

private

Definition at line 142 of file Sector.h.

Referenced by addMem(), and writeVMSME().

VMSTE_

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

private

Definition at line 141 of file Sector.h.

Referenced by addMem(), and writeVMSTE().