ProcessorBase< GoldenPatternType > Class Template Reference

#include <ProcessorBase.h>

Inheritance diagram for ProcessorBase< GoldenPatternType >:

Public Member Functions
virtual void	addGP (GoldenPatternType *aGP)
	Add GoldenPattern to pattern vec. More...
virtual bool	configure (OMTFConfiguration *omtfParams, const L1TMuonOverlapParams *omtfPatterns)
	Fill GP vec with patterns from CondFormats object. More...
const std::vector< OMTFConfiguration::PatternPt > &	getPatternPtRange () const
virtual GoldenPatternVec< GoldenPatternType > &	getPatterns ()
	Return vector of GoldenPatterns. More...
virtual void	initPatternPtRange (bool firstPatFrom0)
virtual void	printInfo () const
	ProcessorBase (OMTFConfiguration *omtfConfig, const L1TMuonOverlapParams *omtfPatterns)
	ProcessorBase (OMTFConfiguration *omtfConfig, GoldenPatternVec< GoldenPatternType > &&gps)
virtual void	resetConfiguration ()
	Reset all configuration parameters. More...
virtual	~ProcessorBase ()

Protected Member Functions
virtual MuonStubPtrs1D	restrictInput (unsigned int iProcessor, unsigned int iCone, unsigned int iLayer, const OMTFinput &input)

Protected Attributes
const OMTFConfiguration *	myOmtfConfig
std::vector< OMTFConfiguration::PatternPt >	patternPts
GoldenPatternVec< GoldenPatternType >	theGPs
	vector holding Golden Patterns More...

Detailed Description

template<class GoldenPatternType>
class ProcessorBase< GoldenPatternType >

Definition at line 21 of file ProcessorBase.h.

Constructor & Destructor Documentation

ProcessorBase() [1/2]

template<class GoldenPatternType>

ProcessorBase< GoldenPatternType >::ProcessorBase ( OMTFConfiguration *  omtfConfig, const L1TMuonOverlapParams *  omtfPatterns  )

inline

Definition at line 23 of file ProcessorBase.h.

References ProcessorBase< GoldenPatternType >::configure().

                                                                                         : myOmtfConfig(omtfConfig) {
    configure(omtfConfig, omtfPatterns);
  };

ProcessorBase() [2/2]

template<class GoldenPatternType >

ProcessorBase< GoldenPatternType >::ProcessorBase	(	OMTFConfiguration *	omtfConfig,
		GoldenPatternVec< GoldenPatternType > &&	gps
	)

omtfConfig is not const, because the omtfConfig->setPatternPtRange is called inside the constructor takes the ownership of the gps (uses move)

Definition at line 21 of file ProcessorBase.cc.

References ProcessorBase< GoldenPatternType >::getPatternPtRange(), runTauDisplay::gp, ProcessorBase< GoldenPatternType >::initPatternPtRange(), ProcessorBase< GoldenPatternType >::myOmtfConfig, OMTFConfiguration::setPatternPtRange(), and ProcessorBase< GoldenPatternType >::theGPs.

    : myOmtfConfig(omtfConfig), theGPs(std::move(gps)) {
  for (auto& gp : theGPs) {
    gp->setConfig(myOmtfConfig);
  }

  initPatternPtRange(true);

  omtfConfig->setPatternPtRange(getPatternPtRange());
};

~ProcessorBase()

template<class GoldenPatternType>

virtual ProcessorBase< GoldenPatternType >::~ProcessorBase ( )

inlinevirtual

Definition at line 31 of file ProcessorBase.h.

{}

Member Function Documentation

addGP()

template<class GoldenPatternType >

void ProcessorBase< GoldenPatternType >::addGP ( GoldenPatternType *  aGP )

virtual

Add GoldenPattern to pattern vec.

Definition at line 138 of file ProcessorBase.cc.

                                                                   {
  theGPs.emplace_back(std::unique_ptr<GoldenPatternType>(aGP));
}

configure()

template<class GoldenPatternType >

bool ProcessorBase< GoldenPatternType >::configure ( OMTFConfiguration *  omtfParams, const L1TMuonOverlapParams *  omtfPatterns  )

virtual

Fill GP vec with patterns from CondFormats object.

Mean dist phi data

Pdf data

Definition at line 41 of file ProcessorBase.cc.

References L1TMuonOverlapParams::chargeLUT(), l1t::LUT::data(), L1TMuonOverlapParams::distPhiShiftLUT(), L1TMuonOverlapParams::etaLUT(), Phase2L1GMT::etaLUT, watchdog::group, L1TowerCalibrationProducer_cfi::iEta, createfilelist::int, LogTrace, L1TMuonOverlapParams::meanDistPhiLUT(), l1t::LUT::nrBitsData(), L1TMuonOverlapParams::pdfLUT(), Phase2L1GMT::ptLUT, L1TMuonOverlapParams::ptLUT(), and OMTFConfiguration::setPatternPtRange().

Referenced by ProcessorBase< GoldenPatternType >::ProcessorBase().

                                                                                           {
  resetConfiguration();

  myOmtfConfig = omtfConfig;

  const l1t::LUT* chargeLUT = omtfPatterns->chargeLUT();
  const l1t::LUT* etaLUT = omtfPatterns->etaLUT();
  const l1t::LUT* ptLUT = omtfPatterns->ptLUT();
  const l1t::LUT* pdfLUT = omtfPatterns->pdfLUT();
  const l1t::LUT* meanDistPhiLUT = omtfPatterns->meanDistPhiLUT();
  const l1t::LUT* distPhiShiftLUT = omtfPatterns->distPhiShiftLUT();

  unsigned int nGPs = myOmtfConfig->nGoldenPatterns();
  edm::LogVerbatim("OMTFReconstruction")
      << "ProcessorBase<>::configure. Building patterns from L1TMuonOverlapParams (LUTs). nGoldenPatterns() " << nGPs
      << std::endl;

  unsigned int address = 0;
  unsigned int iEta, iPt;
  int iCharge;
  //int meanDistPhiSize = myOmtfConfig->nLayers() * myOmtfConfig->nRefLayers() * myOmtfConfig->nGoldenPatterns();

  unsigned int group = 0;
  unsigned int indexInGroup = 0;
  for (unsigned int iGP = 0; iGP < nGPs; ++iGP) {
    address = iGP;
    iEta = etaLUT->data(address);
    iCharge = chargeLUT->data(address) == 0 ? -1 : 1;
    iPt = ptLUT->data(address);

    //the patterns in the LUTs should contain the empty patterns, only then the group and indexInGroup calculation works
    group = iGP / myOmtfConfig->patternsInGroup;
    indexInGroup = iGP % myOmtfConfig->patternsInGroup + 1;
    Key aKey(iEta, iPt, iCharge, theGPs.size(), group, indexInGroup);
    if (iPt == 0) {
      LogTrace("OMTFReconstruction") << "skipping empty pattern " << aKey << " " << std::endl;
      //<<myOmtfConfig->getPatternPtRange(iGP).ptFrom<<" - "<<myOmtfConfig->getPatternPtRange(iGP).ptTo<<" GeV"<<std::endl; PatternPtRange is not initialized here yet, so do not use it!!!!
      continue;
    }

    LogTrace("OMTFReconstruction") << "adding pattern " << aKey << " " << std::endl;
    //<<myOmtfConfig->getPatternPtRange(iGP).ptFrom<<" - "<<myOmtfConfig->getPatternPtRange(iGP).ptTo<<" GeV"<<std::endl; PatternPtRange is not initialized here yet, so do not use it!!!!

    GoldenPatternType* aGP = new GoldenPatternType(aKey, myOmtfConfig);

    for (unsigned int iLayer = 0; iLayer < myOmtfConfig->nLayers(); ++iLayer) {
      for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
        address = iRefLayer + iLayer * myOmtfConfig->nRefLayers() +
                  iGP * (myOmtfConfig->nRefLayers() * myOmtfConfig->nLayers());

        //LUT values are only positive, therefore to have negative  meanDistPh half of the max LUT value is subtracted
        int value = meanDistPhiLUT->data(address) - (1 << (meanDistPhiLUT->nrBitsData() - 1));
        aGP->setMeanDistPhiValue(value, iLayer, iRefLayer, 0);

        /* uncomment this if you need  meanDistPhi1 in the LUTs (and set useMeanDistPhi1 in XMLConfigReader::readLUTs)
        if ( (1 << meanDistPhiLUT->nrBitsAddress()) > 2 * meanDistPhiSize ) {
          //for the  version of the meanDistPhi which have two values for each gp,iLayer,iRefLayer, FIXME: do it a better way
          value = meanDistPhiLUT->data(address + meanDistPhiSize) - (1 << (meanDistPhiLUT->nrBitsData() - 1));
          //the second meanDistPhi is in the LUT at the position (address+meanDistPhiSize)
          aGP->setMeanDistPhiValue(value, iLayer, iRefLayer, 1);
        }*/

        //selDistPhiShift, if the distPhiShiftLUT is nullptr, it means it was not present in the L1TMuonOverlapParamsRcd
        if (distPhiShiftLUT) {
          value = distPhiShiftLUT->data(address);  //distPhiShiftLUT values are only positive
          aGP->setDistPhiBitShift(value, iLayer, iRefLayer);
        }
      }
      for (unsigned int iRefLayer = 0; iRefLayer < myOmtfConfig->nRefLayers(); ++iRefLayer) {
        for (unsigned int iPdf = 0; iPdf < (unsigned int)(1 << myOmtfConfig->nPdfAddrBits()); ++iPdf) {
          address = iPdf + iRefLayer * (1 << myOmtfConfig->nPdfAddrBits()) +
                    iLayer * myOmtfConfig->nRefLayers() * (1 << myOmtfConfig->nPdfAddrBits()) +
                    iGP * myOmtfConfig->nLayers() * myOmtfConfig->nRefLayers() * (1 << myOmtfConfig->nPdfAddrBits());
          int value = pdfLUT->data(address);  //here only int is possible
          aGP->setPdfValue(value, iLayer, iRefLayer, iPdf);

          //LogTrace("OMTFReconstruction") <<" iLayer "<<iLayer<<" iRefLayer "<<iRefLayer<<" iPdf "<<iPdf << " address "<<address<<" value "<<value<<std::endl;
        }
      }
    }

    addGP(aGP);
  }

  initPatternPtRange(true);

  omtfConfig->setPatternPtRange(getPatternPtRange());

  return true;
}

getPatternPtRange()

template<class GoldenPatternType>

const std::vector<OMTFConfiguration::PatternPt>& ProcessorBase< GoldenPatternType >::getPatternPtRange ( ) const

inline

Definition at line 47 of file ProcessorBase.h.

References ProcessorBase< GoldenPatternType >::patternPts.

Referenced by ProcessorBase< GoldenPatternType >::ProcessorBase().

{ return patternPts; }

getPatterns()

template<class GoldenPatternType>

virtual GoldenPatternVec<GoldenPatternType>& ProcessorBase< GoldenPatternType >::getPatterns ( )

inlinevirtual

Return vector of GoldenPatterns.

Definition at line 34 of file ProcessorBase.h.

References ProcessorBase< GoldenPatternType >::theGPs.

{ return theGPs; };

initPatternPtRange()

template<class GoldenPatternType >

void ProcessorBase< GoldenPatternType >::initPatternPtRange ( bool  firstPatFrom0 )

virtual

Definition at line 169 of file ProcessorBase.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, OMTFConfiguration::PatternPt::charge, crabWrapper::key, OMTFConfiguration::PatternPt::ptFrom, OMTFConfiguration::PatternPt::ptTo, and AlignmentTrackSelector_cfi::theCharge.

Referenced by ProcessorBase< GoldenPatternType >::ProcessorBase().

                                                                            {
  patternPts.clear();

  bool firstPos = firstPatFrom0;
  bool firstNeg = firstPatFrom0;
  for (unsigned int iPat = 0; iPat < theGPs.size(); iPat++) {
    OMTFConfiguration::PatternPt patternPt;
    int charge = theGPs[iPat]->key().theCharge;
    if (theGPs[iPat] == nullptr || theGPs[iPat]->key().thePt == 0) {
      patternPts.push_back(patternPt);
      continue;
    }

    patternPt.ptFrom = myOmtfConfig->hwPtToGev(theGPs[iPat]->key().thePt);
    if (firstPos && theGPs[iPat]->key().theCharge == 1) {
      patternPt.ptFrom = 0;
      firstPos = false;
    }
    if (firstNeg && theGPs[iPat]->key().theCharge == -1) {
      patternPt.ptFrom = 0;
      firstNeg = false;
    }

    unsigned int iPat1 = iPat;
    while (true) {  //to skip the empty patterns with pt=0 and patterns with opposite charge
      iPat1++;
      if (iPat1 == theGPs.size())
        break;
      if (theGPs[iPat1]->key().thePt != 0 && theGPs[iPat1]->key().theCharge == charge)
        break;
    }

    if (iPat1 == theGPs.size())
      patternPt.ptTo = 10000;  //inf
    else
      patternPt.ptTo = myOmtfConfig->hwPtToGev(theGPs[iPat1]->key().thePt);

    patternPt.charge = charge;
    patternPts.push_back(patternPt);
  }

  //debug
  /*  for(unsigned int iPat = 0; iPat < theGPs.size(); iPat++) {
    LogTrace("OMTFReconstruction") <<theGPs[iPat]->key()<<" ptFrom "<<patternPts[iPat].ptFrom<<" ptFrom "<<patternPts[iPat].ptTo<<std::endl;
  }*/

  edm::LogTrace_("OMTFReconstruction") << __FUNCTION__ << ":" << __LINE__ << " patternPts.size() " << patternPts.size()
                                       << endl;
}

printInfo()

template<class GoldenPatternType >

void ProcessorBase< GoldenPatternType >::printInfo ( ) const

virtual

Reimplemented in OMTFProcessor< GoldenPatternType >.

Definition at line 220 of file ProcessorBase.cc.

References runTauDisplay::gp.

Referenced by OMTFProcessor< GoldenPatternType >::printInfo().

                                                       {
  myOmtfConfig->printConfig();

  edm::LogVerbatim("OMTFReconstruction") << "\npatterns:" << std::endl;
  unsigned int patNum = 0;
  for (auto& gp : theGPs) {
    edm::LogVerbatim("OMTFReconstruction")
        << std::setw(2) << patNum << " " << gp->key() << " " << myOmtfConfig->getPatternPtRange(patNum).ptFrom << " - "
        << myOmtfConfig->getPatternPtRange(patNum).ptTo << " GeV" << std::endl;
    patNum++;
  }

  /* //can be useful for debug, uncomment if needed
  XMLConfigWriter xmlWriter(this->myOmtfConfig, false, false);
  xmlWriter.writeGPs(this->theGPs, "patternsAsInTheProcessor.xml");*/
}

resetConfiguration()

template<class GoldenPatternType >

void ProcessorBase< GoldenPatternType >::resetConfiguration ( )

virtual

Reset all configuration parameters.

Reimplemented in OMTFProcessor< GoldenPatternType >.

Definition at line 34 of file ProcessorBase.cc.

                                                          {
  theGPs.clear();
}

restrictInput()

template<class GoldenPatternType >

MuonStubPtrs1D ProcessorBase< GoldenPatternType >::restrictInput ( unsigned int  iProcessor, unsigned int  iCone, unsigned int  iLayer, const OMTFinput &  input  )

protectedvirtual

Remove hits whis are outside input range for given processor and cone

Definition at line 145 of file ProcessorBase.cc.

References input.

                                                                                       {
  MuonStubPtrs1D layerStubs;

  unsigned int iStart = myOmtfConfig->getConnections()[iProcessor][iRegion][iLayer].first;
  unsigned int iEnd = iStart + myOmtfConfig->getConnections()[iProcessor][iRegion][iLayer].second - 1;

  for (unsigned int iInput = 0; iInput < input.getMuonStubs()[iLayer].size(); ++iInput) {
    if (iInput >= iStart && iInput <= iEnd) {
      if (this->myOmtfConfig->isBendingLayer(iLayer)) {
        layerStubs.push_back(input.getMuonStub(iLayer - 1, iInput));
      } else
        layerStubs.push_back(input.getMuonStub(iLayer, iInput));  //input.getHitPhi(iLayer, iInput)
    }
  }
  //LogTrace("OMTFReconstruction") <<__FUNCTION__<<":"<<__LINE__<<" layerHits.size() "<<layerHits.size()<<std::endl;
  return layerStubs;
}

Member Data Documentation

myOmtfConfig

template<class GoldenPatternType>

const OMTFConfiguration* ProcessorBase< GoldenPatternType >::myOmtfConfig

protected

Configuration of the algorithm. This object does not contain the patterns data.

Definition at line 54 of file ProcessorBase.h.

Referenced by ProcessorBase< GoldenPatternType >::ProcessorBase().

patternPts

template<class GoldenPatternType>

std::vector<OMTFConfiguration::PatternPt> ProcessorBase< GoldenPatternType >::patternPts

protected

Definition at line 66 of file ProcessorBase.h.

Referenced by ProcessorBase< GoldenPatternType >::getPatternPtRange().

theGPs

template<class GoldenPatternType>

GoldenPatternVec<GoldenPatternType> ProcessorBase< GoldenPatternType >::theGPs

protected

vector holding Golden Patterns

Definition at line 57 of file ProcessorBase.h.

Referenced by ProcessorBase< GoldenPatternType >::getPatterns(), and ProcessorBase< GoldenPatternType >::ProcessorBase().