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	DataWriterExt
class	Description
class	EGamma
class	EMTFDaqOut
class	EMTFHit
class	EMTFHitExtra
class	EmtfPtAssignment
class	EMTFTrack
class	EMTFTrackExtra
class	EndCapParamsHelper
class	EnergySumCondition
class	EtSum
class	EtSumHelper
class	ExternalCondition
class	FakeInputProducer
class	ForestHelper
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	L1TCaloTowersFilter
class	L1TCaloUpgradeToGCTConverter
class	L1TDigiToRaw
class	L1TExtCondLegacyToStage2
class	L1TExtCondProducer
class	L1TGlobalAnalyzer
class	L1TGlobalUtil
class	L1TGlobalUtilHelper
struct	L1TGtObjectStringToEnum
	the string to enum and enum to string conversions for GlobalObject More...
class	L1TRawToDigi
class	L1TStage1Layer2Producer
class	L1TStage2CaloAnalyzer
class	LUT
class	Mask
class	MicroGMTAbsoluteIsolationCheckLUT
class	MicroGMTAbsoluteIsolationCheckLUTFactory
class	MicroGMTCaloIndexSelectionLUT
class	MicroGMTCaloIndexSelectionLUTFactory
class	MicroGMTCancelOutUnit
class	MicroGMTConfiguration
class	MicroGMTExtrapolationLUT
class	MicroGMTExtrapolationLUTFactory
class	MicroGMTIsolationUnit
class	MicroGMTLUT
class	MicroGMTMatchQualFineLUT
class	MicroGMTMatchQualLUT
class	MicroGMTMatchQualLUTFactory
class	MicroGMTMatchQualSimpleLUT
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	PrescalesVetosHelper
class	rctDataBase
class	RegionalMuonCand
class	RegionalMuonRawDigiTranslator
class	Setting
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	TableRow
class	Tau
class	TriggerMenuParser
class	TrigSystem
class	Unpacker
class	UnpackerCollections
class	UnpackerFactory
class	WriterProxy
class	WriterProxyT
class	XmlConfigReader

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< EMTFDaqOut >	EMTFDaqOutCollection
typedef std::vector< EMTFHit >	EMTFHitCollection
typedef std::vector< EMTFHitExtra >	EMTFHitExtraCollection
typedef std::vector< EMTFTrack >	EMTFTrackCollection
typedef std::vector < EMTFTrackExtra >	EMTFTrackExtraCollection
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,   gtETMHF, gtTowerCount, gtMinBiasHFP0, gtMinBiasHFM0,   gtMinBiasHFP1, gtMinBiasHFM1, gtETTem, 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, TypeETMHF,   TypeTowerCount, TypeMinBiasHFP0, TypeMinBiasHFM0, TypeMinBiasHFP1,   TypeMinBiasHFM1, TypeETTem, TypeExternal }
enum	L1GtBoardType { MP7 = 0, BoardNull }
	board types in GT More...
enum	tftype {   bmtf, omtf_neg, omtf_pos, emtf_neg,   emtf_pos }

Functions
int	calc_chamber (int _station, int _sector, int _subsector, int _ring, int _csc_ID)
float	calc_eta (int bits)
float	calc_eta_from_theta_rad (float _theta_rad)
int	calc_eta_GMT (float val)
float	calc_phi_glob_deg (float loc, int sect)
float	calc_phi_glob_deg_hit (float loc, int sect_ind)
float	calc_phi_glob_rad (float loc, int sect)
float	calc_phi_glob_rad_hit (float loc, int sect_ind)
float	calc_phi_GMT_deg (int bits)
float	calc_phi_GMT_deg_corr (int bits)
int	calc_phi_GMT_int (float val)
float	calc_phi_GMT_rad (int bits)
float	calc_phi_loc_deg (int bits)
int	calc_phi_loc_int (float val)
float	calc_phi_loc_rad (int bits)
float	calc_pt (int bits)
int	calc_pt_GMT (float val)
int	calc_ring (int _station, int _csc_ID, int _strip)
int	calc_sector_from_index (int index)
int	calc_sector_GMT (int _sector)
int	calc_subsector (int _station, int _chamber)
float	calc_theta_deg (float _eta)
float	calc_theta_deg_from_int (int _theta_int)
float	calc_theta_rad (float _eta)
float	calc_theta_rad_from_int (int _theta_int)
int	calc_uGMT_chamber (int _csc_ID, int _subsector, int _neighbor, int _station)
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)
unsigned int	convertFromHexStringToInt (const std::string &aHexString)
template<class varType >
varType	convertVariable (const std::string &aVar)
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> (const l1t::Tau &a, const l1t::Tau &b)
bool	operator> (const l1t::EGamma &a, const l1t::EGamma &b)
bool	operator> (l1t::EGamma &a, l1t::EGamma &b)
bool	operator> (l1t::Tau &a, l1t::Tau &b)
bool	operator> (const 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)
std::vector< std::string >	str2VecStr_ (const std::string &aStr, const std::string &delim)
void	str2VecStr_ (const std::string &aStr, const std::string &delim, std::vector< std::string > &aVec)
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

: Brian Winer, OSU 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<EMTFDaqOut> l1t::EMTFDaqOutCollection

Definition at line 130 of file EMTFDaqOut.h.

typedef std::vector<EMTFHit> l1t::EMTFHitCollection

Definition at line 158 of file EMTFHit.h.

typedef std::vector<EMTFHitExtra> l1t::EMTFHitExtraCollection

Definition at line 112 of file EMTFHitExtra.h.

typedef std::vector<EMTFTrack> l1t::EMTFTrackCollection

Definition at line 201 of file EMTFTrack.h.

typedef std::vector<EMTFTrackExtra> l1t::EMTFTrackExtraCollection

Definition at line 96 of file EMTFTrackExtra.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 9 of file PackerFactory.h.

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

Definition at line 10 of file PackerFactory.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 19 of file Packer.h.

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

Definition at line 10 of file PackingSetupFactory.h.

typedef PackingSetup*( l1t::prov_fct)()

Definition at line 9 of file PackingSetupFactory.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 9 of file UnpackerFactory.h.

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

Definition at line 10 of file UnpackerFactory.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 88 of file WriterProxy.h.

Enumeration Type Documentation

enum l1t::block_t

Enumerator
MP7
CTP7
MTF7

Definition at line 10 of file Block.h.

{ MP7 = 0, CTP7, MTF7 };

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.

                  {
        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 l1t::cancelmode

Enumerator
tracks
coordinate

Definition at line 11 of file MicroGMTCancelOutUnit.h.

                  {
    tracks, coordinate
  };

enum l1t::GlobalObject

L1 GT objects ObjNull catch all errors

Enumerator
gtMu
gtEG
gtJet
gtTau
gtETM
gtETT
gtHTT
gtHTM
gtETMHF
gtTowerCount
gtMinBiasHFP0
gtMinBiasHFM0
gtMinBiasHFP1
gtMinBiasHFM1
gtETTem
gtExternal
ObjNull

Definition at line 16 of file GlobalObject.h.

{
    gtMu,
    gtEG,
    gtJet,
    gtTau,
    gtETM,
    gtETT,
    gtHTT,
    gtHTM,
    gtETMHF,
    gtTowerCount,
    gtMinBiasHFP0,
    gtMinBiasHFM0,
    gtMinBiasHFP1,
    gtMinBiasHFM1,
    gtETTem,
    gtExternal,
    ObjNull
};

enum l1t::GtConditionCategory

condition categories

Enumerator
CondNull
CondMuon
CondCalo
CondEnergySum
CondCorrelation
CondExternal

Definition at line 83 of file GlobalDefinitions.h.

                         {
    CondNull,
    CondMuon,
    CondCalo,
    CondEnergySum,
    CondCorrelation,
    CondExternal
};

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
TypeETMHF
TypeTowerCount
TypeMinBiasHFP0
TypeMinBiasHFM0
TypeMinBiasHFP1
TypeMinBiasHFM1
TypeETTem
TypeExternal

Definition at line 52 of file GlobalDefinitions.h.

                     {
    TypeNull,
    Type1s,
    Type2s,
    Type2wsc,
    Type2cor,
    Type3s,
    Type4s,
    TypeETM,
    TypeETT,
    TypeHTT,
    TypeHTM,
    TypeETMHF,
    TypeTowerCount,
    TypeMinBiasHFP0,
    TypeMinBiasHFM0,
    TypeMinBiasHFP1,
    TypeMinBiasHFM1,
    TypeETTem,
    TypeExternal
};

enum l1t::L1GtBoardType

board types in GT

Enumerator
MP7
BoardNull

Definition at line 28 of file GlobalDefinitions.h.

                   {
    MP7,
    BoardNull
};

enum l1t::tftype

Enumerator
bmtf
omtf_neg
omtf_pos
emtf_neg
emtf_pos

Definition at line 7 of file RegionalMuonCandFwd.h.

                {
    bmtf, omtf_neg, omtf_pos, emtf_neg, emtf_pos
    };

Function Documentation

int l1t::calc_chamber	(	int	_station,
		int	_sector,
		int	_subsector,
		int	_ring,
		int	_csc_ID
	)

Definition at line 156 of file EMTFHitTools.cc.

Referenced by l1t::stage2::emtf::MEBlockUnpacker::unpack().

                                                                                       {
    int tmp_chamber = -999;
    if (_station == 1) {
      tmp_chamber = ((_sector-1) * 6) + _csc_ID + 2; // Chamber offset of 2: First chamber in sector 1 is chamber 3
      if (_ring == 2)       tmp_chamber -= 3;
      if (_ring == 3)       tmp_chamber -= 6;
      if (_subsector == 2)  tmp_chamber += 3;
      if (tmp_chamber > 36) tmp_chamber -= 36;
    }
    else if (_ring == 1) { 
      tmp_chamber = ((_sector-1) * 3) + _csc_ID + 1; // Chamber offset of 1: First chamber in sector 1 is chamber 2
      if (tmp_chamber > 18) tmp_chamber -= 18;
    }
    else if (_ring == 2) {
      tmp_chamber = ((_sector-1) * 6) + _csc_ID - 3 + 2; // Chamber offset of 2: First chamber in sector 1 is chamber 3
      if (tmp_chamber > 36) tmp_chamber -= 36;
    }
    return tmp_chamber;
  } // End EMTFHit::calc_chamber

float l1t::calc_eta ( int  bits )

inline

Definition at line 17 of file EMTFTrackTools.h.

Referenced by l1t::EMTFTrack::ImportSP().

{ return bits * 0.010875;                                   }

float l1t::calc_eta_from_theta_rad ( float  _theta_rad )

inline

Definition at line 18 of file EMTFHitTools.h.

References dqm-mbProfile::log, and funct::tan().

Referenced by L1TMuonEndCapTrackProducer::produce().

{ return -1 * log( tan( _theta_rad / 2 ) ); }

int l1t::calc_eta_GMT ( float  val )

inline

Definition at line 18 of file EMTFTrackTools.h.

{ return val / 0.010875;                                    }

float l1t::calc_phi_glob_deg ( float  loc, int  sect  )

inline

Definition at line 28 of file EMTFTrackTools.h.

References tmp.

Referenced by l1t::EMTFTrack::ImportSP(), and L1TMuonEndCapTrackProducer::produce().

                                                      { 
    float tmp = loc + 15 + (sect - 1)*60; return (tmp < 180) ? tmp : tmp - 360; }

float l1t::calc_phi_glob_deg_hit ( float  loc, int  sect_ind  )

inline

Definition at line 19 of file EMTFHitTools.h.

References tmp.

Referenced by L1TMuonEndCapTrackProducer::produce().

                                                              { 
    float tmp = loc + 15 + (sect_ind < 6 ? sect_ind : sect_ind - 6)*60; 
    return (tmp < 180) ? tmp : tmp - 360; }

float l1t::calc_phi_glob_rad ( float  loc, int  sect  )

inline

Definition at line 30 of file EMTFTrackTools.h.

References Geom::pi(), and tmp.

Referenced by l1t::EMTFTrack::ImportSP(), and L1TMuonEndCapTrackProducer::produce().

                                                      { 
    float tmp = loc + (Geom::pi()/12) + (sect - 1)*(Geom::pi()/3); return (tmp < Geom::pi()) ? tmp : tmp - 2*Geom::pi(); }

float l1t::calc_phi_glob_rad_hit ( float  loc, int  sect_ind  )

inline

Definition at line 22 of file EMTFHitTools.h.

References Geom::pi(), and tmp.

Referenced by L1TMuonEndCapTrackProducer::produce().

                                                              { 
    float tmp = loc + (Geom::pi()/12) + (sect_ind < 6 ? sect_ind : sect_ind - 6)*(Geom::pi()/3); 
    return (tmp < Geom::pi()) ? tmp : tmp - 2*Geom::pi(); }

float l1t::calc_phi_GMT_deg ( int  bits )

inline

Definition at line 24 of file EMTFTrackTools.h.

{ return (bits * 0.625) + 0.3125;                           } /* x (360/576) + (180/576) */

float l1t::calc_phi_GMT_deg_corr ( int  bits )

inline

Definition at line 25 of file EMTFTrackTools.h.

{ return (bits * 0.625 * 1.0208) + 0.3125 * 1.0208 + 0.552; } /* AWB mod 09.02.16 */

int l1t::calc_phi_GMT_int ( float  val )

inline

Definition at line 27 of file EMTFTrackTools.h.

{ return (val - 0.3125) / 0.625;                            } /* - (180/576) / (360/576) */

float l1t::calc_phi_GMT_rad ( int  bits )

inline

Definition at line 26 of file EMTFTrackTools.h.

References Geom::pi().

{ return (bits * Geom::pi() / 288) + (Geom::pi() / 576);    } /* x (2*pi/576) + (pi/576) */

float l1t::calc_phi_loc_deg ( int  bits )

inline

Definition at line 21 of file EMTFTrackTools.h.

Referenced by l1t::EMTFTrack::ImportSP(), and L1TMuonEndCapTrackProducer::produce().

{ return (bits / 60.0) - 22.0;                              }

int l1t::calc_phi_loc_int ( float  val )

inline

Definition at line 23 of file EMTFTrackTools.h.

{ return (val + 2) * 60;                                    }

float l1t::calc_phi_loc_rad ( int  bits )

inline

Definition at line 22 of file EMTFTrackTools.h.

References Geom::pi().

Referenced by l1t::EMTFTrack::ImportSP(), and L1TMuonEndCapTrackProducer::produce().

{ return (bits * Geom::pi() / 10800) - (22 * Geom::pi() / 180); }

float l1t::calc_pt ( int  bits )

inline

Definition at line 15 of file EMTFTrackTools.h.

Referenced by l1t::EMTFTrack::ImportSP().

{ return (bits - 1) * 0.5;                                  }

int l1t::calc_pt_GMT ( float  val )

inline

Definition at line 16 of file EMTFTrackTools.h.

{ return (val * 2) + 1;                                     }

int l1t::calc_ring	(	int	_station,
		int	_csc_ID,
		int	_strip
	)

Definition at line 140 of file EMTFHitTools.cc.

Referenced by l1t::stage2::emtf::MEBlockUnpacker::unpack().

                                                        {
    if (_station > 1) {
      if      (_csc_ID <  4) return 1;
      else if (_csc_ID < 10) return 2;
      else return -999;
    }
    else if (_station == 1) {
      if      (_csc_ID < 4 && _strip > 127) return 4;
      else if (_csc_ID < 4 && _strip >=  0) return 1;
      else if (_csc_ID > 3 && _csc_ID <  7) return 2;
      else if (_csc_ID > 6 && _csc_ID < 10) return 3;
      else return -999;
    }
    else return -999;
  } // End EMTFHit::calc_ring

int l1t::calc_sector_from_index ( int  index )

inline

Definition at line 33 of file EMTFTrackTools.h.

Referenced by L1TMuonEndCapTrackProducer::produce().

{ return (index < 6) ? index + 1 : index - 5;               }

int l1t::calc_sector_GMT ( int  _sector )

inline

Definition at line 32 of file EMTFTrackTools.h.

Referenced by l1t::EMTFTrack::ImportSP(), and L1TMuonEndCapTrackProducer::produce().

{ return _sector - 1; }

int l1t::calc_subsector ( int  _station, int  _chamber  )

inline

Definition at line 12 of file EMTFHitTools.h.

Referenced by l1t::EMTFHit::ImportCSCCorrelatedLCTDigi().

                                                              {  // Why does emulator have the following csc_ID dependence? - AWB 11.04.16
    if ( _station == 1 ) return ( (_chamber % 6) > 2 ) ? 1 : 2;  // "if(station == 1 && id > 3 && id < 7)" - AWB 11.04.16
    else if ( _station < 0 || _chamber < 0 ) return -999;        // Function works because first 3 chambers in sector 1 are 3/4/5,
    else return -1; }                                            // while the last 3 in sector 6 are 36/1/2

float l1t::calc_theta_deg ( float  _eta )

inline

Definition at line 19 of file EMTFTrackTools.h.

References create_public_lumi_plots::exp, and Geom::pi().

{ return 2*atan( exp(-1*_eta) ) * (180/Geom::pi());         }

float l1t::calc_theta_deg_from_int ( int  _theta_int )

inline

Definition at line 16 of file EMTFHitTools.h.

Referenced by L1TMuonEndCapTrackProducer::produce().

{ return _theta_int * 0.2851562 + 8.5; }

float l1t::calc_theta_rad ( float  _eta )

inline

Definition at line 20 of file EMTFTrackTools.h.

References create_public_lumi_plots::exp.

{ return 2*atan( exp(-1*_eta) );                            }

float l1t::calc_theta_rad_from_int ( int  _theta_int )

inline

Definition at line 17 of file EMTFHitTools.h.

References Geom::pi().

Referenced by L1TMuonEndCapTrackProducer::produce().

{ return (_theta_int * 0.2851562 + 8.5) * (Geom::pi() / 180); }

int l1t::calc_uGMT_chamber	(	int	_csc_ID,
		int	_subsector,
		int	_neighbor,
		int	_station
	)

Definition at line 32 of file EMTFTrackTools.cc.

Referenced by l1t::stage2::emtf::SPBlockUnpacker::unpack().

                                                                                   {
    if (_station == 1) {
      if      ( _csc_ID == 3 && _neighbor == 1 && _subsector == 2 ) return 1;
      else if ( _csc_ID == 6 && _neighbor == 1 && _subsector == 2 ) return 2;
      else if ( _csc_ID == 9 && _neighbor == 1 && _subsector == 2 ) return 3;
      else if ( _csc_ID == 3 && _neighbor == 0 && _subsector == 2 ) return 4;
      else if ( _csc_ID == 6 && _neighbor == 0 && _subsector == 2 ) return 5;
      else if ( _csc_ID == 9 && _neighbor == 0 && _subsector == 2 ) return 6;
      else return 0;
    }
    else {
      if      ( _csc_ID == 3 && _neighbor == 1 ) return 1;
      else if ( _csc_ID == 9 && _neighbor == 1 ) return 2;
      else if ( _csc_ID == 3 && _neighbor == 0 ) return 3;
      else if ( _csc_ID == 9 && _neighbor == 0 ) return 4;
      else return 0;
    }
  }

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

                                          {

    for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
    itJet != input->end(); ++itJet){
      unsigned int pt = itJet->hwPt();
      if(pt > ((1<<10) -1) )
    pt = ((1<<10) -1);
      unsigned int eta = itJet->hwEta();
      if (eta>10){ // LUT is symmetric in eta. For eta>10 map to corresponding eta<10 bin
    int offset=2*(eta-10)-1;
    eta=eta-offset;
      }
      unsigned int lutAddress = (eta<<10)+pt;

      unsigned int rank = params->jetCalibrationLUT()->data(lutAddress);

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
      l1t::Jet outJet(*&ldummy, rank, itJet->hwEta(), itJet->hwPhi(), itJet->hwQual());
      output->push_back(outJet);
    }
  }

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

                                          {

    for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
    itTau != input->end(); ++itTau){
      unsigned int pt = itTau->hwPt();
      if(pt > ((1<<10) -1) )
    pt = ((1<<10) -1);
      unsigned int eta = itTau->hwEta();
      unsigned int lutAddress = (eta<<10)+pt;

      unsigned int rank = params->tauCalibrationLUT()->data(lutAddress);

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);
      l1t::Tau outTau(*&ldummy, rank, itTau->hwEta(), itTau->hwPhi(), itTau->hwQual());
      output->push_back(outTau);
    }
  }

unsigned int l1t::convertFromHexStringToInt

(

const std::string &

aHexString

)

Definition at line 46 of file Tools.cc.

References i, funct::pow(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by convertVariable().

{   
    std::map<std::string, int> hexnums;
    std::string strHexNums("0123456789ABCDEF");
        for(unsigned int i=0; i<strHexNums.size(); i++)
                hexnums[strHexNums.substr(i,1)] = i;
    unsigned int tempNum(0);
        for (unsigned int i=aHexString.size()-1; i>=2; i--)
            tempNum += hexnums[aHexString.substr(i,1)]*pow(16,(aHexString.size()-1-i));
        
    return tempNum;
}

template<class varType >

varType l1t::convertVariable

(

const std::string &

aVar

)

Definition at line 19 of file Tools.h.

References convertFromHexStringToInt(), alignCSCRings::e, cppFunctionSkipper::exception, i, AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, and dumpRecoGeometry_cfg::varType.

{
    varType temp;
    try{
        temp = boost::lexical_cast<varType>(aVar);
    }
    catch (std::exception& e)
    {
        std::map<std::string, int> hexnums;
            std::string strHexNums("0123456789ABCDEFabcdef");
            for(unsigned int i=0; i<strHexNums.size(); i++)
                    hexnums[strHexNums.substr(i,1)] = i;
        if ( aVar.substr(0,2) == "0x" && aVar.substr(2,aVar.size()).find_first_not_of(strHexNums) == std::string::npos)
            temp = convertFromHexStringToInt(aVar);
        else
            throw std::runtime_error(std::string("Method convertVariable error: ") + e.what());
    }

    return temp;
}

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

  {
    int phi1 = region.hwPhi();
    int phi2 = neighbor.hwPhi();
    int diff = phi1 - phi2;
    if (std::abs(phi1 - phi2) == L1CaloRegionDetId::N_PHI-1) { //18 regions in phi
      diff = -diff/std::abs(diff);
    }
    return diff;
  }

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

                                         {

    for(std::vector<l1t::EGamma>::const_iterator itEGamma = input->begin();
    itEGamma != input->end(); ++itEGamma){
      unsigned newEta = gtEta(itEGamma->hwEta());
      unsigned newPhi = itEGamma->hwPhi();
      const uint16_t rankPt = (uint16_t)itEGamma->hwPt(); //max value?

      //hwQual &10 == 10 means that the object came from a sort and is padding
      if((itEGamma->hwQual() & 0x10) == 0x10)
      {
    newEta = 0x0;
    newPhi = 0x0;
      }

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::EGamma gtEGamma(*&ldummy, rankPt, newEta, newPhi,
               itEGamma->hwQual(), itEGamma->hwIso());
      output->push_back(gtEGamma);
    }
  }

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

                                           {
    for(std::vector<l1t::EtSum>::const_iterator itEtSum = input->begin();
    itEtSum != input->end(); ++itEtSum){

      uint16_t rankPt;
      // Hack for now to make sure they come out with the right scale
      //rankPt = params->jetScale().rank((uint16_t)itEtSum->hwPt());
      rankPt = (uint16_t)itEtSum->hwPt();
      if (EtSum::EtSumType::kMissingHt == itEtSum->getType())
      {
    // if(rankPt > params->HtMissScale().linScaleMax()) rankPt = params->HtMissScale().linScaleMax();
    // params->HtMissScale().linScaleMax() always returns zero.  Hardcode 512 for now

    // comment out for mht/ht (already in GT scale)
    //if(rankPt > 512) rankPt = 512;
    //rankPt = params->HtMissScale().rank(rankPt*params->emScale().linearLsb());
      }

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::EtSum gtEtSum(*&ldummy, itEtSum->getType(), rankPt, 0,
             itEtSum->hwPhi(), itEtSum->hwQual());

      output->push_back(gtEtSum);
    }
  }

void l1t::getBXRange	(	int	nbx,
		int &	first,
		int &	last
	)

Definition at line 11 of file UnpackerFactory.cc.

References min().

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

   {
      last = std::floor(nbx / 2.);
      first = std::min(0, -last + (1 - nbx % 2));
   }

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

  {
    unsigned rctEta = (iEta<11 ? 10-iEta : iEta-11);
    return (((rctEta % 7) & 0x7) | (iEta<11 ? 0x8 : 0));
  }

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_25ns10e33_v2_cff::region.

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

  {
    int puLevelHI[L1CaloRegionDetId::N_ETA];

    for(unsigned i = 0; i < L1CaloRegionDetId::N_ETA; ++i)
    {
      puLevelHI[i] = 0;
    }

    for(std::vector<CaloRegion>::const_iterator region = regions.begin();
    region != regions.end(); region++){
      puLevelHI[region->hwEta()] += region->hwPt();
    }

    for(unsigned i = 0; i < L1CaloRegionDetId::N_ETA; ++i)
    {
      //puLevelHI[i] = floor(((double)puLevelHI[i] / (double)L1CaloRegionDetId::N_PHI)+0.5);
      puLevelHI[i] = (puLevelHI[i] + 9) * 455 / (1 << 13); // approx equals X/18 +0.5
    }

    for(std::vector<CaloRegion>::const_iterator region = regions.begin(); region!= regions.end(); region++){
      int subPt = std::max(0, region->hwPt() - puLevelHI[region->hwEta()]);
      int subEta = region->hwEta();
      int subPhi = region->hwPhi();


      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      CaloRegion newSubRegion(*&ldummy, 0, 0, subPt, subEta, subPhi, region->hwQual(), region->hwEtEm(), region->hwEtHad());
      subRegions->push_back(newSubRegion);
    }
  }

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

  {

    for (std::vector<l1t::Jet>::const_iterator uncalibjet = uncalibjets->begin(); uncalibjet != uncalibjets->end(); ++uncalibjet){

      if (jetCalibrationType == "None") {
    l1t::Jet corrjets = *uncalibjet;
    jets->push_back(corrjets);
    continue;
      }

      if (jetCalibrationType == "Stage1JEC") {
    int jetPt = (uncalibjet->hwPt())*jetLSB;  // correction factors are parameterized as functions of physical pt
    int jetPhi = uncalibjet->hwPhi();
    int jetEta = uncalibjet->hwEta();
    int jetQual = uncalibjet->hwQual();
    double jpt = 0.0;

    double alpha = jetCalibrationParams[2*jetEta + 0]; //Scale factor (See jetSF_cfi.py)
    double gamma = ((jetCalibrationParams[2*jetEta + 1])); //Offset

    jpt = jetPt*alpha+gamma;
    unsigned int corjetET =(int) (jpt/jetLSB);

    ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
    l1t::Jet corrjets(*&jetLorentz, corjetET, jetEta, jetPhi, jetQual);

    jets->push_back(corrjets);
      }
    }
  }

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

                                      {

    for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
    itJet != input->end(); ++itJet){
      unsigned newPhi = itJet->hwPhi();
      unsigned newEta = gtEta(itJet->hwEta());

      // jets with hwQual & 10 ==10 are "padding" jets from a sort, set their eta and phi
      // to the max value
      if((itJet->hwQual() & 0x10) == 0x10)
      {
    newEta = 0x0;
    newPhi = 0x0;
      }

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::Jet gtJet(*&ldummy, itJet->hwPt(), newEta, newPhi, itJet->hwQual());
      output->push_back(gtJet);
    }
  }

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

                                      {

    for(std::vector<l1t::Jet>::const_iterator itJet = input->begin();
    itJet != input->end(); ++itJet){
      uint16_t linPt = (uint16_t)itJet->hwPt();
      if(linPt > params->jetScale().linScaleMax() ) linPt = params->jetScale().linScaleMax();
      const uint16_t rankPt = params->jetScale().rank(linPt);

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::Jet gtJet(*&ldummy, rankPt, itJet->hwEta(), itJet->hwPhi(), itJet->hwQual());
      output->push_back(gtJet);
    }
  }

std::string l1t::l1GtBoardTypeEnumToString

(

const L1GtBoardType &

boardType

)

Definition at line 106 of file GlobalDefinitions.cc.

References BoardNull, and mps_fire::result.

                                                                          {
    char const *result= valueToKey(boardType, l1GtBoardTypeStringToEnumMap);
    if (boardType == l1t::BoardNull) {
        edm::LogInfo("L1TGlobal")
                << "\n  l1t::BoardNull means no valid board type defined!";
    }
    if (!result) {
      edm::LogInfo("L1TGlobal") << "\n  '" << boardType
                  << "' is not a recognized l1t::L1GtBoardType. "
                  << "\n  Return l1t::BoardNull, which means no valid board type defined!";
      return "l1t::BoardNull";
    }
    return result;
}

l1t::L1GtBoardType l1t::l1GtBoardTypeStringToEnum

(

const std::string &

label

)

Definition at line 90 of file GlobalDefinitions.cc.

References BoardNull, BoardNull, and relativeConstraints::value.

                                                                      {
    l1t::L1GtBoardType value = keyToValue(label.c_str(), l1GtBoardTypeStringToEnumMap);
    if (value == (l1t::L1GtBoardType) - 1) {
        edm::LogInfo("L1TGlobal") << "\n  '" << label
                << "' is not a recognized l1t::L1GtBoardType. \n  Return l1t::BoardNull.";
        value = l1t::BoardNull;
    }

    if (value == l1t::BoardNull) {
        edm::LogInfo("L1TGlobal")
                << "\n  l1t::BoardNull means no valid board type defined!";
    }

    return value;
}

std::string l1t::l1GtConditionCategoryEnumToString

(

const GtConditionCategory &

conditionCategory

)

Definition at line 178 of file GlobalDefinitions.cc.

References CondNull, and mps_fire::result.

                                                                                                {
  char const *result = valueToKey(conditionCategory, l1GtConditionCategoryStringToEnumMap);
  if (conditionCategory == l1t::CondNull)
    edm::LogInfo("L1TGlobal")
            << "\n  Return l1t::CondNull, which means no valid condition category defined!";
    
  if (!result) {
    result = "l1t::CondNull";
    edm::LogInfo("L1TGlobal") << "\n  '" << conditionCategory
            << "' is not a recognized l1t::GtConditionCategory. "
            << "\n  Return l1t::CondNull, which means no valid condition category defined!";
  }

  return result;
}

l1t::GtConditionCategory l1t::l1GtConditionCategoryStringToEnum

(

const std::string &

label

)

Definition at line 159 of file GlobalDefinitions.cc.

References CondNull, CondNull, and relativeConstraints::value.

                                                                                    {
  l1t::GtConditionCategory value = keyToValue(label.c_str(), l1GtConditionCategoryStringToEnumMap);
  // in case of unrecognized l1t::GtConditionCategory, return l1t::CondNull
  // to be dealt by the corresponding module
  if (value == (l1t::GtConditionCategory) -1) {
    edm::LogInfo("L1TGlobal") << "\n  '" << label
            << "' is not a recognized l1t::GtConditionCategory. \n  Return l1t::CondNull.";

    value = l1t::CondNull;
  }

  if (value == l1t::CondNull) {
      edm::LogInfo("L1TGlobal")
              << "\n  l1t::CondNull means no valid condition category defined!";
  }

  return value;
}

std::string l1t::l1GtConditionTypeEnumToString

(

const GtConditionType &

conditionType

)

Definition at line 145 of file GlobalDefinitions.cc.

References mps_fire::result, and TypeNull.

                                                                                    {
  const char *result = valueToKey(conditionType, l1GtConditionTypeStringToEnumMap);
  if (conditionType == l1t::TypeNull)
    edm::LogInfo("L1TGlobal") 
      << "\n  Return l1t::TypeNull, which means no valid condition type defined!";
  if (!result) {
    result = "l1t::TypeNull";
    edm::LogInfo("L1TGlobal") << "\n  '" << conditionType
            << "' is not a recognized l1t::GtConditionType. "
            << "\n  Return l1t::TypeNull, which means no valid condition type defined!";
  }
  return result;
}

l1t::GtConditionType l1t::l1GtConditionTypeStringToEnum

(

const std::string &

label

)

Definition at line 125 of file GlobalDefinitions.cc.

References TypeNull, TypeNull, and relativeConstraints::value.

                                                                            {
    l1t::GtConditionType value = keyToValue(label.c_str(), l1GtConditionTypeStringToEnumMap);

    // in case of unrecognized l1t::GtConditionType, return l1t::TypeNull
    // to be dealt by the corresponding module
    if (value == (l1t::GtConditionType) -1) {
        edm::LogInfo("L1TGlobal")  << "\n  '" << label
                << "' is not a recognized l1t::GtConditionType. \n  Return l1t::TypeNull.";

        value = l1t::TypeNull;
    }

    if (value == l1t::TypeNull) {
        edm::LogInfo("L1TGlobal")
                << "\n  l1t::TypeNull means no valid condition type defined!";
    }

    return value;
}

std::string l1t::l1TGtObjectEnumToString

(

const GlobalObject &

gtObject

)

Definition at line 78 of file GlobalObject.cc.

References gtEG, gtETM, gtETMHF, gtETT, gtETTem, gtExternal, gtHTM, gtHTT, gtJet, gtMinBiasHFM0, gtMinBiasHFM1, gtMinBiasHFP0, gtMinBiasHFP1, gtMu, gtTau, gtTowerCount, ObjNull, and AlCaHLTBitMon_QueryRunRegistry::string.

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

                                                                   {

    std::string gtObjectString;

    switch (gtObject) {

        case gtMu: {
            gtObjectString = "Mu";
        }
            break;

        case gtEG: {
            gtObjectString = "EG";
        }
            break;

        case gtTau: {
            gtObjectString = "Tau";
        }
            break;

        case gtJet: {
            gtObjectString = "Jet";
        }
            break;

        case gtETM: {
            gtObjectString = "ETM";
        }
            break;

        case gtETT: {
            gtObjectString = "ETT";
        }
            break;

        case gtHTT: {
            gtObjectString = "HTT";
        }
            break;

        case gtHTM: {
            gtObjectString = "HTM";
        }
            break;

        case gtETMHF: {
            gtObjectString = "ETMHF";
        }
            break;

        case gtTowerCount: {
            gtObjectString = "TowerCount";
        }
            break;

        case gtMinBiasHFP0: {
            gtObjectString = "MinBiasHFP0";
        }
            break;

        case gtMinBiasHFM0: {
            gtObjectString = "MinBiasHFM0";
        }
            break;

        case gtMinBiasHFP1: {
            gtObjectString = "MinBiasHFP1";
        }
            break;

        case gtMinBiasHFM1: {
            gtObjectString = "MinBiasHFM1";
        }
            break;

        case gtETTem: {
            gtObjectString = "ETTem";
        }
            break;

        case gtExternal: {
            gtObjectString = "External";
        }
            break;

        case ObjNull: {
            gtObjectString = "ObjNull";
            edm::LogInfo("L1TGlobal")
                    << "\n  ObjNull means no valid GlobalObject defined!";
        }
            break;

        default: {
            edm::LogInfo("L1TGlobal") << "\n  '" << gtObject
                    << "' is not a recognized GlobalObject. "
                    << "\n  Return ObjNull, which means no valid GlobalObject defined!";

            gtObjectString = "ObjNull";

        }
            break;
    }

    return gtObjectString;

}

l1t::GlobalObject l1t::l1TGtObjectStringToEnum

(

const std::string &

)

Definition at line 27 of file GlobalObject.cc.

References newFWLiteAna::found, gtEG, gtETM, gtETMHF, gtETT, gtETTem, gtExternal, gtHTM, gtHTT, gtJet, gtMinBiasHFM0, gtMinBiasHFM1, gtMinBiasHFP0, gtMinBiasHFP1, gtMu, gtTau, gtTowerCount, i, l1t::L1TGtObjectStringToEnum::label, ObjNull, l1t::L1TGtObjectStringToEnum::value, and relativeConstraints::value.

                                                                {

     
    
    static const l1t::L1TGtObjectStringToEnum l1TGtObjectStringToEnumMap[] = {
            {"Mu",  gtMu},
            {"EG",  gtEG},
        {"Tau", gtTau},
            {"Jet", gtJet},
            {"ETM", gtETM},
            {"ETT", gtETT},
            {"HTT", gtHTT},
            {"HTM", gtHTM},
        {"ETMHF", gtETMHF},
        {"TowerCount",gtTowerCount},
        {"MinBiasHFP0", gtMinBiasHFP0},
        {"MinBiasHFM0", gtMinBiasHFM0},
        {"MinBiasHFP1", gtMinBiasHFP1},
        {"MinBiasHFM1", gtMinBiasHFM1},
        {"ETTem", gtETTem},
            {"External", gtExternal},
            {"ObjNull", ObjNull},
            {0, (GlobalObject) - 1}
    };

    l1t::GlobalObject value = (GlobalObject) - 1;

    bool found = false;
    for (int i = 0; l1TGtObjectStringToEnumMap[i].label && (!found); ++i)
        if (!std::strcmp(label.c_str(), l1TGtObjectStringToEnumMap[i].label)) {
            found = true;
            value = l1TGtObjectStringToEnumMap[i].value;
        }

    // in case of unrecognized GlobalObject, returns Mu
    // and write a warning (to not throw an exception)
    if (!found) {
        edm::LogInfo("L1TGlobal") << "\n  '" << label
                << "' is not a recognized GlobalObject. \n  Return ObjNull.";

        value = ObjNull;
    }

    if (value == ObjNull) {
        edm::LogInfo("L1TGlobal")
                << "\n  ObjNull means no valid GlobalObject defined!";
    }

    return value;
}

std::ostream & l1t::operator<<	(	std::ostream &	os,
		const l1t::CaloParamsHelper &	p
	)

Definition at line 17 of file CaloParamsHelper.cc.

                                                                       {
    return os << "CaloParamsHelper...";
  }

bool l1t::operator>	(	const l1t::Tau &	a,
		const l1t::Tau &	b
	)

Definition at line 16 of file Stage2Layer2TauAlgorithmFirmwareImp1.cc.

References reco::LeafCandidate::pt().

  {
    return a.pt() > b.pt();
  }

bool l1t::operator>	(	const l1t::EGamma &	a,
		const l1t::EGamma &	b
	)

Definition at line 18 of file Stage2Layer2EGammaAlgorithmFirmwareImp1.cc.

References reco::LeafCandidate::pt().

  {
      return a.pt() > b.pt();
  }

bool l1t::operator> ( l1t::EGamma &  a, l1t::EGamma &  b  )

inline

Definition at line 18 of file Stage2Layer2DemuxEGAlgoFirmwareImp1.cc.

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

  {
    if ( a.pt() == b.pt() ){
      if( a.hwPhi() == b.hwPhi() ){
    return a.hwEta() > b.hwEta();
      }
      else{
      return a.hwPhi() > b.hwPhi();   
    }

    }
    else{
    return a.pt() > b.pt();
      }
  }

bool l1t::operator> ( l1t::Tau &  a, l1t::Tau &  b  )

inline

Definition at line 18 of file Stage2Layer2DemuxTauAlgoFirmwareImp1.cc.

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

  {
    if ( a.pt() == b.pt() ){
      if( a.hwPhi() == b.hwPhi() ){
    return a.hwEta() > b.hwEta();
      }
      else{
      return a.hwPhi() > b.hwPhi();   
    }

    }
    else{
    return a.pt() > b.pt();
      }
  }

bool l1t::operator>	(	const l1t::Jet &	a,
		l1t::Jet &	b
	)

Definition at line 22 of file Stage2Layer2JetAlgorithmFirmwareImp1.cc.

References l1t::L1Candidate::hwPt().

                                                 {
    return  a.hwPt() > b.hwPt();
  }

unsigned int l1t::pack15bits	(	int	pt,
		int	eta,
		int	phi
	)

Definition at line 19 of file HardwareSortingMethods.cc.

  {
    return( ((pt & 0x3f)) + ((eta & 0xf) << 6) + ((phi & 0x1f) << 10));
  }

unsigned int l1t::pack16bits	(	int	pt,
		int	eta,
		int	phi
	)

Definition at line 24 of file HardwareSortingMethods.cc.

  {
    return( 0x8000 + ((pt & 0x3f)) + ((eta & 0xf) << 6) + ((phi & 0x1f) << 10));
  }

unsigned int l1t::pack16bitsEgammaSpecial	(	int	pt,
		int	eta,
		int	phi
	)

Definition at line 29 of file HardwareSortingMethods.cc.

  {
    return( 0x8000 + ((pt & 0x3f) << 9) + ((eta & 0xf)) + ((phi & 0x1f) << 4));
  }

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_25ns10e33_v2_cff::region.

  {
    for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
      int jetQual = 0;
      if( region->hwEta() < 4 || region->hwEta() > 17)
    jetQual = 2;
      int jetET = region->hwPt();
      int jetEta = region->hwEta();
      int jetPhi = region->hwPhi();

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
      l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
      uncalibjets->push_back(theJet);
    }
  }

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

  {

    std::string regionPUSType = params->regionPUSType();

    if(regionPUSType == "None") {
      for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
      notCorrectedRegion != regions.end(); notCorrectedRegion++){
    CaloRegion newSubRegion= *notCorrectedRegion;
    subRegions->push_back(newSubRegion);
      }
    }

    if (regionPUSType == "HICaloRingSub") {
      HICaloRingSubtraction(regions, subRegions, params);
    }

    if (regionPUSType == "PUM0") {
      int puMult = 0;

      // ------------ This calulates PUM0 ------------------
      for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
      notCorrectedRegion != regions.end(); notCorrectedRegion++){
    int regionET = notCorrectedRegion->hwPt();
    if (regionET > 0) {puMult++;}
      }
      int pumbin = (int) puMult/22;
      if(pumbin == 18) pumbin = 17; // if puMult = 396 exactly there is an overflow

      for(std::vector<CaloRegion>::const_iterator notCorrectedRegion = regions.begin();
      notCorrectedRegion != regions.end(); notCorrectedRegion++){

    int regionET = notCorrectedRegion->hwPt();
    int regionEta = notCorrectedRegion->hwEta();
    int regionPhi = notCorrectedRegion->hwPhi();

    //int puSub = ceil(regionPUSParams[18*regionEta+pumbin]*2);
    int puSub = params->regionPUSValue(pumbin, regionEta);
    // The values in regionSubtraction are MULTIPLIED by
    // RegionLSB=.5 (physicalRegionEt), so to get back unmultiplied
    // regionSubtraction we want to multiply the number by 2
    // (aka divide by LSB).

    int regionEtCorr = std::max(0, regionET - puSub);
    if(regionET == 1023)
      regionEtCorr = 1023; // do not subtract overflow regions
    if((regionET==255) && (regionEta < 4 || regionEta > 17))
      regionEtCorr = 255;

    ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > lorentz(0,0,0,0);
    CaloRegion newSubRegion(*&lorentz, 0, 0, regionEtCorr, regionEta, regionPhi, notCorrectedRegion->hwQual(), notCorrectedRegion->hwEtEm(), notCorrectedRegion->hwEtHad());
    subRegions->push_back(newSubRegion);
      }
    }
  }

void l1t::simpleHWSubtraction	(	const std::vector< l1t::CaloRegion > &	regions,
		std::vector< l1t::CaloRegion > *	subRegions
	)

Definition at line 54 of file PUSubtractionMethods.cc.

References HLT_25ns10e33_v2_cff::region.

  {
    for(std::vector<CaloRegion>::const_iterator region = regions.begin();
    region != regions.end(); region++){
      int subEta = region->hwEta();
      int subPhi = region->hwPhi();
      int subPt = region->hwPt();

      if(subPt != (2<<10)-1)
    subPt = subPt - (10+subEta); // arbitrary value chosen in meeting
      if(subPt < 0)
    subPt = 0;
      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      CaloRegion newSubRegion(*&ldummy, 0, 0, subPt, subEta, subPhi, region->hwQual(), region->hwEtEm(), region->hwEtHad());
      subRegions->push_back(newSubRegion);
    }
  }

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, neighbor(), and HLT_25ns10e33_v2_cff::region.

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

  {
    for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
      int regionET = region->hwPt(); //regionPhysicalEt(*region);
      if (regionET  <= jetSeedThreshold) continue;
      int neighborN_et = 0;
      int neighborS_et = 0;
      int neighborE_et = 0;
      int neighborW_et = 0;
      int neighborNE_et = 0;
      int neighborSW_et = 0;
      int neighborNW_et = 0;
      int neighborSE_et = 0;
      unsigned int nNeighbors = 0;
      for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
    int neighborET = neighbor->hwPt(); //regionPhysicalEt(*neighbor);
    if(deltaGctPhi(*region, *neighbor) == 1 &&
       (region->hwEta()    ) == neighbor->hwEta()) {
      neighborN_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta()    ) == neighbor->hwEta()) {
      neighborS_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborNE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborSW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborNW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborSE_et = neighborET;
      nNeighbors++;
      continue;
    }
      }
      if(regionET > neighborN_et &&
     regionET > neighborNW_et &&
     regionET > neighborW_et &&
     regionET > neighborSW_et &&
     regionET >= neighborNE_et &&
     regionET >= neighborE_et &&
     regionET >= neighborSE_et &&
     regionET >= neighborS_et) {
    unsigned int jetET = regionET +
      neighborN_et + neighborS_et + neighborE_et + neighborW_et +
      neighborNE_et + neighborSW_et + neighborSE_et + neighborNW_et;

    int jetPhi = region->hwPhi();
    int jetEta = region->hwEta();

    bool neighborCheck = (nNeighbors == 8);
    // On the eta edge we only expect 5 neighbors
    if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
      neighborCheck = true;

    if (!neighborCheck) {
      std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
      assert(false);
    }

    //first iteration, eta cut defines forward
    //const bool forward = (jetEta <= 4 || jetEta >= 17);
    const bool forward = (jetEta < 4 || jetEta > 17);
    int jetQual = 0;
    if(forward)
      jetQual |= 0x2;

    // check for input overflow regions
    if(forward && regionET == 255) {
      jetET = 1023; // 10 bit max
    } else if(!forward && regionET == 1023) {
      jetET = 1023; // 10 bit max
    } else if(region->hwEta() == 17) {
      if(neighborNE_et == 255 || neighborE_et == 255 || neighborSE_et == 255)
        jetET = 1023; // 10 bit max
    } else if(region->hwEta() == 4) {
      if(neighborNW_et == 255 || neighborW_et == 255 || neighborSW_et == 255)
        jetET = 1023; // 10 bit max
    }

    ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
    l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
    //l1t::Jet theJet(0, jetET, jetEta, jetPhi);

    uncalibjets->push_back(theJet);
      }
    }
  }

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

  {
    //Initialize
    const int FIBER_PAIRS = 18;
    const int N_INPUT_EGAMMAS = 4;
    const int N_PRESORTED_ROWS_EGAMMA = 36;
    const int PRESORT_DEPTH = 4;
    const int N_EGAMMA_FIRST_GROUP_SIZE = 6;
    const int N_EGAMMA_SECOND_GROUP_SIZE = 6;
    const int N_EGAMMA_FIRST_GROUPS = 6;
    const int N_KEEP_EGAMMA = 4;

    //Input
    //Each egamma: RCT isolation, RCT order, phi index, eta index

    vector<l1t::L1Candidate> iso_egamma_array_p, iso_egamma_array_m; //reusing objects.  should probably rename to something like "object"
    vector<l1t::L1Candidate> noniso_egamma_array_p, noniso_egamma_array_m;

    for(int k=0; k<2*N_INPUT_EGAMMAS*FIBER_PAIRS; k++){
      l1t::L1Candidate dummyJet;
      dummyJet.setHwPt(0);
      dummyJet.setHwEta(99);
      dummyJet.setHwPhi(99);
      dummyJet.setHwQual(0x10);
      if(k<N_INPUT_EGAMMAS*FIBER_PAIRS){
    iso_egamma_array_p.push_back(dummyJet);
    noniso_egamma_array_p.push_back(dummyJet);
      }
      else{
    iso_egamma_array_m.push_back(dummyJet);
    noniso_egamma_array_m.push_back(dummyJet);
      }
    }

    for (std::vector<l1t::EGamma>::const_iterator ineg = input->begin();
     ineg != input->end(); ++ineg){
      int fiberNum = (int) floor(gt_to_fw_phi_map[ineg->hwPhi()]/2);
      int index = ineg->hwQual();
      bool iso = ineg->hwIso();
      bool minus = (ineg->hwEta() < 11);

      // while waiting for firmware LUT, set all iso to true
      //iso = true;

      if(iso && minus)
    iso_egamma_array_m[8*fiberNum+index] = *ineg;
      else if (iso && !minus)
    iso_egamma_array_p[8*fiberNum+index] = *ineg;
      else if (!iso && minus)
    noniso_egamma_array_m[8*fiberNum+index] = *ineg;
      else if (!iso && !minus)
    noniso_egamma_array_p[8*fiberNum+index] = *ineg;

    }

    // std::cout << "iso_egamma_array_m" << std::endl;
    // for(int i = 0; i < (int)iso_egamma_array_m.size(); ++i)
    // {
    //   std::cout << iso_egamma_array_m[i].hwPt() << " "
    //     << iso_egamma_array_m[i].hwEta() << " "
    //     << iso_egamma_array_m[i].hwPhi() << std::endl;
    // }

    // std::cout << "iso_egamma_array_p" << std::endl;
    // for(int i = 0; i < (int)iso_egamma_array_p.size(); ++i)
    // {
    //   std::cout << iso_egamma_array_p[i].hwPt() << " "
    //     << iso_egamma_array_p[i].hwEta() << " "
    //     << iso_egamma_array_p[i].hwPhi() << std::endl;
    // }

    //verbose = true;
    //1
    std::vector<std::vector<l1t::L1Candidate> > presorted_iso_matrix_sig_p = presort_egamma(iso_egamma_array_p, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
    std::vector<std::vector<l1t::L1Candidate> > presorted_iso_matrix_sig_m = presort_egamma(iso_egamma_array_m, N_PRESORTED_ROWS_EGAMMA/2, PRESORT_DEPTH);
    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);
    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);

    //2
    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);
    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);
    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);
    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);

    //3
    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);
    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);
    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);
    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);
    //combine plus and minus
    std::vector<std::vector<l1t::L1Candidate> > iso_super_sorted_energies_matrix_sig (N_EGAMMA_FIRST_GROUPS, std::vector<l1t::L1Candidate>(N_KEEP_EGAMMA) );
    std::vector<std::vector<l1t::L1Candidate> > non_iso_super_sorted_energies_matrix_sig (N_EGAMMA_FIRST_GROUPS, std::vector<l1t::L1Candidate>(N_KEEP_EGAMMA) );
    for(int r=0; r<N_EGAMMA_FIRST_GROUPS/2; r++){
      iso_super_sorted_energies_matrix_sig[r] = iso_super_sorted_energies_matrix_sig_m[r];
      iso_super_sorted_energies_matrix_sig[r+N_EGAMMA_FIRST_GROUPS/2] = iso_super_sorted_energies_matrix_sig_p[r];
      non_iso_super_sorted_energies_matrix_sig[r] = non_iso_super_sorted_energies_matrix_sig_m[r];
      non_iso_super_sorted_energies_matrix_sig[r+N_EGAMMA_FIRST_GROUPS/2] = non_iso_super_sorted_energies_matrix_sig_p[r];
    }

    //4
    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);
    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);

    //5
    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);
    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);

    //Prepare output
    std::vector<l1t::L1Candidate> sorted_iso_egammas = iso_stage2_super_sorted_matrix_sig[0];
    std::vector<l1t::L1Candidate> sorted_noniso_egammas = non_iso_stage2_super_sorted_matrix_sig[0];

    //verbose = false;

    for(unsigned int i = 0; i < 4; ++i)
    {
      l1t::EGamma *ineg = static_cast<l1t::EGamma *>( &sorted_iso_egammas[i] );
      ineg->setHwIso(1);
      output->push_back(*ineg);
    }
    for(unsigned int i = 0; i < 4; ++i)
    {
      l1t::EGamma *ineg = static_cast<l1t::EGamma *>( &sorted_noniso_egammas[i] );
      output->push_back(*ineg);
    }
  }

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

                                   {
    //verbose = true;
    const int CENTRAL_ETA_SLICES = 14;
    const int N_PHI_GROUPS = 5;
    const int N_PRESORTED_ROWS_CENTRAL = CENTRAL_ETA_SLICES*N_PHI_GROUPS;
    const int PRESORT_DEPTH = 4;
    const int N_KEEP_CENTRAL = 4;
    const int N_ETA_GROUP_SIZE_CENTRAL = 4;
    const int N_ETA_GROUPS_CENTRAL = 4;

    const int HFM_ETA_SLICES = 4;
    const int HFP_ETA_SLICES = 4;
    const int N_PRESORTED_ROWS_HFM = HFM_ETA_SLICES*N_PHI_GROUPS;
    const int N_PRESORTED_ROWS_HFP = HFP_ETA_SLICES*N_PHI_GROUPS;
    const int N_KEEP_FORWARD = 4;

    const int cen_nrows = 18;
    const int cen_ncols = 14;
    const int hfm_nrows = 18, hfp_nrows = 18;
    const int hfm_ncols = 4, hfp_ncols = 4;

    std::vector<std::vector<l1t::L1Candidate> > cen_input_energy (cen_nrows, std::vector<l1t::L1Candidate>(cen_ncols));
    std::vector<std::vector<l1t::L1Candidate> > hfm_input_energy (hfm_nrows, std::vector<l1t::L1Candidate>(hfm_ncols));
    std::vector<std::vector<l1t::L1Candidate> > hfp_input_energy (hfp_nrows, std::vector<l1t::L1Candidate>(hfp_ncols));

    for (std::vector<l1t::Jet>::const_iterator injet = input->begin();
     injet != input->end(); ++injet){
      if(injet->hwEta() >= 4 && injet->hwEta() <= 17 )
      {
    unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
    unsigned int mycol = injet->hwEta()-4; //hardcoding is bad
    cen_input_energy[myrow][mycol] = *injet;
      }
      else if(injet->hwEta() < 4)
      {
    unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
    unsigned int mycol = injet->hwEta(); //hardcoding is bad
    hfm_input_energy[myrow][mycol] = *injet;
      }
      else if(injet->hwEta() > 17)
      {
    unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
    unsigned int mycol = injet->hwEta()-18; //hardcoding is bad
    hfp_input_energy[myrow][mycol] = *injet;
      }
      else
    edm::LogError("HardwareJetSort") << "Region out of bounds: " << injet->hwEta();
    }

    for(int i = 0; i < cen_nrows; ++i)
      for(int j = 0; j < cen_ncols; ++j)
      {
    if(cen_input_energy[i][j].hwPt() == 0)
    {
      cen_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
      cen_input_energy[i][j].setHwEta(4+j);
    }
      }

    for(int i = 0; i < hfm_nrows; ++i)
      for(int j = 0; j < hfm_ncols; ++j)
      {
    if(hfm_input_energy[i][j].hwPt() == 0)
    {
      hfm_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
      hfm_input_energy[i][j].setHwEta(j);
      hfm_input_energy[i][j].setHwQual(2);
    }
      }

    for(int i = 0; i < hfp_nrows; ++i)
      for(int j = 0; j < hfp_ncols; ++j)
      {
    if(hfp_input_energy[i][j].hwPt() == 0)
    {
      hfp_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
      hfp_input_energy[i][j].setHwEta(j+18);
      hfp_input_energy[i][j].setHwQual(2);
    }
      }

    //Each CLK is one clock

    //CLK 1
    std::vector<std::vector<l1t::L1Candidate> > presorted_energies_matrix_sig = presort(cen_input_energy, N_PRESORTED_ROWS_CENTRAL, PRESORT_DEPTH);
    std::vector<std::vector<l1t::L1Candidate> > hfm_presorted_energies_matrix_sig = presort(hfm_input_energy, N_PRESORTED_ROWS_HFM, PRESORT_DEPTH);
    std::vector<std::vector<l1t::L1Candidate> > hfp_presorted_energies_matrix_sig = presort(hfp_input_energy, N_PRESORTED_ROWS_HFP, PRESORT_DEPTH);

    //CLK 2
    std::vector<std::vector<l1t::L1Candidate> > row_presorted_energies_matrix_sig = sort_by_row_in_groups(presorted_energies_matrix_sig, N_PHI_GROUPS);
    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);
    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);

    //CLK 3
    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);
    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);
    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);

    //CLK 4
    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);
    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);
    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);

    //CLK 5
    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);
    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);
    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);

    //CLK 6
    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);
    std::vector<std::vector<l1t::L1Candidate> > hf_merged_plus_minus_forward_energies_matrix_sig(2, std::vector<l1t::L1Candidate>(N_KEEP_FORWARD));
    hf_merged_plus_minus_forward_energies_matrix_sig[0] = hfm_sorted_final_energies_matrix_sig[0];
    hf_merged_plus_minus_forward_energies_matrix_sig[1] = hfp_sorted_final_energies_matrix_sig[0];
    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);

    //CLK 7
    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);
    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);

    for(unsigned int i = 0; i < 4; ++i)
    {
      l1t::Jet *intjet = static_cast<l1t::Jet *>( &sorted_final_energies_matrix_sig[0][i] );
      output->push_back(*intjet);
    }
    for(unsigned int i = 0; i < 4; ++i)
    {
      l1t::Jet *intjet = static_cast<l1t::Jet *>( &hf_sorted_final_merged_plus_minus_forward_energies_matrix_sig[0][i] );
      intjet->setHwQual(intjet->hwQual() | 2);
      output->push_back(*intjet);
    }
    //verbose = false;
  }

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

                                   {
    const int CENTRAL_ETA_SLICES = 14;
    const int N_PHI_GROUPS = 5;
    const int N_PRESORTED_ROWS_CENTRAL = CENTRAL_ETA_SLICES*N_PHI_GROUPS;
    const int PRESORT_DEPTH = 4;
    const int N_KEEP_CENTRAL = 4;
    const int N_ETA_GROUP_SIZE_CENTRAL = 4;
    const int N_ETA_GROUPS_CENTRAL = 4;

    const int cen_nrows = 18;
    const int cen_ncols = 14;

    std::vector<std::vector<l1t::L1Candidate> > cen_input_energy (cen_nrows, std::vector<l1t::L1Candidate>(cen_ncols));

    for (std::vector<l1t::Tau>::const_iterator injet = input->begin();
     injet != input->end(); ++injet){
      if(injet->hwEta() >= 4 && injet->hwEta() <= 17 )
      {
    unsigned int myrow = gt_to_fw_phi_map[injet->hwPhi()];
    unsigned int mycol = injet->hwEta()-4; //hardcoding is bad
    cen_input_energy[myrow][mycol] = *injet;
      }
      else
    edm::LogError("HardwareTauSort") << "Region out of bounds: " << injet->hwEta();
    }

    for(int i = 0; i < cen_nrows; ++i)
      for(int j = 0; j < cen_ncols; ++j)
      {
    if(cen_input_energy[i][j].hwPt() == 0)
    {
      cen_input_energy[i][j].setHwPhi(fw_to_gt_phi_map[i]);
      cen_input_energy[i][j].setHwEta(4+j);
    }
      }

    //Each CLK is one clock

    //CLK 1
    std::vector<std::vector<l1t::L1Candidate> > presorted_energies_matrix_sig = presort(cen_input_energy, N_PRESORTED_ROWS_CENTRAL, PRESORT_DEPTH);
    //CLK 2
    std::vector<std::vector<l1t::L1Candidate> > row_presorted_energies_matrix_sig = sort_by_row_in_groups(presorted_energies_matrix_sig, N_PHI_GROUPS);
    //CLK 3
    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);
    //CLK 4
    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);
    //CLK 5
    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);
    //CLK 6
    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);
    //CLK 7
    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);

    for(unsigned int i = 0; i < 4; ++i)
    {
      l1t::Tau *intjet = static_cast<l1t::Tau *>( &sorted_final_energies_matrix_sig[0][i] );
      output->push_back(*intjet);
    }
  }

std::vector< std::string > l1t::str2VecStr_	(	const std::string &	aStr,
		const std::string &	delim
	)

Definition at line 23 of file Tools.cc.

References full, and dumpparser::parse().

Referenced by l1t::Setting::addTableRow(), l1t::TrigSystem::checkIdExistsAndSetSetting_(), l1t::Setting::getVector(), l1t::Setting::Setting(), and l1t::Setting::setValue().

{
        std::vector<std::string> aVec;

        if ( !parse ( aStr.c_str(),
        (
                  (  (*(boost::spirit::classic::anychar_p - delim.c_str() )) [boost::spirit::classic::push_back_a ( aVec ) ] % delim.c_str() )
        ), boost::spirit::classic::nothing_p ).full )
        {
                throw std::runtime_error ("Wrong value format: " + aStr);
        }

        for(auto it = aVec.begin(); it != aVec.end(); ++it)
        {
                while (*(it->begin()) == ' ' || *(it->begin()) == '\n')
                        it->erase(it->begin());
                while (*(it->end()-1) == ' ' || *(it->end()-1) == '\n')
            it->erase(it->end()-1);
        }

        return aVec;
}

void l1t::str2VecStr_	(	const std::string &	aStr,
		const std::string &	delim,
		std::vector< std::string > &	aVec
	)

Definition at line 4 of file Tools.cc.

References full, and dumpparser::parse().

{
        if ( !parse ( aStr.c_str(),
        (
                  (  (*(boost::spirit::classic::anychar_p - delim.c_str() )) [boost::spirit::classic::push_back_a ( aVec ) ] % delim.c_str() )
        ), boost::spirit::classic::nothing_p ).full )
        {
                throw std::runtime_error ("Wrong value format: " + aStr);
        }

        for(auto it = aVec.begin(); it != aVec.end(); ++it)
        {
                while (*(it->begin()) == ' ' || *(it->begin()) == '\n')
                        it->erase(it->begin());
                while (*(it->end()-1) == ' ' || *(it->end()-1) == '\n')
            it->erase(it->end()-1);
        }
}

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

                                      {
    for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
    itTau != input->end(); ++itTau){
      unsigned newPhi = itTau->hwPhi();
      unsigned newEta = gtEta(itTau->hwEta());

      // taus with hwQual & 10 ==10 are "padding" jets from a sort, set their eta and phi
      // to the max value
      if((itTau->hwQual() & 0x10) == 0x10)
      {
    newEta = 0x0;
    newPhi = 0x0;
      }


      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::Tau gtTau(*&ldummy, itTau->hwPt(), newEta, newPhi, itTau->hwQual(), itTau->hwIso());
      output->push_back(gtTau);
    }
  }

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

                                         {
    for(std::vector<l1t::Tau>::const_iterator itTau = input->begin();
    itTau != input->end(); ++itTau){
      uint16_t linPt = (uint16_t)itTau->hwPt();
      if(linPt > params->jetScale().linScaleMax() ) linPt = params->jetScale().linScaleMax();
      const uint16_t rankPt = params->jetScale().rank(linPt);

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > ldummy(0,0,0,0);

      l1t::Tau gtTau(*&ldummy, rankPt, itTau->hwEta(), itTau->hwPhi(), itTau->hwQual(), itTau->hwIso());
      output->push_back(gtTau);
    }
  }

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, neighbor(), and HLT_25ns10e33_v2_cff::region.

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

  {
    for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
      int regionET = region->hwPt(); //regionPhysicalEt(*region);
      if (regionET  < jetSeedThreshold) continue;
      int neighborN_et = 0;
      int neighborS_et = 0;
      int neighborE_et = 0;
      int neighborW_et = 0;
      int neighborNE_et = 0;
      int neighborSW_et = 0;
      int neighborNW_et = 0;
      int neighborSE_et = 0;
      unsigned int nNeighbors = 0;
      for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
    int neighborET = neighbor->hwPt(); //regionPhysicalEt(*neighbor);
    if(deltaGctPhi(*region, *neighbor) == 1 &&
       (region->hwEta()    ) == neighbor->hwEta()) {
      neighborN_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta()    ) == neighbor->hwEta()) {
      neighborS_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborNE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborSW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborNW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborSE_et = neighborET;
      nNeighbors++;
      continue;
    }
      }
      unsigned int jetET = regionET +
    neighborN_et + neighborS_et + neighborE_et + neighborW_et +
    neighborNE_et + neighborSW_et + neighborSE_et + neighborNW_et;

      int jetPhi = region->hwPhi();
      int jetEta = region->hwEta();

      bool neighborCheck = (nNeighbors == 8);
      // On the eta edge we only expect 5 neighbors
      if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
    neighborCheck = true;

      if (!neighborCheck) {
    std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
    assert(false);
      }

      //first iteration, eta cut defines forward
      //const bool forward = (jetEta <= 4 || jetEta >= 17);
      const bool forward = (jetEta < 4 || jetEta > 17);
      int jetQual = 0;
      if(forward)
    jetQual |= 0x2;

      ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
      l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
      //l1t::Jet theJet(0, jetET, jetEta, jetPhi);

      uncalibjets->push_back(theJet);
    }
  }

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, neighbor(), and HLT_25ns10e33_v2_cff::region.

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

  {
    for(std::vector<CaloRegion>::const_iterator region = regions->begin(); region != regions->end(); region++) {
      int regionET = region->hwPt();
      if (regionET  <= jetSeedThreshold) continue;
      int subEta = region->hwEta();
      if((etaMask & (1<<subEta))>>subEta) regionET = 0;
      int neighborN_et = 0;
      int neighborS_et = 0;
      int neighborE_et = 0;
      int neighborW_et = 0;
      int neighborNE_et = 0;
      int neighborSW_et = 0;
      int neighborNW_et = 0;
      int neighborSE_et = 0;
      unsigned int nNeighbors = 0;
      for(std::vector<CaloRegion>::const_iterator neighbor = regions->begin(); neighbor != regions->end(); neighbor++) {
    int neighborET = neighbor->hwPt();
    int subEta2 = neighbor->hwEta();
    if((etaMask & (1<<subEta2))>>subEta2) neighborET = 0;

    if(deltaGctPhi(*region, *neighbor) == 1 &&
       (region->hwEta()    ) == neighbor->hwEta()) {
      neighborN_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta()    ) == neighbor->hwEta()) {
      neighborS_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 0 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborNE_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborSW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == 1 &&
        (region->hwEta() - 1) == neighbor->hwEta()) {
      neighborNW_et = neighborET;
      nNeighbors++;
      continue;
    }
    else if(deltaGctPhi(*region, *neighbor) == -1 &&
        (region->hwEta() + 1) == neighbor->hwEta()) {
      neighborSE_et = neighborET;
      nNeighbors++;
      continue;
    }

      }
      if(regionET > neighborN_et &&
     regionET > neighborNW_et &&
     regionET > neighborW_et &&
     regionET > neighborSW_et &&
     regionET >= neighborNE_et &&
     regionET >= neighborE_et &&
     regionET >= neighborSE_et &&
     regionET >= neighborS_et) {

    // use the highest-pT 2x2 jet inside this 3x3
    unsigned int jetET_NW;
    unsigned int jetET_NE;
    unsigned int jetET_SW;
    unsigned int jetET_SE;

    jetET_NW = regionET + neighborW_et + neighborNW_et + neighborN_et;
    jetET_NE = regionET + neighborE_et + neighborNE_et + neighborN_et;
    jetET_SW = regionET + neighborS_et + neighborSW_et + neighborW_et;
    jetET_SE = regionET + neighborS_et + neighborSE_et + neighborE_et;

    unsigned int jetET = std::max(jetET_NW, jetET_NE);
    jetET = std::max(jetET, jetET_SW);
    jetET = std::max(jetET, jetET_SE);

    int jetPhi = region->hwPhi();
    int jetEta = region->hwEta();

    bool neighborCheck = (nNeighbors == 8);
    // On the eta edge we only expect 5 neighbor
    if (!neighborCheck && (jetEta == 0 || jetEta == 21) && nNeighbors == 5)
      neighborCheck = true;

    if (!neighborCheck) {
      std::cout << "phi: " << jetPhi << " eta: " << jetEta << " n: " << nNeighbors << std::endl;
      assert(false);
    }

    //first iteration, eta cut defines forward
    const bool forward = (jetEta < 4 || jetEta > 17);
    int jetQual = 0;
    if(forward)
      jetQual |= 0x2;

    ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > jetLorentz(0,0,0,0);
    l1t::Jet theJet(*&jetLorentz, jetET, jetEta, jetPhi, jetQual);
    uncalibjets->push_back(theJet);
      }
    }
  }