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 (std::vector< std::vector< std::string >> &streamsTrackRaw, std::vector< std::vector< StubStreamData >> &streamsStubRaw)
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	executeTPD ()
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< TrackletProcessorDisplaced > >	TPD_
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 63 of file Sector.h.

Constructor & Destructor Documentation

Sector()

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

Definition at line 52 of file Sector.cc.

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

~Sector()

Sector::~Sector ( )

default

Member Function Documentation

addMem()

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

Definition at line 107 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);
  }
}

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

References writedatasetfile::args, 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());
    }

addProc()

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

Definition at line 146 of file Sector.cc.

References addProcToVec(), beamvalidation::exit(), FT_, globals_, IR_, MC_, ME_, MP_, PD_, PR_, settings_, TC_, TCD_, TE_, TED_, TP_, TPD_, 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 == "TrackletProcessorDisplaced:") {
    addProcToVec(TPD_, 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);
  }
}

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

References writedatasetfile::args, and Processes_.

Referenced by addProc().

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

addStub()

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

Definition at line 72 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, Skims_PA_cff::name, trklet::Globals::phiCorr(), trklet::Stub::r(), trklet::Settings::reduced(), trklet::Stub::setPhiCorr(), settings_, and trklet::FPGAWord::value().

                                             {
  unsigned int layerdisk = stub.layerdisk();
  int nrbits = 3;

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

  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() - nrbits);
    const TrackletLUT& phiCorrTable = *globals_->phiCorr(layerdisk);
    int iphicorr = phiCorrTable.lookup(bendbin * (1 << nrbits) + 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++;
  }

  if (!(settings_.reduced()))
    assert(nadd == 1);

  return true;
}

addWire()

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

Definition at line 186 of file Sector.cc.

References trklet::ProcessBase::addInput(), trklet::ProcessBase::addOutput(), getMem(), getProc(), input, mem, 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);
  }
}

clean()

void Sector::clean

(

)

Definition at line 326 of file Sector.cc.

References mem, and MemoriesV_.

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

executeFT()

void Sector::executeFT	(	std::vector< std::vector< std::string >> &	streamsTrackRaw,
		std::vector< std::vector< StubStreamData >> &	streamsStubRaw
	)

Definition at line 430 of file Sector.cc.

References FT_, mps_fire::i, isector_, trklet::N_SECTOR, settings_, trklet::Settings::storeTrackBuilderOutput(), and cms::cuda::stream.

                                                                                                              {
  const int numChannels = streamsTrackRaw.size() / N_SECTOR;
  const int maxNumProjectionLayers = streamsStubRaw.size() / streamsTrackRaw.size();
  const int offsetTrack = isector_ * numChannels;
  int channelTrack(0);

  for (auto& i : FT_) {
    // Temporary streams for a single TrackBuilder (i.e. seed type)
    deque<string> streamTrackTmp;
    vector<deque<StubStreamData>> streamsStubTmp(maxNumProjectionLayers);
    i->execute(streamTrackTmp, streamsStubTmp, isector_);
    if (!settings_.storeTrackBuilderOutput())
      continue;
    const int offsetStub = (offsetTrack + channelTrack) * maxNumProjectionLayers;
    streamsTrackRaw[offsetTrack + channelTrack] = vector<string>(streamTrackTmp.begin(), streamTrackTmp.end());
    channelTrack++;
    int channelStub(0);
    for (auto& stream : streamsStubTmp)
      streamsStubRaw[offsetStub + channelStub++] = vector<StubStreamData>(stream.begin(), stream.end());
  }
}

executeIR()

void Sector::executeIR

(

)

Definition at line 332 of file Sector.cc.

References mps_fire::i, and IR_.

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

executeMC()

void Sector::executeMC

(

)

Definition at line 414 of file Sector.cc.

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

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

executeME()

void Sector::executeME

(

)

Definition at line 408 of file Sector.cc.

References mps_fire::i, isector_, and ME_.

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

executeMP()

void Sector::executeMP

(

)

Definition at line 420 of file Sector.cc.

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

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

executePD()

void Sector::executePD

(

std::vector< Track > &

tracks

)

Definition at line 453 of file Sector.cc.

References mps_fire::i, isector_, PD_, and pwdgSkimBPark_cfi::tracks.

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

executePR()

void Sector::executePR

(

)

Definition at line 402 of file Sector.cc.

References mps_fire::i, and PR_.

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

executeTC()

void Sector::executeTC

(

)

Definition at line 383 of file Sector.cc.

References globals_, mps_fire::i, isector_, trklet::Globals::ofstream(), MillePedeFileConverter_cfg::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;
    }
  }
}

executeTCD()

void Sector::executeTCD

(

)

Definition at line 396 of file Sector.cc.

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

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

executeTE()

void Sector::executeTE

(

)

Definition at line 353 of file Sector.cc.

References mps_fire::i, and TE_.

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

executeTED()

void Sector::executeTED

(

)

Definition at line 359 of file Sector.cc.

References mps_fire::i, and TED_.

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

executeTP()

void Sector::executeTP

(

)

Definition at line 371 of file Sector.cc.

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

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

executeTPD()

void Sector::executeTPD

(

)

Definition at line 377 of file Sector.cc.

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

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

executeTRE()

void Sector::executeTRE

(

)

Definition at line 365 of file Sector.cc.

References mps_fire::i, and TRE_.

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

executeVMR()

void Sector::executeVMR

(

)

Definition at line 338 of file Sector.cc.

References globals_, mps_fire::i, IL_, isector_, trklet::Globals::ofstream(), MillePedeFileConverter_cfg::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(isector_);
  }
}

getAllTracklets()

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

(

)

const

Definition at line 459 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;
}

getMem()

MemoryBase * Sector::getMem

(

std::string

memName

)

Definition at line 220 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;
}

getProc()

ProcessBase * Sector::getProc

(

std::string

procName

)

Definition at line 210 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;
}

getStubs()

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

(

)

const

Definition at line 469 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;
}

phimax()

double trklet::Sector::phimax ( ) const

inline

Definition at line 130 of file Sector.h.

References phimax_.

{ return phimax_; }

phimin()

double trklet::Sector::phimin ( ) const

inline

Definition at line 129 of file Sector.h.

References phimin_.

{ return phimin_; }

seedMatch()

std::unordered_set< int > Sector::seedMatch

(

int

itp

)

const

Definition at line 481 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;
}

setSector()

void Sector::setSector

(

unsigned int

isector

)

Definition at line 56 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;
  }
}

writeAIS()

void Sector::writeAIS

(

bool

first

)

Definition at line 260 of file Sector.cc.

References AIS_, dqmdumpme::first, mps_fire::i, and isector_.

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

writeAP()

void Sector::writeAP

(

bool

first

)

Definition at line 290 of file Sector.cc.

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

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

writeAS()

void Sector::writeAS

(

bool

first

)

Definition at line 254 of file Sector.cc.

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

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

writeCM()

void Sector::writeCM

(

bool

first

)

Definition at line 302 of file Sector.cc.

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

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

writeCT()

void Sector::writeCT

(

bool

first

)

Definition at line 320 of file Sector.cc.

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

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

writeDTCStubs()

void Sector::writeDTCStubs

(

bool

first

)

Definition at line 230 of file Sector.cc.

References DL_, dqmdumpme::first, mps_fire::i, and isector_.

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

writeIRStubs()

void Sector::writeIRStubs

(

bool

first

)

Definition at line 236 of file Sector.cc.

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

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

writeMC()

void Sector::writeMC

(

bool

first

)

Definition at line 308 of file Sector.cc.

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

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

writeSP()

void Sector::writeSP

(

bool

first

)

Definition at line 266 of file Sector.cc.

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

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

writeST()

void Sector::writeST

(

bool

first

)

Definition at line 272 of file Sector.cc.

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

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

writeTF()

void Sector::writeTF

(

bool

first

)

Definition at line 314 of file Sector.cc.

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

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

writeTPAR()

void Sector::writeTPAR

(

bool

first

)

Definition at line 278 of file Sector.cc.

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

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

writeTPROJ()

void Sector::writeTPROJ

(

bool

first

)

Definition at line 284 of file Sector.cc.

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

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

writeVMPROJ()

void Sector::writeVMPROJ

(

bool

first

)

Definition at line 296 of file Sector.cc.

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

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

writeVMSME()

void Sector::writeVMSME

(

bool

first

)

Definition at line 248 of file Sector.cc.

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

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

writeVMSTE()

void Sector::writeVMSTE

(

bool

first

)

Definition at line 242 of file Sector.cc.

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

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

Member Data Documentation

AIS_

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

private

Definition at line 157 of file Sector.h.

Referenced by addMem(), and writeAIS().

AP_

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

private

Definition at line 164 of file Sector.h.

Referenced by addMem(), and writeAP().

AS_

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

private

Definition at line 156 of file Sector.h.

Referenced by addMem(), and writeAS().

CM_

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

private

Definition at line 166 of file Sector.h.

Referenced by addMem(), and writeCM().

CT_

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

private

Definition at line 169 of file Sector.h.

Referenced by addMem(), and writeCT().

DL_

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

private

Definition at line 154 of file Sector.h.

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

FM_

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

private

Definition at line 167 of file Sector.h.

Referenced by addMem(), and writeMC().

FT_

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

private

Definition at line 186 of file Sector.h.

Referenced by addProc(), and executeFT().

globals_

Globals* trklet::Sector::globals_

private

Definition at line 148 of file Sector.h.

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

IL_

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

private

Definition at line 155 of file Sector.h.

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

IR_

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

private

Definition at line 172 of file Sector.h.

Referenced by addProc(), and executeIR().

isector_

int trklet::Sector::isector_

private

Definition at line 146 of file Sector.h.

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

MC_

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

private

Definition at line 184 of file Sector.h.

Referenced by addProc(), and executeMC().

ME_

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

private

Definition at line 183 of file Sector.h.

Referenced by addProc(), and executeME().

Memories_

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

private

Definition at line 152 of file Sector.h.

Referenced by addMemToVec(), and getMem().

MemoriesV_

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

private

Definition at line 153 of file Sector.h.

Referenced by addMemToVec(), and clean().

MP_

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

private

Definition at line 185 of file Sector.h.

Referenced by addProc(), and executeMP().

PD_

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

private

Definition at line 187 of file Sector.h.

Referenced by addProc(), and executePD().

phimax_

double trklet::Sector::phimax_

private

Definition at line 150 of file Sector.h.

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

phimin_

double trklet::Sector::phimin_

private

Definition at line 149 of file Sector.h.

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

PR_

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

private

Definition at line 182 of file Sector.h.

Referenced by addProc(), and executePR().

Processes_

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

private

Definition at line 171 of file Sector.h.

Referenced by addProcToVec(), and getProc().

settings_

Settings const& trklet::Sector::settings_

private

Definition at line 147 of file Sector.h.

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

SP_

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

private

Definition at line 160 of file Sector.h.

Referenced by addMem(), and writeSP().

ST_

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

private

Definition at line 161 of file Sector.h.

Referenced by addMem(), and writeST().

TC_

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

private

Definition at line 180 of file Sector.h.

Referenced by addProc(), and executeTC().

TCD_

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

private

Definition at line 181 of file Sector.h.

Referenced by addProc(), and executeTCD().

TE_

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

private

Definition at line 175 of file Sector.h.

Referenced by addProc(), and executeTE().

TED_

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

private

Definition at line 176 of file Sector.h.

Referenced by addProc(), and executeTED().

TF_

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

private

Definition at line 168 of file Sector.h.

Referenced by addMem(), and writeTF().

TP_

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

private

Definition at line 178 of file Sector.h.

Referenced by addProc(), and executeTP().

TPAR_

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

private

Definition at line 162 of file Sector.h.

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

TPD_

std::vector<std::unique_ptr<TrackletProcessorDisplaced> > trklet::Sector::TPD_

private

Definition at line 179 of file Sector.h.

Referenced by addProc(), and executeTPD().

TPROJ_

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

private

Definition at line 163 of file Sector.h.

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

TRE_

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

private

Definition at line 177 of file Sector.h.

Referenced by addProc(), and executeTRE().

VMPROJ_

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

private

Definition at line 165 of file Sector.h.

Referenced by addMem(), and writeVMPROJ().

VMR_

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

private

Definition at line 173 of file Sector.h.

Referenced by addProc(), and executeVMR().

VMRCM_

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

private

Definition at line 174 of file Sector.h.

Referenced by addProc(), and executeVMR().

VMSME_

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

private

Definition at line 159 of file Sector.h.

Referenced by addMem(), and writeVMSME().

VMSTE_

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

private

Definition at line 158 of file Sector.h.

Referenced by addMem(), and writeVMSTE().