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	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< 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< FullMatchMemory > >	FM_
std::vector< std::unique_ptr< FitTrack > >	FT_
Globals *	globals_
std::vector< std::unique_ptr< InputLinkMemory > >	IL_
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 57 of file Sector.h.

Constructor & Destructor Documentation

Sector()

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

Definition at line 44 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 58 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 94 of file Sector.cc.

                                                  {
  if (memType == "InputLink:") {
    addMemToVec(IL_, memName, settings_, isector_, phimin_, phimax_);
  } else if (memType == "AllStubs:") {
    addMemToVec(AS_, memName, settings_, isector_);
  } else if (memType == "VMStubsTE:") {
    addMemToVec(VMSTE_, memName, settings_, isector_);
  } else if (memType == "VMStubsME:") {
    addMemToVec(VMSME_, memName, settings_, isector_);
  } else if (memType == "StubPairs:" || memType == "StubPairsDisplaced:") {
    addMemToVec(SP_, memName, settings_, isector_);
  } else if (memType == "StubTriplets:") {
    addMemToVec(ST_, memName, settings_, isector_);
  } else if (memType == "TrackletParameters:") {
    addMemToVec(TPAR_, memName, settings_, isector_);
  } else if (memType == "TrackletProjections:") {
    addMemToVec(TPROJ_, memName, settings_, isector_);
  } else if (memType == "AllProj:") {
    addMemToVec(AP_, memName, settings_, isector_);
  } else if (memType == "VMProjections:") {
    addMemToVec(VMPROJ_, memName, settings_, isector_);
  } else if (memType == "CandidateMatch:") {
    addMemToVec(CM_, memName, settings_, isector_);
  } else if (memType == "FullMatch:") {
    addMemToVec(FM_, memName, settings_, isector_);
  } else if (memType == "TrackFit:") {
    addMemToVec(TF_, memName, settings_, isector_, phimin_, phimax_);
  } else if (memType == "CleanTrack:") {
    addMemToVec(CT_, memName, settings_, isector_, phimin_, phimax_);
  } 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 , typename... Args>

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

inline

Definition at line 119 of file Sector.h.

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

References writedatasetfile::args, Memories_, and MemoriesV_.

Referenced by addMem().

addProc()

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

Definition at line 129 of file Sector.cc.

                                                     {
  if (procType == "VMRouter:") {
    addProcToVec(VMR_, procName, settings_, globals_, isector_);
  } else if (procType == "VMRouterCM:") {
    addProcToVec(VMRCM_, procName, settings_, globals_, isector_);
  } else if (procType == "TrackletEngine:") {
    addProcToVec(TE_, procName, settings_, globals_, isector_);
  } else if (procType == "TrackletEngineDisplaced:") {
    addProcToVec(TED_, procName, settings_, globals_, isector_);
  } else if (procType == "TripletEngine:") {
    addProcToVec(TRE_, procName, settings_, globals_, isector_);
  } else if (procType == "TrackletCalculator:") {
    addProcToVec(TC_, procName, settings_, globals_, isector_);
  } else if (procType == "TrackletProcessor:") {
    addProcToVec(TP_, procName, settings_, globals_, isector_);
  } else if (procType == "TrackletCalculatorDisplaced:") {
    addProcToVec(TCD_, procName, settings_, globals_, isector_);
  } else if (procType == "ProjectionRouter:") {
    addProcToVec(PR_, procName, settings_, globals_, isector_);
  } else if (procType == "MatchEngine:") {
    addProcToVec(ME_, procName, settings_, globals_, isector_);
  } else if (procType == "MatchCalculator:" ||
             procType == "DiskMatchCalculator:") {  //TODO should not be used in configurations
    addProcToVec(MC_, procName, settings_, globals_, isector_);
  } else if (procType == "MatchProcessor:") {
    addProcToVec(MP_, procName, settings_, globals_, isector_);
  } else if (procType == "FitTrack:") {
    addProcToVec(FT_, procName, settings_, globals_, isector_);
  } else if (procType == "PurgeDuplicate:") {
    addProcToVec(PD_, procName, settings_, globals_, isector_);
  } 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_, VMR_, and VMRCM_.

addProcToVec()

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 126 of file Sector.h.

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

References writedatasetfile::args, and Processes_.

Referenced by addProc().

addStub()

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

Definition at line 64 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 165 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, and convertSQLitetoXML_cfg::output.

clean()

void Sector::clean

(

)

Definition at line 293 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 391 of file Sector.cc.

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

References FT_, and mps_fire::i.

executeMC()

void Sector::executeMC

(

)

Definition at line 379 of file Sector.cc.

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

References mps_fire::i, and MC_.

executeME()

void Sector::executeME

(

)

Definition at line 373 of file Sector.cc.

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

References mps_fire::i, and ME_.

executeMP()

void Sector::executeMP

(

)

Definition at line 385 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 397 of file Sector.cc.

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

References mps_fire::i, PD_, and tracks.

executePR()

void Sector::executePR

(

)

Definition at line 367 of file Sector.cc.

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

References mps_fire::i, and PR_.

executeTC()

void Sector::executeTC

(

)

Definition at line 348 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 361 of file Sector.cc.

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

References mps_fire::i, and TCD_.

executeTE()

void Sector::executeTE

(

)

Definition at line 324 of file Sector.cc.

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

References mps_fire::i, and TE_.

executeTED()

void Sector::executeTED

(

)

Definition at line 330 of file Sector.cc.

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

References mps_fire::i, and TED_.

executeTP()

void Sector::executeTP

(

)

Definition at line 342 of file Sector.cc.

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

References mps_fire::i, and TP_.

executeTRE()

void Sector::executeTRE

(

)

Definition at line 336 of file Sector.cc.

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

References mps_fire::i, and TRE_.

executeVMR()

void Sector::executeVMR

(

)

Definition at line 309 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();
  }
  for (auto& i : VMRCM_) {
    i->execute();
  }
}

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

getAllTracklets()

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

(

)

const

Definition at line 403 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 199 of file Sector.cc.

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

References Exception, and Memories_.

Referenced by addWire().

getProc()

ProcessBase * Sector::getProc

(

std::string

procName

)

Definition at line 189 of file Sector.cc.

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

References Exception, and Processes_.

Referenced by addWire().

getStubs()

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

(

)

const

Definition at line 413 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 116 of file Sector.h.

{ return phimax_; }

References phimax_.

phimin()

double trklet::Sector::phimin ( ) const

inline

Definition at line 115 of file Sector.h.

{ return phimin_; }

References phimin_.

seedMatch()

std::unordered_set< int > Sector::seedMatch

(

int

itp

)

const

Definition at line 425 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 257 of file Sector.cc.

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

References AP_, first, and mps_fire::i.

writeAS()

void Sector::writeAS

(

bool

first

)

Definition at line 227 of file Sector.cc.

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

References AS_, first, and mps_fire::i.

writeCM()

void Sector::writeCM

(

bool

first

)

Definition at line 269 of file Sector.cc.

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

References CM_, first, and mps_fire::i.

writeCT()

void Sector::writeCT

(

bool

first

)

Definition at line 287 of file Sector.cc.

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

References CT_, first, and mps_fire::i.

writeInputStubs()

void Sector::writeInputStubs

(

bool

first

)

Definition at line 209 of file Sector.cc.

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

References first, mps_fire::i, and IL_.

writeMC()

void Sector::writeMC

(

bool

first

)

Definition at line 275 of file Sector.cc.

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

References first, FM_, and mps_fire::i.

writeSP()

void Sector::writeSP

(

bool

first

)

Definition at line 233 of file Sector.cc.

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

References first, mps_fire::i, and SP_.

writeST()

void Sector::writeST

(

bool

first

)

Definition at line 239 of file Sector.cc.

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

References first, mps_fire::i, and ST_.

writeTF()

void Sector::writeTF

(

bool

first

)

Definition at line 281 of file Sector.cc.

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

References first, mps_fire::i, and TF_.

writeTPAR()

void Sector::writeTPAR

(

bool

first

)

Definition at line 245 of file Sector.cc.

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

References first, mps_fire::i, and TPAR_.

writeTPROJ()

void Sector::writeTPROJ

(

bool

first

)

Definition at line 251 of file Sector.cc.

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

References first, mps_fire::i, and TPROJ_.

writeVMPROJ()

void Sector::writeVMPROJ

(

bool

first

)

Definition at line 263 of file Sector.cc.

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

References first, mps_fire::i, and VMPROJ_.

writeVMSME()

void Sector::writeVMSME

(

bool

first

)

Definition at line 221 of file Sector.cc.

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

References first, mps_fire::i, and VMSME_.

writeVMSTE()

void Sector::writeVMSTE

(

bool

first

)

Definition at line 215 of file Sector.cc.

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

References first, mps_fire::i, and VMSTE_.

Member Data Documentation

AP_

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

private

Definition at line 148 of file Sector.h.

Referenced by addMem(), and writeAP().

AS_

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

private

Definition at line 141 of file Sector.h.

Referenced by addMem(), and writeAS().

CM_

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

private

Definition at line 150 of file Sector.h.

Referenced by addMem(), and writeCM().

CT_

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

private

Definition at line 153 of file Sector.h.

Referenced by addMem(), and writeCT().

FM_

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

private

Definition at line 151 of file Sector.h.

Referenced by addMem(), and writeMC().

FT_

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

private

Definition at line 168 of file Sector.h.

Referenced by addProc(), and executeFT().

globals_

Globals* trklet::Sector::globals_

private

Definition at line 134 of file Sector.h.

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

IL_

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

private

Definition at line 140 of file Sector.h.

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

isector_

int trklet::Sector::isector_

private

Definition at line 132 of file Sector.h.

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

MC_

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

private

Definition at line 166 of file Sector.h.

Referenced by addProc(), and executeMC().

ME_

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

private

Definition at line 165 of file Sector.h.

Referenced by addProc(), and executeME().

Memories_

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

private

Definition at line 138 of file Sector.h.

Referenced by addMemToVec(), and getMem().

MemoriesV_

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

private

Definition at line 139 of file Sector.h.

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

MP_

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

private

Definition at line 167 of file Sector.h.

Referenced by addProc(), and executeMP().

PD_

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

private

Definition at line 169 of file Sector.h.

Referenced by addProc(), and executePD().

phimax_

double trklet::Sector::phimax_

private

Definition at line 136 of file Sector.h.

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

phimin_

double trklet::Sector::phimin_

private

Definition at line 135 of file Sector.h.

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

PR_

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

private

Definition at line 164 of file Sector.h.

Referenced by addProc(), and executePR().

Processes_

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

private

Definition at line 155 of file Sector.h.

Referenced by addProcToVec(), and getProc().

settings_

Settings const& trklet::Sector::settings_

private

Definition at line 133 of file Sector.h.

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

SP_

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

private

Definition at line 144 of file Sector.h.

Referenced by addMem(), and writeSP().

ST_

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

private

Definition at line 145 of file Sector.h.

Referenced by addMem(), and writeST().

TC_

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

private

Definition at line 162 of file Sector.h.

Referenced by addProc(), and executeTC().

TCD_

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

private

Definition at line 163 of file Sector.h.

Referenced by addProc(), and executeTCD().

TE_

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

private

Definition at line 158 of file Sector.h.

Referenced by addProc(), and executeTE().

TED_

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

private

Definition at line 159 of file Sector.h.

Referenced by addProc(), and executeTED().

TF_

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

private

Definition at line 152 of file Sector.h.

Referenced by addMem(), and writeTF().

TP_

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

private

Definition at line 161 of file Sector.h.

Referenced by addProc(), and executeTP().

TPAR_

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

private

Definition at line 146 of file Sector.h.

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

TPROJ_

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

private

Definition at line 147 of file Sector.h.

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

TRE_

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

private

Definition at line 160 of file Sector.h.

Referenced by addProc(), and executeTRE().

VMPROJ_

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

private

Definition at line 149 of file Sector.h.

Referenced by addMem(), and writeVMPROJ().

VMR_

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

private

Definition at line 156 of file Sector.h.

Referenced by addProc(), and executeVMR().

VMRCM_

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

private

Definition at line 157 of file Sector.h.

Referenced by addProc(), and executeVMR().

VMSME_

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

private

Definition at line 143 of file Sector.h.

Referenced by addMem(), and writeVMSME().

VMSTE_

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

private

Definition at line 142 of file Sector.h.

Referenced by addMem(), and writeVMSTE().