trklet::TrackletConfigBuilder Class Reference

#include <TrackletConfigBuilder.h>

Classes
struct	DTCinfo

Public Member Functions
std::string	iRegStr (unsigned int iReg, unsigned int iSeed) const
std::string	iSeedStr (unsigned int iSeed) const
std::string	iTCStr (unsigned int iTC) const
std::string	PRName (unsigned int ilayer, unsigned int ireg) const
std::string	TCName (unsigned int iSeed, unsigned int iTC) const
std::string	TPROJName (unsigned int iSeed, unsigned int iTC, unsigned int ilayer, unsigned int ireg) const
	TrackletConfigBuilder (const Settings &settings, const tt::Setup *setup=nullptr)
void	writeAll (std::ostream &wires, std::ostream &memories, std::ostream &modules)

Static Public Member Functions
static std::string	LayerName (unsigned int ilayer)
static std::string	numStr (unsigned int i)

Private Member Functions
void	buildProjections ()
void	buildTC ()
void	buildTE ()
std::string	FTName (unsigned int l1, unsigned int l2, unsigned int l3) const
void	initGeom ()
double	phi (double r1, double phi1, double r2, double phi2, double r)
double	rinv (double r1, double phi1, double r2, double phi2)
std::pair< unsigned int, unsigned int >	seedLayers (unsigned int iSeed)
std::pair< double, double >	seedPhiRange (double rproj, unsigned int iSeed, unsigned int iTC)
std::pair< double, double >	seedRadii (unsigned int iseed)
void	setDTCphirange (const tt::Setup *setup=nullptr)
std::string	SPDName (unsigned int l1, unsigned int ireg1, unsigned int ivm1, unsigned int l2, unsigned int ireg2, unsigned int ivm2, unsigned int l3, unsigned int ireg3, unsigned int ivm3, unsigned int iseed) const
std::string	SPName (unsigned int l1, unsigned int ireg1, unsigned int ivm1, unsigned int l2, unsigned int ireg2, unsigned int ivm2, unsigned int iseed) const
std::string	STName (unsigned int l1, unsigned int ireg1, unsigned int l2, unsigned int ireg2, unsigned int l3, unsigned int ireg3, unsigned int iseed, unsigned int count) const
std::string	TCDName (unsigned int l1, unsigned int l2, unsigned int l3, unsigned int itc) const
std::string	TEDName (unsigned int l1, unsigned int ireg1, unsigned int ivm1, unsigned int l2, unsigned int ireg2, unsigned int ivm2, unsigned int iseed) const
std::string	TEName (unsigned int l1, unsigned int ireg1, unsigned int ivm1, unsigned int l2, unsigned int ireg2, unsigned int ivm2, unsigned int iseed) const
std::string	TParName (unsigned int l1, unsigned int l2, unsigned int l3, unsigned int itc) const
std::string	TPROJName (unsigned int l1, unsigned int l2, unsigned int l3, unsigned int itc, unsigned int projlay, unsigned int projreg) const
std::string	TREName (unsigned int l1, unsigned int ireg1, unsigned int l2, unsigned int ireg2, unsigned int iseed, unsigned int count) const
bool	validTEPair (unsigned int iseed, unsigned int iTE1, unsigned int iTE2)
void	writeAPMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeASMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeCMMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeCTMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeFMMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeILMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeProjectionMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeSPDMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeSPMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeTFMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeTPARMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeVMPROJMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)
void	writeVMSMemories (std::ostream &os, std::ostream &memories, std::ostream &modules)

Private Attributes
std::vector< std::pair< double, double > >	allStubs_ [N_LAYER+N_DISK]
bool	combinedmodules_
double	dphisectorHG_
bool	extended_
int	matchport_ [N_SEED_PROMPT][N_LAYER+N_DISK]
unsigned int	NRegions_ [N_LAYER+N_DISK]
unsigned int	NSector_
unsigned int	NTC_ [N_SEED_PROMPT]
unsigned int	NVMME_ [N_LAYER+N_DISK]
std::pair< unsigned int, unsigned int >	NVMTE_ [N_SEED_PROMPT]
std::vector< std::vector< std::pair< unsigned int, unsigned int > > >	projections_ [N_LAYER+N_DISK]
double	rcrit_
double	rinvmax_
double	rmaxdisk_
double	rmean_ [N_LAYER]
const Settings &	settings_
std::vector< std::vector< unsigned int > >	TC_ [N_SEED_PROMPT]
std::vector< std::pair< unsigned int, unsigned int > >	TE_ [N_SEED_PROMPT]
std::list< DTCinfo >	vecDTCinfo_
std::vector< std::pair< double, double > >	VMStubsME_ [N_LAYER+N_DISK]
std::pair< std::vector< std::pair< double, double > >, std::vector< std::pair< double, double > > >	VMStubsTE_ [N_SEED_PROMPT]
double	zlength_
double	zmean_ [N_DISK]

Detailed Description

Definition at line 25 of file TrackletConfigBuilder.h.

Constructor & Destructor Documentation

TrackletConfigBuilder()

TrackletConfigBuilder::TrackletConfigBuilder	(	const Settings &	settings,
		const tt::Setup *	setup = nullptr
	)

Definition at line 22 of file TrackletConfigBuilder.cc.

References buildProjections(), buildTC(), buildTE(), trklet::Settings::combined(), combinedmodules_, trklet::Settings::dphisectorHG(), dphisectorHG_, trklet::Settings::extended(), extended_, mps_fire::i, initGeom(), iseed, trklet::N_DISK, trklet::N_LAYER, trklet::N_SECTOR, trklet::N_SEED_PROMPT, trklet::Settings::nallstubs(), NRegions_, NSector_, trklet::Settings::NTC(), NTC_, trklet::Settings::nvmme(), NVMME_, trklet::Settings::nvmte(), NVMTE_, trklet::Settings::rcrit(), rcrit_, trklet::Settings::rinvmax(), rinvmax_, trklet::Settings::rmaxdisk(), rmaxdisk_, trklet::Settings::rmean(), rmean_, setDTCphirange(), settings_, singleTopDQM_cfi::setup, trklet::Settings::writeConfig(), trklet::Settings::zlength(), zlength_, trklet::Settings::zmean(), and zmean_.

                                                                                           : settings_(settings) {
  NSector_ = N_SECTOR;
  rcrit_ = settings.rcrit();

  combinedmodules_ = settings.combined();

  extended_ = settings.extended();

  rinvmax_ = settings.rinvmax();

  rmaxdisk_ = settings.rmaxdisk();
  zlength_ = settings.zlength();

  for (int i = 0; i < N_LAYER; i++) {
    rmean_[i] = settings.rmean(i);
  }

  for (int i = 0; i < N_DISK; i++) {
    zmean_[i] = settings.zmean(i);
  }

  dphisectorHG_ = settings.dphisectorHG();

  for (int layerdisk = 0; layerdisk < N_LAYER + N_DISK; layerdisk++) {
    NRegions_[layerdisk] = settings.nallstubs(layerdisk);
    NVMME_[layerdisk] = settings.nvmme(layerdisk);
  }

  for (unsigned int iseed = 0; iseed < N_SEED_PROMPT; iseed++) {
    NVMTE_[iseed] = std::pair<unsigned int, unsigned int>(settings.nvmte(0, iseed), settings.nvmte(1, iseed));
    NTC_[iseed] = settings.NTC(iseed);
  }

  initGeom();

  buildTE();

  buildTC();

  buildProjections();

  setDTCphirange(setup);

  if (settings_.writeConfig()) {
    static std::once_flag runOnce;  // Only one thread should call this.
    std::call_once(runOnce, &TrackletConfigBuilder::writeDTCphirange, this);
  }
}

Member Function Documentation

buildProjections()

void TrackletConfigBuilder::buildProjections ( )

private

Definition at line 363 of file TrackletConfigBuilder.cc.

References allStubs_, combinedmodules_, iseed, matchport_, trklet::N_DISK, trklet::N_LAYER, trklet::N_SEED_PROMPT, NRegions_, projections_, rmaxdisk_, rmean_, seedPhiRange(), TC_, createJobs::tmp, and TPROJName().

Referenced by TrackletConfigBuilder().

                                             {
  set<string> emptyProjStandard = {
      "TPROJ_L1L2H_L3PHIB", "TPROJ_L1L2E_L3PHIC", "TPROJ_L1L2K_L3PHIC", "TPROJ_L1L2H_L3PHID", "TPROJ_L1L2F_L5PHIA",
      "TPROJ_L1L2G_L5PHID", "TPROJ_L1L2A_L6PHIA", "TPROJ_L1L2J_L6PHIB", "TPROJ_L1L2C_L6PHIC", "TPROJ_L1L2L_L6PHID",
      "TPROJ_L3L4D_D1PHIB", "TPROJ_L2L3A_D1PHIC", "TPROJ_L3L4A_D1PHIC", "TPROJ_L1L2G_D2PHIA", "TPROJ_L1D1D_D2PHIA",
      "TPROJ_L1D1E_D2PHIA", "TPROJ_L1L2J_D2PHIB", "TPROJ_L3L4D_D2PHIB", "TPROJ_L1D1A_D2PHIB", "TPROJ_L1D1F_D2PHIB",
      "TPROJ_L1D1G_D2PHIB", "TPROJ_L1L2C_D2PHIC", "TPROJ_L2L3A_D2PHIC", "TPROJ_L3L4A_D2PHIC", "TPROJ_L1D1B_D2PHIC",
      "TPROJ_L1D1C_D2PHIC", "TPROJ_L1D1H_D2PHIC", "TPROJ_L2D1A_D2PHIC", "TPROJ_L1L2F_D2PHID", "TPROJ_L1D1D_D2PHID",
      "TPROJ_L1D1E_D2PHID", "TPROJ_L1L2G_D3PHIA", "TPROJ_L1D1D_D3PHIA", "TPROJ_L1D1E_D3PHIA", "TPROJ_L1L2J_D3PHIB",
      "TPROJ_L1D1A_D3PHIB", "TPROJ_L1D1F_D3PHIB", "TPROJ_L1D1G_D3PHIB", "TPROJ_L1L2C_D3PHIC", "TPROJ_L2L3A_D3PHIC",
      "TPROJ_L1D1B_D3PHIC", "TPROJ_L1D1C_D3PHIC", "TPROJ_L1D1H_D3PHIC", "TPROJ_L2D1A_D3PHIC", "TPROJ_L1L2F_D3PHID",
      "TPROJ_L1D1D_D3PHID", "TPROJ_L1D1E_D3PHID", "TPROJ_L1L2G_D4PHIA", "TPROJ_L1D1D_D4PHIA", "TPROJ_L1D1E_D4PHIA",
      "TPROJ_L1L2J_D4PHIB", "TPROJ_L1D1G_D4PHIB", "TPROJ_L1L2C_D4PHIC", "TPROJ_L2L3A_D4PHIC", "TPROJ_L1D1B_D4PHIC",
      "TPROJ_L2D1A_D4PHIC", "TPROJ_L1L2F_D4PHID", "TPROJ_L1D1D_D4PHID", "TPROJ_L1D1E_D5PHIA", "TPROJ_L1D1G_D5PHIB",
      "TPROJ_L1D1B_D5PHIC", "TPROJ_L1D1D_D5PHID"};

  set<string> emptyProjCombined = {
      "TPROJ_L1L2J_L6PHIB", "TPROJ_L1L2C_L6PHIC", "TPROJ_L1L2G_D1PHIA", "TPROJ_L1L2J_D1PHIB", "TPROJ_L2L3D_D1PHIB",
      "TPROJ_L3L4D_D1PHIB", "TPROJ_L1L2C_D1PHIC", "TPROJ_L2L3A_D1PHIC", "TPROJ_L3L4A_D1PHIC", "TPROJ_L1L2F_D1PHID",
      "TPROJ_L1L2G_D2PHIA", "TPROJ_L1D1E_D2PHIA", "TPROJ_L1L2J_D2PHIB", "TPROJ_L2L3D_D2PHIB", "TPROJ_L3L4D_D2PHIB",
      "TPROJ_L1D1G_D2PHIB", "TPROJ_L1L2C_D2PHIC", "TPROJ_L2L3A_D2PHIC", "TPROJ_L3L4A_D2PHIC", "TPROJ_L1D1B_D2PHIC",
      "TPROJ_L2D1A_D2PHIC", "TPROJ_L1L2F_D2PHID", "TPROJ_L1D1D_D2PHID", "TPROJ_L1L2G_D3PHIA", "TPROJ_L1D1E_D3PHIA",
      "TPROJ_L1L2J_D3PHIB", "TPROJ_L2L3D_D3PHIB", "TPROJ_L1D1G_D3PHIB", "TPROJ_L1L2C_D3PHIC", "TPROJ_L2L3A_D3PHIC",
      "TPROJ_L1D1B_D3PHIC", "TPROJ_L2D1A_D3PHIC", "TPROJ_L1L2F_D3PHID", "TPROJ_L1D1D_D3PHID", "TPROJ_L1L2G_D4PHIA",
      "TPROJ_L1D1E_D4PHIA", "TPROJ_L1L2J_D4PHIB", "TPROJ_L2L3D_D4PHIB", "TPROJ_L1D1G_D4PHIB", "TPROJ_L1L2C_D4PHIC",
      "TPROJ_L2L3A_D4PHIC", "TPROJ_L1D1B_D4PHIC", "TPROJ_L2D1A_D4PHIC", "TPROJ_L1L2F_D4PHID", "TPROJ_L1D1D_D4PHID",
      "TPROJ_L1D1E_D5PHIA", "TPROJ_L1D1G_D5PHIB", "TPROJ_L1D1B_D5PHIC", "TPROJ_L1D1D_D5PHID"};

  for (unsigned int iseed = 0; iseed < N_SEED_PROMPT; iseed++) {
    std::vector<std::vector<unsigned int> >& TCs = TC_[iseed];

    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      if (matchport_[iseed][ilayer] == -1)
        continue;
      for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
        for (unsigned int iTC = 0; iTC < TCs.size(); iTC++) {
          double rproj = rmaxdisk_;
          if (ilayer < 6)
            rproj = rmean_[ilayer];
          std::pair<double, double> phiRange = seedPhiRange(rproj, iseed, iTC);
          if (phiRange.first < allStubs_[ilayer][iReg].second && phiRange.second > allStubs_[ilayer][iReg].first) {
            std::pair<unsigned int, unsigned int> tmp(iseed, iTC);  //seedindex and TC
            string projName = TPROJName(iseed, iTC, ilayer, iReg);
            if (combinedmodules_) {
              if (emptyProjCombined.find(projName) == emptyProjCombined.end()) {
                projections_[ilayer][iReg].push_back(tmp);
              }
            } else {
              if (emptyProjStandard.find(projName) == emptyProjStandard.end()) {
                projections_[ilayer][iReg].push_back(tmp);
              }
            }
          }
        }
      }
    }
  }
}

buildTC()

void TrackletConfigBuilder::buildTC ( )

private

Definition at line 309 of file TrackletConfigBuilder.cc.

References cms::cuda::assert(), trklet::N_SEED_PROMPT, NTC_, TC_, TE_, and createJobs::tmp.

Referenced by TrackletConfigBuilder().

                                    {
  for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
    unsigned int nTC = NTC_[iSeed];
    std::vector<std::pair<unsigned int, unsigned int> >& TEs = TE_[iSeed];
    std::vector<std::vector<unsigned int> >& TCs = TC_[iSeed];

    //Very naive method to group TEs in TC

    double invnTC = nTC * (1.0 / TEs.size());

    for (unsigned int iTE = 0; iTE < TEs.size(); iTE++) {
      int iTC = invnTC * iTE;
      assert(iTC < (int)nTC);
      if (iTC >= (int)TCs.size()) {
        std::vector<unsigned int> tmp;
        tmp.push_back(iTE);
        TCs.push_back(tmp);
      } else {
        TCs[iTC].push_back(iTE);
      }
    }
  }
}

buildTE()

void TrackletConfigBuilder::buildTE ( )

private

Definition at line 293 of file TrackletConfigBuilder.cc.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, iseed, trklet::N_SEED_PROMPT, TE_, createJobs::tmp, validTEPair(), and VMStubsTE_.

Referenced by TrackletConfigBuilder().

                                    {
  for (unsigned int iseed = 0; iseed < N_SEED_PROMPT; iseed++) {
    for (unsigned int i1 = 0; i1 < VMStubsTE_[iseed].first.size(); i1++) {
      for (unsigned int i2 = 0; i2 < VMStubsTE_[iseed].second.size(); i2++) {
        if (validTEPair(iseed, i1, i2)) {
          std::pair<unsigned int, unsigned int> tmp(i1, i2);
          // Contains pairs of indices of all valid VM pairs in seeding layers
          TE_[iseed].push_back(tmp);
        }
      }
    }
  }
}

FTName()

std::string TrackletConfigBuilder::FTName ( unsigned int  l1, unsigned int  l2, unsigned int  l3  ) const

private

Definition at line 595 of file TrackletConfigBuilder.cc.

References LayerName().

Referenced by writeSPDMemories().

                                                                                               {
  return "FT_" + LayerName(l1) + LayerName(l2) + LayerName(l3);
}

initGeom()

void TrackletConfigBuilder::initGeom ( )

private

Definition at line 195 of file TrackletConfigBuilder.cc.

References allStubs_, dphisectorHG_, iseed, trklet::N_DISK, trklet::N_LAYER, trklet::N_SEED_PROMPT, NRegions_, NVMME_, NVMTE_, phimax, phimin, projections_, seedLayers(), createJobs::tmp, VMStubsME_, and VMStubsTE_.

Referenced by TrackletConfigBuilder().

                                     {
  for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
    double dphi = dphisectorHG_ / NRegions_[ilayer];
    for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
      std::vector<std::pair<unsigned int, unsigned int> > emptyVec;
      projections_[ilayer].push_back(emptyVec);
      // FIX: sector doesn't have hourglass shape
      double phimin = dphi * iReg;
      double phimax = phimin + dphi;
      std::pair<double, double> tmp(phimin, phimax);
      allStubs_[ilayer].push_back(tmp);
      double dphiVM = dphi / NVMME_[ilayer];
      for (unsigned int iVM = 0; iVM < NVMME_[ilayer]; iVM++) {
        double phivmmin = phimin + iVM * dphiVM;
        double phivmmax = phivmmin + dphiVM;
        std::pair<double, double> tmp(phivmmin, phivmmax);
        VMStubsME_[ilayer].push_back(tmp);
      }
    }
  }
  for (unsigned int iseed = 0; iseed < N_SEED_PROMPT; iseed++) {
    unsigned int l1 = seedLayers(iseed).first;
    unsigned int l2 = seedLayers(iseed).second;
    unsigned int nVM1 = NVMTE_[iseed].first;
    unsigned int nVM2 = NVMTE_[iseed].second;
    double dphiVM = dphisectorHG_ / (nVM1 * NRegions_[l1]);
    for (unsigned int iVM = 0; iVM < nVM1 * NRegions_[l1]; iVM++) {
      double phivmmin = iVM * dphiVM;
      double phivmmax = phivmmin + dphiVM;
      std::pair<double, double> tmp(phivmmin, phivmmax);
      VMStubsTE_[iseed].first.push_back(tmp);
    }
    dphiVM = dphisectorHG_ / (nVM2 * NRegions_[l2]);
    for (unsigned int iVM = 0; iVM < nVM2 * NRegions_[l2]; iVM++) {
      double phivmmin = iVM * dphiVM;
      double phivmmax = phivmmin + dphiVM;
      std::pair<double, double> tmp(phivmmin, phivmmax);
      VMStubsTE_[iseed].second.push_back(tmp);
    }
  }
}

iRegStr()

std::string TrackletConfigBuilder::iRegStr	(	unsigned int	iReg,
		unsigned int	iSeed
	)		const

Definition at line 462 of file TrackletConfigBuilder.cc.

References cms::cuda::assert(), trklet::L1D1, trklet::L2D1, trklet::L2L3, Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by SPDName(), SPName(), STName(), TEDName(), TEName(), TREName(), and writeVMSMemories().

                                                                                    {
  static std::string name[8] = {"A", "B", "C", "D", "E", "F", "G", "H"};

  static std::string nameOverlap[8] = {"X", "Y", "Z", "W", "Q", "R", "S", "T"};

  static std::string nameL2L3[4] = {"I", "J", "K", "L"};

  if (iSeed == Seed::L2L3) {
    assert(iReg < 4);
    return nameL2L3[iReg];
  }
  if (iSeed == Seed::L1D1 || iSeed == Seed::L2D1) {
    assert(iReg < 8);
    return nameOverlap[iReg];
  }
  assert(iReg < 8);
  return name[iReg];
}

iSeedStr()

std::string TrackletConfigBuilder::iSeedStr

(

unsigned int

iSeed

)

const

Definition at line 440 of file TrackletConfigBuilder.cc.

References cms::cuda::assert(), Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by TCName(), TPROJName(), writeASMemories(), writeCTMemories(), writeFMMemories(), writeTFMemories(), and writeTPARMemories().

                                                                  {
  static std::string name[8] = {"L1L2", "L2L3", "L3L4", "L5L6", "D1D2", "D3D4", "L1D1", "L2D1"};

  assert(iSeed < 8);
  return name[iSeed];
}

iTCStr()

std::string TrackletConfigBuilder::iTCStr

(

unsigned int

iTC

)

const

Definition at line 455 of file TrackletConfigBuilder.cc.

References cms::cuda::assert(), Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PRName(), TCDName(), TCName(), TParName(), TPROJName(), writeAPMemories(), writeASMemories(), writeCMMemories(), writeFMMemories(), writeILMemories(), writeProjectionMemories(), writeSPDMemories(), writeTPARMemories(), writeVMPROJMemories(), and writeVMSMemories().

                                                              {
  static std::string name[12] = {"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L"};

  assert(iTC < 12);
  return name[iTC];
}

LayerName()

std::string TrackletConfigBuilder::LayerName ( unsigned int  ilayer )

static

Definition at line 489 of file TrackletConfigBuilder.cc.

References numStr().

Referenced by FTName(), trklet::TrackletLUT::initBendMatch(), trklet::TrackletLUT::initmatchcut(), trklet::TrackletLUT::initProjectionBend(), trklet::TrackletLUT::initTPlut(), trklet::TrackletLUT::initTPregionlut(), trklet::TrackletLUT::initVMRTable(), PRName(), SPDName(), SPName(), STName(), TCDName(), TEDName(), TEName(), TParName(), TPROJName(), TREName(), writeAPMemories(), writeASMemories(), writeCMMemories(), writeFMMemories(), writeILMemories(), writeProjectionMemories(), writeSPDMemories(), writeVMPROJMemories(), and writeVMSMemories().

                                                              {
  return ilayer < 6 ? ("L" + numStr(ilayer)) : ("D" + numStr(ilayer - 6));
}

numStr()

std::string TrackletConfigBuilder::numStr ( unsigned int  i )

static

Definition at line 447 of file TrackletConfigBuilder.cc.

References cms::cuda::assert(), mps_fire::i, EgammaValidation_cff::num, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by LayerName(), SPDName(), SPName(), STName(), TEDName(), TEName(), and TREName().

                                                      {
  static std::string num[32] = {"1",  "2",  "3",  "4",  "5",  "6",  "7",  "8",  "9",  "10", "11",
                                "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22",
                                "23", "24", "25", "26", "27", "28", "29", "30", "31", "32"};
  assert(i < 32);
  return num[i];
}

phi()

double TrackletConfigBuilder::phi ( double  r1, double  phi1, double  r2, double  phi2, double  r  )

private

Definition at line 425 of file TrackletConfigBuilder.cc.

References funct::abs(), diffTwoXMLs::r2, rinv(), and rinvmax_.

Referenced by Particle.Particle::__str__(), ntupleDataFormat.Track::phiPull(), and seedPhiRange().

                                                                                          {
  double rhoinv = rinv(r1, phi1, r2, phi2);
  if (std::abs(rhoinv) > rinvmax_) {
    rhoinv = rinvmax_ * rhoinv / std::abs(rhoinv);
  }
  return phi1 + asin(0.5 * r * rhoinv) - asin(0.5 * r1 * rhoinv);
}

PRName()

std::string TrackletConfigBuilder::PRName	(	unsigned int	ilayer,
		unsigned int	ireg
	)		const

Definition at line 500 of file TrackletConfigBuilder.cc.

References combinedmodules_, iTCStr(), and LayerName().

Referenced by writeProjectionMemories().

                                                                                    {
  if (combinedmodules_) {
    return "MP_" + LayerName(ilayer) + "PHI" + iTCStr(ireg);
  } else {
    return "PR_" + LayerName(ilayer) + "PHI" + iTCStr(ireg);
  }
}

rinv()

double TrackletConfigBuilder::rinv ( double  r1, double  phi1, double  r2, double  phi2  )

private

Definition at line 435 of file TrackletConfigBuilder.cc.

References funct::cos(), diffTwoXMLs::r2, funct::sin(), and mathSSE::sqrt().

Referenced by phi(), and validTEPair().

                                                                                 {
  double deltaphi = phi1 - phi2;
  return 2 * sin(deltaphi) / sqrt(r2 * r2 + r1 * r1 - 2 * r1 * r2 * cos(deltaphi));
}

seedLayers()

std::pair< unsigned int, unsigned int > TrackletConfigBuilder::seedLayers ( unsigned int  iSeed )

private

Definition at line 189 of file TrackletConfigBuilder.cc.

References trklet::Settings::seedlayers(), and settings_.

Referenced by initGeom(), seedRadii(), writeASMemories(), writeSPMemories(), and writeVMSMemories().

                                                                                        {
  return std::pair<unsigned int, unsigned int>(settings_.seedlayers(0, iSeed), settings_.seedlayers(1, iSeed));
}

seedPhiRange()

std::pair< double, double > TrackletConfigBuilder::seedPhiRange ( double  rproj, unsigned int  iSeed, unsigned int  iTC  )

private

Definition at line 335 of file TrackletConfigBuilder.cc.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, phi(), phimax, phimin, seedRadii(), TC_, TE_, and VMStubsTE_.

Referenced by buildProjections().

                                                                                                              {
  std::vector<std::vector<unsigned int> >& TCs = TC_[iSeed];

  std::pair<double, double> seedradii = seedRadii(iSeed);

  double phimin = 999.0;
  double phimax = -999.0;
  for (unsigned int iTE = 0; iTE < TCs[iTC].size(); iTE++) {
    unsigned int theTE = TCs[iTC][iTE];
    unsigned int l1TE = TE_[iSeed][theTE].first;
    unsigned int l2TE = TE_[iSeed][theTE].second;
    double phi1[2] = {VMStubsTE_[iSeed].first[l1TE].first, VMStubsTE_[iSeed].first[l1TE].second};
    double phi2[2] = {VMStubsTE_[iSeed].second[l2TE].first, VMStubsTE_[iSeed].second[l2TE].second};
    for (unsigned int i1 = 0; i1 < 2; i1++) {
      for (unsigned int i2 = 0; i2 < 2; i2++) {
        double aphi = phi(seedradii.first, phi1[i1], seedradii.second, phi2[i2], rproj);
        if (aphi < phimin)
          phimin = aphi;
        if (aphi > phimax)
          phimax = aphi;
      }
    }
  }
  return std::pair<double, double>(phimin, phimax);
}

seedRadii()

std::pair< double, double > TrackletConfigBuilder::seedRadii ( unsigned int  iseed )

private

Definition at line 239 of file TrackletConfigBuilder.cc.

References iseed, diffTwoXMLs::r2, rmean_, seedLayers(), zlength_, and zmean_.

Referenced by seedPhiRange(), and validTEPair().

                                                                           {
  std::pair<unsigned int, unsigned int> seedlayers = seedLayers(iseed);

  unsigned int l1 = seedlayers.first;
  unsigned int l2 = seedlayers.second;

  double r1, r2;

  if (iseed < 4) {  //barrel seeding
    r1 = rmean_[l1];
    r2 = rmean_[l2];
  } else if (iseed < 6) {   //disk seeding
    r1 = rmean_[0] + 40.0;  //FIX: Somewhat of a hack - but allows finding all the regions
    //when projecting to L1
    r2 = r1 * zmean_[l2 - 6] / zmean_[l1 - 6];
  } else {  //overlap seeding
    r1 = rmean_[l1];
    r2 = r1 * zmean_[l2 - 6] / zlength_;
  }

  return std::pair<double, double>(r1, r2);
}

setDTCphirange()

void TrackletConfigBuilder::setDTCphirange ( const tt::Setup *  setup = nullptr )

private

Definition at line 167 of file TrackletConfigBuilder.cc.

References cms::cuda::assert(), alignmentValidation::fname, info(), mps_splice::line, and vecDTCinfo_.

Referenced by TrackletConfigBuilder().

                                                               {
  // This file previously written by writeDTCphirange().
  const string fname = "../data/dtcphirange.txt";
  if (vecDTCinfo_.empty()) {  // Only run once per thread.
    std::ifstream str_dtc;
    str_dtc.open(fname);
    assert(str_dtc.good());
    string line;
    while (ifstream, getline(line)) {
      std::istringstream iss(line);
      DTCinfo info;
      iss >> info.name >> info.layer >> info.phimin >> info.phimax;
      vecDTCinfo_.push_back(info);
    }
    str_dtc.close();
  }
}

SPDName()

std::string TrackletConfigBuilder::SPDName ( unsigned int  l1, unsigned int  ireg1, unsigned int  ivm1, unsigned int  l2, unsigned int  ireg2, unsigned int  ivm2, unsigned int  l3, unsigned int  ireg3, unsigned int  ivm3, unsigned int  iseed  ) const

private

Definition at line 541 of file TrackletConfigBuilder.cc.

References iRegStr(), iseed, LayerName(), and numStr().

Referenced by writeSPDMemories().

                                                                     {
  return "SPD_" + LayerName(l1) + "PHI" + iRegStr(ireg1, iseed) + numStr(ivm1) + "_" + LayerName(l2) + "PHI" +
         iRegStr(ireg2, iseed) + numStr(ivm2) + "_" + LayerName(l3) + "PHI" + iRegStr(ireg3, iseed) + numStr(ivm3);
}

SPName()

std::string TrackletConfigBuilder::SPName ( unsigned int  l1, unsigned int  ireg1, unsigned int  ivm1, unsigned int  l2, unsigned int  ireg2, unsigned int  ivm2, unsigned int  iseed  ) const

private

Definition at line 530 of file TrackletConfigBuilder.cc.

References iRegStr(), iseed, LayerName(), and numStr().

Referenced by writeSPMemories().

                                                                    {
  return "SP_" + LayerName(l1) + "PHI" + iRegStr(ireg1, iseed) + numStr(ivm1) + "_" + LayerName(l2) + "PHI" +
         iRegStr(ireg2, iseed) + numStr(ivm2);
}

STName()

std::string TrackletConfigBuilder::STName ( unsigned int  l1, unsigned int  ireg1, unsigned int  l2, unsigned int  ireg2, unsigned int  l3, unsigned int  ireg3, unsigned int  iseed, unsigned int  count  ) const

private

Definition at line 608 of file TrackletConfigBuilder.cc.

References submitPVResolutionJobs::count, iRegStr(), iseed, LayerName(), and numStr().

Referenced by writeSPDMemories().

                                                                    {
  return "ST_" + LayerName(l1) + iRegStr(ireg1, iseed) + LayerName(l2) + iRegStr(ireg2, iseed) + "_" + LayerName(l3) +
         iRegStr(ireg3, iseed) + "_" + numStr(count);
}

TCDName()

std::string TrackletConfigBuilder::TCDName ( unsigned int  l1, unsigned int  l2, unsigned int  l3, unsigned int  itc  ) const

private

Definition at line 581 of file TrackletConfigBuilder.cc.

References iTCStr(), and LayerName().

Referenced by writeSPDMemories().

                                                                                                                  {
  return "TCD_" + LayerName(l1) + LayerName(l2) + LayerName(l3) + iTCStr(itc);
}

TCName()

std::string TrackletConfigBuilder::TCName	(	unsigned int	iSeed,
		unsigned int	iTC
	)		const

Definition at line 481 of file TrackletConfigBuilder.cc.

References combinedmodules_, iSeedStr(), and iTCStr().

Referenced by writeProjectionMemories(), and writeSPMemories().

                                                                                  {
  if (combinedmodules_) {
    return "TP_" + iSeedStr(iSeed) + iTCStr(iTC);
  } else {
    return "TC_" + iSeedStr(iSeed) + iTCStr(iTC);
  }
}

TEDName()

std::string TrackletConfigBuilder::TEDName ( unsigned int  l1, unsigned int  ireg1, unsigned int  ivm1, unsigned int  l2, unsigned int  ireg2, unsigned int  ivm2, unsigned int  iseed  ) const

private

Definition at line 566 of file TrackletConfigBuilder.cc.

References iRegStr(), iseed, LayerName(), and numStr().

Referenced by writeSPDMemories().

                                                                     {
  return "TED_" + LayerName(l1) + "PHI" + iRegStr(ireg1, iseed) + numStr(ivm1) + "_" + LayerName(l2) + "PHI" +
         iRegStr(ireg2, iseed) + numStr(ivm2);
}

TEName()

std::string TrackletConfigBuilder::TEName ( unsigned int  l1, unsigned int  ireg1, unsigned int  ivm1, unsigned int  l2, unsigned int  ireg2, unsigned int  ivm2, unsigned int  iseed  ) const

private

Definition at line 555 of file TrackletConfigBuilder.cc.

References iRegStr(), iseed, LayerName(), and numStr().

Referenced by writeSPMemories().

                                                                    {
  return "TE_" + LayerName(l1) + "PHI" + iRegStr(ireg1, iseed) + numStr(ivm1) + "_" + LayerName(l2) + "PHI" +
         iRegStr(ireg2, iseed) + numStr(ivm2);
}

TParName()

std::string TrackletConfigBuilder::TParName ( unsigned int  l1, unsigned int  l2, unsigned int  l3, unsigned int  itc  ) const

private

Definition at line 577 of file TrackletConfigBuilder.cc.

References iTCStr(), and LayerName().

Referenced by writeSPDMemories().

                                                                                                                   {
  return "TPAR_" + LayerName(l1) + LayerName(l2) + LayerName(l3) + iTCStr(itc);
}

TPROJName() [1/2]

std::string TrackletConfigBuilder::TPROJName	(	unsigned int	iSeed,
		unsigned int	iTC,
		unsigned int	ilayer,
		unsigned int	ireg
	)		const

Definition at line 493 of file TrackletConfigBuilder.cc.

References iSeedStr(), iTCStr(), and LayerName().

Referenced by buildProjections(), writeProjectionMemories(), and writeSPDMemories().

                                                                      {
  return "TPROJ_" + iSeedStr(iSeed) + iTCStr(iTC) + "_" + LayerName(ilayer) + "PHI" + iTCStr(ireg);
}

TPROJName() [2/2]

std::string TrackletConfigBuilder::TPROJName ( unsigned int  l1, unsigned int  l2, unsigned int  l3, unsigned int  itc, unsigned int  projlay, unsigned int  projreg  ) const

private

Definition at line 585 of file TrackletConfigBuilder.cc.

References iTCStr(), and LayerName().

                                                                         {
  return "TPROJ_" + LayerName(l1) + LayerName(l2) + LayerName(l3) + iTCStr(itc) + "_" + LayerName(projlayer) + "PHI" +
         iTCStr(projreg);
}

TREName()

std::string TrackletConfigBuilder::TREName ( unsigned int  l1, unsigned int  ireg1, unsigned int  l2, unsigned int  ireg2, unsigned int  iseed, unsigned int  count  ) const

private

Definition at line 599 of file TrackletConfigBuilder.cc.

References submitPVResolutionJobs::count, iRegStr(), iseed, LayerName(), and numStr().

Referenced by writeSPDMemories().

                                                                     {
  return "TRE_" + LayerName(l1) + iRegStr(ireg1, iseed) + LayerName(l2) + iRegStr(ireg2, iseed) + "_" + numStr(count);
}

validTEPair()

bool TrackletConfigBuilder::validTEPair ( unsigned int  iseed, unsigned int  iTE1, unsigned int  iTE2  )

private

Definition at line 264 of file TrackletConfigBuilder.cc.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, iseed, rinv(), rinvmax_, seedRadii(), and VMStubsTE_.

Referenced by buildTE().

                                                                                                {
  double rinvmin = 999.9;
  double rinvmax = -999.9;

  double phi1[2] = {VMStubsTE_[iseed].first[iTE1].first, VMStubsTE_[iseed].first[iTE1].second};
  double phi2[2] = {VMStubsTE_[iseed].second[iTE2].first, VMStubsTE_[iseed].second[iTE2].second};

  std::pair<double, double> seedradii = seedRadii(iseed);

  for (unsigned int i1 = 0; i1 < 2; i1++) {
    for (unsigned int i2 = 0; i2 < 2; i2++) {
      double arinv = rinv(seedradii.first, phi1[i1], seedradii.second, phi2[i2]);
      if (arinv < rinvmin)
        rinvmin = arinv;
      if (arinv > rinvmax)
        rinvmax = arinv;
    }
  }

  if (rinvmin > rinvmax_)
    return false;
  if (rinvmax < -rinvmax_)
    return false;

  return true;
}

writeAll()

void TrackletConfigBuilder::writeAll	(	std::ostream &	wires,
		std::ostream &	memories,
		std::ostream &	modules
	)

Definition at line 1349 of file TrackletConfigBuilder.cc.

References DigiDM_cff::wires, writeAPMemories(), writeASMemories(), writeCMMemories(), writeCTMemories(), writeFMMemories(), writeILMemories(), writeProjectionMemories(), writeSPDMemories(), writeSPMemories(), writeTFMemories(), writeTPARMemories(), writeVMPROJMemories(), and writeVMSMemories().

                                                                                                 {
  writeILMemories(wires, memories, modules);
  writeASMemories(wires, memories, modules);
  writeVMSMemories(wires, memories, modules);
  writeSPMemories(wires, memories, modules);
  writeSPDMemories(wires, memories, modules);
  writeProjectionMemories(wires, memories, modules);
  writeTPARMemories(wires, memories, modules);
  writeVMPROJMemories(wires, memories, modules);
  writeAPMemories(wires, memories, modules);
  writeCMMemories(wires, memories, modules);
  writeFMMemories(wires, memories, modules);
  writeTFMemories(wires, memories, modules);
  writeCTMemories(wires, memories, modules);
}

writeAPMemories()

void TrackletConfigBuilder::writeAPMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 794 of file TrackletConfigBuilder.cc.

References combinedmodules_, iTCStr(), LayerName(), trklet::N_DISK, trklet::N_LAYER, and NRegions_.

Referenced by writeAll().

                                                                                                     {
  // The AllProjection memories (e.g. AP_L2PHIA) contain the intercept point of the projection to
  // a layer. Each is written by one PR module of similar name (e.g. PR_L2PHIA), and read by
  // a MC (e.g. MC_L2PHIA).

  if (combinedmodules_)
    return;

  for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
    for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
      memories << "AllProj: AP_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << " [56]" << std::endl;
      modules << "ProjectionRouter: PR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << std::endl;

      os << "AP_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << " input=> PR_" << LayerName(ilayer) << "PHI"
         << iTCStr(iReg) << ".allprojout output=> MC_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".allprojin"
         << std::endl;
    }
  }
}

writeASMemories()

void TrackletConfigBuilder::writeASMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 901 of file TrackletConfigBuilder.cc.

References cms::cuda::assert(), combinedmodules_, dqmdumpme::first, SurfaceOrientation::inner, createfilelist::int, iSeedStr(), iTCStr(), LayerName(), SiStripPI::max, SiStripPI::min, trklet::N_DISK, trklet::N_LAYER, trklet::N_SEED_PROMPT, NRegions_, NVMTE_, particleFlowDisplacedVertex_cfi::ratio, edm::second(), seedLayers(), TC_, and TE_.

Referenced by writeAll().

                                                                                                     {
  // Each VMR writes AllStub memories (AS) for a single phi region (e.g. PHIC),
  // merging data from all DTCs related to this phi region. It does so by merging data from
  // the IL memories written by all IRs for this phi region. The wiring map lists all
  // IL memories that feed (">") into a single VMR ("VMR_L1PHIC") that writes to the
  // an AS memory ("AS_L1PHIC").
  // Multiple copies of each AS memory exist where several modules in chain want to read it.

  if (combinedmodules_) {
    //First write AS memories used by MatchProcessor
    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
        memories << "AllStubs: AS_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << "n1"
                 << " [42]" << std::endl;
        if (combinedmodules_) {
          modules << "VMRouterCM: VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << std::endl;
        } else {
          modules << "VMRouter: VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << std::endl;
        }
        os << "AS_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << "n1"
           << " input=> VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".allstubout output=> MP_"
           << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".allstubin" << std::endl;
      }
    }

    //Next write AS memories used by TrackletProcessor
    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      for (int iReg = 0; iReg < (int)NRegions_[ilayer]; iReg++) {
        for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
          unsigned int l1 = seedLayers(iSeed).first;
          unsigned int l2 = seedLayers(iSeed).second;

          if (ilayer != l1 && ilayer != l2)
            continue;

          bool inner = ilayer == l1;

          for (unsigned int iTC = 0; iTC < TC_[iSeed].size(); iTC++) {
            int nTCReg = TC_[iSeed].size() / NRegions_[l2];

            int iTCReg = iTC / nTCReg;

            int jTCReg = iTC % nTCReg;

            if (ilayer == l2) {
              if (iTCReg != iReg)
                continue;
            }

            string ext = "";

            if (ilayer == l1) {
              int ratio = NRegions_[l1] / NRegions_[l2];
              int min = iTCReg * ratio - 1 + jTCReg;
              int max = (iTCReg + 1) * ratio - (nTCReg - jTCReg - 1);
              if ((int)iReg < min || (int)iReg > max)
                continue;

              if (max - min >= 2) {
                ext = "M";
                if (iReg == min)
                  ext = "R";
                if (iReg == max)
                  ext = "L";
              }

              if (max - min == 1) {
                if (nTCReg == 2) {
                  assert(0);
                  if (jTCReg == 0) {
                    if (iReg == min)
                      ext = "R";
                    if (iReg == max)
                      ext = "B";
                  }
                  if (jTCReg == 1) {
                    if (iReg == min)
                      ext = "A";
                    if (iReg == max)
                      ext = "L";
                  }
                }
                if (nTCReg == 3) {
                  if (jTCReg == 0) {
                    if (iReg == min)
                      ext = "A";
                    if (iReg == max)
                      ext = "F";
                  }
                  if (jTCReg == 1) {
                    if (iReg == min)
                      ext = "E";
                    if (iReg == max)
                      ext = "D";
                  }
                  if (jTCReg == 2) {
                    if (iReg == min)
                      ext = "C";
                    if (iReg == max)
                      ext = "B";
                  }
                }
              }
              assert(!ext.empty());
            }

            if (ext.empty()) {
              ext = "_" + LayerName(l1) + iTCStr(iTC);
            }

            if (iSeed < 4) {  //Barrel seeding
              ext = "_B" + ext;
            } else if (iSeed > 5) {
              ext = "_O" + ext;
            } else {
              ext = "_D" + ext;
            }

            if (inner) {
              memories << "AllInnerStubs: ";
            } else {
              memories << "AllStubs: ";
            }
            memories << "AS_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ext << " [42]" << std::endl;
            os << "AS_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ext << " input=> VMR_" << LayerName(ilayer)
               << "PHI" << iTCStr(iReg) << ".all" << (inner ? "inner" : "") << "stubout output=> TP_" << iSeedStr(iSeed)
               << iTCStr(iTC);
            if (inner) {
              os << ".innerallstubin" << std::endl;
            } else {
              os << ".outerallstubin" << std::endl;
            }
          }
        }
      }
    }

  } else {
    //First write AS memories used by MatchCalculator
    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
        memories << "AllStubs: AS_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << "n1"
                 << " [42]" << std::endl;
        if (combinedmodules_) {
          modules << "VMRouterCM: VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << std::endl;
        } else {
          modules << "VMRouter: VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << std::endl;
        }
        os << "AS_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << "n1"
           << " input=> VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".allstubout output=> MC_"
           << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".allstubin" << std::endl;
      }
    }

    //Next write AS memories used by TrackletCalculator
    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
        unsigned int nmem = 1;

        for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
          unsigned int l1 = seedLayers(iSeed).first;
          unsigned int l2 = seedLayers(iSeed).second;

          if (ilayer != l1 && ilayer != l2)
            continue;

          for (unsigned int iTC = 0; iTC < TC_[iSeed].size(); iTC++) {
            bool used = false;
            // Each TC processes data from several TEs.
            for (unsigned int iTE = 0; iTE < TC_[iSeed][iTC].size(); iTE++) {
              unsigned int theTE = TC_[iSeed][iTC][iTE];

              unsigned int TE1 = TE_[iSeed][theTE].first;  // VM in inner/outer layer of this TE.
              unsigned int TE2 = TE_[iSeed][theTE].second;

              if (l1 == ilayer && iReg == TE1 / NVMTE_[iSeed].first)
                used = true;
              if (l2 == ilayer && iReg == TE2 / NVMTE_[iSeed].second)
                used = true;
            }

            if (used) {
              nmem++;  // Another copy of memory
              memories << "AllStubs: AS_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << "n" << nmem << " [42]"
                       << std::endl;
              os << "AS_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << "n" << nmem << " input=> VMR_"
                 << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".allstubout output=> TC_" << iSeedStr(iSeed)
                 << iTCStr(iTC);
              if (ilayer == l1) {
                os << ".innerallstubin" << std::endl;
              } else {
                os << ".outerallstubin" << std::endl;
              }
            }
          }
        }
      }
    }
  }
}

writeCMMemories()

void TrackletConfigBuilder::writeCMMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 814 of file TrackletConfigBuilder.cc.

References combinedmodules_, iTCStr(), LayerName(), trklet::N_DISK, trklet::N_LAYER, NRegions_, and NVMME_.

Referenced by writeAll().

                                                                                                     {
  // The CandidateMatch memory (e.g. CM_L1PHIA1) are each written by ME module of similar name
  // (e.g. ME_L1PHIA1) and contain indices of matching (tracklet projections,stubs) in the specified
  // VM region.
  // All CM memories in a given phi region (e.g. L1PHIA) are read by a MC module (e.g. MC_L1PHIA) that
  // does more precise matching.

  if (combinedmodules_)
    return;

  for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
    for (unsigned int iME = 0; iME < NVMME_[ilayer] * NRegions_[ilayer]; iME++) {
      memories << "CandidateMatch: CM_" << LayerName(ilayer) << "PHI" << iTCStr(iME / NVMME_[ilayer]) << iME + 1
               << " [12]" << std::endl;
      modules << "MatchEngine: ME_" << LayerName(ilayer) << "PHI" << iTCStr(iME / NVMME_[ilayer]) << iME + 1
              << std::endl;

      os << "CM_" << LayerName(ilayer) << "PHI" << iTCStr(iME / NVMME_[ilayer]) << iME + 1 << " input=> ME_"
         << LayerName(ilayer) << "PHI" << iTCStr(iME / NVMME_[ilayer]) << iME + 1 << ".matchout output=> MC_"
         << LayerName(ilayer) << "PHI" << iTCStr(iME / NVMME_[ilayer]) << ".matchin" << std::endl;
    }
  }
}

writeCTMemories()

void TrackletConfigBuilder::writeCTMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 1262 of file TrackletConfigBuilder.cc.

References iSeedStr(), and trklet::N_SEED_PROMPT.

Referenced by writeAll().

                                                                                                     {
  modules << "PurgeDuplicate: PD" << std::endl;

  for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
    memories << "CleanTrack: CT_" << iSeedStr(iSeed) << " [126]" << std::endl;
    os << "CT_" << iSeedStr(iSeed) << " input=> PD.trackout output=>" << std::endl;
  }
}

writeFMMemories()

void TrackletConfigBuilder::writeFMMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 861 of file TrackletConfigBuilder.cc.

References combinedmodules_, iSeedStr(), iTCStr(), LayerName(), matchport_, trklet::N_DISK, trklet::N_LAYER, trklet::N_SEED_PROMPT, and NRegions_.

Referenced by writeAll().

                                                                                                     {
  // All FullMatch (e.g. FM_L2L3_L1PHIA) memories corresponding to a matches between stubs & tracklets
  // in a given region (e.g. L1PHIA) from all seeding layers, are written by a MC module (e.g. MC_L1PHIA).
  //
  // All FullMatch memories corresponding to a given seed pair are read by the TrackBuilder (e.g. FT_L1L2),
  // which checks if the track has stubs in enough layers.

  if (combinedmodules_) {
    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
        modules << "MatchProcessor: MP_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << std::endl;
        for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
          if (matchport_[iSeed][ilayer] == -1)
            continue;
          memories << "FullMatch: FM_" << iSeedStr(iSeed) << "_" << LayerName(ilayer) << "PHI" << iTCStr(iReg)
                   << " [36]" << std::endl;
          os << "FM_" << iSeedStr(iSeed) << "_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << " input=> MP_"
             << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".matchout1 output=> FT_" << iSeedStr(iSeed)
             << ".fullmatch" << matchport_[iSeed][ilayer] << "in" << iReg + 1 << std::endl;
        }
      }
    }
  } else {
    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
        modules << "MatchCalculator: MC_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << std::endl;
        for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
          if (matchport_[iSeed][ilayer] == -1)
            continue;
          memories << "FullMatch: FM_" << iSeedStr(iSeed) << "_" << LayerName(ilayer) << "PHI" << iTCStr(iReg)
                   << " [36]" << std::endl;
          os << "FM_" << iSeedStr(iSeed) << "_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << " input=> MC_"
             << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".matchout1 output=> FT_" << iSeedStr(iSeed)
             << ".fullmatch" << matchport_[iSeed][ilayer] << "in" << iReg + 1 << std::endl;
        }
      }
    }
  }
}

writeILMemories()

void TrackletConfigBuilder::writeILMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 1271 of file TrackletConfigBuilder.cc.

References allStubs_, dqmdumpme::first, info(), iTCStr(), LayerName(), M_PI, trklet::N_SECTOR, NRegions_, edm::second(), and vecDTCinfo_.

Referenced by writeAll().

                                                                                                     {
  // Each Input Router (IR) reads stubs from one DTC (e.g. PS10G_1) & sends them
  // to 4-8 InputLink (IL) memories (labelled PHIA-PHIH), each corresponding to a small
  // phi region of a nonant, for each tracklet layer (L1-L6 or D1-D5) that the DTC
  // reads. The InputLink memories have names such as IL_L1PHIC_PS10G_1 to reflect this.

  string olddtc = "";
  for (const DTCinfo& info : vecDTCinfo_) {
    string dtcname = info.name;
    if (olddtc != dtcname) {
      // Write one entry per DTC, with each DTC connected to one IR.
      modules << "InputRouter: IR_" << dtcname << "_A" << std::endl;
      modules << "InputRouter: IR_" << dtcname << "_B" << std::endl;
      memories << "DTCLink: DL_" << dtcname << "_A [36]" << std::endl;
      memories << "DTCLink: DL_" << dtcname << "_B [36]" << std::endl;
      os << "DL_" << dtcname << "_A"
         << " input=> output=> IR_" << dtcname << "_A.stubin" << std::endl;
      os << "DL_" << dtcname << "_B"
         << " input=> output=> IR_" << dtcname << "_B.stubin" << std::endl;
    }
    olddtc = dtcname;
  }

  for (const DTCinfo& info : vecDTCinfo_) {
    string dtcname = info.name;
    int layerdisk = info.layer;

    for (unsigned int iReg = 0; iReg < NRegions_[layerdisk]; iReg++) {
      //--- Ian Tomalin's proposed bug fix
      double phiminDTC_A = info.phimin - M_PI / N_SECTOR;  // Phi range of each DTC.
      double phimaxDTC_A = info.phimax - M_PI / N_SECTOR;
      double phiminDTC_B = info.phimin + M_PI / N_SECTOR;  // Phi range of each DTC.
      double phimaxDTC_B = info.phimax + M_PI / N_SECTOR;
      if (allStubs_[layerdisk][iReg].second > phiminDTC_A && allStubs_[layerdisk][iReg].first < phimaxDTC_A) {
        memories << "InputLink: IL_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg) << "_" << dtcname << "_A"
                 << " [36]" << std::endl;
        os << "IL_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg) << "_" << dtcname << "_A"
           << " input=> IR_" << dtcname << "_A.stubout output=> VMR_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg)
           << ".stubin" << std::endl;
      }
      if (allStubs_[layerdisk][iReg].second > phiminDTC_B && allStubs_[layerdisk][iReg].first < phimaxDTC_B) {
        memories << "InputLink: IL_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg) << "_" << dtcname << "_B"
                 << " [36]" << std::endl;
        os << "IL_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg) << "_" << dtcname << "_B"
           << " input=> IR_" << dtcname << "_B.stubout output=> VMR_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg)
           << ".stubin" << std::endl;
      }
      //--- Original (buggy) code
      /*
      double phiminDTC = info.phimin; // Phi range of each DTC.
      double phimaxDTC = info.phimax;

      if (allStubs_[layerdisk][iReg].first > phimaxDTC && allStubs_[layerdisk][iReg].second < phiminDTC) 
        continue;

      // Phi region range must be entirely contained in this DTC to keep this connection.
      if (allStubs_[layerdisk][iReg].second < phimaxDTC) {
        memories << "InputLink: IL_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg) << "_" << dtcname << "_A"
                 << " [36]" << std::endl;
        os << "IL_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg) << "_" << dtcname << "_A"
           << " input=> IR_" << dtcname << "_A.stubout output=> VMR_" << LayerName(layerdisk) << "PHI"
           << iTCStr(iReg) << ".stubin" << std::endl;
      }

      if (allStubs_[layerdisk][iReg].first > phiminDTC) {
        memories << "InputLink: IL_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg) << "_" << dtcname << "_B"
                 << " [36]" << std::endl;
        os << "IL_" << LayerName(layerdisk) << "PHI" << iTCStr(iReg) << "_" << dtcname << "_B"
           << " input=> IR_" << dtcname << "_B.stubout output=> VMR_" << LayerName(layerdisk) << "PHI"
           << iTCStr(iReg) << ".stubin" << std::endl;
      }
*/
    }
  }
}

writeProjectionMemories()

void TrackletConfigBuilder::writeProjectionMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 508 of file TrackletConfigBuilder.cc.

References iTCStr(), LayerName(), trklet::N_DISK, trklet::N_LAYER, PRName(), projections_, TCName(), and TPROJName().

Referenced by writeAll().

                                                                                                     {
  // Each TC (e.g. TC_L1L2D) writes a projection memory (TPROJ) for each layer the seed projects to,
  // with name indicating the TC and which layer & phi region it projects to (e.g. TPROJ_L1L2D_L3PHIA).
  //
  // Each PR (e.g. PR_L3PHIA) reads all TPROJ memories for the given layer & phi region.

  for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
    for (unsigned int ireg = 0; ireg < projections_[ilayer].size(); ireg++) {
      for (unsigned int imem = 0; imem < projections_[ilayer][ireg].size(); imem++) {
        unsigned int iSeed = projections_[ilayer][ireg][imem].first;
        unsigned int iTC = projections_[ilayer][ireg][imem].second;

        memories << "TrackletProjections: " + TPROJName(iSeed, iTC, ilayer, ireg) + " [54]" << std::endl;

        os << TPROJName(iSeed, iTC, ilayer, ireg) << " input=> " << TCName(iSeed, iTC) << ".projout"
           << LayerName(ilayer) << "PHI" << iTCStr(ireg) << " output=> " << PRName(ilayer, ireg) << ".projin"
           << std::endl;
      }
    }
  }
}

writeSPDMemories()

void TrackletConfigBuilder::writeSPDMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 655 of file TrackletConfigBuilder.cc.

References cms::cuda::assert(), submitPVResolutionJobs::count, extended_, FTName(), iTCStr(), LayerName(), trklet::N_SEED, trklet::N_SEED_PROMPT, trklet::Settings::nallstubs(), trklet::Settings::nvmte(), trklet::Settings::projdisks(), trklet::Settings::projlayers(), trklet::Settings::seedlayers(), settings_, SPDName(), STName(), TCDName(), TEDName(), TParName(), TPROJName(), TREName(), and DigiDM_cff::wires.

Referenced by writeAll().

                                                                                                         {
  // Similar to writeSPMemories, but for displaced (=extended) tracking,
  // with seeds based on triplets of layers.

  if (!extended_)
    return;

  vector<string> stubTriplets[N_SEED];

  for (unsigned int iSeed = N_SEED_PROMPT; iSeed < N_SEED; iSeed++) {
    int layerdisk1 = settings_.seedlayers(0, iSeed);
    int layerdisk2 = settings_.seedlayers(1, iSeed);
    int layerdisk3 = settings_.seedlayers(2, iSeed);

    unsigned int nallstub1 = settings_.nallstubs(layerdisk1);
    unsigned int nallstub2 = settings_.nallstubs(layerdisk2);
    unsigned int nallstub3 = settings_.nallstubs(layerdisk3);

    unsigned int nvm1 = settings_.nvmte(0, iSeed);
    unsigned int nvm2 = settings_.nvmte(1, iSeed);
    unsigned int nvm3 = settings_.nvmte(2, iSeed);

    int count = 0;
    for (unsigned int ireg1 = 0; ireg1 < nallstub1; ireg1++) {
      for (unsigned int ireg2 = 0; ireg2 < nallstub2; ireg2++) {
        for (unsigned int ireg3 = 0; ireg3 < nallstub3; ireg3++) {
          count++;
          memories << "StubTriplets: " << STName(layerdisk1, ireg1, layerdisk2, ireg2, layerdisk3, ireg3, iSeed, count)
                   << " [18]" << std::endl;
          stubTriplets[iSeed].push_back(STName(layerdisk1, ireg1, layerdisk2, ireg2, layerdisk3, ireg3, iSeed, count));
        }
      }
    }

    for (unsigned int ireg1 = 0; ireg1 < nallstub1; ireg1++) {
      for (unsigned int ivm1 = 0; ivm1 < nvm1; ivm1++) {
        for (unsigned int ireg2 = 0; ireg2 < nallstub2; ireg2++) {
          for (unsigned int ivm2 = 0; ivm2 < nvm2; ivm2++) {
            int count = 0;

            modules << "TrackletEngineDisplaced: "
                    << TEDName(layerdisk1, ireg1, ireg1 * nvm1 + ivm1, layerdisk2, ireg2, ireg2 * nvm2 + ivm2, iSeed)
                    << std::endl;

            for (unsigned int ireg3 = 0; ireg3 < nallstub3; ireg3++) {
              for (unsigned int ivm3 = 0; ivm3 < nvm3; ivm3++) {
                count++;

                memories << "StubPairsDisplaced: "
                         << SPDName(layerdisk1,
                                    ireg1,
                                    ireg1 * nvm1 + ivm1,
                                    layerdisk2,
                                    ireg2,
                                    ireg2 * nvm2 + ivm2,
                                    layerdisk3,
                                    ireg3,
                                    ireg3 * nvm3 + ivm3,
                                    iSeed)
                         << " [12]" << std::endl;

                modules << "TripletEngine: " << TREName(layerdisk1, ireg1, layerdisk2, ireg2, iSeed, count)
                        << std::endl;

                wires << SPDName(layerdisk1,
                                 ireg1,
                                 ireg1 * nvm1 + ivm1,
                                 layerdisk2,
                                 ireg2,
                                 ireg2 * nvm2 + ivm2,
                                 layerdisk3,
                                 ireg3,
                                 ireg3 * nvm3 + ivm3,
                                 iSeed)
                      << " input=> "
                      << TEDName(layerdisk1, ireg1, ireg1 * nvm1 + ivm1, layerdisk2, ireg2, ireg2 * nvm2 + ivm2, iSeed)
                      << ".stubpairout output=> " << TREName(layerdisk1, ireg1, layerdisk2, ireg2, iSeed, count)
                      << ".stubpair"
                      << "1"
                      << "in" << std::endl;
              }
            }
          }
        }
      }
    }

    unsigned int nTC = 10;
    for (unsigned int itc = 0; itc < nTC; itc++) {
      for (int iproj = 0; iproj < 4; iproj++) {
        int ilay = settings_.projlayers(iSeed, iproj);
        if (ilay > 0) {
          unsigned int nallstub = settings_.nallstubs(ilay - 1);
          for (unsigned int ireg = 0; ireg < nallstub; ireg++) {
            memories << "TrackletProjections: " << TPROJName(layerdisk1, layerdisk2, layerdisk3, itc, ilay - 1, ireg)
                     << " [54]" << std::endl;
          }
        }

        int idisk = settings_.projdisks(iSeed, iproj);
        if (idisk > 0) {
          unsigned int nallstub = settings_.nallstubs(idisk + 5);
          for (unsigned int ireg = 0; ireg < nallstub; ireg++) {
            memories << "TrackletProjections: " << TPROJName(layerdisk1, layerdisk2, layerdisk3, itc, idisk + 5, ireg)
                     << " [54]" << std::endl;

            wires << TPROJName(layerdisk1, layerdisk2, layerdisk3, itc, idisk + 5, ireg) << " input=> "
                  << TCDName(layerdisk1, layerdisk2, layerdisk3, itc) << ".projout" << LayerName(idisk + 1) << "PHI"
                  << iTCStr(ireg) << " output=> "
                  << "PR_" << LayerName(idisk + 1) << "PHI" << iTCStr(ireg) << ".projin" << std::endl;
          }
        }
      }

      memories << "TrackletParameters: " << TParName(layerdisk1, layerdisk2, layerdisk3, itc) << " [56]" << std::endl;

      modules << "TrackletCalculatorDisplaced: " << TCDName(layerdisk1, layerdisk2, layerdisk3, itc) << std::endl;
    }

    unsigned int nST = stubTriplets[iSeed].size();
    for (unsigned int iST = 0; iST < nST; iST++) {
      unsigned int iTC = (iST * nTC) / nST;
      assert(iTC < nTC);
      string stname = stubTriplets[iSeed][iST];
      string trename = "TRE_" + stname.substr(3, 6) + "_";
      unsigned int stlen = stname.size();
      if (stname[stlen - 2] == '_')
        trename += stname.substr(stlen - 1, 1);
      if (stname[stlen - 3] == '_')
        trename += stname.substr(stlen - 2, 2);
      wires << stname << " input=> " << trename << ".stubtripout output=> "
            << TCDName(layerdisk1, layerdisk2, layerdisk3, iTC) << ".stubtriplet" << ((iST * nTC) % nST) << "in"
            << std::endl;
    }

    modules << "FitTrack: " << FTName(layerdisk1, layerdisk2, layerdisk3) << std::endl;
  }
}

writeSPMemories()

void TrackletConfigBuilder::writeSPMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 620 of file TrackletConfigBuilder.cc.

References combinedmodules_, dqmdumpme::first, trklet::N_SEED_PROMPT, NVMTE_, edm::second(), seedLayers(), SPName(), TC_, TCName(), TE_, and TEName().

Referenced by writeAll().

                                                                                                     {
  // Each TE reads one VM in two seed layers, finds stub pairs & writes to a StubPair ("SP") memory.
  //
  // Each TC reads several StubPair (SP) memories, each containing a pair of VMs of two seeding layers.
  // Several TC are created for each layer pair, and the SP distributed between them.
  // If TC name is TC_L1L2C, "C" indicates this is the 3rd TC in L1L2.

  if (combinedmodules_)
    return;

  for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
    for (unsigned int iTC = 0; iTC < TC_[iSeed].size(); iTC++) {
      for (unsigned int iTE = 0; iTE < TC_[iSeed][iTC].size(); iTE++) {
        unsigned int theTE = TC_[iSeed][iTC][iTE];

        unsigned int TE1 = TE_[iSeed][theTE].first;
        unsigned int TE2 = TE_[iSeed][theTE].second;

        unsigned int l1 = seedLayers(iSeed).first;
        unsigned int l2 = seedLayers(iSeed).second;

        memories << "StubPairs: "
                 << SPName(l1, TE1 / NVMTE_[iSeed].first, TE1, l2, TE2 / NVMTE_[iSeed].second, TE2, iSeed) << " [12]"
                 << std::endl;
        modules << "TrackletEngine: "
                << TEName(l1, TE1 / NVMTE_[iSeed].first, TE1, l2, TE2 / NVMTE_[iSeed].second, TE2, iSeed) << std::endl;

        os << SPName(l1, TE1 / NVMTE_[iSeed].first, TE1, l2, TE2 / NVMTE_[iSeed].second, TE2, iSeed) << " input=> "
           << TEName(l1, TE1 / NVMTE_[iSeed].first, TE1, l2, TE2 / NVMTE_[iSeed].second, TE2, iSeed)
           << ".stubpairout output=> " << TCName(iSeed, iTC) << ".stubpairin" << std::endl;
      }
    }
  }
}

writeTFMemories()

void TrackletConfigBuilder::writeTFMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 1254 of file TrackletConfigBuilder.cc.

References iSeedStr(), and trklet::N_SEED_PROMPT.

Referenced by writeAll().

                                                                                                     {
  for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
    memories << "TrackFit: TF_" << iSeedStr(iSeed) << " [126]" << std::endl;
    modules << "FitTrack: FT_" << iSeedStr(iSeed) << std::endl;
    os << "TF_" << iSeedStr(iSeed) << " input=> FT_" << iSeedStr(iSeed) << ".trackout output=> PD.trackin" << std::endl;
  }
}

writeTPARMemories()

void TrackletConfigBuilder::writeTPARMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 1229 of file TrackletConfigBuilder.cc.

References combinedmodules_, iSeedStr(), iTCStr(), trklet::N_SEED_PROMPT, and TC_.

Referenced by writeAll().

                                                                                                       {
  // Each TC module (e.g. TC_L1L2A) stores helix params in a single TPAR memory of similar name
  // (e.g. TPAR_L1L2A). The TPAR is subsequently read by the TrackBuilder (FT).

  if (combinedmodules_) {
    for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
      for (unsigned int iTP = 0; iTP < TC_[iSeed].size(); iTP++) {
        memories << "TrackletParameters: TPAR_" << iSeedStr(iSeed) << iTCStr(iTP) << " [56]" << std::endl;
        modules << "TrackletProcessor: TP_" << iSeedStr(iSeed) << iTCStr(iTP) << std::endl;
        os << "TPAR_" << iSeedStr(iSeed) << iTCStr(iTP) << " input=> TP_" << iSeedStr(iSeed) << iTCStr(iTP)
           << ".trackpar output=> FT_" << iSeedStr(iSeed) << ".tparin" << std::endl;
      }
    }
  } else {
    for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
      for (unsigned int iTC = 0; iTC < TC_[iSeed].size(); iTC++) {
        memories << "TrackletParameters: TPAR_" << iSeedStr(iSeed) << iTCStr(iTC) << " [56]" << std::endl;
        modules << "TrackletCalculator: TC_" << iSeedStr(iSeed) << iTCStr(iTC) << std::endl;
        os << "TPAR_" << iSeedStr(iSeed) << iTCStr(iTC) << " input=> TC_" << iSeedStr(iSeed) << iTCStr(iTC)
           << ".trackpar output=> FT_" << iSeedStr(iSeed) << ".tparin" << std::endl;
      }
    }
  }
}

writeVMPROJMemories()

void TrackletConfigBuilder::writeVMPROJMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 838 of file TrackletConfigBuilder.cc.

References combinedmodules_, iTCStr(), LayerName(), trklet::N_DISK, trklet::N_LAYER, NRegions_, and NVMME_.

Referenced by writeAll().

                                                                                                 {
  // The VMPROJ memories (e.g. VMPROJ_L2PHIA1) written by a PR module each correspond to projections to
  // a single VM region in a layer. Each is filled by the PR using all projections (TPROJ) to this VM
  // from different seeding layers.
  //
  // Each VMPROJ memory is read by a ME module, which matches the projection to stubs.

  if (combinedmodules_)
    return;

  for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
    for (unsigned int iME = 0; iME < NVMME_[ilayer] * NRegions_[ilayer]; iME++) {
      memories << "VMProjections: VMPROJ_" << LayerName(ilayer) << "PHI" << iTCStr(iME / NVMME_[ilayer]) << iME + 1
               << " [13]" << std::endl;

      os << "VMPROJ_" << LayerName(ilayer) << "PHI" << iTCStr(iME / NVMME_[ilayer]) << iME + 1 << " input=> PR_"
         << LayerName(ilayer) << "PHI" << iTCStr(iME / NVMME_[ilayer]) << ".vmprojout"
         << "PHI" << iTCStr(iME / NVMME_[ilayer]) << iME + 1 << " output=> ME_" << LayerName(ilayer) << "PHI"
         << iTCStr(iME / NVMME_[ilayer]) << iME + 1 << ".vmprojin" << std::endl;
    }
  }
}

writeVMSMemories()

void TrackletConfigBuilder::writeVMSMemories ( std::ostream &  os, std::ostream &  memories, std::ostream &  modules  )

private

Definition at line 1102 of file TrackletConfigBuilder.cc.

References combinedmodules_, iRegStr(), iTCStr(), trklet::L2D1, LayerName(), trklet::N_DISK, trklet::N_LAYER, trklet::N_SEED_PROMPT, NRegions_, NVMME_, NVMTE_, seedLayers(), TC_, and TE_.

Referenced by writeAll().

                                                                                              {
  // Each VMR writes to Virtual Module memories ("VMS") to be used later by the ME or TE etc.
  // Memory VMSTE_L1PHIC9-12 is the memory for small phi region C in L1 for the TE module.
  // Numbers 9-12 correspond to the 4 VMs in this phi region.
  //
  // Each TE reads one VMS memory in each seeding layer.

  if (combinedmodules_) {
    //First write VMS memories used by MatchProcessor
    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      for (unsigned int iReg = 0; iReg < NRegions_[ilayer]; iReg++) {
        memories << "VMStubsME: VMSME_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << "n1 [18]" << std::endl;
        os << "VMSME_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << "n1"
           << " input=> VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".vmstuboutPHI" << iTCStr(iReg)
           << " output=> MP_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".vmstubin" << std::endl;
      }
    }

    //Next write VMS memories used by TrackletProcessor
    for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
      //FIXME - code could be cleaner
      unsigned int l1 = seedLayers(iSeed).first;
      unsigned int l2 = seedLayers(iSeed).second;

      unsigned int ilayer = seedLayers(iSeed).second;

      //for(unsigned int iReg=0;iReg<NRegions_[ilayer];iReg++){

      unsigned int nTCReg = TC_[iSeed].size() / NRegions_[l2];

      for (unsigned int iReg = 0; iReg < NRegions_[l2]; iReg++) {
        unsigned int nmem = 0;
        //Hack since we use same module twice
        if (iSeed == Seed::L2D1) {
          nmem = 2;
        }

        for (unsigned iTC = 0; iTC < nTCReg; iTC++) {
          nmem++;
          memories << "VMStubsTE: VMSTE_" << LayerName(ilayer) << "PHI" << iRegStr(iReg, iSeed) << "n" << nmem
                   << " [18]" << std::endl;
          os << "VMSTE_" << LayerName(ilayer) << "PHI" << iRegStr(iReg, iSeed) << "n" << nmem << " input=> VMR_"
             << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".vmstubout_seed_" << iSeed << " output=> TP_"
             << LayerName(l1) << LayerName(l2) << iTCStr(iReg * nTCReg + iTC) << ".outervmstubin" << std::endl;
        }
      }
    }

  } else {
    //First write VMS memories used by MatchEngine
    for (unsigned int ilayer = 0; ilayer < N_LAYER + N_DISK; ilayer++) {
      for (unsigned int iVMME = 0; iVMME < NVMME_[ilayer] * NRegions_[ilayer]; iVMME++) {
        unsigned int iReg = iVMME / NVMME_[ilayer];
        memories << "VMStubsME: VMSME_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << iVMME + 1 << "n1 [18]"
                 << std::endl;
        os << "VMSME_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << iVMME + 1 << "n1"
           << " input=> VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".vmstuboutMEPHI" << iTCStr(iReg)
           << iVMME + 1 << " output=> ME_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << iVMME + 1 << ".vmstubin"
           << std::endl;
      }
    }

    // Next write VMS memories used by TrackletEngine
    // Each TE processes one VM region in inner + outer seeding layers, and needs its own copy of input memories.
    for (unsigned int iSeed = 0; iSeed < N_SEED_PROMPT; iSeed++) {
      for (unsigned int innerouterseed = 0; innerouterseed < 2; innerouterseed++) {
        //FIXME - code could be cleaner
        unsigned int l1 = seedLayers(iSeed).first;
        unsigned int l2 = seedLayers(iSeed).second;

        unsigned int NVMTE1 = NVMTE_[iSeed].first;
        unsigned int NVMTE2 = NVMTE_[iSeed].second;

        unsigned int ilayer = l1;
        unsigned int NVMTE = NVMTE1;
        if (innerouterseed == 1) {
          ilayer = l2;
          NVMTE = NVMTE2;
        }

        for (unsigned int iVMTE = 0; iVMTE < NVMTE * NRegions_[ilayer]; iVMTE++) {
          unsigned int iReg = iVMTE / NVMTE;

          unsigned int nmem = 0;

          if (iSeed == Seed::L2D1) {
            nmem = 4;
          }

          for (unsigned int iTE = 0; iTE < TE_[iSeed].size(); iTE++) {
            unsigned int TE1 = TE_[iSeed][iTE].first;  // VM region in inner/outer layer of this TE
            unsigned int TE2 = TE_[iSeed][iTE].second;

            bool used = false;

            if (innerouterseed == 0 && iVMTE == TE1)
              used = true;
            if (innerouterseed == 1 && iVMTE == TE2)
              used = true;

            if (!used)
              continue;

            string inorout = "I";
            if (innerouterseed == 1)
              inorout = "O";

            nmem++;  // Add another copy of memory.
            memories << "VMStubsTE: VMSTE_" << LayerName(ilayer) << "PHI" << iRegStr(iReg, iSeed) << iVMTE + 1 << "n"
                     << nmem << " [18]" << std::endl;
            os << "VMSTE_" << LayerName(ilayer) << "PHI" << iRegStr(iReg, iSeed) << iVMTE + 1 << "n" << nmem
               << " input=> VMR_" << LayerName(ilayer) << "PHI" << iTCStr(iReg) << ".vmstuboutTE" << inorout << "PHI"
               << iRegStr(iReg, iSeed) << iVMTE + 1 << " output=> TE_" << LayerName(l1) << "PHI"
               << iRegStr(TE1 / NVMTE1, iSeed) << TE1 + 1 << "_" << LayerName(l2) << "PHI"
               << iRegStr(TE2 / NVMTE2, iSeed) << TE2 + 1;
            if (innerouterseed == 0) {
              os << ".innervmstubin" << std::endl;
            } else {
              os << ".outervmstubin" << std::endl;
            }
          }
        }
      }
    }
  }
}

Member Data Documentation

allStubs_

std::vector<std::pair<double, double> > trklet::TrackletConfigBuilder::allStubs_[N_LAYER+N_DISK]

private

Definition at line 254 of file TrackletConfigBuilder.h.

Referenced by buildProjections(), initGeom(), and writeILMemories().

combinedmodules_

bool trklet::TrackletConfigBuilder::combinedmodules_

private

Definition at line 235 of file TrackletConfigBuilder.h.

Referenced by buildProjections(), PRName(), TCName(), TrackletConfigBuilder(), writeAPMemories(), writeASMemories(), writeCMMemories(), writeFMMemories(), writeSPMemories(), writeTPARMemories(), writeVMPROJMemories(), and writeVMSMemories().

dphisectorHG_

double trklet::TrackletConfigBuilder::dphisectorHG_

private

Definition at line 245 of file TrackletConfigBuilder.h.

Referenced by initGeom(), and TrackletConfigBuilder().

extended_

bool trklet::TrackletConfigBuilder::extended_

private

Definition at line 237 of file TrackletConfigBuilder.h.

Referenced by TrackletConfigBuilder(), and writeSPDMemories().

matchport_

int trklet::TrackletConfigBuilder::matchport_[N_SEED_PROMPT][N_LAYER+N_DISK]

private

Initial value:

= {{-1, -1, 1, 2, 3, 4, 4, 3, 2, 1, -1},       
                                                       {1, -1, -1, 2, 3, -1, 4, 3, 2, 1, -1},      
                                                       {1, 2, -1, -1, 3, 4, 4, 3, -1, -1, -1},     
                                                       {1, 2, 3, 4, -1, -1, -1, -1, -1, -1, -1},   
                                                       {1, 2, -1, -1, -1, -1, -1, -1, 2, 3, 4},    
                                                       {1, -1, -1, -1, -1, -1, 2, 3, -1, -1, 4},   
                                                       {-1, -1, -1, -1, -1, -1, -1, 1, 2, 3, 4},   
                                                       {1, -1, -1, -1, -1, -1, -1, 2, 3, 4, -1}}

Definition at line 274 of file TrackletConfigBuilder.h.

Referenced by buildProjections(), and writeFMMemories().

NRegions_

unsigned int trklet::TrackletConfigBuilder::NRegions_[N_LAYER+N_DISK]

private

Definition at line 249 of file TrackletConfigBuilder.h.

Referenced by buildProjections(), initGeom(), TrackletConfigBuilder(), writeAPMemories(), writeASMemories(), writeCMMemories(), writeFMMemories(), writeILMemories(), writeVMPROJMemories(), and writeVMSMemories().

NSector_

unsigned int trklet::TrackletConfigBuilder::NSector_

private

Definition at line 232 of file TrackletConfigBuilder.h.

Referenced by TrackletConfigBuilder().

NTC_

unsigned int trklet::TrackletConfigBuilder::NTC_[N_SEED_PROMPT]

private

Definition at line 247 of file TrackletConfigBuilder.h.

Referenced by buildTC(), and TrackletConfigBuilder().

NVMME_

unsigned int trklet::TrackletConfigBuilder::NVMME_[N_LAYER+N_DISK]

private

Definition at line 250 of file TrackletConfigBuilder.h.

Referenced by initGeom(), TrackletConfigBuilder(), writeCMMemories(), writeVMPROJMemories(), and writeVMSMemories().

NVMTE_

std::pair<unsigned int, unsigned int> trklet::TrackletConfigBuilder::NVMTE_[N_SEED_PROMPT]

private

Definition at line 251 of file TrackletConfigBuilder.h.

Referenced by initGeom(), TrackletConfigBuilder(), writeASMemories(), writeSPMemories(), and writeVMSMemories().

projections_

std::vector<std::vector<std::pair<unsigned int, unsigned int> > > trklet::TrackletConfigBuilder::projections_[N_LAYER+N_DISK]

private

Definition at line 270 of file TrackletConfigBuilder.h.

Referenced by buildProjections(), initGeom(), and writeProjectionMemories().

rcrit_

double trklet::TrackletConfigBuilder::rcrit_

private

Definition at line 233 of file TrackletConfigBuilder.h.

Referenced by TrackletConfigBuilder().

rinvmax_

double trklet::TrackletConfigBuilder::rinvmax_

private

Definition at line 239 of file TrackletConfigBuilder.h.

Referenced by phi(), TrackletConfigBuilder(), and validTEPair().

rmaxdisk_

double trklet::TrackletConfigBuilder::rmaxdisk_

private

Definition at line 240 of file TrackletConfigBuilder.h.

Referenced by buildProjections(), and TrackletConfigBuilder().

rmean_

double trklet::TrackletConfigBuilder::rmean_[N_LAYER]

private

Definition at line 242 of file TrackletConfigBuilder.h.

Referenced by buildProjections(), seedRadii(), and TrackletConfigBuilder().

settings_

const Settings& trklet::TrackletConfigBuilder::settings_

private

Definition at line 292 of file TrackletConfigBuilder.h.

Referenced by seedLayers(), TrackletConfigBuilder(), and writeSPDMemories().

TC_

std::vector<std::vector<unsigned int> > trklet::TrackletConfigBuilder::TC_[N_SEED_PROMPT]

private

Definition at line 267 of file TrackletConfigBuilder.h.

Referenced by buildProjections(), buildTC(), seedPhiRange(), writeASMemories(), writeSPMemories(), writeTPARMemories(), and writeVMSMemories().

TE_

std::vector<std::pair<unsigned int, unsigned int> > trklet::TrackletConfigBuilder::TE_[N_SEED_PROMPT]

private

Definition at line 264 of file TrackletConfigBuilder.h.

Referenced by buildTC(), buildTE(), seedPhiRange(), writeASMemories(), writeSPMemories(), and writeVMSMemories().

vecDTCinfo_

std::list<DTCinfo> trklet::TrackletConfigBuilder::vecDTCinfo_

private

Definition at line 289 of file TrackletConfigBuilder.h.

Referenced by setDTCphirange(), and writeILMemories().

VMStubsME_

std::vector<std::pair<double, double> > trklet::TrackletConfigBuilder::VMStubsME_[N_LAYER+N_DISK]

private

Definition at line 257 of file TrackletConfigBuilder.h.

Referenced by initGeom().

VMStubsTE_

std::pair<std::vector<std::pair<double, double> >, std::vector<std::pair<double, double> > > trklet::TrackletConfigBuilder::VMStubsTE_[N_SEED_PROMPT]

private

Definition at line 261 of file TrackletConfigBuilder.h.

Referenced by buildTE(), initGeom(), seedPhiRange(), and validTEPair().

zlength_

double trklet::TrackletConfigBuilder::zlength_

private

Definition at line 241 of file TrackletConfigBuilder.h.

Referenced by seedRadii(), and TrackletConfigBuilder().

zmean_

double trklet::TrackletConfigBuilder::zmean_[N_DISK]

private

Definition at line 243 of file TrackletConfigBuilder.h.

Referenced by seedRadii(), and TrackletConfigBuilder().