CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Namespaces | Classes | Typedefs | Enumerations | Functions
l1t Namespace Reference

delete x; More...

Namespaces

 emtf
 
 stage1
 
 stage2
 

Classes

class  AlgorithmEvaluation
 
class  AMC13DumpToRaw
 
class  AMCDumpToRaw
 
class  Block
 
class  BlockHeader
 
class  BXVectorInputProducer
 
class  CaloCluster
 
class  CaloCondition
 
class  CaloConfig
 
class  CaloConfigHelper
 
class  CaloEmCand
 
class  CaloMainProcessor
 
class  CaloParams
 
class  CaloParamsHelper
 
class  CaloRegion
 
class  CaloSpare
 
class  CaloStage1Cluster
 
class  CaloStage1FirmwareFactory
 
class  CaloStage2JetAlgorithm
 
class  CaloStage2Nav
 
class  CaloStage2TowerAlgorithmFirmwareImp1
 
class  CaloTools
 
class  CaloTower
 
class  ConditionEvaluation
 
class  CorrCondition
 
class  CTP7Payload
 
class  DataAlreadyPresentException
 
class  DataInvalidException
 
class  DataManager
 
class  DataWriter
 
class  Description
 
class  EGamma
 
class  EMTFOutput
 
class  EnergySumCondition
 
class  EtSum
 
class  EtSumHelper
 
class  ExternalCondition
 
class  FakeInputProducer
 
class  GenToInputProducer
 
class  GlobalBoard
 
class  GlobalParamsHelper
 
class  GlobalScales
 
class  GMTInternalMuon
 
struct  GtConditionCategoryStringToEnum
 
struct  GtConditionTypeStringToEnum
 
class  GtInputDump
 
class  GtRecordDump
 
class  Interval
 
class  IntervalManager
 
class  Jet
 
class  L1Candidate
 
class  L1ComparatorRun2
 
class  L1DataEmulResult
 
struct  L1GtBoardTypeStringToEnum
 
class  L1TCaloRCTToUpgradeConverter
 
class  L1TCaloStage1LutWriter
 
class  L1TCaloUpgradeToGCTConverter
 
class  L1TDigiToRaw
 
class  L1TExtCondLegacyToStage2
 
class  L1TExtCondProducer
 
class  L1TGlobalAnalyzer
 
class  L1TGlobalUtil
 
struct  L1TGtObjectStringToEnum
 the string to enum and enum to string conversions for GlobalObject More...
 
class  L1TRawToDigi
 
class  L1TStage1Layer2Producer
 
class  L1TStage2CaloAnalyzer
 
class  LUT
 
class  MicroGMTAbsoluteIsolationCheckLUT
 
class  MicroGMTAbsoluteIsolationCheckLUTFactory
 
class  MicroGMTCaloIndexSelectionLUT
 
class  MicroGMTCaloIndexSelectionLUTFactory
 
class  MicroGMTCancelOutUnit
 
class  MicroGMTConfiguration
 
class  MicroGMTExtrapolationLUT
 
class  MicroGMTExtrapolationLUTFactory
 
class  MicroGMTIsolationUnit
 
class  MicroGMTLUT
 
class  MicroGMTMatchQualLUT
 
class  MicroGMTMatchQualLUTFactory
 
class  MicroGMTRankPtQualLUT
 
class  MicroGMTRankPtQualLUTFactory
 
class  MicroGMTRelativeIsolationCheckLUT
 
class  MicroGMTRelativeIsolationCheckLUTFactory
 
class  MP7BufferDumpToRaw
 
class  MP7Payload
 
class  MTF7Payload
 
class  MuCondition
 
class  Muon
 
class  MuonCaloSum
 
class  MuonRawDigiTranslator
 
class  OMDSReader
 
class  Packer
 
class  PackerFactory
 
class  PackerTokens
 
class  PackingSetup
 
class  PackingSetupFactory
 
class  Payload
 
class  PhysicsToBitConverter
 
class  rctDataBase
 
class  RegionalMuonCand
 
class  RegionalMuonRawDigiTranslator
 
class  Stage1Layer2CentralityAlgorithm
 
class  Stage1Layer2DiTauAlgorithm
 
class  Stage1Layer2EGammaAlgorithm
 
class  Stage1Layer2EGammaAlgorithmImpHI
 
class  Stage1Layer2EGammaAlgorithmImpHW
 
class  Stage1Layer2EGammaAlgorithmImpPP
 
class  Stage1Layer2EtSumAlgorithm
 
class  Stage1Layer2EtSumAlgorithmImpHI
 
class  Stage1Layer2EtSumAlgorithmImpHW
 
class  Stage1Layer2EtSumAlgorithmImpPP
 
class  Stage1Layer2FirmwareFactory
 
class  Stage1Layer2FlowAlgorithm
 
class  Stage1Layer2HFBitCountAlgorithm
 
class  Stage1Layer2HFMinimumBias
 
class  Stage1Layer2HFRingSumAlgorithm
 
class  Stage1Layer2JetAlgorithm
 
class  Stage1Layer2JetAlgorithmImpHI
 
class  Stage1Layer2JetAlgorithmImpPP
 
class  Stage1Layer2JetAlgorithmImpSimpleHW
 
class  Stage1Layer2MainProcessor
 
class  Stage1Layer2MainProcessorFirmwareImp1
 
class  Stage1Layer2SingleTrackHI
 
class  Stage1Layer2TauAlgorithm
 
class  Stage1Layer2TauAlgorithmImpHW
 
class  Stage1Layer2TauAlgorithmImpPP
 
class  Stage1TauIsolationLUT
 
class  Stage2Layer1FirmwareFactory
 
class  Stage2Layer2ClusterAlgorithm
 
class  Stage2Layer2ClusterAlgorithmFirmwareImp1
 
class  Stage2Layer2DemuxEGAlgo
 
class  Stage2Layer2DemuxEGAlgoFirmwareImp1
 
class  Stage2Layer2DemuxJetAlgo
 
class  Stage2Layer2DemuxJetAlgoFirmwareImp1
 
class  Stage2Layer2DemuxSumsAlgo
 
class  Stage2Layer2DemuxSumsAlgoFirmwareImp1
 
class  Stage2Layer2DemuxTauAlgo
 
class  Stage2Layer2DemuxTauAlgoFirmwareImp1
 
class  Stage2Layer2EGAlgorithmFirmwareImp1
 
class  Stage2Layer2EGammaAlgorithm
 
class  Stage2Layer2EGammaAlgorithmFirmwareImp1
 
class  Stage2Layer2EtSumAlgorithm
 
class  Stage2Layer2EtSumAlgorithmFirmwareImp1
 
class  Stage2Layer2FirmwareFactory
 
class  Stage2Layer2JetAlgorithm
 
class  Stage2Layer2JetAlgorithmFirmwareImp1
 
class  Stage2Layer2JetSumAlgorithm
 
class  Stage2Layer2JetSumAlgorithmFirmwareImp1
 
class  Stage2Layer2MainProcessorFirmwareImp1
 
class  Stage2Layer2SumsAlgorithmFirmwareImp1
 
class  Stage2Layer2TauAlgorithm
 
class  Stage2Layer2TauAlgorithmFirmwareImp1
 
class  Stage2MainProcessor
 
class  Stage2MainProcessorFirmwareImp1
 
class  Stage2PreProcessor
 
class  Stage2PreProcessorFirmwareImp1
 
class  Stage2TowerCompressAlgorithm
 
class  Stage2TowerCompressAlgorithmFirmwareImp1
 
class  Stage2TowerDecompressAlgorithm
 
class  Stage2TowerDecompressAlgorithmFirmwareImp1
 
class  Tau
 
class  TriggerMenuParser
 
class  Unpacker
 
class  UnpackerCollections
 
class  UnpackerFactory
 
class  WriterProxy
 
class  WriterProxyT
 

Typedefs

typedef std::map< std::string,
GlobalAlgorithm > 		AlgorithmMap
 map containing the algorithms More...
 
typedef std::vector< Block > Blocks
 
typedef BXVector< CaloCluster > CaloClusterBxCollection
 
typedef BXVector< CaloEmCand > CaloEmCandBxCollection
 
typedef BXVector< CaloRegion > CaloRegionBxCollection
 
typedef BXVector< CaloSpare > CaloSpareBxCollection
 
typedef BXVector
< CaloStage1Cluster > 		CaloStage1ClusterBxCollection
 
typedef BXVector< CaloTower > CaloTowerBxCollection
 
typedef
AlgorithmMap::const_iterator 		CItAlgo
 iterators through map containing the algorithms More...
 
typedef
ConditionMap::const_iterator 		CItCond
 iterators through map containing the conditions More...
 
typedef std::map< std::string,
GlobalCondition * > 		ConditionMap
 
typedef BXVector< EGamma > EGammaBxCollection
 
typedef edm::Ref
< EGammaBxCollection > 		EGammaRef
 
typedef edm::RefVector
< EGammaBxCollection > 		EGammaRefVector
 
typedef std::vector< EGammaRef > EGammaVectorRef
 
typedef std::vector< EMTFOutput > EMTFOutputCollection
 
typedef BXVector< EtSum > EtSumBxCollection
 
typedef edm::Ref
< EtSumBxCollection > 		EtSumRef
 
typedef edm::RefVector
< EtSumBxCollection > 		EtSumRefVector
 
typedef std::vector< EtSumRef > EtSumVectorRef
 
typedef std::vector
< GMTInternalMuon > 		GMTInternalMuonCollection
 
typedef std::list
< std::shared_ptr
< GMTInternalMuon > > 		GMTInternalMuonList
 
typedef std::map< int,
std::vector< std::shared_ptr
< GMTInternalMuon > > > 		GMTInternalWedges
 
typedef AlgorithmMap::iterator ItAlgo
 
typedef ConditionMap::iterator ItCond
 
typedef BXVector< Jet > JetBxCollection
 
typedef edm::Ref< JetBxCollection > JetRef
 
typedef edm::RefVector
< JetBxCollection > 		JetRefVector
 
typedef std::vector< JetRef > JetVectorRef
 
typedef BXVector< L1Candidate > L1CandidateBxCollection
 
typedef edm::Ref
< L1CandidateBxCollection > 		L1CandidateRef
 
typedef edm::RefVector
< L1CandidateBxCollection > 		L1CandidateRefVector
 
typedef std::vector
< L1CandidateRef > 		L1CandidateVectorRef
 
typedef BXVector
< L1DataEmulResult > 		L1DataEmulResultBxCollection
 
typedef BXVector< Muon > MuonBxCollection
 
typedef BXVector< MuonCaloSum > MuonCaloSumBxCollection
 
typedef edm::Ref
< MuonBxCollection > 		MuonRef
 
typedef edm::RefVector
< MuonBxCollection > 		MuonRefVector
 
typedef std::vector< MuonRef > MuonVectorRef
 
typedef Packer *( pack_fct )()
 
typedef
edmplugin::PluginFactory
< pack_fct > 		PackerFactoryT
 
typedef std::map< std::pair
< int, int >, Packers > 		PackerMap
 
typedef std::vector
< std::shared_ptr< Packer > > 		Packers
 
typedef
edmplugin::PluginFactory
< prov_fct > 		PackingSetupFactoryT
 
typedef PackingSetup *( prov_fct )()
 
typedef BXVector
< RegionalMuonCand > 		RegionalMuonCandBxCollection
 
typedef BXVector< Tau > TauBxCollection
 
typedef edm::Ref< TauBxCollection > TauRef
 
typedef edm::RefVector
< TauBxCollection > 		TauRefVector
 
typedef std::vector< TauRef > TauVectorRef
 
typedef Unpacker *( unpack_fct )()
 
typedef
edmplugin::PluginFactory
< unpack_fct > 		UnpackerFactoryT
 
typedef std::map< int,
std::shared_ptr< Unpacker > > 		UnpackerMap
 
typedef
edmplugin::PluginFactory
< l1t::WriterProxy *()> 		WriterFactory
 

Enumerations

enum  block_t { MP7 = 0, CTP7, MTF7 }
 
enum  cancel_t {
  bmtf_bmtf, omtf_bmtf_pos, omtf_emtf_pos, omtf_omtf_pos,
  emtf_emtf_pos, omtf_bmtf_neg, omtf_emtf_neg, omtf_omtf_neg,
  emtf_emtf_neg
}
 
enum  cancelmode { tracks, coordinate }
 
enum  GlobalObject {
  gtMu, gtEG, gtJet, gtTau,
  gtETM, gtETT, gtHTT, gtHTM,
  gtETM2, gtMinBias, gtExternal, ObjNull
}
 
enum  GtConditionCategory {
  CondNull, CondMuon, CondCalo, CondEnergySum,
  CondCorrelation, CondExternal
}
 condition categories More...
 
enum  GtConditionType {
  TypeNull, Type1s, Type2s, Type2wsc,
  Type2cor, Type3s, Type4s, TypeETM,
  TypeETT, TypeHTT, TypeHTM, TypeETM2,
  TypeMinBias, TypeExternal
}
 
enum  L1GtBoardType { MP7 = 0, BoardNull }
 board types in GT More...
 
enum  tftype {
  bmtf, omtf_neg, omtf_pos, emtf_neg,
  emtf_pos
}
 

Functions

void calibrateAndRankJets (CaloParamsHelper *params, const std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
 
void calibrateAndRankTaus (CaloParamsHelper *params, const std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
 
int deltaGctPhi (const CaloRegion &region, const CaloRegion &neighbor)
 
void EGammaToGtScales (CaloParamsHelper *params, const std::vector< l1t::EGamma > *input, std::vector< l1t::EGamma > *output)
 
void EtSumToGtScales (CaloParamsHelper *params, const std::vector< l1t::EtSum > *input, std::vector< l1t::EtSum > *output)
 
void getBXRange (int nbx, int &first, int &last)
 
const unsigned int gtEta (const unsigned int iEta)
 
void HICaloRingSubtraction (const std::vector< l1t::CaloRegion > &regions, std::vector< l1t::CaloRegion > *subRegions, CaloParamsHelper *params)
 ------------— For heavy ion ----------------------------------— More...
 
void JetCalibration (std::vector< l1t::Jet > *uncalibjets, std::vector< double > jetCalibrationParams, std::vector< l1t::Jet > *jets, std::string jetCalibrationType, double jetLSB)
 
void JetToGtEtaScales (CaloParamsHelper *params, const std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
 
void JetToGtPtScales (CaloParamsHelper *params, const std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
 
std::string l1GtBoardTypeEnumToString (const L1GtBoardType &)
 
L1GtBoardType l1GtBoardTypeStringToEnum (const std::string &)
 
std::string l1GtConditionCategoryEnumToString (const GtConditionCategory &)
 
GtConditionCategory l1GtConditionCategoryStringToEnum (const std::string &)
 
std::string l1GtConditionTypeEnumToString (const GtConditionType &)
 
GtConditionType l1GtConditionTypeStringToEnum (const std::string &)
 
std::string l1TGtObjectEnumToString (const GlobalObject &)
 
l1t::GlobalObject l1TGtObjectStringToEnum (const std::string &)
 
std::ostream & operator<< (std::ostream &os, const l1t::CaloParamsHelper &p)
 
bool operator> (l1t::Tau &a, l1t::Tau &b)
 
bool operator> (l1t::EGamma &a, l1t::EGamma &b)
 
bool operator> (l1t::Jet &a, l1t::Jet &b)
 
unsigned int pack15bits (int pt, int eta, int phi)
 
unsigned int pack16bits (int pt, int eta, int phi)
 
unsigned int pack16bitsEgammaSpecial (int pt, int eta, int phi)
 
void passThroughJets (const std::vector< l1t::CaloRegion > *regions, std::vector< l1t::Jet > *uncalibjets)
 
void RegionCorrection (const std::vector< l1t::CaloRegion > &regions, std::vector< l1t::CaloRegion > *subRegions, CaloParamsHelper *params)
 ------— New region correction (PUsub, no response correction at the moment) --------— More...
 
void simpleHWSubtraction (const std::vector< l1t::CaloRegion > &regions, std::vector< l1t::CaloRegion > *subRegions)
 
void slidingWindowJetFinder (const int, const std::vector< l1t::CaloRegion > *regions, std::vector< l1t::Jet > *uncalibjets)
 
void SortEGammas (std::vector< l1t::EGamma > *input, std::vector< l1t::EGamma > *output)
 
void SortJets (std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
 
void SortTaus (std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
 
void TauToGtEtaScales (CaloParamsHelper *params, const std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
 
void TauToGtPtScales (CaloParamsHelper *params, const std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
 
void TwelveByTwelveFinder (const int, const std::vector< l1t::CaloRegion > *regions, std::vector< l1t::Jet > *uncalibjets)
 
void TwoByTwoFinder (const int, const int, const std::vector< l1t::CaloRegion > *regions, std::vector< l1t::Jet > *uncalibjets)
 

Detailed Description

delete x;

map containing the conditions

Description: Simple Navigator class for the CaloTowers

Author
: Sam Harper - RAL

Description: Firmware headers

Implementation: Collects concrete algorithm implmentations.

Author
: R. Alex Barbieri MIT Kalanand Mishra, Fermilab

Description: Firmware headers

Implementation: Collects concrete algorithm implmentations.

Author
: R. Alex Barbieri MIT

Description: Firmware headers

Implementation: Concrete firmware implementations

Author
: Jim Brooke - University of Bristol

Description: Firmware headers

Implementation: Concrete firmware implementations

Author
: Jim Brooke - University of Bristol Modified: Adam Elwood - ICL

Description: enums for the L1 GT.

Implementation: Defines various enums for CondFormats L1 GT. For each enum, define the lightweight "maps" for enum string label and enum value

Author
: Vasile Mihai Ghete - HEPHY Vienna

$Date$ $Revision$

Typedef Documentation

typedef std::map<std::string, GlobalAlgorithm> l1t::AlgorithmMap

map containing the algorithms

Definition at line 32 of file TriggerMenuFwd.h.

typedef std::vector<Block> l1t::Blocks

Definition at line 68 of file Block.h.

typedef BXVector<CaloCluster> l1t::CaloClusterBxCollection

Definition at line 85 of file CaloCluster.h.

typedef BXVector<CaloEmCand> l1t::CaloEmCandBxCollection

Definition at line 26 of file CaloEmCand.h.

typedef BXVector<CaloRegion> l1t::CaloRegionBxCollection

Definition at line 47 of file CaloRegion.h.

typedef BXVector<CaloSpare> l1t::CaloSpareBxCollection

Definition at line 10 of file CaloSpare.h.

typedef BXVector<CaloStage1Cluster> l1t::CaloStage1ClusterBxCollection

Definition at line 27 of file CaloStage1Cluster.h.

typedef BXVector<CaloTower> l1t::CaloTowerBxCollection

Definition at line 10 of file CaloTower.h.

typedef AlgorithmMap::const_iterator l1t::CItAlgo

iterators through map containing the algorithms

Definition at line 39 of file TriggerMenuFwd.h.

typedef ConditionMap::const_iterator l1t::CItCond

iterators through map containing the conditions

Definition at line 35 of file TriggerMenuFwd.h.

typedef std::map<std::string, GlobalCondition*> l1t::ConditionMap

Definition at line 29 of file TriggerMenuFwd.h.

typedef BXVector<EGamma> l1t::EGammaBxCollection

Definition at line 11 of file EGamma.h.

typedef edm::Ref< EGammaBxCollection > l1t::EGammaRef

Definition at line 13 of file EGamma.h.

typedef edm::RefVector< EGammaBxCollection > l1t::EGammaRefVector

Definition at line 14 of file EGamma.h.

typedef std::vector< EGammaRef > l1t::EGammaVectorRef

Definition at line 15 of file EGamma.h.

typedef std::vector<EMTFOutput> l1t::EMTFOutputCollection

Definition at line 104 of file EMTFOutput.h.

typedef BXVector<EtSum> l1t::EtSumBxCollection

Definition at line 10 of file EtSum.h.

typedef edm::Ref< EtSumBxCollection > l1t::EtSumRef

Definition at line 12 of file EtSum.h.

typedef edm::RefVector< EtSumBxCollection > l1t::EtSumRefVector

Definition at line 13 of file EtSum.h.

typedef std::vector< EtSumRef > l1t::EtSumVectorRef

Definition at line 14 of file EtSum.h.

typedef std::vector<GMTInternalMuon> l1t::GMTInternalMuonCollection

Definition at line 7 of file GMTInternalMuonFwd.h.

typedef std::list<std::shared_ptr<GMTInternalMuon> > l1t::GMTInternalMuonList

Definition at line 10 of file GMTInternalMuonFwd.h.

typedef std::map<int, std::vector<std::shared_ptr<GMTInternalMuon> > > l1t::GMTInternalWedges

Definition at line 9 of file GMTInternalMuonFwd.h.

typedef AlgorithmMap::iterator l1t::ItAlgo

Definition at line 40 of file TriggerMenuFwd.h.

typedef ConditionMap::iterator l1t::ItCond

Definition at line 36 of file TriggerMenuFwd.h.

typedef BXVector<Jet> l1t::JetBxCollection

Definition at line 10 of file Jet.h.

typedef edm::Ref< JetBxCollection > l1t::JetRef

Definition at line 12 of file Jet.h.

typedef edm::RefVector< JetBxCollection > l1t::JetRefVector

Definition at line 13 of file Jet.h.

typedef std::vector< JetRef > l1t::JetVectorRef

Definition at line 14 of file Jet.h.

typedef BXVector<L1Candidate> l1t::L1CandidateBxCollection

Definition at line 9 of file L1Candidate.h.

typedef edm::Ref< L1CandidateBxCollection > l1t::L1CandidateRef

Definition at line 11 of file L1Candidate.h.

typedef edm::RefVector< L1CandidateBxCollection > l1t::L1CandidateRefVector

Definition at line 12 of file L1Candidate.h.

typedef std::vector< L1CandidateRef > l1t::L1CandidateVectorRef

Definition at line 13 of file L1Candidate.h.

typedef BXVector<L1DataEmulResult> l1t::L1DataEmulResultBxCollection

Definition at line 7 of file L1DataEmulResult.h.

typedef BXVector<Muon> l1t::MuonBxCollection

Definition at line 10 of file Muon.h.

typedef BXVector<MuonCaloSum> l1t::MuonCaloSumBxCollection

Definition at line 7 of file MuonCaloSumFwd.h.

typedef edm::Ref< MuonBxCollection > l1t::MuonRef

Definition at line 12 of file Muon.h.

typedef edm::RefVector< MuonBxCollection > l1t::MuonRefVector

Definition at line 13 of file Muon.h.

typedef std::vector< MuonRef > l1t::MuonVectorRef

Definition at line 14 of file Muon.h.

typedef Packer*( l1t::pack_fct)()

Definition at line 23 of file Packer.h.

typedef edmplugin::PluginFactory<pack_fct> l1t::PackerFactoryT

Definition at line 24 of file Packer.h.

typedef std::map<std::pair<int, int>, Packers> l1t::PackerMap

Definition at line 25 of file PackingSetup.h.

typedef std::vector<std::shared_ptr<Packer> > l1t::Packers

Definition at line 21 of file Packer.h.

typedef edmplugin::PluginFactory<prov_fct> l1t::PackingSetupFactoryT

Definition at line 48 of file PackingSetup.h.

typedef PackingSetup*( l1t::prov_fct)()

Definition at line 47 of file PackingSetup.h.

typedef BXVector<RegionalMuonCand> l1t::RegionalMuonCandBxCollection

Definition at line 10 of file RegionalMuonCandFwd.h.

typedef BXVector<Tau> l1t::TauBxCollection

Definition at line 10 of file Tau.h.

typedef edm::Ref< TauBxCollection > l1t::TauRef

Definition at line 12 of file Tau.h.

typedef edm::RefVector< TauBxCollection > l1t::TauRefVector

Definition at line 13 of file Tau.h.

typedef std::vector< TauRef > l1t::TauVectorRef

Definition at line 14 of file Tau.h.

typedef Unpacker*( l1t::unpack_fct)()

Definition at line 18 of file Unpacker.h.

typedef edmplugin::PluginFactory<unpack_fct> l1t::UnpackerFactoryT

Definition at line 19 of file Unpacker.h.

typedef std::map<int, std::shared_ptr<Unpacker> > l1t::UnpackerMap

Definition at line 27 of file PackingSetup.h.

typedef edmplugin::PluginFactory<l1t::WriterProxy * ()> l1t::WriterFactory

Definition at line 86 of file WriterProxy.h.

Enumeration Type Documentation

enum l1t::block_t
Enumerator
MP7 
CTP7 
MTF7 

Definition at line 10 of file Block.h.

10 { MP7 = 0, CTP7, MTF7 };
l1t::MP7
Definition: Block.h:10
enum l1t::cancel_t
Enumerator
bmtf_bmtf 
omtf_bmtf_pos 
omtf_emtf_pos 
omtf_omtf_pos 
emtf_emtf_pos 
omtf_bmtf_neg 
omtf_emtf_neg 
omtf_omtf_neg 
emtf_emtf_neg 

Definition at line 12 of file MicroGMTMatchQualLUT.h.

12  {
13  bmtf_bmtf, omtf_bmtf_pos, omtf_emtf_pos, omtf_omtf_pos, emtf_emtf_pos, omtf_bmtf_neg, omtf_emtf_neg, omtf_omtf_neg, emtf_emtf_neg
14  };
enum l1t::cancelmode
Enumerator
tracks 
coordinate 

Definition at line 11 of file MicroGMTCancelOutUnit.h.

11  {
12  tracks, coordinate
13  };
testEve_cfg.tracks
tuple tracks
Definition: testEve_cfg.py:39
enum l1t::GlobalObject

L1 GT objects ObjNull catch all errors

Enumerator
gtMu 
gtEG 
gtJet 
gtTau 
gtETM 
gtETT 
gtHTT 
gtHTM 
gtETM2 
gtMinBias 
gtExternal 
ObjNull 

Definition at line 16 of file GlobalObject.h.

17 {
18  gtMu,
19  gtEG,
20  gtJet,
21  gtTau,
22  gtETM,
23  gtETT,
24  gtHTT,
25  gtHTM,
26  gtETM2,
27  gtMinBias,
28  gtExternal,
29  ObjNull
30 };
enum l1t::GtConditionCategory

condition categories

Enumerator
CondNull 
CondMuon 
CondCalo 
CondEnergySum 
CondCorrelation 
CondExternal 

Definition at line 78 of file GlobalDefinitions.h.

78  {
79  CondNull,
80  CondMuon,
81  CondCalo,
82  CondEnergySum,
83  CondCorrelation,
84  CondExternal
85 };
enum l1t::GtConditionType

condition types TypeNull: null type - for condition constructor only Type1s : one particle Type2s : two particles, same type, no spatial correlations among them Type2wsc : two particles, same type, with spatial correlations among them Type2cor : two particles, different type, with spatial correlations among them Type3s : three particles, same type Type4s : four particles, same type TypeETM, TypeETT, TypeHTT, TypeHTM : ETM, ETT, HTT, HTM TypeExternal: external conditions (logical result only; definition in L1 GT external systems)

Enumerator
TypeNull 
Type1s 
Type2s 
Type2wsc 
Type2cor 
Type3s 
Type4s 
TypeETM 
TypeETT 
TypeHTT 
TypeHTM 
TypeETM2 
TypeMinBias 
TypeExternal 

Definition at line 52 of file GlobalDefinitions.h.

52  {
53  TypeNull,
54  Type1s,
55  Type2s,
56  Type2wsc,
57  Type2cor,
58  Type3s,
59  Type4s,
60  TypeETM,
61  TypeETT,
62  TypeHTT,
63  TypeHTM,
64  TypeETM2,
65  TypeMinBias,
66  TypeExternal
67 };
enum l1t::L1GtBoardType

board types in GT

Enumerator
MP7 
BoardNull 

Definition at line 28 of file GlobalDefinitions.h.

28  {
29  MP7,
30  BoardNull
31 };
l1t::MP7
Definition: Block.h:10
enum l1t::tftype
Enumerator
bmtf 
omtf_neg 
omtf_pos 
emtf_neg 
emtf_pos 

Definition at line 7 of file RegionalMuonCandFwd.h.

7  {
8  bmtf, omtf_neg, omtf_pos, emtf_neg, emtf_pos
9  };

Function Documentation

void l1t::calibrateAndRankJets ( CaloParamsHelper *  params,
const std::vector< l1t::Jet > *  input,
std::vector< l1t::Jet > *  output 
)

Definition at line 12 of file legacyGtHelper.cc.

References l1t::LUT::data(), eta, l1t::CaloParamsHelper::jetCalibrationLUT(), hltrates_dqm_sourceclient-live_cfg::offset, and EnergyCorrector::pt.

Referenced by l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent().

14  {
15 
16  for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
17  itJet != input->end(); ++itJet){
18  unsigned int pt = itJet->hwPt();
19  if(pt > ((1<<10) -1) )
20  pt = ((1<<10) -1);
21  unsigned int eta = itJet->hwEta();
22  if (eta>10){ // LUT is symmetric in eta. For eta>10 map to corresponding eta<10 bin
23  int offset=2*(eta-10)-1;
24  eta=eta-offset;
25  }
26  unsigned int lutAddress = (eta<<10)+pt;
27 
28  unsigned int rank = params->jetCalibrationLUT()->data(lutAddress);
29 
30  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
31  l1t::Jet outJet(*&ldummy, rank, itJet->hwEta(), itJet->hwPhi(), itJet->hwQual());
32  output->push_back(outJet);
33  }
34  }
input
static std::string const input
Definition: EdmProvDump.cc:44
l1t::Jet
Definition: Jet.h:16
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
hltrates_dqm_sourceclient-live_cfg.offset
tuple offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:81
void l1t::calibrateAndRankTaus ( CaloParamsHelper *  params,
const std::vector< l1t::Tau > *  input,
std::vector< l1t::Tau > *  output 
)

Definition at line 36 of file legacyGtHelper.cc.

References l1t::LUT::data(), eta, EnergyCorrector::pt, and l1t::CaloParamsHelper::tauCalibrationLUT().

Referenced by l1t::Stage1Layer2TauAlgorithmImpHW::processEvent().

38  {
39 
40  for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
41  itTau != input->end(); ++itTau){
42  unsigned int pt = itTau->hwPt();
43  if(pt > ((1<<10) -1) )
44  pt = ((1<<10) -1);
45  unsigned int eta = itTau->hwEta();
46  unsigned int lutAddress = (eta<<10)+pt;
47 
48  unsigned int rank = params->tauCalibrationLUT()->data(lutAddress);
49 
50  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
51  l1t::Tau outTau(*&ldummy, rank, itTau->hwEta(), itTau->hwPhi(), itTau->hwQual());
52  output->push_back(outTau);
53  }
54  }
l1t::Tau
Definition: Tau.h:16
input
static std::string const input
Definition: EdmProvDump.cc:44
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
int l1t::deltaGctPhi ( const CaloRegion &  region,
const CaloRegion &  neighbor 
)

Definition at line 18 of file JetFinderMethods.cc.

References funct::abs(), mps_update::diff, l1t::L1Candidate::hwPhi(), and L1CaloRegionDetId::N_PHI.

Referenced by slidingWindowJetFinder(), TwelveByTwelveFinder(), and TwoByTwoFinder().

19  {
20  int phi1 = region.hwPhi();
21  int phi2 = neighbor.hwPhi();
22  int diff = phi1 - phi2;
23  if (std::abs(phi1 - phi2) == L1CaloRegionDetId::N_PHI-1) { //18 regions in phi
24  diff = -diff/std::abs(diff);
25  }
26  return diff;
27  }
mps_update.diff
list diff
Definition: mps_update.py:85
HLT_FULL_cff.region
tuple region
Definition: HLT_FULL_cff.py:76378
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
L1CaloRegionDetId::N_PHI
static const unsigned N_PHI
Definition: L1CaloRegionDetId.h:22
void l1t::EGammaToGtScales ( CaloParamsHelper *  params,
const std::vector< l1t::EGamma > *  input,
std::vector< l1t::EGamma > *  output 
)

Definition at line 99 of file legacyGtHelper.cc.

References gtEta().

Referenced by l1t::Stage1Layer2EGammaAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EGammaAlgorithmImpHI::processEvent(), and l1t::Stage1Layer2EGammaAlgorithmImpHW::processEvent().

101  {
102 
103  for(std::vector<l1t::EGamma>::const_iterator itEGamma = input->begin();
104  itEGamma != input->end(); ++itEGamma){
105  unsigned newEta = gtEta(itEGamma->hwEta());
106  unsigned newPhi = itEGamma->hwPhi();
107  const uint16_t rankPt = (uint16_t)itEGamma->hwPt(); //max value?
108 
109  //hwQual &10 == 10 means that the object came from a sort and is padding
110  if((itEGamma->hwQual() & 0x10) == 0x10)
111  {
112  newEta = 0x0;
113  newPhi = 0x0;
114  }
115 
116  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
117 
118  l1t::EGamma gtEGamma(*&ldummy, rankPt, newEta, newPhi,
119  itEGamma->hwQual(), itEGamma->hwIso());
120  output->push_back(gtEGamma);
121  }
122  }
l1t::gtEta
const unsigned int gtEta(const unsigned int iEta)
Definition: legacyGtHelper.cc:194
input
static std::string const input
Definition: EdmProvDump.cc:44
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
void l1t::EtSumToGtScales ( CaloParamsHelper *  params,
const std::vector< l1t::EtSum > *  input,
std::vector< l1t::EtSum > *  output 
)

Definition at line 165 of file legacyGtHelper.cc.

References L1Analysis::kMissingHt.

Referenced by l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EtSumAlgorithmImpHW::processEvent(), and l1t::Stage1Layer2EtSumAlgorithmImpHI::processEvent().

167  {
168  for(std::vector<l1t::EtSum>::const_iterator itEtSum = input->begin();
169  itEtSum != input->end(); ++itEtSum){
170 
171  uint16_t rankPt;
172  // Hack for now to make sure they come out with the right scale
173  //rankPt = params->jetScale().rank((uint16_t)itEtSum->hwPt());
174  rankPt = (uint16_t)itEtSum->hwPt();
175  if (EtSum::EtSumType::kMissingHt == itEtSum->getType())
176  {
177  // if(rankPt > params->HtMissScale().linScaleMax()) rankPt = params->HtMissScale().linScaleMax();
178  // params->HtMissScale().linScaleMax() always returns zero. Hardcode 512 for now
179 
180  // comment out for mht/ht (already in GT scale)
181  //if(rankPt > 512) rankPt = 512;
182  //rankPt = params->HtMissScale().rank(rankPt*params->emScale().linearLsb());
183  }
184 
185  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
186 
187  l1t::EtSum gtEtSum(*&ldummy, itEtSum->getType(), rankPt, 0,
188  itEtSum->hwPhi(), itEtSum->hwQual());
189 
190  output->push_back(gtEtSum);
191  }
192  }
input
static std::string const input
Definition: EdmProvDump.cc:44
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
void l1t::getBXRange ( int  nbx,
int &  first,
int &  last 
)

Definition at line 14 of file Unpacker.cc.

References min().

Referenced by process(), l1t::stage1::CaloSpareHFUnpacker::unpack(), l1t::stage1::EtSumUnpacker::unpack(), l1t::stage2::BMTFUnpackerInputs::unpack(), l1t::stage2::BMTFUnpackerOutput::unpack(), l1t::stage1::MissEtUnpacker::unpack(), l1t::stage1::MissHtUnpacker::unpack(), l1t::stage1::legacy::HFRingUnpacker::unpack(), l1t::stage2::RegionalMuonGMTUnpacker::unpack(), l1t::stage1::legacy::EtSumUnpacker::unpack(), l1t::stage2::MuonUnpacker::unpack(), l1t::stage1::unpack_em(), and l1t::stage1::unpack_region().

15  {
16  last = std::floor(nbx / 2.);
17  first = std::min(0, -last + (1 - nbx % 2));
18  }
min
T min(T a, T b)
Definition: MathUtil.h:58
const unsigned int l1t::gtEta ( const unsigned int  iEta)

Definition at line 194 of file legacyGtHelper.cc.

Referenced by EGammaToGtScales(), getRegionEta(), JetToGtEtaScales(), l1t::Stage2Layer2DemuxJetAlgoFirmwareImp1::processEvent(), and TauToGtEtaScales().

195  {
196  unsigned rctEta = (iEta<11 ? 10-iEta : iEta-11);
197  return (((rctEta % 7) & 0x7) | (iEta<11 ? 0x8 : 0));
198  }
void l1t::HICaloRingSubtraction ( const std::vector< l1t::CaloRegion > &  regions,
std::vector< l1t::CaloRegion > *  subRegions,
CaloParamsHelper *  params 
)

------------— For heavy ion ----------------------------------—

Definition at line 19 of file PUSubtractionMethods.cc.

References i, bookConverter::max, L1CaloRegionDetId::N_ETA, and HLT_FULL_cff::region.

Referenced by l1t::Stage1Layer2SingleTrackHI::processEvent(), l1t::Stage1Layer2JetAlgorithmImpHI::processEvent(), and RegionCorrection().

22  {
23  int puLevelHI[L1CaloRegionDetId::N_ETA];
24 
25  for(unsigned i = 0; i < L1CaloRegionDetId::N_ETA; ++i)
26  {
27  puLevelHI[i] = 0;
28  }
29 
30  for(std::vector<CaloRegion>::const_iterator region = regions.begin();
31  region != regions.end(); region++){
32  puLevelHI[region->hwEta()] += region->hwPt();
33  }
34 
35  for(unsigned i = 0; i < L1CaloRegionDetId::N_ETA; ++i)
36  {
37  //puLevelHI[i] = floor(((double)puLevelHI[i] / (double)L1CaloRegionDetId::N_PHI)+0.5);
38  puLevelHI[i] = (puLevelHI[i] + 9) * 455 / (1 << 13); // approx equals X/18 +0.5
39  }
40 
41  for(std::vector<CaloRegion>::const_iterator region = regions.begin(); region!= regions.end(); region++){
42  int subPt = std::max(0, region->hwPt() - puLevelHI[region->hwEta()]);
43  int subEta = region->hwEta();
44  int subPhi = region->hwPhi();
45 
46 
47  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
48 
49  CaloRegion newSubRegion(*&ldummy, 0, 0, subPt, subEta, subPhi, region->hwQual(), region->hwEtEm(), region->hwEtHad());
50  subRegions->push_back(newSubRegion);
51  }
52  }
i
int i
Definition: DBlmapReader.cc:9
L1CaloRegionDetId::N_ETA
static const unsigned N_ETA
Definition: L1CaloRegionDetId.h:23
HLT_FULL_cff.region
tuple region
Definition: HLT_FULL_cff.py:76378
void l1t::JetCalibration ( std::vector< l1t::Jet > *  uncalibjets,
std::vector< double >  jetCalibrationParams,
std::vector< l1t::Jet > *  jets,
std::string  jetCalibrationType,
double  jetLSB 
)

Definition at line 12 of file JetCalibrationMethods.cc.

References alpha, reco::btau::jetEta, reco::btau::jetPhi, and reco::btau::jetPt.

Referenced by l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpPP::processEvent().

17  {
18 
19  for (std::vector<l1t::Jet>::const_iterator uncalibjet = uncalibjets->begin(); uncalibjet != uncalibjets->end(); ++uncalibjet){
20 
21  if (jetCalibrationType == "None") {
22  l1t::Jet corrjets = *uncalibjet;
23  jets->push_back(corrjets);
24  continue;
25  }
26 
27  if (jetCalibrationType == "Stage1JEC") {
28  int jetPt = (uncalibjet->hwPt())*jetLSB; // correction factors are parameterized as functions of physical pt
29  int jetPhi = uncalibjet->hwPhi();
30  int jetEta = uncalibjet->hwEta();
31  int jetQual = uncalibjet->hwQual();
32  double jpt = 0.0;
33 
34  double alpha = jetCalibrationParams[2*jetEta + 0]; //Scale factor (See jetSF_cfi.py)
35  double gamma = ((jetCalibrationParams[2*jetEta + 1])); //Offset
36 
37  jpt = jetPt*alpha+gamma;
38  unsigned int corjetET =(int) (jpt/jetLSB);
39 
40  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
41  l1t::Jet corrjets(*&jetLorentz, corjetET, jetEta, jetPhi, jetQual);
42 
43  jets->push_back(corrjets);
44  }
45  }
46  }
alpha
float alpha
Definition: AMPTWrapper.h:95
l1t::Jet
Definition: Jet.h:16
fwrapper::jets
vector< PseudoJet > jets
Definition: fastjetfortran_madfks.cc:42
void l1t::JetToGtEtaScales ( CaloParamsHelper *  params,
const std::vector< l1t::Jet > *  input,
std::vector< l1t::Jet > *  output 
)

Definition at line 57 of file legacyGtHelper.cc.

References gtEta(), and gtJet.

Referenced by l1t::Stage1Layer2JetAlgorithmImpHI::processEvent(), l1t::Stage1Layer2JetAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent().

59  {
60 
61  for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
62  itJet != input->end(); ++itJet){
63  unsigned newPhi = itJet->hwPhi();
64  unsigned newEta = gtEta(itJet->hwEta());
65 
66  // jets with hwQual & 10 ==10 are "padding" jets from a sort, set their eta and phi
67  // to the max value
68  if((itJet->hwQual() & 0x10) == 0x10)
69  {
70  newEta = 0x0;
71  newPhi = 0x0;
72  }
73 
74  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
75 
76  l1t::Jet gtJet(*&ldummy, itJet->hwPt(), newEta, newPhi, itJet->hwQual());
77  output->push_back(gtJet);
78  }
79  }
l1t::gtEta
const unsigned int gtEta(const unsigned int iEta)
Definition: legacyGtHelper.cc:194
input
static std::string const input
Definition: EdmProvDump.cc:44
l1t::Jet
Definition: Jet.h:16
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
void l1t::JetToGtPtScales ( CaloParamsHelper *  params,
const std::vector< l1t::Jet > *  input,
std::vector< l1t::Jet > *  output 
)

Definition at line 81 of file legacyGtHelper.cc.

References gtJet, l1t::CaloParamsHelper::jetScale(), L1CaloEtScale::linScaleMax(), and L1CaloEtScale::rank().

Referenced by l1t::Stage1Layer2JetAlgorithmImpHI::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpPP::processEvent().

83  {
84 
85  for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
86  itJet != input->end(); ++itJet){
87  uint16_t linPt = (uint16_t)itJet->hwPt();
88  if(linPt > params->jetScale().linScaleMax() ) linPt = params->jetScale().linScaleMax();
89  const uint16_t rankPt = params->jetScale().rank(linPt);
90 
91  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
92 
93  l1t::Jet gtJet(*&ldummy, rankPt, itJet->hwEta(), itJet->hwPhi(), itJet->hwQual());
94  output->push_back(gtJet);
95  }
96  }
input
static std::string const input
Definition: EdmProvDump.cc:44
l1t::Jet
Definition: Jet.h:16
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
std::string l1t::l1GtBoardTypeEnumToString ( const L1GtBoardType &  boardType)

Definition at line 102 of file GlobalDefinitions.cc.

References BoardNull, and mps_fire::result.

102  {
103  char const *result= valueToKey(boardType, l1GtBoardTypeStringToEnumMap);
104  if (boardType == l1t::BoardNull) {
105  edm::LogInfo("L1TGlobal")
106  << "\n l1t::BoardNull means no valid board type defined!";
107  }
108  if (!result) {
109  edm::LogInfo("L1TGlobal") << "\n '" << boardType
110  << "' is not a recognized l1t::L1GtBoardType. "
111  << "\n Return l1t::BoardNull, which means no valid board type defined!";
112  return "l1t::BoardNull";
113  }
114  return result;
115 }
mps_fire.result
tuple result
Definition: mps_fire.py:95
l1t::L1GtBoardType l1t::l1GtBoardTypeStringToEnum ( const std::string &  label)

Definition at line 86 of file GlobalDefinitions.cc.

References BoardNull, BoardNull, and relativeConstraints::value.

86  {
87  l1t::L1GtBoardType value = keyToValue(label.c_str(), l1GtBoardTypeStringToEnumMap);
88  if (value == (l1t::L1GtBoardType) - 1) {
89  edm::LogInfo("L1TGlobal") << "\n '" << label
90  << "' is not a recognized l1t::L1GtBoardType. \n Return l1t::BoardNull.";
91  value = l1t::BoardNull;
92  }
93 
94  if (value == l1t::BoardNull) {
95  edm::LogInfo("L1TGlobal")
96  << "\n l1t::BoardNull means no valid board type defined!";
97  }
98 
99  return value;
100 }
l1t::L1GtBoardType
L1GtBoardType
board types in GT
Definition: GlobalDefinitions.h:28
std::string l1t::l1GtConditionCategoryEnumToString ( const GtConditionCategory &  conditionCategory)

Definition at line 174 of file GlobalDefinitions.cc.

References CondNull, and mps_fire::result.

174  {
175  char const *result = valueToKey(conditionCategory, l1GtConditionCategoryStringToEnumMap);
176  if (conditionCategory == l1t::CondNull)
177  edm::LogInfo("L1TGlobal")
178  << "\n Return l1t::CondNull, which means no valid condition category defined!";
179 
180  if (!result) {
181  result = "l1t::CondNull";
182  edm::LogInfo("L1TGlobal") << "\n '" << conditionCategory
183  << "' is not a recognized l1t::GtConditionCategory. "
184  << "\n Return l1t::CondNull, which means no valid condition category defined!";
185  }
186 
187  return result;
188 }
mps_fire.result
tuple result
Definition: mps_fire.py:95
l1t::GtConditionCategory l1t::l1GtConditionCategoryStringToEnum ( const std::string &  label)

Definition at line 155 of file GlobalDefinitions.cc.

References CondNull, CondNull, and relativeConstraints::value.

155  {
156  l1t::GtConditionCategory value = keyToValue(label.c_str(), l1GtConditionCategoryStringToEnumMap);
157  // in case of unrecognized l1t::GtConditionCategory, return l1t::CondNull
158  // to be dealt by the corresponding module
159  if (value == (l1t::GtConditionCategory) -1) {
160  edm::LogInfo("L1TGlobal") << "\n '" << label
161  << "' is not a recognized l1t::GtConditionCategory. \n Return l1t::CondNull.";
162 
163  value = l1t::CondNull;
164  }
165 
166  if (value == l1t::CondNull) {
167  edm::LogInfo("L1TGlobal")
168  << "\n l1t::CondNull means no valid condition category defined!";
169  }
170 
171  return value;
172 }
l1t::GtConditionCategory
GtConditionCategory
condition categories
Definition: GlobalDefinitions.h:78
std::string l1t::l1GtConditionTypeEnumToString ( const GtConditionType &  conditionType)

Definition at line 141 of file GlobalDefinitions.cc.

References mps_fire::result, and TypeNull.

141  {
142  const char *result = valueToKey(conditionType, l1GtConditionTypeStringToEnumMap);
143  if (conditionType == l1t::TypeNull)
144  edm::LogInfo("L1TGlobal")
145  << "\n Return l1t::TypeNull, which means no valid condition type defined!";
146  if (!result) {
147  result = "l1t::TypeNull";
148  edm::LogInfo("L1TGlobal") << "\n '" << conditionType
149  << "' is not a recognized l1t::GtConditionType. "
150  << "\n Return l1t::TypeNull, which means no valid condition type defined!";
151  }
152  return result;
153 }
mps_fire.result
tuple result
Definition: mps_fire.py:95
l1t::GtConditionType l1t::l1GtConditionTypeStringToEnum ( const std::string &  label)

Definition at line 121 of file GlobalDefinitions.cc.

References TypeNull, TypeNull, and relativeConstraints::value.

121  {
122  l1t::GtConditionType value = keyToValue(label.c_str(), l1GtConditionTypeStringToEnumMap);
123 
124  // in case of unrecognized l1t::GtConditionType, return l1t::TypeNull
125  // to be dealt by the corresponding module
126  if (value == (l1t::GtConditionType) -1) {
127  edm::LogInfo("L1TGlobal") << "\n '" << label
128  << "' is not a recognized l1t::GtConditionType. \n Return l1t::TypeNull.";
129 
130  value = l1t::TypeNull;
131  }
132 
133  if (value == l1t::TypeNull) {
134  edm::LogInfo("L1TGlobal")
135  << "\n l1t::TypeNull means no valid condition type defined!";
136  }
137 
138  return value;
139 }
std::string l1t::l1TGtObjectEnumToString ( const GlobalObject &  gtObject)

Definition at line 73 of file GlobalObject.cc.

References gtEG, gtETM, gtETM2, gtETT, gtExternal, gtHTM, gtHTT, gtJet, gtMinBias, gtMu, gtTau, ObjNull, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by l1t::CorrCondition::evaluateCondition().

73  {
74 
75  std::string gtObjectString;
76 
77  switch (gtObject) {
78 
79  case gtMu: {
80  gtObjectString = "Mu";
81  }
82  break;
83 
84  case gtEG: {
85  gtObjectString = "EG";
86  }
87  break;
88 
89  case gtTau: {
90  gtObjectString = "Tau";
91  }
92  break;
93 
94  case gtJet: {
95  gtObjectString = "Jet";
96  }
97  break;
98 
99  case gtETM: {
100  gtObjectString = "ETM";
101  }
102  break;
103 
104  case gtETT: {
105  gtObjectString = "ETT";
106  }
107  break;
108 
109  case gtHTT: {
110  gtObjectString = "HTT";
111  }
112  break;
113 
114  case gtHTM: {
115  gtObjectString = "HTM";
116  }
117  break;
118 
119  case gtETM2: {
120  gtObjectString = "ETM2";
121  }
122  break;
123 
124  case gtMinBias: {
125  gtObjectString = "MinBias";
126  }
127  break;
128 
129  case gtExternal: {
130  gtObjectString = "External";
131  }
132  break;
133 
134  case ObjNull: {
135  gtObjectString = "ObjNull";
136  edm::LogInfo("L1TGlobal")
137  << "\n ObjNull means no valid GlobalObject defined!";
138  }
139  break;
140 
141  default: {
142  edm::LogInfo("L1TGlobal") << "\n '" << gtObject
143  << "' is not a recognized GlobalObject. "
144  << "\n Return ObjNull, which means no valid GlobalObject defined!";
145 
146  gtObjectString = "ObjNull";
147 
148  }
149  break;
150  }
151 
152  return gtObjectString;
153 
154 }
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
l1t::GlobalObject l1t::l1TGtObjectStringToEnum ( const std::string &  )

Definition at line 27 of file GlobalObject.cc.

References newFWLiteAna::found, gtEG, gtETM, gtETM2, gtETT, gtExternal, gtHTM, gtHTT, gtJet, gtMinBias, gtMu, gtTau, i, l1t::L1TGtObjectStringToEnum::label, ObjNull, l1t::L1TGtObjectStringToEnum::value, and relativeConstraints::value.

27  {
28 
29 
30 
31  static const l1t::L1TGtObjectStringToEnum l1TGtObjectStringToEnumMap[] = {
32  {"Mu", gtMu},
33  {"EG", gtEG},
34  {"Tau", gtTau},
35  {"Jet", gtJet},
36  {"ETM", gtETM},
37  {"ETT", gtETT},
38  {"HTT", gtHTT},
39  {"HTM", gtHTM},
40  {"ETM2", gtETM2},
41  {"MinBias", gtMinBias},
42  {"External", gtExternal},
43  {"ObjNull", ObjNull},
44  {0, (GlobalObject) - 1}
45  };
46 
47  l1t::GlobalObject value = (GlobalObject) - 1;
48 
49  bool found = false;
50  for (int i = 0; l1TGtObjectStringToEnumMap[i].label && (!found); ++i)
51  if (!std::strcmp(label.c_str(), l1TGtObjectStringToEnumMap[i].label)) {
52  found = true;
53  value = l1TGtObjectStringToEnumMap[i].value;
54  }
55 
56  // in case of unrecognized GlobalObject, returns Mu
57  // and write a warning (to not throw an exception)
58  if (!found) {
59  edm::LogInfo("L1TGlobal") << "\n '" << label
60  << "' is not a recognized GlobalObject. \n Return ObjNull.";
61 
62  value = ObjNull;
63  }
64 
65  if (value == ObjNull) {
66  edm::LogInfo("L1TGlobal")
67  << "\n ObjNull means no valid GlobalObject defined!";
68  }
69 
70  return value;
71 }
i
int i
Definition: DBlmapReader.cc:9
l1t::GlobalObject
GlobalObject
Definition: GlobalObject.h:16
l1t::L1TGtObjectStringToEnum
the string to enum and enum to string conversions for GlobalObject
Definition: GlobalObject.h:34
std::ostream & l1t::operator<< ( std::ostream &  os,
const l1t::CaloParamsHelper &  p 
)

Definition at line 17 of file CaloParamsHelper.cc.

17  {
18  return os << "CaloParamsHelper...";
19  }
bool l1t::operator> ( l1t::Tau &  a,
l1t::Tau &  b 
)

Definition at line 15 of file Stage2Layer2TauAlgorithmFirmwareImp1.cc.

References funct::abs(), l1t::L1Candidate::hwEta(), l1t::L1Candidate::hwPhi(), and reco::LeafCandidate::pt().

16  {
17  if ( a.pt() == b.pt() ){
18  if( a.hwPhi() == b.hwPhi() )
19  return abs(a.hwEta()) > abs(b.hwEta());
20  else
21  return a.hwPhi() > b.hwPhi();
22  }
23  else
24  return a.pt() > b.pt();
25  }
l1t::L1Candidate::hwPhi
int hwPhi() const
Definition: L1Candidate.cc:79
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
l1t::L1Candidate::hwEta
int hwEta() const
Definition: L1Candidate.cc:74
reco::LeafCandidate::pt
virtual double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
bool l1t::operator> ( l1t::EGamma &  a,
l1t::EGamma &  b 
)

Definition at line 18 of file Stage2Layer2EGammaAlgorithmFirmwareImp1.cc.

References funct::abs(), l1t::L1Candidate::hwEta(), l1t::L1Candidate::hwPhi(), and reco::LeafCandidate::pt().

19  {
20  if ( a.pt() == b.pt() ){
21  if( a.hwPhi() == b.hwPhi() )
22  return abs(a.hwEta()) > abs(b.hwEta());
23  else
24  return a.hwPhi() > b.hwPhi();
25  }
26  else
27  return a.pt() > b.pt();
28  }
l1t::L1Candidate::hwPhi
int hwPhi() const
Definition: L1Candidate.cc:79
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
l1t::L1Candidate::hwEta
int hwEta() const
Definition: L1Candidate.cc:74
reco::LeafCandidate::pt
virtual double pt() const final
transverse momentum
Definition: LeafCandidate.h:131
bool l1t::operator> ( l1t::Jet &  a,
l1t::Jet &  b 
)

Definition at line 20 of file Stage2Layer2JetAlgorithmFirmwareImp1.cc.

References l1t::L1Candidate::hwPt().

21  {
22  if ( a.hwPt() > b.hwPt() ) {
23  return true;
24  } else {
25  return false;
26  }
27  }
l1t::L1Candidate::hwPt
int hwPt() const
Definition: L1Candidate.cc:69
unsigned int l1t::pack15bits ( int  pt,
int  eta,
int  phi 
)

Definition at line 19 of file HardwareSortingMethods.cc.

20  {
21  return( ((pt & 0x3f)) + ((eta & 0xf) << 6) + ((phi & 0x1f) << 10));
22  }
phi
Geom::Phi< T > phi() const
Definition: Basic3DVectorLD.h:163
unsigned int l1t::pack16bits ( int  pt,
int  eta,
int  phi 
)

Definition at line 24 of file HardwareSortingMethods.cc.

25  {
26  return( 0x8000 + ((pt & 0x3f)) + ((eta & 0xf) << 6) + ((phi & 0x1f) << 10));
27  }
phi
Geom::Phi< T > phi() const
Definition: Basic3DVectorLD.h:163
unsigned int l1t::pack16bitsEgammaSpecial ( int  pt,
int  eta,
int  phi 
)

Definition at line 29 of file HardwareSortingMethods.cc.

30  {
31  return( 0x8000 + ((pt & 0x3f) << 9) + ((eta & 0xf)) + ((phi & 0x1f) << 4));
32  }
phi
Geom::Phi< T > phi() const
Definition: Basic3DVectorLD.h:163
void l1t::passThroughJets ( const std::vector< l1t::CaloRegion > *  regions,
std::vector< l1t::Jet > *  uncalibjets 
)

Definition at line 30 of file JetFinderMethods.cc.

References reco::btau::jetEta, reco::btau::jetPhi, and HLT_FULL_cff::region.

32  {
33  for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
34  int jetQual = 0;
35  if( region->hwEta() < 4 || region->hwEta() > 17)
36  jetQual = 2;
37  int jetET = region->hwPt();
38  int jetEta = region->hwEta();
39  int jetPhi = region->hwPhi();
40 
41  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
42  l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
43  uncalibjets->push_back(theJet);
44  }
45  }
HLT_FULL_cff.region
tuple region
Definition: HLT_FULL_cff.py:76378
l1t::Jet
Definition: Jet.h:16
void l1t::RegionCorrection ( const std::vector< l1t::CaloRegion > &  regions,
std::vector< l1t::CaloRegion > *  subRegions,
CaloParamsHelper *  params 
)

------— New region correction (PUsub, no response correction at the moment) --------—

Definition at line 77 of file PUSubtractionMethods.cc.

References HICaloRingSubtraction(), bookConverter::max, l1t::CaloParamsHelper::regionPUSType(), l1t::CaloParamsHelper::regionPUSValue(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by l1t::Stage1Layer2EGammaAlgorithmImpPP::processEvent(), l1t::Stage1Layer2TauAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), l1t::Stage1Layer2JetAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EtSumAlgorithmImpHW::processEvent(), l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent(), l1t::Stage1Layer2TauAlgorithmImpHW::processEvent(), and l1t::Stage1Layer2EGammaAlgorithmImpHW::processEvent().

80  {
81 
82  std::string regionPUSType = params->regionPUSType();
83 
84  if(regionPUSType == "None") {
85  for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
86  notCorrectedRegion != regions.end(); notCorrectedRegion++){
87  CaloRegion newSubRegion= *notCorrectedRegion;
88  subRegions->push_back(newSubRegion);
89  }
90  }
91 
92  if (regionPUSType == "HICaloRingSub") {
93  HICaloRingSubtraction(regions, subRegions, params);
94  }
95 
96  if (regionPUSType == "PUM0") {
97  int puMult = 0;
98 
99  // ------------ This calulates PUM0 ------------------
100  for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
101  notCorrectedRegion != regions.end(); notCorrectedRegion++){
102  int regionET = notCorrectedRegion->hwPt();
103  if (regionET > 0) {puMult++;}
104  }
105  int pumbin = (int) puMult/22;
106  if(pumbin == 18) pumbin = 17; // if puMult = 396 exactly there is an overflow
107 
108  for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
109  notCorrectedRegion != regions.end(); notCorrectedRegion++){
110 
111  int regionET = notCorrectedRegion->hwPt();
112  int regionEta = notCorrectedRegion->hwEta();
113  int regionPhi = notCorrectedRegion->hwPhi();
114 
115  //int puSub = ceil(regionPUSParams[18*regionEta+pumbin]*2);
116  int puSub = params->regionPUSValue(pumbin, regionEta);
117  // The values in regionSubtraction are MULTIPLIED by
118  // RegionLSB=.5 (physicalRegionEt), so to get back unmultiplied
119  // regionSubtraction we want to multiply the number by 2
120  // (aka divide by LSB).
121 
122  int regionEtCorr = std::max(0, regionET - puSub);
123  if(regionET == 1023)
124  regionEtCorr = 1023; // do not subtract overflow regions
125  if((regionET==255) && (regionEta < 4 || regionEta > 17))
126  regionEtCorr = 255;
127 
128  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > lorentz(0,0,0,0);
129  CaloRegion newSubRegion(*&lorentz, 0, 0, regionEtCorr, regionEta, regionPhi, notCorrectedRegion->hwQual(), notCorrectedRegion->hwEtEm(), notCorrectedRegion->hwEtHad());
130  subRegions->push_back(newSubRegion);
131  }
132  }
133  }
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
l1t::HICaloRingSubtraction
void HICaloRingSubtraction(const std::vector< l1t::CaloRegion > &regions, std::vector< l1t::CaloRegion > *subRegions, CaloParamsHelper *params)
------------— For heavy ion ----------------------------------—
Definition: PUSubtractionMethods.cc:19
void l1t::simpleHWSubtraction ( const std::vector< l1t::CaloRegion > &  regions,
std::vector< l1t::CaloRegion > *  subRegions 
)

Definition at line 54 of file PUSubtractionMethods.cc.

References HLT_FULL_cff::region.

56  {
57  for(std::vector<CaloRegion>::const_iterator region = regions.begin();
58  region != regions.end(); region++){
59  int subEta = region->hwEta();
60  int subPhi = region->hwPhi();
61  int subPt = region->hwPt();
62 
63  if(subPt != (2<<10)-1)
64  subPt = subPt - (10+subEta); // arbitrary value chosen in meeting
65  if(subPt < 0)
66  subPt = 0;
67  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
68 
69  CaloRegion newSubRegion(*&ldummy, 0, 0, subPt, subEta, subPhi, region->hwQual(), region->hwEtEm(), region->hwEtHad());
70  subRegions->push_back(newSubRegion);
71  }
72  }
HLT_FULL_cff.region
tuple region
Definition: HLT_FULL_cff.py:76378
void l1t::slidingWindowJetFinder ( const int  jetSeedThreshold,
const std::vector< l1t::CaloRegion > *  regions,
std::vector< l1t::Jet > *  uncalibjets 
)

Definition at line 47 of file JetFinderMethods.cc.

References assert(), gather_cfg::cout, deltaGctPhi(), reco::btau::jetEta, reco::btau::jetPhi, and HLT_FULL_cff::region.

Referenced by l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), l1t::Stage1Layer2JetAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent().

50  {
51  for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
52  int regionET = region->hwPt(); //regionPhysicalEt(*region);
53  if (regionET <= jetSeedThreshold) continue;
54  int neighborN_et = 0;
55  int neighborS_et = 0;
56  int neighborE_et = 0;
57  int neighborW_et = 0;
58  int neighborNE_et = 0;
59  int neighborSW_et = 0;
60  int neighborNW_et = 0;
61  int neighborSE_et = 0;
62  unsigned int nNeighbors = 0;
63  for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
64  int neighborET = neighbor->hwPt(); //regionPhysicalEt(*neighbor);
65  if(deltaGctPhi(*region, *neighbor) == 1 &&
66  (region->hwEta() ) == neighbor->hwEta()) {
67  neighborN_et = neighborET;
68  nNeighbors++;
69  continue;
70  }
71  else if(deltaGctPhi(*region, *neighbor) == -1 &&
72  (region->hwEta() ) == neighbor->hwEta()) {
73  neighborS_et = neighborET;
74  nNeighbors++;
75  continue;
76  }
77  else if(deltaGctPhi(*region, *neighbor) == 0 &&
78  (region->hwEta() + 1) == neighbor->hwEta()) {
79  neighborE_et = neighborET;
80  nNeighbors++;
81  continue;
82  }
83  else if(deltaGctPhi(*region, *neighbor) == 0 &&
84  (region->hwEta() - 1) == neighbor->hwEta()) {
85  neighborW_et = neighborET;
86  nNeighbors++;
87  continue;
88  }
89  else if(deltaGctPhi(*region, *neighbor) == 1 &&
90  (region->hwEta() + 1) == neighbor->hwEta()) {
91  neighborNE_et = neighborET;
92  nNeighbors++;
93  continue;
94  }
95  else if(deltaGctPhi(*region, *neighbor) == -1 &&
96  (region->hwEta() - 1) == neighbor->hwEta()) {
97  neighborSW_et = neighborET;
98  nNeighbors++;
99  continue;
100  }
101  else if(deltaGctPhi(*region, *neighbor) == 1 &&
102  (region->hwEta() - 1) == neighbor->hwEta()) {
103  neighborNW_et = neighborET;
104  nNeighbors++;
105  continue;
106  }
107  else if(deltaGctPhi(*region, *neighbor) == -1 &&
108  (region->hwEta() + 1) == neighbor->hwEta()) {
109  neighborSE_et = neighborET;
110  nNeighbors++;
111  continue;
112  }
113  }
114  if(regionET > neighborN_et &&
115  regionET > neighborNW_et &&
116  regionET > neighborW_et &&
117  regionET > neighborSW_et &&
118  regionET >= neighborNE_et &&
119  regionET >= neighborE_et &&
120  regionET >= neighborSE_et &&
121  regionET >= neighborS_et) {
122  unsigned int jetET = regionET +
123  neighborN_et + neighborS_et + neighborE_et + neighborW_et +
124  neighborNE_et + neighborSW_et + neighborSE_et + neighborNW_et;
125 
126  int jetPhi = region->hwPhi();
127  int jetEta = region->hwEta();
128 
129  bool neighborCheck = (nNeighbors == 8);
130  // On the eta edge we only expect 5 neighbors
131  if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
132  neighborCheck = true;
133 
134  if (!neighborCheck) {
135  std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
136  assert(false);
137  }
138 
139  //first iteration, eta cut defines forward
140  //const bool forward = (jetEta <= 4 || jetEta >= 17);
141  const bool forward = (jetEta < 4 || jetEta > 17);
142  int jetQual = 0;
143  if(forward)
144  jetQual |= 0x2;
145 
146  // check for input overflow regions
147  if(forward && regionET == 255) {
148  jetET = 1023; // 10 bit max
149  } else if(!forward && regionET == 1023) {
150  jetET = 1023; // 10 bit max
151  } else if(region->hwEta() == 17) {
152  if(neighborNE_et == 255 || neighborE_et == 255 || neighborSE_et == 255)
153  jetET = 1023; // 10 bit max
154  } else if(region->hwEta() == 4) {
155  if(neighborNW_et == 255 || neighborW_et == 255 || neighborSW_et == 255)
156  jetET = 1023; // 10 bit max
157  }
158 
159  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
160  l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
161  //l1t::Jet theJet(0, jetET, jetEta, jetPhi);
162 
163  uncalibjets->push_back(theJet);
164  }
165  }
166  }
assert
assert(m_qm.get())
HLT_FULL_cff.region
tuple region
Definition: HLT_FULL_cff.py:76378
l1t::Jet
Definition: Jet.h:16
l1t::deltaGctPhi
int deltaGctPhi(const CaloRegion &region, const CaloRegion &neighbor)
Definition: JetFinderMethods.cc:18
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
void l1t::SortEGammas ( std::vector< l1t::EGamma > *  input,
std::vector< l1t::EGamma > *  output 
)

Definition at line 392 of file HardwareSortingMethods.cc.

References gt_to_fw_phi_map, i, cmsHarvester::index, relval_2017::k, reco::HaloData::minus, presort_egamma(), alignCSCRings::r, l1t::L1Candidate::setHwEta(), l1t::L1Candidate::setHwIso(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), l1t::L1Candidate::setHwQual(), sort_by_row_in_groups(), and super_sort_matrix_rows().

Referenced by l1t::Stage1Layer2EGammaAlgorithmImpPP::processEvent(), l1t::Stage1Layer2EGammaAlgorithmImpHI::processEvent(), and l1t::Stage1Layer2EGammaAlgorithmImpHW::processEvent().

394  {
395  //Initialize
396  const int FIBER_PAIRS = 18;
397  const int N_INPUT_EGAMMAS = 4;
398  const int N_PRESORTED_ROWS_EGAMMA = 36;
399  const int PRESORT_DEPTH = 4;
400  const int N_EGAMMA_FIRST_GROUP_SIZE = 6;
401  const int N_EGAMMA_SECOND_GROUP_SIZE = 6;
402  const int N_EGAMMA_FIRST_GROUPS = 6;
403  const int N_KEEP_EGAMMA = 4;
404 
405  //Input
406  //Each egamma: RCT isolation, RCT order, phi index, eta index
407 
408  vector<l1t::L1Candidate> iso_egamma_array_p, iso_egamma_array_m; //reusing objects. should probably rename to something like "object"
409  vector<l1t::L1Candidate> noniso_egamma_array_p, noniso_egamma_array_m;
410 
411  for(int k=0; k<2*N_INPUT_EGAMMAS*FIBER_PAIRS; k++){
412  l1t::L1Candidate dummyJet;
413  dummyJet.setHwPt(0);
414  dummyJet.setHwEta(99);
415  dummyJet.setHwPhi(99);
416  dummyJet.setHwQual(0x10);
417  if(k<N_INPUT_EGAMMAS*FIBER_PAIRS){
418  iso_egamma_array_p.push_back(dummyJet);
419  noniso_egamma_array_p.push_back(dummyJet);
420  }
421  else{
422  iso_egamma_array_m.push_back(dummyJet);
423  noniso_egamma_array_m.push_back(dummyJet);
424  }
425  }
426 
427  for (std::vector<l1t::EGamma>::const_iterator ineg = input->begin();
428  ineg != input->end(); ++ineg){
429  int fiberNum = (int) floor(gt_to_fw_phi_map[ineg->hwPhi()]/2);
430  int index = ineg->hwQual();
431  bool iso = ineg->hwIso();
432  bool minus = (ineg->hwEta() < 11);
433 
434  // while waiting for firmware LUT, set all iso to true
435  //iso = true;
436 
437  if(iso && minus)
438  iso_egamma_array_m[8*fiberNum+index] = *ineg;
439  else if (iso && !minus)
440  iso_egamma_array_p[8*fiberNum+index] = *ineg;
441  else if (!iso && minus)
442  noniso_egamma_array_m[8*fiberNum+index] = *ineg;
443  else if (!iso && !minus)
444  noniso_egamma_array_p[8*fiberNum+index] = *ineg;
445 
446  }
447 
448  // std::cout << "iso_egamma_array_m" << std::endl;
449  // for(int i = 0; i < (int)iso_egamma_array_m.size(); ++i)
450  // {
451  // std::cout << iso_egamma_array_m[i].hwPt() << " "
452  // << iso_egamma_array_m[i].hwEta() << " "
453  // << iso_egamma_array_m[i].hwPhi() << std::endl;
454  // }
455 
456  // std::cout << "iso_egamma_array_p" << std::endl;
457  // for(int i = 0; i < (int)iso_egamma_array_p.size(); ++i)
458  // {
459  // std::cout << iso_egamma_array_p[i].hwPt() << " "
460  // << iso_egamma_array_p[i].hwEta() << " "
461  // << iso_egamma_array_p[i].hwPhi() << std::endl;
462  // }
463 
464  //verbose = true;
465  //1
466  std::vector<std::vector<l1t::L1Candidate> > presorted_iso_matrix_sig_p = presort_egamma(iso_egamma_array_p, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
467  std::vector<std::vector<l1t::L1Candidate> > presorted_iso_matrix_sig_m = presort_egamma(iso_egamma_array_m, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
468  std::vector<std::vector<l1t::L1Candidate> > presorted_non_iso_matrix_sig_p = presort_egamma(noniso_egamma_array_p, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
469  std::vector<std::vector<l1t::L1Candidate> > presorted_non_iso_matrix_sig_m = presort_egamma(noniso_egamma_array_m, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
470 
471  //2
472  std::vector<std::vector<l1t::L1Candidate> > iso_row_presorted_energies_matrix_sig_p = sort_by_row_in_groups(presorted_iso_matrix_sig_p, N_EGAMMA_FIRST_GROUP_SIZE);
473  std::vector<std::vector<l1t::L1Candidate> > iso_row_presorted_energies_matrix_sig_m = sort_by_row_in_groups(presorted_iso_matrix_sig_m, N_EGAMMA_FIRST_GROUP_SIZE);
474  std::vector<std::vector<l1t::L1Candidate> > non_iso_row_presorted_energies_matrix_sig_p = sort_by_row_in_groups(presorted_non_iso_matrix_sig_p, N_EGAMMA_FIRST_GROUP_SIZE);
475  std::vector<std::vector<l1t::L1Candidate> > non_iso_row_presorted_energies_matrix_sig_m = sort_by_row_in_groups(presorted_non_iso_matrix_sig_m, N_EGAMMA_FIRST_GROUP_SIZE);
476 
477  //3
478  std::vector<std::vector<l1t::L1Candidate> > iso_super_sorted_energies_matrix_sig_p = super_sort_matrix_rows(iso_row_presorted_energies_matrix_sig_p, N_EGAMMA_FIRST_GROUP_SIZE, N_KEEP_EGAMMA);
479  std::vector<std::vector<l1t::L1Candidate> > iso_super_sorted_energies_matrix_sig_m = super_sort_matrix_rows(iso_row_presorted_energies_matrix_sig_m, N_EGAMMA_FIRST_GROUP_SIZE, N_KEEP_EGAMMA);
480  std::vector<std::vector<l1t::L1Candidate> > non_iso_super_sorted_energies_matrix_sig_p = super_sort_matrix_rows(non_iso_row_presorted_energies_matrix_sig_p, N_EGAMMA_FIRST_GROUP_SIZE, N_KEEP_EGAMMA);
481  std::vector<std::vector<l1t::L1Candidate> > non_iso_super_sorted_energies_matrix_sig_m = super_sort_matrix_rows(non_iso_row_presorted_energies_matrix_sig_m, N_EGAMMA_FIRST_GROUP_SIZE, N_KEEP_EGAMMA);
482  //combine plus and minus
483  std::vector<std::vector<l1t::L1Candidate> > iso_super_sorted_energies_matrix_sig (N_EGAMMA_FIRST_GROUPS, std::vector<l1t::L1Candidate>(N_KEEP_EGAMMA) );
484  std::vector<std::vector<l1t::L1Candidate> > non_iso_super_sorted_energies_matrix_sig (N_EGAMMA_FIRST_GROUPS, std::vector<l1t::L1Candidate>(N_KEEP_EGAMMA) );
485  for(int r=0; r<N_EGAMMA_FIRST_GROUPS/2; r++){
486  iso_super_sorted_energies_matrix_sig[r] = iso_super_sorted_energies_matrix_sig_m[r];
487  iso_super_sorted_energies_matrix_sig[r+N_EGAMMA_FIRST_GROUPS/2] = iso_super_sorted_energies_matrix_sig_p[r];
488  non_iso_super_sorted_energies_matrix_sig[r] = non_iso_super_sorted_energies_matrix_sig_m[r];
489  non_iso_super_sorted_energies_matrix_sig[r+N_EGAMMA_FIRST_GROUPS/2] = non_iso_super_sorted_energies_matrix_sig_p[r];
490  }
491 
492  //4
493  std::vector<std::vector<l1t::L1Candidate> > iso_stage2_row_sorted_matrix_sig = sort_by_row_in_groups(iso_super_sorted_energies_matrix_sig, N_EGAMMA_SECOND_GROUP_SIZE);
494  std::vector<std::vector<l1t::L1Candidate> > non_iso_stage2_row_sorted_matrix_sig = sort_by_row_in_groups(non_iso_super_sorted_energies_matrix_sig, N_EGAMMA_SECOND_GROUP_SIZE);
495 
496  //5
497  std::vector<std::vector<l1t::L1Candidate> > iso_stage2_super_sorted_matrix_sig = super_sort_matrix_rows(iso_stage2_row_sorted_matrix_sig, N_EGAMMA_SECOND_GROUP_SIZE, N_KEEP_EGAMMA);
498  std::vector<std::vector<l1t::L1Candidate> > non_iso_stage2_super_sorted_matrix_sig = super_sort_matrix_rows(non_iso_stage2_row_sorted_matrix_sig, N_EGAMMA_SECOND_GROUP_SIZE, N_KEEP_EGAMMA);
499 
500  //Prepare output
501  std::vector<l1t::L1Candidate> sorted_iso_egammas = iso_stage2_super_sorted_matrix_sig[0];
502  std::vector<l1t::L1Candidate> sorted_noniso_egammas = non_iso_stage2_super_sorted_matrix_sig[0];
503 
504  //verbose = false;
505 
506  for(unsigned int i = 0; i < 4; ++i)
507  {
508  l1t::EGamma *ineg = static_cast<l1t::EGamma *>( &sorted_iso_egammas[i] );
509  ineg->setHwIso(1);
510  output->push_back(*ineg);
511  }
512  for(unsigned int i = 0; i < 4; ++i)
513  {
514  l1t::EGamma *ineg = static_cast<l1t::EGamma *>( &sorted_noniso_egammas[i] );
515  output->push_back(*ineg);
516  }
517  }
i
int i
Definition: DBlmapReader.cc:9
relval_2017.k
list k
Definition: relval_2017.py:23
l1t::L1Candidate::setHwQual
void setHwQual(int qual)
Definition: L1Candidate.cc:64
input
static std::string const input
Definition: EdmProvDump.cc:44
l1t::L1Candidate::setHwPhi
void setHwPhi(int phi)
Definition: L1Candidate.cc:54
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
l1t::L1Candidate::setHwIso
void setHwIso(int iso)
Definition: L1Candidate.cc:59
gt_to_fw_phi_map
int gt_to_fw_phi_map[]
Definition: HardwareSortingMethods.cc:16
presort_egamma
std::vector< std::vector< l1t::L1Candidate > > presort_egamma(std::vector< l1t::L1Candidate > input_egamma, int rows, int cols)
Definition: HardwareSortingMethods.cc:212
super_sort_matrix_rows
std::vector< std::vector< l1t::L1Candidate > > super_sort_matrix_rows(std::vector< std::vector< l1t::L1Candidate > > input_matrix, unsigned int group_size, unsigned int n_keep)
Definition: HardwareSortingMethods.cc:186
l1t::L1Candidate::setHwPt
void setHwPt(int pt)
Definition: L1Candidate.cc:44
l1t::L1Candidate::setHwEta
void setHwEta(int eta)
Definition: L1Candidate.cc:49
sort_by_row_in_groups
std::vector< std::vector< l1t::L1Candidate > > sort_by_row_in_groups(std::vector< std::vector< l1t::L1Candidate > > input_matrix, int group_size)
Definition: HardwareSortingMethods.cc:134
void l1t::SortJets ( std::vector< l1t::Jet > *  input,
std::vector< l1t::Jet > *  output 
)

Definition at line 258 of file HardwareSortingMethods.cc.

References fw_to_gt_phi_map, gt_to_fw_phi_map, l1t::L1Candidate::hwQual(), i, j, presort(), l1t::L1Candidate::setHwQual(), sort_by_row_in_groups(), and super_sort_matrix_rows().

Referenced by l1t::Stage1Layer2JetAlgorithmImpHI::processEvent(), l1t::Stage1Layer2EtSumAlgorithmImpPP::processEvent(), l1t::Stage1Layer2JetAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2JetAlgorithmImpSimpleHW::processEvent().

259  {
260  //verbose = true;
261  const int CENTRAL_ETA_SLICES = 14;
262  const int N_PHI_GROUPS = 5;
263  const int N_PRESORTED_ROWS_CENTRAL = CENTRAL_ETA_SLICES*N_PHI_GROUPS;
264  const int PRESORT_DEPTH = 4;
265  const int N_KEEP_CENTRAL = 4;
266  const int N_ETA_GROUP_SIZE_CENTRAL = 4;
267  const int N_ETA_GROUPS_CENTRAL = 4;
268 
269  const int HFM_ETA_SLICES = 4;
270  const int HFP_ETA_SLICES = 4;
271  const int N_PRESORTED_ROWS_HFM = HFM_ETA_SLICES*N_PHI_GROUPS;
272  const int N_PRESORTED_ROWS_HFP = HFP_ETA_SLICES*N_PHI_GROUPS;
273  const int N_KEEP_FORWARD = 4;
274 
275  const int cen_nrows = 18;
276  const int cen_ncols = 14;
277  const int hfm_nrows = 18, hfp_nrows = 18;
278  const int hfm_ncols = 4, hfp_ncols = 4;
279 
280  std::vector<std::vector<l1t::L1Candidate> > cen_input_energy (cen_nrows, std::vector<l1t::L1Candidate>(cen_ncols));
281  std::vector<std::vector<l1t::L1Candidate> > hfm_input_energy (hfm_nrows, std::vector<l1t::L1Candidate>(hfm_ncols));
282  std::vector<std::vector<l1t::L1Candidate> > hfp_input_energy (hfp_nrows, std::vector<l1t::L1Candidate>(hfp_ncols));
283 
284  for (std::vector<l1t::Jet>::const_iterator injet = input->begin();
285  injet != input->end(); ++injet){
286  if(injet->hwEta() >= 4 && injet->hwEta() <= 17 )
287  {
288  unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
289  unsigned int mycol = injet->hwEta()-4; //hardcoding is bad
290  cen_input_energy[myrow][mycol] = *injet;
291  }
292  else if(injet->hwEta() < 4)
293  {
294  unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
295  unsigned int mycol = injet->hwEta(); //hardcoding is bad
296  hfm_input_energy[myrow][mycol] = *injet;
297  }
298  else if(injet->hwEta() > 17)
299  {
300  unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
301  unsigned int mycol = injet->hwEta()-18; //hardcoding is bad
302  hfp_input_energy[myrow][mycol] = *injet;
303  }
304  else
305  edm::LogError("HardwareJetSort") << "Region out of bounds: " << injet->hwEta();
306  }
307 
308  for(int i = 0; i < cen_nrows; ++i)
309  for(int j = 0; j < cen_ncols; ++j)
310  {
311  if(cen_input_energy[i][j].hwPt() == 0)
312  {
313  cen_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
314  cen_input_energy[i][j].setHwEta(4+j);
315  }
316  }
317 
318  for(int i = 0; i < hfm_nrows; ++i)
319  for(int j = 0; j < hfm_ncols; ++j)
320  {
321  if(hfm_input_energy[i][j].hwPt() == 0)
322  {
323  hfm_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
324  hfm_input_energy[i][j].setHwEta(j);
325  hfm_input_energy[i][j].setHwQual(2);
326  }
327  }
328 
329  for(int i = 0; i < hfp_nrows; ++i)
330  for(int j = 0; j < hfp_ncols; ++j)
331  {
332  if(hfp_input_energy[i][j].hwPt() == 0)
333  {
334  hfp_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
335  hfp_input_energy[i][j].setHwEta(j+18);
336  hfp_input_energy[i][j].setHwQual(2);
337  }
338  }
339 
340  //Each CLK is one clock
341 
342  //CLK 1
343  std::vector<std::vector<l1t::L1Candidate> > presorted_energies_matrix_sig = presort(cen_input_energy, N_PRESORTED_ROWS_CENTRAL, PRESORT_DEPTH);
344  std::vector<std::vector<l1t::L1Candidate> > hfm_presorted_energies_matrix_sig = presort(hfm_input_energy, N_PRESORTED_ROWS_HFM, PRESORT_DEPTH);
345  std::vector<std::vector<l1t::L1Candidate> > hfp_presorted_energies_matrix_sig = presort(hfp_input_energy, N_PRESORTED_ROWS_HFP, PRESORT_DEPTH);
346 
347  //CLK 2
348  std::vector<std::vector<l1t::L1Candidate> > row_presorted_energies_matrix_sig = sort_by_row_in_groups(presorted_energies_matrix_sig, N_PHI_GROUPS);
349  std::vector<std::vector<l1t::L1Candidate> > hfm_row_presorted_energies_matrix_sig = sort_by_row_in_groups(hfm_presorted_energies_matrix_sig, N_PHI_GROUPS);
350  std::vector<std::vector<l1t::L1Candidate> > hfp_row_presorted_energies_matrix_sig = sort_by_row_in_groups(hfp_presorted_energies_matrix_sig, N_PHI_GROUPS);
351 
352  //CLK 3
353  std::vector<std::vector<l1t::L1Candidate> > sorted_eta_slices_energies_matrix_sig = super_sort_matrix_rows(row_presorted_energies_matrix_sig, N_PHI_GROUPS, N_KEEP_CENTRAL);
354  std::vector<std::vector<l1t::L1Candidate> > hfm_sorted_eta_slices_energies_matrix_sig = super_sort_matrix_rows(hfm_row_presorted_energies_matrix_sig, N_PHI_GROUPS, N_KEEP_FORWARD);
355  std::vector<std::vector<l1t::L1Candidate> > hfp_sorted_eta_slices_energies_matrix_sig = super_sort_matrix_rows(hfp_row_presorted_energies_matrix_sig, N_PHI_GROUPS, N_KEEP_FORWARD);
356 
357  //CLK 4
358  std::vector<std::vector<l1t::L1Candidate> > row_presorted_eta_slices_energies_matrix_sig = sort_by_row_in_groups(sorted_eta_slices_energies_matrix_sig, N_ETA_GROUP_SIZE_CENTRAL);
359  std::vector<std::vector<l1t::L1Candidate> > hfm_row_presorted_eta_slices_energies_matrix_sig = sort_by_row_in_groups(hfm_sorted_eta_slices_energies_matrix_sig, HFM_ETA_SLICES);
360  std::vector<std::vector<l1t::L1Candidate> > hfp_row_presorted_eta_slices_energies_matrix_sig = sort_by_row_in_groups(hfp_sorted_eta_slices_energies_matrix_sig, HFP_ETA_SLICES);
361 
362  //CLK 5
363  std::vector<std::vector<l1t::L1Candidate> > sorted_eta_groups_energies_matrix_sig = super_sort_matrix_rows(row_presorted_eta_slices_energies_matrix_sig, N_ETA_GROUP_SIZE_CENTRAL, N_KEEP_CENTRAL);
364  std::vector<std::vector<l1t::L1Candidate> > hfm_sorted_final_energies_matrix_sig = super_sort_matrix_rows(hfm_row_presorted_eta_slices_energies_matrix_sig, HFM_ETA_SLICES, N_KEEP_FORWARD);
365  std::vector<std::vector<l1t::L1Candidate> > hfp_sorted_final_energies_matrix_sig = super_sort_matrix_rows(hfp_row_presorted_eta_slices_energies_matrix_sig, HFP_ETA_SLICES, N_KEEP_FORWARD);
366 
367  //CLK 6
368  std::vector<std::vector<l1t::L1Candidate> > row_presorted_eta_groups_energies_matrix_sig = sort_by_row_in_groups(sorted_eta_groups_energies_matrix_sig, N_ETA_GROUPS_CENTRAL);
369  std::vector<std::vector<l1t::L1Candidate> > hf_merged_plus_minus_forward_energies_matrix_sig(2, std::vector<l1t::L1Candidate>(N_KEEP_FORWARD));
370  hf_merged_plus_minus_forward_energies_matrix_sig[0] = hfm_sorted_final_energies_matrix_sig[0];
371  hf_merged_plus_minus_forward_energies_matrix_sig[1] = hfp_sorted_final_energies_matrix_sig[0];
372  std::vector<std::vector<l1t::L1Candidate> > hf_row_presorted_merged_plus_minus_forward_energies_matrix_sig = sort_by_row_in_groups(hf_merged_plus_minus_forward_energies_matrix_sig, 2);
373 
374  //CLK 7
375  std::vector<std::vector<l1t::L1Candidate> > sorted_final_energies_matrix_sig = super_sort_matrix_rows(row_presorted_eta_groups_energies_matrix_sig, N_ETA_GROUPS_CENTRAL, N_KEEP_CENTRAL);
376  std::vector<std::vector<l1t::L1Candidate> > hf_sorted_final_merged_plus_minus_forward_energies_matrix_sig = super_sort_matrix_rows(hf_row_presorted_merged_plus_minus_forward_energies_matrix_sig, 2, N_KEEP_FORWARD);
377 
378  for(unsigned int i = 0; i < 4; ++i)
379  {
380  l1t::Jet *intjet = static_cast<l1t::Jet *>( &sorted_final_energies_matrix_sig[0][i] );
381  output->push_back(*intjet);
382  }
383  for(unsigned int i = 0; i < 4; ++i)
384  {
385  l1t::Jet *intjet = static_cast<l1t::Jet *>( &hf_sorted_final_merged_plus_minus_forward_energies_matrix_sig[0][i] );
386  intjet->setHwQual(intjet->hwQual() | 2);
387  output->push_back(*intjet);
388  }
389  //verbose = false;
390  }
i
int i
Definition: DBlmapReader.cc:9
l1t::L1Candidate::setHwQual
void setHwQual(int qual)
Definition: L1Candidate.cc:64
input
static std::string const input
Definition: EdmProvDump.cc:44
l1t::Jet
Definition: Jet.h:16
fw_to_gt_phi_map
int fw_to_gt_phi_map[]
Definition: HardwareSortingMethods.cc:15
j
int j
Definition: DBlmapReader.cc:9
l1t::L1Candidate::hwQual
int hwQual() const
Definition: L1Candidate.cc:89
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
gt_to_fw_phi_map
int gt_to_fw_phi_map[]
Definition: HardwareSortingMethods.cc:16
super_sort_matrix_rows
std::vector< std::vector< l1t::L1Candidate > > super_sort_matrix_rows(std::vector< std::vector< l1t::L1Candidate > > input_matrix, unsigned int group_size, unsigned int n_keep)
Definition: HardwareSortingMethods.cc:186
presort
std::vector< std::vector< l1t::L1Candidate > > presort(std::vector< std::vector< l1t::L1Candidate > > energies, int rows, int cols)
Definition: HardwareSortingMethods.cc:62
sort_by_row_in_groups
std::vector< std::vector< l1t::L1Candidate > > sort_by_row_in_groups(std::vector< std::vector< l1t::L1Candidate > > input_matrix, int group_size)
Definition: HardwareSortingMethods.cc:134
void l1t::SortTaus ( std::vector< l1t::Tau > *  input,
std::vector< l1t::Tau > *  output 
)

Definition at line 519 of file HardwareSortingMethods.cc.

References fw_to_gt_phi_map, gt_to_fw_phi_map, i, j, presort(), sort_by_row_in_groups(), and super_sort_matrix_rows().

Referenced by l1t::Stage1Layer2SingleTrackHI::processEvent(), l1t::Stage1Layer2TauAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2TauAlgorithmImpHW::processEvent().

520  {
521  const int CENTRAL_ETA_SLICES = 14;
522  const int N_PHI_GROUPS = 5;
523  const int N_PRESORTED_ROWS_CENTRAL = CENTRAL_ETA_SLICES*N_PHI_GROUPS;
524  const int PRESORT_DEPTH = 4;
525  const int N_KEEP_CENTRAL = 4;
526  const int N_ETA_GROUP_SIZE_CENTRAL = 4;
527  const int N_ETA_GROUPS_CENTRAL = 4;
528 
529  const int cen_nrows = 18;
530  const int cen_ncols = 14;
531 
532  std::vector<std::vector<l1t::L1Candidate> > cen_input_energy (cen_nrows, std::vector<l1t::L1Candidate>(cen_ncols));
533 
534  for (std::vector<l1t::Tau>::const_iterator injet = input->begin();
535  injet != input->end(); ++injet){
536  if(injet->hwEta() >= 4 && injet->hwEta() <= 17 )
537  {
538  unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
539  unsigned int mycol = injet->hwEta()-4; //hardcoding is bad
540  cen_input_energy[myrow][mycol] = *injet;
541  }
542  else
543  edm::LogError("HardwareTauSort") << "Region out of bounds: " << injet->hwEta();
544  }
545 
546  for(int i = 0; i < cen_nrows; ++i)
547  for(int j = 0; j < cen_ncols; ++j)
548  {
549  if(cen_input_energy[i][j].hwPt() == 0)
550  {
551  cen_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
552  cen_input_energy[i][j].setHwEta(4+j);
553  }
554  }
555 
556  //Each CLK is one clock
557 
558  //CLK 1
559  std::vector<std::vector<l1t::L1Candidate> > presorted_energies_matrix_sig = presort(cen_input_energy, N_PRESORTED_ROWS_CENTRAL, PRESORT_DEPTH);
560  //CLK 2
561  std::vector<std::vector<l1t::L1Candidate> > row_presorted_energies_matrix_sig = sort_by_row_in_groups(presorted_energies_matrix_sig, N_PHI_GROUPS);
562  //CLK 3
563  std::vector<std::vector<l1t::L1Candidate> > sorted_eta_slices_energies_matrix_sig = super_sort_matrix_rows(row_presorted_energies_matrix_sig, N_PHI_GROUPS, N_KEEP_CENTRAL);
564  //CLK 4
565  std::vector<std::vector<l1t::L1Candidate> > row_presorted_eta_slices_energies_matrix_sig = sort_by_row_in_groups(sorted_eta_slices_energies_matrix_sig, N_ETA_GROUP_SIZE_CENTRAL);
566  //CLK 5
567  std::vector<std::vector<l1t::L1Candidate> > sorted_eta_groups_energies_matrix_sig = super_sort_matrix_rows(row_presorted_eta_slices_energies_matrix_sig, N_ETA_GROUP_SIZE_CENTRAL, N_KEEP_CENTRAL);
568  //CLK 6
569  std::vector<std::vector<l1t::L1Candidate> > row_presorted_eta_groups_energies_matrix_sig = sort_by_row_in_groups(sorted_eta_groups_energies_matrix_sig, N_ETA_GROUPS_CENTRAL);
570  //CLK 7
571  std::vector<std::vector<l1t::L1Candidate> > sorted_final_energies_matrix_sig = super_sort_matrix_rows(row_presorted_eta_groups_energies_matrix_sig, N_ETA_GROUPS_CENTRAL, N_KEEP_CENTRAL);
572 
573  for(unsigned int i = 0; i < 4; ++i)
574  {
575  l1t::Tau *intjet = static_cast<l1t::Tau *>( &sorted_final_energies_matrix_sig[0][i] );
576  output->push_back(*intjet);
577  }
578  }
i
int i
Definition: DBlmapReader.cc:9
l1t::Tau
Definition: Tau.h:16
input
static std::string const input
Definition: EdmProvDump.cc:44
fw_to_gt_phi_map
int fw_to_gt_phi_map[]
Definition: HardwareSortingMethods.cc:15
j
int j
Definition: DBlmapReader.cc:9
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
gt_to_fw_phi_map
int gt_to_fw_phi_map[]
Definition: HardwareSortingMethods.cc:16
super_sort_matrix_rows
std::vector< std::vector< l1t::L1Candidate > > super_sort_matrix_rows(std::vector< std::vector< l1t::L1Candidate > > input_matrix, unsigned int group_size, unsigned int n_keep)
Definition: HardwareSortingMethods.cc:186
presort
std::vector< std::vector< l1t::L1Candidate > > presort(std::vector< std::vector< l1t::L1Candidate > > energies, int rows, int cols)
Definition: HardwareSortingMethods.cc:62
sort_by_row_in_groups
std::vector< std::vector< l1t::L1Candidate > > sort_by_row_in_groups(std::vector< std::vector< l1t::L1Candidate > > input_matrix, int group_size)
Definition: HardwareSortingMethods.cc:134
void l1t::TauToGtEtaScales ( CaloParamsHelper *  params,
const std::vector< l1t::Tau > *  input,
std::vector< l1t::Tau > *  output 
)

Definition at line 124 of file legacyGtHelper.cc.

References gtEta(), and gtTau.

Referenced by l1t::Stage1Layer2SingleTrackHI::processEvent(), l1t::Stage1Layer2TauAlgorithmImpPP::processEvent(), and l1t::Stage1Layer2TauAlgorithmImpHW::processEvent().

126  {
127  for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
128  itTau != input->end(); ++itTau){
129  unsigned newPhi = itTau->hwPhi();
130  unsigned newEta = gtEta(itTau->hwEta());
131 
132  // taus with hwQual & 10 ==10 are "padding" jets from a sort, set their eta and phi
133  // to the max value
134  if((itTau->hwQual() & 0x10) == 0x10)
135  {
136  newEta = 0x0;
137  newPhi = 0x0;
138  }
139 
140 
141  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
142 
143  l1t::Tau gtTau(*&ldummy, itTau->hwPt(), newEta, newPhi, itTau->hwQual(), itTau->hwIso());
144  output->push_back(gtTau);
145  }
146  }
l1t::Tau
Definition: Tau.h:16
l1t::gtEta
const unsigned int gtEta(const unsigned int iEta)
Definition: legacyGtHelper.cc:194
input
static std::string const input
Definition: EdmProvDump.cc:44
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
void l1t::TauToGtPtScales ( CaloParamsHelper *  params,
const std::vector< l1t::Tau > *  input,
std::vector< l1t::Tau > *  output 
)

Definition at line 148 of file legacyGtHelper.cc.

References gtTau, l1t::CaloParamsHelper::jetScale(), L1CaloEtScale::linScaleMax(), and L1CaloEtScale::rank().

Referenced by l1t::Stage1Layer2SingleTrackHI::processEvent(), and l1t::Stage1Layer2TauAlgorithmImpPP::processEvent().

150  {
151  for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
152  itTau != input->end(); ++itTau){
153  uint16_t linPt = (uint16_t)itTau->hwPt();
154  if(linPt > params->jetScale().linScaleMax() ) linPt = params->jetScale().linScaleMax();
155  const uint16_t rankPt = params->jetScale().rank(linPt);
156 
157  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
158 
159  l1t::Tau gtTau(*&ldummy, rankPt, itTau->hwEta(), itTau->hwPhi(), itTau->hwQual(), itTau->hwIso());
160  output->push_back(gtTau);
161  }
162  }
l1t::Tau
Definition: Tau.h:16
input
static std::string const input
Definition: EdmProvDump.cc:44
convertSQLitetoXML_cfg.output
tuple output
Definition: convertSQLitetoXML_cfg.py:32
void l1t::TwelveByTwelveFinder ( const int  jetSeedThreshold,
const std::vector< l1t::CaloRegion > *  regions,
std::vector< l1t::Jet > *  uncalibjets 
)

Definition at line 168 of file JetFinderMethods.cc.

References assert(), gather_cfg::cout, deltaGctPhi(), reco::btau::jetEta, reco::btau::jetPhi, and HLT_FULL_cff::region.

Referenced by l1t::Stage1Layer2EGammaAlgorithmImpPP::processEvent(), l1t::Stage1Layer2TauAlgorithmImpPP::processEvent(), l1t::Stage1Layer2TauAlgorithmImpHW::processEvent(), and l1t::Stage1Layer2EGammaAlgorithmImpHW::processEvent().

171  {
172  for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
173  int regionET = region->hwPt(); //regionPhysicalEt(*region);
174  if (regionET < jetSeedThreshold) continue;
175  int neighborN_et = 0;
176  int neighborS_et = 0;
177  int neighborE_et = 0;
178  int neighborW_et = 0;
179  int neighborNE_et = 0;
180  int neighborSW_et = 0;
181  int neighborNW_et = 0;
182  int neighborSE_et = 0;
183  unsigned int nNeighbors = 0;
184  for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
185  int neighborET = neighbor->hwPt(); //regionPhysicalEt(*neighbor);
186  if(deltaGctPhi(*region, *neighbor) == 1 &&
187  (region->hwEta() ) == neighbor->hwEta()) {
188  neighborN_et = neighborET;
189  nNeighbors++;
190  continue;
191  }
192  else if(deltaGctPhi(*region, *neighbor) == -1 &&
193  (region->hwEta() ) == neighbor->hwEta()) {
194  neighborS_et = neighborET;
195  nNeighbors++;
196  continue;
197  }
198  else if(deltaGctPhi(*region, *neighbor) == 0 &&
199  (region->hwEta() + 1) == neighbor->hwEta()) {
200  neighborE_et = neighborET;
201  nNeighbors++;
202  continue;
203  }
204  else if(deltaGctPhi(*region, *neighbor) == 0 &&
205  (region->hwEta() - 1) == neighbor->hwEta()) {
206  neighborW_et = neighborET;
207  nNeighbors++;
208  continue;
209  }
210  else if(deltaGctPhi(*region, *neighbor) == 1 &&
211  (region->hwEta() + 1) == neighbor->hwEta()) {
212  neighborNE_et = neighborET;
213  nNeighbors++;
214  continue;
215  }
216  else if(deltaGctPhi(*region, *neighbor) == -1 &&
217  (region->hwEta() - 1) == neighbor->hwEta()) {
218  neighborSW_et = neighborET;
219  nNeighbors++;
220  continue;
221  }
222  else if(deltaGctPhi(*region, *neighbor) == 1 &&
223  (region->hwEta() - 1) == neighbor->hwEta()) {
224  neighborNW_et = neighborET;
225  nNeighbors++;
226  continue;
227  }
228  else if(deltaGctPhi(*region, *neighbor) == -1 &&
229  (region->hwEta() + 1) == neighbor->hwEta()) {
230  neighborSE_et = neighborET;
231  nNeighbors++;
232  continue;
233  }
234  }
235  unsigned int jetET = regionET +
236  neighborN_et + neighborS_et + neighborE_et + neighborW_et +
237  neighborNE_et + neighborSW_et + neighborSE_et + neighborNW_et;
238 
239  int jetPhi = region->hwPhi();
240  int jetEta = region->hwEta();
241 
242  bool neighborCheck = (nNeighbors == 8);
243  // On the eta edge we only expect 5 neighbors
244  if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
245  neighborCheck = true;
246 
247  if (!neighborCheck) {
248  std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
249  assert(false);
250  }
251 
252  //first iteration, eta cut defines forward
253  //const bool forward = (jetEta <= 4 || jetEta >= 17);
254  const bool forward = (jetEta < 4 || jetEta > 17);
255  int jetQual = 0;
256  if(forward)
257  jetQual |= 0x2;
258 
259  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
260  l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
261  //l1t::Jet theJet(0, jetET, jetEta, jetPhi);
262 
263  uncalibjets->push_back(theJet);
264  }
265  }
assert
assert(m_qm.get())
HLT_FULL_cff.region
tuple region
Definition: HLT_FULL_cff.py:76378
l1t::Jet
Definition: Jet.h:16
l1t::deltaGctPhi
int deltaGctPhi(const CaloRegion &region, const CaloRegion &neighbor)
Definition: JetFinderMethods.cc:18
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
void l1t::TwoByTwoFinder ( const int  jetSeedThreshold,
const int  etaMask,
const std::vector< l1t::CaloRegion > *  regions,
std::vector< l1t::Jet > *  uncalibjets 
)

Definition at line 267 of file JetFinderMethods.cc.

References assert(), gather_cfg::cout, deltaGctPhi(), reco::btau::jetEta, reco::btau::jetPhi, bookConverter::max, and HLT_FULL_cff::region.

Referenced by l1t::Stage1Layer2JetAlgorithmImpHI::processEvent().

271  {
272  for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
273  int regionET = region->hwPt();
274  if (regionET <= jetSeedThreshold) continue;
275  int subEta = region->hwEta();
276  if((etaMask & (1<<subEta))>>subEta) regionET = 0;
277  int neighborN_et = 0;
278  int neighborS_et = 0;
279  int neighborE_et = 0;
280  int neighborW_et = 0;
281  int neighborNE_et = 0;
282  int neighborSW_et = 0;
283  int neighborNW_et = 0;
284  int neighborSE_et = 0;
285  unsigned int nNeighbors = 0;
286  for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
287  int neighborET = neighbor->hwPt();
288  int subEta2 = neighbor->hwEta();
289  if((etaMask & (1<<subEta2))>>subEta2) neighborET = 0;
290 
291  if(deltaGctPhi(*region, *neighbor) == 1 &&
292  (region->hwEta() ) == neighbor->hwEta()) {
293  neighborN_et = neighborET;
294  nNeighbors++;
295  continue;
296  }
297  else if(deltaGctPhi(*region, *neighbor) == -1 &&
298  (region->hwEta() ) == neighbor->hwEta()) {
299  neighborS_et = neighborET;
300  nNeighbors++;
301  continue;
302  }
303  else if(deltaGctPhi(*region, *neighbor) == 0 &&
304  (region->hwEta() + 1) == neighbor->hwEta()) {
305  neighborE_et = neighborET;
306  nNeighbors++;
307  continue;
308  }
309  else if(deltaGctPhi(*region, *neighbor) == 0 &&
310  (region->hwEta() - 1) == neighbor->hwEta()) {
311  neighborW_et = neighborET;
312  nNeighbors++;
313  continue;
314  }
315  else if(deltaGctPhi(*region, *neighbor) == 1 &&
316  (region->hwEta() + 1) == neighbor->hwEta()) {
317  neighborNE_et = neighborET;
318  nNeighbors++;
319  continue;
320  }
321  else if(deltaGctPhi(*region, *neighbor) == -1 &&
322  (region->hwEta() - 1) == neighbor->hwEta()) {
323  neighborSW_et = neighborET;
324  nNeighbors++;
325  continue;
326  }
327  else if(deltaGctPhi(*region, *neighbor) == 1 &&
328  (region->hwEta() - 1) == neighbor->hwEta()) {
329  neighborNW_et = neighborET;
330  nNeighbors++;
331  continue;
332  }
333  else if(deltaGctPhi(*region, *neighbor) == -1 &&
334  (region->hwEta() + 1) == neighbor->hwEta()) {
335  neighborSE_et = neighborET;
336  nNeighbors++;
337  continue;
338  }
339 
340  }
341  if(regionET > neighborN_et &&
342  regionET > neighborNW_et &&
343  regionET > neighborW_et &&
344  regionET > neighborSW_et &&
345  regionET >= neighborNE_et &&
346  regionET >= neighborE_et &&
347  regionET >= neighborSE_et &&
348  regionET >= neighborS_et) {
349 
350  // use the highest-pT 2x2 jet inside this 3x3
351  unsigned int jetET_NW;
352  unsigned int jetET_NE;
353  unsigned int jetET_SW;
354  unsigned int jetET_SE;
355 
356  jetET_NW = regionET + neighborW_et + neighborNW_et + neighborN_et;
357  jetET_NE = regionET + neighborE_et + neighborNE_et + neighborN_et;
358  jetET_SW = regionET + neighborS_et + neighborSW_et + neighborW_et;
359  jetET_SE = regionET + neighborS_et + neighborSE_et + neighborE_et;
360 
361  unsigned int jetET = std::max(jetET_NW, jetET_NE);
362  jetET = std::max(jetET, jetET_SW);
363  jetET = std::max(jetET, jetET_SE);
364 
365  int jetPhi = region->hwPhi();
366  int jetEta = region->hwEta();
367 
368  bool neighborCheck = (nNeighbors == 8);
369  // On the eta edge we only expect 5 neighbor
370  if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
371  neighborCheck = true;
372 
373  if (!neighborCheck) {
374  std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
375  assert(false);
376  }
377 
378  //first iteration, eta cut defines forward
379  const bool forward = (jetEta < 4 || jetEta > 17);
380  int jetQual = 0;
381  if(forward)
382  jetQual |= 0x2;
383 
384  ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
385  l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
386  uncalibjets->push_back(theJet);
387  }
388  }
389  }
assert
assert(m_qm.get())
HLT_FULL_cff.region
tuple region
Definition: HLT_FULL_cff.py:76378
l1t::Jet
Definition: Jet.h:16
l1t::deltaGctPhi
int deltaGctPhi(const CaloRegion &region, const CaloRegion &neighbor)
Definition: JetFinderMethods.cc:18
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:145
Generated for CMSSW Reference Manual by doxygen 1.8.5