#include <TrackletCalculator.h>

Inheritance diagram for trklet::TrackletCalculator:

Public Member Functions
void	addInput (MemoryBase *memory, std::string input) override

void	addOutput (MemoryBase *memory, std::string output) override

void	addOutputProjection (TrackletProjectionsMemory &outputProj, MemoryBase memory)

void	execute (unsigned int iSector, double phimin, double phimax)

	TrackletCalculator (std::string name, Settings const &settings, Globals *globals)

	~TrackletCalculator () override=default

Public Member Functions inherited from trklet::TrackletCalculatorBase
void	addDiskProj (Tracklet *tracklet, int disk)

bool	addLayerProj (Tracklet *tracklet, int layer)

void	addProjection (int layer, int iphi, TrackletProjectionsMemory trackletprojs, Tracklet tracklet)

void	addProjectionDisk (int disk, int iphi, TrackletProjectionsMemory trackletprojs, Tracklet tracklet)

bool	barrelSeeding (const Stub innerFPGAStub, const L1TStub innerStub, const Stub outerFPGAStub, const L1TStub outerStub)

bool	diskSeeding (const Stub innerFPGAStub, const L1TStub innerStub, const Stub outerFPGAStub, const L1TStub outerStub)

void	exactproj (double rproj, double rinv, double phi0, double t, double z0, double &phiproj, double &zproj, double &phider, double &zder)

void	exactprojdisk (double zproj, double rinv, double phi0, double t, double z0, double &phiproj, double &rproj, double &phider, double &rder)

void	exacttracklet (double r1, double z1, double phi1, double r2, double z2, double phi2, double, double &rinv, double &phi0, double &t, double &z0, double phiproj[N_LAYER - 2], double zproj[N_LAYER - 2], double phider[N_LAYER - 2], double zder[N_LAYER - 2], double phiprojdisk[N_DISK], double rprojdisk[N_DISK], double phiderdisk[N_DISK], double rderdisk[N_DISK])

void	exacttrackletdisk (double r1, double z1, double phi1, double r2, double z2, double phi2, double, double &rinv, double &phi0, double &t, double &z0, double phiprojLayer[N_PSLAYER], double zprojLayer[N_PSLAYER], double phiderLayer[N_PSLAYER], double zderLayer[N_PSLAYER], double phiproj[N_DISK - 2], double rproj[N_DISK - 2], double phider[N_DISK - 2], double rder[N_DISK - 2])

void	exacttrackletOverlap (double r1, double z1, double phi1, double r2, double z2, double phi2, double, double &rinv, double &phi0, double &t, double &z0, double phiprojLayer[N_PSLAYER], double zprojLayer[N_PSLAYER], double phiderLayer[N_PSLAYER], double zderLayer[N_PSLAYER], double phiproj[N_DISK - 2], double rproj[N_DISK - 2], double phider[N_DISK - 2], double rder[N_DISK - 2])

bool	goodTrackPars (bool goodrinv, bool goodz0)

bool	inSector (int iphi0, int irinv, double phi0approx, double rinvapprox)

bool	overlapSeeding (const Stub innerFPGAStub, const L1TStub innerStub, const Stub outerFPGAStub, const L1TStub outerStub)

	TrackletCalculatorBase (std::string name, Settings const &settings, Globals *global)

	~TrackletCalculatorBase () override=default

Public Member Functions inherited from trklet::ProcessBase
unsigned int	getISeed (const std::string &name)

std::string const &	getName () const

void	initLayerDisk (unsigned int pos, int &layer, int &disk)

void	initLayerDisk (unsigned int pos, int &layer, int &disk, int &layerdisk)

unsigned int	initLayerDisk (unsigned int pos)

void	initLayerDisksandISeed (unsigned int &layerdisk1, unsigned int &layerdisk2, unsigned int &iSeed)

unsigned int	nbits (unsigned int power)

	ProcessBase (std::string name, Settings const &settings, Globals *global)

virtual	~ProcessBase ()=default

Private Member Functions
void	writeFirmwareDesign (void(writeDesign)(const std::vector< VarBase > &, const std::string &))

void	writeInvTable (void(*writeLUT)(const VarInv &, const std::string &))

Private Attributes
std::vector< AllStubsMemory * >	innerallstubs_

int	iTC_

std::vector< AllStubsMemory * >	outerallstubs_

std::vector< StubPairsMemory * >	stubpairs_

Additional Inherited Members
Protected Attributes inherited from trklet::TrackletCalculatorBase
unsigned int	iSector_

unsigned int	iSeed_

unsigned int	layerdisk1_

unsigned int	layerdisk2_

double	phimax_

double	phimin_

int	TCIndex_

TrackletParametersMemory *	trackletpars_

std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojdisks_

std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojlayers_

Protected Attributes inherited from trklet::ProcessBase
Globals *	globals_

std::string	name_

Settings const &	settings_

Detailed Description

Definition at line 20 of file TrackletCalculator.h.

Constructor & Destructor Documentation

◆ TrackletCalculator()

TrackletCalculator::TrackletCalculator	(	std::string	name,
		Settings const &	settings,
		Globals *	globals
	)

Definition at line 17 of file TrackletCalculator.cc.

References funct::abs(), cms::cuda::assert(), compareTotals::fs, trklet::ProcessBase::globals_, trklet::VarBase::hls, trklet::VarBase::hls_print(), trklet::ProcessBase::initLayerDisksandISeed(), trklet::TrackletCalculatorBase::iSeed_, iTC_, trklet::Globals::ITC_L1L2(), trklet::VarBase::K(), trklet::TrackletCalculatorBase::layerdisk1_, trklet::TrackletCalculatorBase::layerdisk2_, trklet::N_DISK, trklet::N_LAYER, trklet::Settings::nallstubs(), trklet::ProcessBase::name_, trklet::Settings::ntrackletmax(), trklet::IMATH_TrackletCalculator::phi0_final, trklet::Settings::rcrit(), trklet::IMATH_TrackletCalculator::rinv_final, trklet::ProcessBase::settings_, trklet::TrackletCalculatorBase::TCIndex_, createJobs::tmp, trklet::TrackletCalculatorBase::trackletprojdisks_, trklet::TrackletCalculatorBase::trackletprojlayers_, trklet::Settings::usephicritapprox(), findQualityFiles::v, trklet::VarBase::verilog, trklet::VarBase::verilog_print(), funct::void, writeFirmwareDesign(), trklet::Settings::writeHLS(), trklet::Settings::writeHLSInvTable(), writeInvTable(), trklet::Settings::writeInvTable(), trklet::Settings::writeTable(), trklet::Settings::writeVerilog(), and x.

     : TrackletCalculatorBase(name, settings, globals) {
   for (unsigned int ilayer = 0; ilayer < N_LAYER; ilayer++) {
     vector<TrackletProjectionsMemory*> tmp(settings.nallstubs(ilayer), nullptr);
     trackletprojlayers_.push_back(tmp);
   }
 
   for (unsigned int idisk = 0; idisk < N_DISK; idisk++) {
     vector<TrackletProjectionsMemory*> tmp(settings.nallstubs(idisk + N_LAYER), nullptr);
     trackletprojdisks_.push_back(tmp);
   }
 
   initLayerDisksandISeed(layerdisk1_, layerdisk2_, iSeed_);
 
   // set TC index
   iTC_ = name_[7] - 'A';
 
   TCIndex_ = (iSeed_ << 4) + iTC_;
   assert(TCIndex_ >= 0 && TCIndex_ <= (int)settings_.ntrackletmax());
 
   if (settings_.usephicritapprox()) {
     double phicritFactor =
         0.5 * settings_.rcrit() * globals_->ITC_L1L2()->rinv_final.K() / globals_->ITC_L1L2()->phi0_final.K();
     if (std::abs(phicritFactor - 2.) > 0.25)
       edm::LogPrint("Tracklet")
           << "TrackletCalculator::TrackletCalculator phicrit approximation may be invalid! Please check.";
   }
 
   // write the drinv and invt inverse tables
   if ((settings_.writeInvTable() || settings_.writeHLSInvTable() || settings_.writeTable()) && iTC_ == 0) {
     void (*writeLUT)(const VarInv&, const string&) = nullptr;
     if (settings.writeInvTable()) {  // Verilog version
       writeLUT = [](const VarInv& x, const string& basename) -> void {
         ofstream fs(basename + ".tab");
         return x.writeLUT(fs, VarBase::verilog);
       };
     } else {  // HLS version
       writeLUT = [](const VarInv& x, const string& basename) -> void {
         ofstream fs(basename + ".tab");
         return x.writeLUT(fs, VarBase::hls);
       };
     }
     writeInvTable(writeLUT);
   }
 
   // write the firmware design for the calculation of the tracklet parameters
   // and projections
   if ((settings_.writeVerilog() || settings_.writeHLS()) && iTC_ == 0) {
     void (*writeDesign)(const vector<VarBase*>&, const string&) = nullptr;
     if (settings.writeVerilog()) {  // Verilog version
       writeDesign = [](const vector<VarBase*>& v, const string& basename) -> void {
         ofstream fs(basename + ".v");
         return VarBase::verilog_print(v, fs);
       };
     } else {  // HLS version
       writeDesign = [](const vector<VarBase*>& v, const string& basename) -> void {
         ofstream fs(basename + ".cpp");
         return VarBase::hls_print(v, fs);
       };
     }
     writeFirmwareDesign(writeDesign);
   }
 }

◆ ~TrackletCalculator()

trklet::TrackletCalculator::~TrackletCalculator ( )

overridedefault

Member Function Documentation

◆ addInput()

void TrackletCalculator::addInput	(	MemoryBase *	memory,
		std::string	input
	)

overridevirtual

Implements trklet::ProcessBase.

Definition at line 128 of file TrackletCalculator.cc.

References cms::cuda::assert(), Exception, innerallstubs_, input, mps_setup::memory, trklet::ProcessBase::name_, outerallstubs_, trklet::ProcessBase::settings_, stubpairs_, createJobs::tmp, and trklet::Settings::writetrace().

                                                                   {
   if (settings_.writetrace()) {
     edm::LogVerbatim("Tracklet") << "In " << name_ << " adding input from " << memory->getName() << " to input "
                                  << input;
   }
   if (input == "innerallstubin") {
     auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
     assert(tmp != nullptr);
     innerallstubs_.push_back(tmp);
     return;
   }
   if (input == "outerallstubin") {
     auto* tmp = dynamic_cast<AllStubsMemory*>(memory);
     assert(tmp != nullptr);
     outerallstubs_.push_back(tmp);
     return;
   }
   if (input.substr(0, 8) == "stubpair") {
     auto* tmp = dynamic_cast<StubPairsMemory*>(memory);
     assert(tmp != nullptr);
     stubpairs_.push_back(tmp);
     return;
   }
   throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find intput : " << input;
 }

◆ addOutput()

void TrackletCalculator::addOutput	(	MemoryBase *	memory,
		std::string	output
	)

overridevirtual

Implements trklet::ProcessBase.

Definition at line 86 of file TrackletCalculator.cc.

References cms::cuda::assert(), Exception, mps_setup::memory, trklet::N_DISK, trklet::N_LAYER, trklet::ProcessBase::name_, convertSQLitetoXML_cfg::output, trklet::ProcessBase::settings_, findQualityFiles::size, createJobs::tmp, trklet::TrackletCalculatorBase::trackletpars_, trklet::TrackletCalculatorBase::trackletprojdisks_, trklet::TrackletCalculatorBase::trackletprojlayers_, and trklet::Settings::writetrace().

                                                                     {
   if (settings_.writetrace()) {
     edm::LogVerbatim("Tracklet") << "In " << name_ << " adding output to " << memory->getName() << " to output "
                                  << output;
   }
   if (output == "trackpar") {
     auto* tmp = dynamic_cast<TrackletParametersMemory*>(memory);
     assert(tmp != nullptr);
     trackletpars_ = tmp;
     return;
   }
 
   if (output.substr(0, 7) == "projout") {
     //output is on the form 'projoutL2PHIC' or 'projoutD3PHIB'
     auto* tmp = dynamic_cast<TrackletProjectionsMemory*>(memory);
     assert(tmp != nullptr);
 
     unsigned int layerdisk = output[8] - '1';   //layer or disk counting from 0
     unsigned int phiregion = output[12] - 'A';  //phiregion counting from 0
 
     if (output[7] == 'L') {
       assert(layerdisk < N_LAYER);
       assert(phiregion < trackletprojlayers_[layerdisk].size());
       //check that phiregion not already initialized
       assert(trackletprojlayers_[layerdisk][phiregion] == nullptr);
       trackletprojlayers_[layerdisk][phiregion] = tmp;
       return;
     }
 
     if (output[7] == 'D') {
       assert(layerdisk < N_DISK);
       assert(phiregion < trackletprojdisks_[layerdisk].size());
       //check that phiregion not already initialized
       assert(trackletprojdisks_[layerdisk][phiregion] == nullptr);
       trackletprojdisks_[layerdisk][phiregion] = tmp;
       return;
     }
   }
 
   throw cms::Exception("BadConfig") << __FILE__ << " " << __LINE__ << " Could not find output : " << output;
 }

◆ addOutputProjection()

void TrackletCalculator::addOutputProjection	(	TrackletProjectionsMemory *&	outputProj,
		MemoryBase *	memory
	)

Definition at line 81 of file TrackletCalculator.cc.

References cms::cuda::assert(), and mps_setup::memory.

                                                                                                        {
   outputProj = dynamic_cast<TrackletProjectionsMemory*>(memory);
   assert(outputProj != nullptr);
 }

◆ execute()

void TrackletCalculator::execute	(	unsigned int	iSector,
		double	phimin,
		double	phimax
	)

Definition at line 154 of file TrackletCalculator.cc.

References accept(), trklet::TrackletCalculatorBase::barrelSeeding(), trklet::Settings::debugTracklet(), trklet::TrackletCalculatorBase::diskSeeding(), Exception, trklet::ProcessBase::getName(), trklet::ProcessBase::globals_, mps_fire::i, trklet::TrackletCalculatorBase::iSector_, trklet::Stub::l1tstub(), trklet::Stub::layerdisk(), trklet::Settings::maxStep(), trklet::N_LAYER, trklet::Settings::ntrackletmax(), trklet::TrackletParametersMemory::nTracklets(), trklet::Globals::ofstream(), trklet::TrackletCalculatorBase::overlapSeeding(), phimax, trklet::TrackletCalculatorBase::phimax_, phimin, trklet::TrackletCalculatorBase::phimin_, trklet::ProcessBase::settings_, stubpairs_, trklet::TrackletCalculatorBase::trackletpars_, and trklet::Settings::writeMonitorData().

                                                                                    {
   unsigned int countall = 0;
   unsigned int countsel = 0;
 
   phimin_ = phimin;
   phimax_ = phimax;
   iSector_ = iSector;
 
   //Helpfull to have for debugging the HLS code - will keep here for now.
   //bool print = (iSector == 3) && (getName() == "TC_L1L2G");
   //print = false;
 
   for (auto& stubpair : stubpairs_) {
     if (trackletpars_->nTracklets() >= settings_.ntrackletmax()) {
       edm::LogVerbatim("Tracklet") << "Will break on too many tracklets in " << getName();
       break;
     }
     for (unsigned int i = 0; i < stubpair->nStubPairs(); i++) {
       countall++;
       const Stub* innerFPGAStub = stubpair->getVMStub1(i).stub();
       const L1TStub* innerStub = innerFPGAStub->l1tstub();
 
       const Stub* outerFPGAStub = stubpair->getVMStub2(i).stub();
       const L1TStub* outerStub = outerFPGAStub->l1tstub();
 
       if (settings_.debugTracklet()) {
         edm::LogVerbatim("Tracklet") << "TrackletCalculator execute " << getName() << "[" << iSector << "]";
       }
 
       if (innerFPGAStub->layerdisk() < N_LAYER && (getName() != "TC_D1L2A" && getName() != "TC_D1L2B")) {
         if (outerFPGAStub->layerdisk() >= N_LAYER) {
           //overlap seeding
           bool accept = overlapSeeding(outerFPGAStub, outerStub, innerFPGAStub, innerStub);
           if (accept)
             countsel++;
         } else {
           //barrel+barrel seeding
           bool accept = barrelSeeding(innerFPGAStub, innerStub, outerFPGAStub, outerStub);
           if (accept)
             countsel++;
         }
       } else {
         if (outerFPGAStub->layerdisk() >= N_LAYER) {
           //disk+disk seeding
           bool accept = diskSeeding(innerFPGAStub, innerStub, outerFPGAStub, outerStub);
           if (accept)
             countsel++;
         } else if (innerFPGAStub->layerdisk() >= N_LAYER) {
           //layer+disk seeding
           bool accept = overlapSeeding(innerFPGAStub, innerStub, outerFPGAStub, outerStub);
           if (accept)
             countsel++;
         } else {
           throw cms::Exception("LogicError") << __FILE__ << " " << __LINE__ << " invalid seeding";
         }
       }
 
       if (trackletpars_->nTracklets() >= settings_.ntrackletmax()) {
         edm::LogVerbatim("Tracklet") << "Will break on number of tracklets in " << getName();
         break;
       }
 
       if (countall >= settings_.maxStep("TC")) {
         if (settings_.debugTracklet())
           edm::LogVerbatim("Tracklet") << "Will break on MAXTC 1";
         break;
       }
       if (settings_.debugTracklet()) {
         edm::LogVerbatim("Tracklet") << "TrackletCalculator execute done";
       }
     }
     if (countall >= settings_.maxStep("TC")) {
       if (settings_.debugTracklet())
         edm::LogVerbatim("Tracklet") << "Will break on MAXTC 2";
       break;
     }
   }
 
   if (settings_.writeMonitorData("TC")) {
     globals_->ofstream("trackletcalculator.txt") << getName() << " " << countall << " " << countsel << endl;
   }
 }

◆ writeFirmwareDesign()

void TrackletCalculator::writeFirmwareDesign ( void(*)(const std::vector< VarBase *> &, const std::string &) writeDesign )

private

Definition at line 282 of file TrackletCalculator.cc.

Referenced by TrackletCalculator().

                                                                                                         {
   switch (iSeed_) {
     case 0:  // L1L2
     {
       const vector<VarBase*> v = {&globals_->ITC_L1L2()->rinv_final,     &globals_->ITC_L1L2()->phi0_final,
                                   &globals_->ITC_L1L2()->t_final,        &globals_->ITC_L1L2()->z0_final,
                                   &globals_->ITC_L1L2()->phiL_0_final,   &globals_->ITC_L1L2()->phiL_1_final,
                                   &globals_->ITC_L1L2()->phiL_2_final,   &globals_->ITC_L1L2()->phiL_3_final,
                                   &globals_->ITC_L1L2()->zL_0_final,     &globals_->ITC_L1L2()->zL_1_final,
                                   &globals_->ITC_L1L2()->zL_2_final,     &globals_->ITC_L1L2()->zL_3_final,
                                   &globals_->ITC_L1L2()->der_phiL_final, &globals_->ITC_L1L2()->der_zL_final,
                                   &globals_->ITC_L1L2()->phiD_0_final,   &globals_->ITC_L1L2()->phiD_1_final,
                                   &globals_->ITC_L1L2()->phiD_2_final,   &globals_->ITC_L1L2()->phiD_3_final,
                                   &globals_->ITC_L1L2()->phiD_4_final,   &globals_->ITC_L1L2()->rD_0_final,
                                   &globals_->ITC_L1L2()->rD_1_final,     &globals_->ITC_L1L2()->rD_2_final,
                                   &globals_->ITC_L1L2()->rD_3_final,     &globals_->ITC_L1L2()->rD_4_final,
                                   &globals_->ITC_L1L2()->der_phiD_final, &globals_->ITC_L1L2()->der_rD_final};
       writeDesign(v, "TC_L1L2");
     } break;
     case 1:  // L2L3
     {
       const vector<VarBase*> v = {&globals_->ITC_L2L3()->rinv_final,     &globals_->ITC_L2L3()->phi0_final,
                                   &globals_->ITC_L2L3()->t_final,        &globals_->ITC_L2L3()->z0_final,
                                   &globals_->ITC_L2L3()->phiL_0_final,   &globals_->ITC_L2L3()->phiL_1_final,
                                   &globals_->ITC_L2L3()->phiL_2_final,   &globals_->ITC_L2L3()->phiL_3_final,
                                   &globals_->ITC_L2L3()->zL_0_final,     &globals_->ITC_L2L3()->zL_1_final,
                                   &globals_->ITC_L2L3()->zL_2_final,     &globals_->ITC_L2L3()->zL_3_final,
                                   &globals_->ITC_L2L3()->der_phiL_final, &globals_->ITC_L2L3()->der_zL_final,
                                   &globals_->ITC_L2L3()->phiD_0_final,   &globals_->ITC_L2L3()->phiD_1_final,
                                   &globals_->ITC_L2L3()->phiD_2_final,   &globals_->ITC_L2L3()->phiD_3_final,
                                   &globals_->ITC_L2L3()->phiD_4_final,   &globals_->ITC_L2L3()->rD_0_final,
                                   &globals_->ITC_L2L3()->rD_1_final,     &globals_->ITC_L2L3()->rD_2_final,
                                   &globals_->ITC_L2L3()->rD_3_final,     &globals_->ITC_L2L3()->rD_4_final,
                                   &globals_->ITC_L2L3()->der_phiD_final, &globals_->ITC_L2L3()->der_rD_final};
       writeDesign(v, "TC_L2L3");
     } break;
     case 2:  // L3L4
     {
       const vector<VarBase*> v = {&globals_->ITC_L3L4()->rinv_final,     &globals_->ITC_L3L4()->phi0_final,
                                   &globals_->ITC_L3L4()->t_final,        &globals_->ITC_L3L4()->z0_final,
                                   &globals_->ITC_L3L4()->phiL_0_final,   &globals_->ITC_L3L4()->phiL_1_final,
                                   &globals_->ITC_L3L4()->phiL_2_final,   &globals_->ITC_L3L4()->phiL_3_final,
                                   &globals_->ITC_L3L4()->zL_0_final,     &globals_->ITC_L3L4()->zL_1_final,
                                   &globals_->ITC_L3L4()->zL_2_final,     &globals_->ITC_L3L4()->zL_3_final,
                                   &globals_->ITC_L3L4()->der_phiL_final, &globals_->ITC_L3L4()->der_zL_final,
                                   &globals_->ITC_L3L4()->phiD_0_final,   &globals_->ITC_L3L4()->phiD_1_final,
                                   &globals_->ITC_L3L4()->phiD_2_final,   &globals_->ITC_L3L4()->phiD_3_final,
                                   &globals_->ITC_L3L4()->phiD_4_final,   &globals_->ITC_L3L4()->rD_0_final,
                                   &globals_->ITC_L3L4()->rD_1_final,     &globals_->ITC_L3L4()->rD_2_final,
                                   &globals_->ITC_L3L4()->rD_3_final,     &globals_->ITC_L3L4()->rD_4_final,
                                   &globals_->ITC_L3L4()->der_phiD_final, &globals_->ITC_L3L4()->der_rD_final};
       writeDesign(v, "TC_L3L4");
     } break;
     case 3:  // L5L6
     {
       const vector<VarBase*> v = {&globals_->ITC_L5L6()->rinv_final,     &globals_->ITC_L5L6()->phi0_final,
                                   &globals_->ITC_L5L6()->t_final,        &globals_->ITC_L5L6()->z0_final,
                                   &globals_->ITC_L5L6()->phiL_0_final,   &globals_->ITC_L5L6()->phiL_1_final,
                                   &globals_->ITC_L5L6()->phiL_2_final,   &globals_->ITC_L5L6()->phiL_3_final,
                                   &globals_->ITC_L5L6()->zL_0_final,     &globals_->ITC_L5L6()->zL_1_final,
                                   &globals_->ITC_L5L6()->zL_2_final,     &globals_->ITC_L5L6()->zL_3_final,
                                   &globals_->ITC_L5L6()->der_phiL_final, &globals_->ITC_L5L6()->der_zL_final,
                                   &globals_->ITC_L5L6()->phiD_0_final,   &globals_->ITC_L5L6()->phiD_1_final,
                                   &globals_->ITC_L5L6()->phiD_2_final,   &globals_->ITC_L5L6()->phiD_3_final,
                                   &globals_->ITC_L5L6()->phiD_4_final,   &globals_->ITC_L5L6()->rD_0_final,
                                   &globals_->ITC_L5L6()->rD_1_final,     &globals_->ITC_L5L6()->rD_2_final,
                                   &globals_->ITC_L5L6()->rD_3_final,     &globals_->ITC_L5L6()->rD_4_final,
                                   &globals_->ITC_L5L6()->der_phiD_final, &globals_->ITC_L5L6()->der_rD_final};
       writeDesign(v, "TC_L5L6");
     } break;
     case 4:  // D1D2
     {
       const vector<VarBase*> v = {&globals_->ITC_F1F2()->rinv_final,     &globals_->ITC_F1F2()->phi0_final,
                                   &globals_->ITC_F1F2()->t_final,        &globals_->ITC_F1F2()->z0_final,
                                   &globals_->ITC_F1F2()->phiL_0_final,   &globals_->ITC_F1F2()->phiL_1_final,
                                   &globals_->ITC_F1F2()->phiL_2_final,   &globals_->ITC_F1F2()->zL_0_final,
                                   &globals_->ITC_F1F2()->zL_1_final,     &globals_->ITC_F1F2()->zL_2_final,
                                   &globals_->ITC_F1F2()->der_phiL_final, &globals_->ITC_F1F2()->der_zL_final,
                                   &globals_->ITC_F1F2()->phiD_0_final,   &globals_->ITC_F1F2()->phiD_1_final,
                                   &globals_->ITC_F1F2()->phiD_2_final,   &globals_->ITC_F1F2()->rD_0_final,
                                   &globals_->ITC_F1F2()->rD_1_final,     &globals_->ITC_F1F2()->rD_2_final,
                                   &globals_->ITC_F1F2()->der_phiD_final, &globals_->ITC_F1F2()->der_rD_final};
       writeDesign(v, "TC_F1F2");
     }
       {
         const vector<VarBase*> v = {&globals_->ITC_B1B2()->rinv_final,     &globals_->ITC_B1B2()->phi0_final,
                                     &globals_->ITC_B1B2()->t_final,        &globals_->ITC_B1B2()->z0_final,
                                     &globals_->ITC_B1B2()->phiL_0_final,   &globals_->ITC_B1B2()->phiL_1_final,
                                     &globals_->ITC_B1B2()->phiL_2_final,   &globals_->ITC_B1B2()->zL_0_final,
                                     &globals_->ITC_B1B2()->zL_1_final,     &globals_->ITC_B1B2()->zL_2_final,
                                     &globals_->ITC_B1B2()->der_phiL_final, &globals_->ITC_B1B2()->der_zL_final,
                                     &globals_->ITC_B1B2()->phiD_0_final,   &globals_->ITC_B1B2()->phiD_1_final,
                                     &globals_->ITC_B1B2()->phiD_2_final,   &globals_->ITC_B1B2()->rD_0_final,
                                     &globals_->ITC_B1B2()->rD_1_final,     &globals_->ITC_B1B2()->rD_2_final,
                                     &globals_->ITC_B1B2()->der_phiD_final, &globals_->ITC_B1B2()->der_rD_final};
         writeDesign(v, "TC_B1B2");
       }
       break;
     case 5:  // D3D4
     {
       const vector<VarBase*> v = {&globals_->ITC_F3F4()->rinv_final,     &globals_->ITC_F3F4()->phi0_final,
                                   &globals_->ITC_F3F4()->t_final,        &globals_->ITC_F3F4()->z0_final,
                                   &globals_->ITC_F3F4()->phiL_0_final,   &globals_->ITC_F3F4()->phiL_1_final,
                                   &globals_->ITC_F3F4()->phiL_2_final,   &globals_->ITC_F3F4()->zL_0_final,
                                   &globals_->ITC_F3F4()->zL_1_final,     &globals_->ITC_F3F4()->zL_2_final,
                                   &globals_->ITC_F3F4()->der_phiL_final, &globals_->ITC_F3F4()->der_zL_final,
                                   &globals_->ITC_F3F4()->phiD_0_final,   &globals_->ITC_F3F4()->phiD_1_final,
                                   &globals_->ITC_F3F4()->phiD_2_final,   &globals_->ITC_F3F4()->rD_0_final,
                                   &globals_->ITC_F3F4()->rD_1_final,     &globals_->ITC_F3F4()->rD_2_final,
                                   &globals_->ITC_F3F4()->der_phiD_final, &globals_->ITC_F3F4()->der_rD_final};
       writeDesign(v, "TC_F3F4");
     }
       {
         const vector<VarBase*> v = {&globals_->ITC_B3B4()->rinv_final,     &globals_->ITC_B3B4()->phi0_final,
                                     &globals_->ITC_B3B4()->t_final,        &globals_->ITC_B3B4()->z0_final,
                                     &globals_->ITC_B3B4()->phiL_0_final,   &globals_->ITC_B3B4()->phiL_1_final,
                                     &globals_->ITC_B3B4()->phiL_2_final,   &globals_->ITC_B3B4()->zL_0_final,
                                     &globals_->ITC_B3B4()->zL_1_final,     &globals_->ITC_B3B4()->zL_2_final,
                                     &globals_->ITC_B3B4()->der_phiL_final, &globals_->ITC_B3B4()->der_zL_final,
                                     &globals_->ITC_B3B4()->phiD_0_final,   &globals_->ITC_B3B4()->phiD_1_final,
                                     &globals_->ITC_B3B4()->phiD_2_final,   &globals_->ITC_B3B4()->rD_0_final,
                                     &globals_->ITC_B3B4()->rD_1_final,     &globals_->ITC_B3B4()->rD_2_final,
                                     &globals_->ITC_B3B4()->der_phiD_final, &globals_->ITC_B3B4()->der_rD_final};
         writeDesign(v, "TC_B3B4");
       }
       break;
     case 6:  // L1D1
     {
       const vector<VarBase*> v = {&globals_->ITC_L1F1()->rinv_final,     &globals_->ITC_L1F1()->phi0_final,
                                   &globals_->ITC_L1F1()->t_final,        &globals_->ITC_L1F1()->z0_final,
                                   &globals_->ITC_L1F1()->phiL_0_final,   &globals_->ITC_L1F1()->phiL_1_final,
                                   &globals_->ITC_L1F1()->phiL_2_final,   &globals_->ITC_L1F1()->zL_0_final,
                                   &globals_->ITC_L1F1()->zL_1_final,     &globals_->ITC_L1F1()->zL_2_final,
                                   &globals_->ITC_L1F1()->der_phiL_final, &globals_->ITC_L1F1()->der_zL_final,
                                   &globals_->ITC_L1F1()->phiD_0_final,   &globals_->ITC_L1F1()->phiD_1_final,
                                   &globals_->ITC_L1F1()->phiD_2_final,   &globals_->ITC_L1F1()->phiD_3_final,
                                   &globals_->ITC_L1F1()->rD_0_final,     &globals_->ITC_L1F1()->rD_1_final,
                                   &globals_->ITC_L1F1()->rD_2_final,     &globals_->ITC_L1F1()->rD_3_final,
                                   &globals_->ITC_L1F1()->der_phiD_final, &globals_->ITC_L1F1()->der_rD_final};
       writeDesign(v, "TC_L1F1");
     }
       {
         const vector<VarBase*> v = {&globals_->ITC_L1B1()->rinv_final,     &globals_->ITC_L1B1()->phi0_final,
                                     &globals_->ITC_L1B1()->t_final,        &globals_->ITC_L1B1()->z0_final,
                                     &globals_->ITC_L1B1()->phiL_0_final,   &globals_->ITC_L1B1()->phiL_1_final,
                                     &globals_->ITC_L1B1()->phiL_2_final,   &globals_->ITC_L1B1()->zL_0_final,
                                     &globals_->ITC_L1B1()->zL_1_final,     &globals_->ITC_L1B1()->zL_2_final,
                                     &globals_->ITC_L1B1()->der_phiL_final, &globals_->ITC_L1B1()->der_zL_final,
                                     &globals_->ITC_L1B1()->phiD_0_final,   &globals_->ITC_L1B1()->phiD_1_final,
                                     &globals_->ITC_L1B1()->phiD_2_final,   &globals_->ITC_L1B1()->phiD_3_final,
                                     &globals_->ITC_L1B1()->rD_0_final,     &globals_->ITC_L1B1()->rD_1_final,
                                     &globals_->ITC_L1B1()->rD_2_final,     &globals_->ITC_L1B1()->rD_3_final,
                                     &globals_->ITC_L1B1()->der_phiD_final, &globals_->ITC_L1B1()->der_rD_final};
         writeDesign(v, "TC_L1B1");
       }
       break;
     case 7:  // L2D1
     {
       const vector<VarBase*> v = {&globals_->ITC_L2F1()->rinv_final,     &globals_->ITC_L2F1()->phi0_final,
                                   &globals_->ITC_L2F1()->t_final,        &globals_->ITC_L2F1()->z0_final,
                                   &globals_->ITC_L2F1()->phiL_0_final,   &globals_->ITC_L2F1()->phiL_1_final,
                                   &globals_->ITC_L2F1()->phiL_2_final,   &globals_->ITC_L2F1()->zL_0_final,
                                   &globals_->ITC_L2F1()->zL_1_final,     &globals_->ITC_L2F1()->zL_2_final,
                                   &globals_->ITC_L2F1()->der_phiL_final, &globals_->ITC_L2F1()->der_zL_final,
                                   &globals_->ITC_L2F1()->phiD_0_final,   &globals_->ITC_L2F1()->phiD_1_final,
                                   &globals_->ITC_L2F1()->phiD_2_final,   &globals_->ITC_L2F1()->phiD_3_final,
                                   &globals_->ITC_L2F1()->rD_0_final,     &globals_->ITC_L2F1()->rD_1_final,
                                   &globals_->ITC_L2F1()->rD_2_final,     &globals_->ITC_L2F1()->rD_3_final,
                                   &globals_->ITC_L2F1()->der_phiD_final, &globals_->ITC_L2F1()->der_rD_final};
       writeDesign(v, "TC_L2F1");
     }
       {
         const vector<VarBase*> v = {&globals_->ITC_L2B1()->rinv_final,     &globals_->ITC_L2B1()->phi0_final,
                                     &globals_->ITC_L2B1()->t_final,        &globals_->ITC_L2B1()->z0_final,
                                     &globals_->ITC_L2B1()->phiL_0_final,   &globals_->ITC_L2B1()->phiL_1_final,
                                     &globals_->ITC_L2B1()->phiL_2_final,   &globals_->ITC_L2B1()->zL_0_final,
                                     &globals_->ITC_L2B1()->zL_1_final,     &globals_->ITC_L2B1()->zL_2_final,
                                     &globals_->ITC_L2B1()->der_phiL_final, &globals_->ITC_L2B1()->der_zL_final,
                                     &globals_->ITC_L2B1()->phiD_0_final,   &globals_->ITC_L2B1()->phiD_1_final,
                                     &globals_->ITC_L2B1()->phiD_2_final,   &globals_->ITC_L2B1()->phiD_3_final,
                                     &globals_->ITC_L2B1()->rD_0_final,     &globals_->ITC_L2B1()->rD_1_final,
                                     &globals_->ITC_L2B1()->rD_2_final,     &globals_->ITC_L2B1()->rD_3_final,
                                     &globals_->ITC_L2B1()->der_phiD_final, &globals_->ITC_L2B1()->der_rD_final};
         writeDesign(v, "TC_L2B1");
       }
       break;
   }
 }

◆ writeInvTable()

void TrackletCalculator::writeInvTable ( void(*)(const VarInv &, const std::string &) writeLUT )

private

Definition at line 237 of file TrackletCalculator.cc.

Referenced by TrackletCalculator().

                                                                                      {
   switch (iSeed_) {
     case 0:  // L1L2
       writeLUT(globals_->ITC_L1L2()->drinv, settings_.tablePath() + "TC_L1L2_drinv");
       writeLUT(globals_->ITC_L1L2()->invt, settings_.tablePath() + "TC_L1L2_invt");
       break;
     case 1:  // L2L3
       writeLUT(globals_->ITC_L2L3()->drinv, settings_.tablePath() + "TC_L2L3_drinv");
       writeLUT(globals_->ITC_L2L3()->invt, settings_.tablePath() + "TC_L2L3_invt");
       break;
     case 2:  // L3L4
       writeLUT(globals_->ITC_L3L4()->drinv, settings_.tablePath() + "TC_L3L4_drinv");
       writeLUT(globals_->ITC_L3L4()->invt, settings_.tablePath() + "TC_L3L4_invt");
       break;
     case 3:  // L5L6
       writeLUT(globals_->ITC_L5L6()->drinv, settings_.tablePath() + "TC_L5L6_drinv");
       writeLUT(globals_->ITC_L5L6()->invt, settings_.tablePath() + "TC_L5L6_invt");
       break;
     case 4:  // D1D2
       writeLUT(globals_->ITC_F1F2()->drinv, settings_.tablePath() + "TC_F1F2_drinv");
       writeLUT(globals_->ITC_F1F2()->invt, settings_.tablePath() + "TC_F1F2_invt");
       writeLUT(globals_->ITC_B1B2()->drinv, settings_.tablePath() + "TC_B1B2_drinv");
       writeLUT(globals_->ITC_B1B2()->invt, settings_.tablePath() + "TC_B1B2_invt");
       break;
     case 5:  // D3D4
       writeLUT(globals_->ITC_F3F4()->drinv, settings_.tablePath() + "TC_F3F4_drinv");
       writeLUT(globals_->ITC_F3F4()->invt, settings_.tablePath() + "TC_F3F4_invt");
       writeLUT(globals_->ITC_B3B4()->drinv, settings_.tablePath() + "TC_B3B4_drinv");
       writeLUT(globals_->ITC_B3B4()->invt, settings_.tablePath() + "TC_B3B4_invt");
       break;
     case 6:  // L1D1
       writeLUT(globals_->ITC_L1F1()->drinv, settings_.tablePath() + "TC_L1F1_drinv");
       writeLUT(globals_->ITC_L1F1()->invt, settings_.tablePath() + "TC_L1F1_invt");
       writeLUT(globals_->ITC_L1B1()->drinv, settings_.tablePath() + "TC_L1B1_drinv");
       writeLUT(globals_->ITC_L1B1()->invt, settings_.tablePath() + "TC_L1B1_invt");
       break;
     case 7:  // L2D1
       writeLUT(globals_->ITC_L2F1()->drinv, settings_.tablePath() + "TC_L2F1_drinv");
       writeLUT(globals_->ITC_L2F1()->invt, settings_.tablePath() + "TC_L2F1_invt");
       writeLUT(globals_->ITC_L2B1()->drinv, settings_.tablePath() + "TC_L2B1_drinv");
       writeLUT(globals_->ITC_L2B1()->invt, settings_.tablePath() + "TC_L2B1_invt");
       break;
   }
 }

Member Data Documentation

◆ innerallstubs_

std::vector<AllStubsMemory*> trklet::TrackletCalculator::innerallstubs_

private

Definition at line 35 of file TrackletCalculator.h.

Referenced by addInput().

◆ iTC_

int trklet::TrackletCalculator::iTC_

private

Definition at line 33 of file TrackletCalculator.h.

Referenced by TrackletCalculator().

◆ outerallstubs_

std::vector<AllStubsMemory*> trklet::TrackletCalculator::outerallstubs_

private

Definition at line 36 of file TrackletCalculator.h.

Referenced by addInput().

◆ stubpairs_

std::vector<StubPairsMemory*> trklet::TrackletCalculator::stubpairs_

private

Definition at line 37 of file TrackletCalculator.h.

Referenced by addInput(), and execute().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TrackletCalculator()

◆ ~TrackletCalculator()

Member Function Documentation

◆ addInput()

◆ addOutput()

◆ addOutputProjection()

◆ execute()

◆ writeFirmwareDesign()

◆ writeInvTable()

Member Data Documentation

◆ innerallstubs_

◆ iTC_

◆ outerallstubs_

◆ stubpairs_