trklet::TrackletCalculator Class Reference

#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 ()
	TrackletCalculator (std::string name, Settings const &settings, Globals *globals, unsigned int iSector)
	~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, unsigned int iSector)
	~TrackletCalculatorBase () override=default
Public Member Functions inherited from trklet::ProcessBase
unsigned int	getISeed (const std::string &name)
std::string const &	getName () const
unsigned int	initLayerDisk (unsigned int pos)
void	initLayerDisk (unsigned int pos, int &layer, int &disk)
void	initLayerDisk (unsigned int pos, int &layer, int &disk, int &layerdisk)
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, unsigned int iSector)
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	iSeed_
unsigned int	layerdisk1_
unsigned int	layerdisk2_
int	TCIndex_
TrackletParametersMemory *	trackletpars_
std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojdisks_
std::vector< std::vector< TrackletProjectionsMemory * > >	trackletprojlayers_
Protected Attributes inherited from trklet::ProcessBase
Globals *	globals_
unsigned int	iSector_
std::string	name_
double	phimax_
double	phimin_
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,
		unsigned int	iSector
	)

Definition at line 17 of file TrackletCalculator.cc.

    : TrackletCalculatorBase(name, settings, globals, iSector) {
  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()) && iTC_ == 0 && iSector_ == 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 && iSector_ == 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);
  }
}

References funct::abs(), cms::cuda::assert(), trklet::ProcessBase::globals_, trklet::VarBase::hls, trklet::VarBase::hls_print(), trklet::ProcessBase::initLayerDisksandISeed(), trklet::ProcessBase::iSector_, 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(), and trklet::Settings::writeVerilog().

~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.

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

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

addOutput()

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

overridevirtual

Implements trklet::ProcessBase.

Definition at line 86 of file TrackletCalculator.cc.

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

References cms::cuda::assert(), Exception, 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().

addOutputProjection()

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

Definition at line 81 of file TrackletCalculator.cc.

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

References cms::cuda::assert().

execute()

void TrackletCalculator::execute

(

void

)

Definition at line 154 of file TrackletCalculator.cc.

                                 {
  unsigned int countall = 0;
  unsigned int countsel = 0;
 
  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->isBarrel() && (getName() != "TC_D1L2A" && getName() != "TC_D1L2B")) {
        if (outerFPGAStub->isDisk()) {
          //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->isDisk()) {
          //disk+disk seeding
          bool accept = diskSeeding(innerFPGAStub, innerStub, outerFPGAStub, outerStub);
          if (accept)
            countsel++;
        } else if (innerFPGAStub->isDisk()) {
          //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;
  }
}

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

writeFirmwareDesign()

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

private

Definition at line 274 of file TrackletCalculator.cc.

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

References trklet::IMATH_TrackletCalculatorDisk::der_phiD_final, trklet::IMATH_TrackletCalculatorOverlap::der_phiD_final, trklet::IMATH_TrackletCalculator::der_phiD_final, trklet::IMATH_TrackletCalculatorDisk::der_phiL_final, trklet::IMATH_TrackletCalculatorOverlap::der_phiL_final, trklet::IMATH_TrackletCalculator::der_phiL_final, trklet::IMATH_TrackletCalculatorDisk::der_rD_final, trklet::IMATH_TrackletCalculatorOverlap::der_rD_final, trklet::IMATH_TrackletCalculator::der_rD_final, trklet::IMATH_TrackletCalculatorDisk::der_zL_final, trklet::IMATH_TrackletCalculatorOverlap::der_zL_final, trklet::IMATH_TrackletCalculator::der_zL_final, trklet::ProcessBase::globals_, trklet::TrackletCalculatorBase::iSeed_, trklet::Globals::ITC_B1B2(), trklet::Globals::ITC_B3B4(), trklet::Globals::ITC_F1F2(), trklet::Globals::ITC_F3F4(), trklet::Globals::ITC_L1B1(), trklet::Globals::ITC_L1F1(), trklet::Globals::ITC_L1L2(), trklet::Globals::ITC_L2B1(), trklet::Globals::ITC_L2F1(), trklet::Globals::ITC_L2L3(), trklet::Globals::ITC_L3L4(), trklet::Globals::ITC_L5L6(), trklet::IMATH_TrackletCalculatorDisk::phi0_final, trklet::IMATH_TrackletCalculatorOverlap::phi0_final, trklet::IMATH_TrackletCalculator::phi0_final, trklet::IMATH_TrackletCalculatorDisk::phiD_0_final, trklet::IMATH_TrackletCalculatorOverlap::phiD_0_final, trklet::IMATH_TrackletCalculator::phiD_0_final, trklet::IMATH_TrackletCalculatorDisk::phiD_1_final, trklet::IMATH_TrackletCalculatorOverlap::phiD_1_final, trklet::IMATH_TrackletCalculator::phiD_1_final, trklet::IMATH_TrackletCalculatorDisk::phiD_2_final, trklet::IMATH_TrackletCalculatorOverlap::phiD_2_final, trklet::IMATH_TrackletCalculator::phiD_2_final, trklet::IMATH_TrackletCalculatorOverlap::phiD_3_final, trklet::IMATH_TrackletCalculator::phiD_3_final, trklet::IMATH_TrackletCalculator::phiD_4_final, trklet::IMATH_TrackletCalculatorDisk::phiL_0_final, trklet::IMATH_TrackletCalculatorOverlap::phiL_0_final, trklet::IMATH_TrackletCalculator::phiL_0_final, trklet::IMATH_TrackletCalculatorDisk::phiL_1_final, trklet::IMATH_TrackletCalculatorOverlap::phiL_1_final, trklet::IMATH_TrackletCalculator::phiL_1_final, trklet::IMATH_TrackletCalculatorDisk::phiL_2_final, trklet::IMATH_TrackletCalculatorOverlap::phiL_2_final, trklet::IMATH_TrackletCalculator::phiL_2_final, trklet::IMATH_TrackletCalculator::phiL_3_final, trklet::IMATH_TrackletCalculatorDisk::rD_0_final, trklet::IMATH_TrackletCalculatorOverlap::rD_0_final, trklet::IMATH_TrackletCalculator::rD_0_final, trklet::IMATH_TrackletCalculatorDisk::rD_1_final, trklet::IMATH_TrackletCalculatorOverlap::rD_1_final, trklet::IMATH_TrackletCalculator::rD_1_final, trklet::IMATH_TrackletCalculatorDisk::rD_2_final, trklet::IMATH_TrackletCalculatorOverlap::rD_2_final, trklet::IMATH_TrackletCalculator::rD_2_final, trklet::IMATH_TrackletCalculatorOverlap::rD_3_final, trklet::IMATH_TrackletCalculator::rD_3_final, trklet::IMATH_TrackletCalculator::rD_4_final, trklet::IMATH_TrackletCalculatorDisk::rinv_final, trklet::IMATH_TrackletCalculatorOverlap::rinv_final, trklet::IMATH_TrackletCalculator::rinv_final, trklet::IMATH_TrackletCalculatorDisk::t_final, trklet::IMATH_TrackletCalculatorOverlap::t_final, trklet::IMATH_TrackletCalculator::t_final, findQualityFiles::v, trklet::IMATH_TrackletCalculatorDisk::z0_final, trklet::IMATH_TrackletCalculatorOverlap::z0_final, trklet::IMATH_TrackletCalculator::z0_final, trklet::IMATH_TrackletCalculatorDisk::zL_0_final, trklet::IMATH_TrackletCalculatorOverlap::zL_0_final, trklet::IMATH_TrackletCalculator::zL_0_final, trklet::IMATH_TrackletCalculatorDisk::zL_1_final, trklet::IMATH_TrackletCalculatorOverlap::zL_1_final, trklet::IMATH_TrackletCalculator::zL_1_final, trklet::IMATH_TrackletCalculatorDisk::zL_2_final, trklet::IMATH_TrackletCalculatorOverlap::zL_2_final, trklet::IMATH_TrackletCalculator::zL_2_final, and trklet::IMATH_TrackletCalculator::zL_3_final.

Referenced by TrackletCalculator().

writeInvTable()

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

private

Definition at line 229 of file TrackletCalculator.cc.

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

References trklet::IMATH_TrackletCalculatorDisk::drinv, trklet::IMATH_TrackletCalculatorOverlap::drinv, trklet::IMATH_TrackletCalculator::drinv, trklet::ProcessBase::globals_, trklet::IMATH_TrackletCalculatorDisk::invt, trklet::IMATH_TrackletCalculatorOverlap::invt, trklet::IMATH_TrackletCalculator::invt, trklet::TrackletCalculatorBase::iSeed_, trklet::Globals::ITC_B1B2(), trklet::Globals::ITC_B3B4(), trklet::Globals::ITC_F1F2(), trklet::Globals::ITC_F3F4(), trklet::Globals::ITC_L1B1(), trklet::Globals::ITC_L1F1(), trklet::Globals::ITC_L1L2(), trklet::Globals::ITC_L2B1(), trklet::Globals::ITC_L2F1(), trklet::Globals::ITC_L2L3(), trklet::Globals::ITC_L3L4(), trklet::Globals::ITC_L5L6(), trklet::ProcessBase::settings_, and trklet::Settings::tablePath().

Referenced by TrackletCalculator().

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().