|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
#ifndef GctFormatTranslateBase_h_
#define GctFormatTranslateBase_h_
// C++ includes
#include <map>
#include <utility>
#include <string>
// CMSSW includes
#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h"
#include "L1Trigger/TextToDigi/interface/SourceCardRouting.h"
#include "EventFilter/GctRawToDigi/src/GctBlockHeader.h"
#include "EventFilter/GctRawToDigi/src/GctUnpackCollections.h"
/*!
* \class GctFormatTranslateBase
* \brief Abstract interface for RawToDigi/DigiToRaw conversions of GCT data.
*
* This class provides the common interface/functionality for the various
* concrete classes that can translate to/from specific RAW formats.
*
* \author Robert Frazier
*/
class GctFormatTranslateBase {
public:
/// Constructor.
/*! \param hltMode - set true to unpack only BX zero and GCT output data (i.e. to run as quick as possible).
* \param unpackSharedRegions - this is a commissioning option to unpack the shared RCT calo regions. */
explicit GctFormatTranslateBase(bool hltMode = false, bool unpackSharedRegions = false);
virtual ~GctFormatTranslateBase(); ///< Destructor.
/// Set the pointer to the unpack collections
void setUnpackCollections(GctUnpackCollections* const collections) { m_collections = collections; }
// Set the bunch crossing ID that will be put into the block headers when packing raw data (i.e. Digi -> Raw).
void setPackingBxId(uint32_t bxId) { m_packingBxId = bxId; }
// Set the event ID that will be put into the block headers when packing raw data (i.e. Digi -> Raw).
void setPackingEventId(uint32_t eventId) { m_packingEventId = eventId; }
/// Generate a block header from four 8-bit values
virtual GctBlockHeader generateBlockHeader(const unsigned char* data) const = 0;
/// Get block description
const std::string& getBlockDescription(const GctBlockHeader& header) const;
/// Get digis from the block - will return true if it succeeds, false otherwise.
virtual bool convertBlock(const unsigned char* d, const GctBlockHeader& hdr) = 0;
protected:
/* PROTECTED TYPDEFS, ENUMS, AND CLASS CONSTANTS. */
/// An enum of the EM candidate types.
/*! Note that the order here mimicks the order in the RAW data format. */
enum EmCandCatagory { NON_ISO_EM_CANDS, ISO_EM_CANDS, NUM_EM_CAND_CATEGORIES };
/// Useful enumeration for jet candidate pack/unpack.
/*! Note that the order here mimicks the order in the RAW data format. */
enum JetCandCategory { TAU_JETS, FORWARD_JETS, CENTRAL_JETS, NUM_JET_CATEGORIES };
typedef std::map<unsigned int, unsigned int> BlockLengthMap; ///< Block ID to Block Length map
typedef std::pair<unsigned int, unsigned int> BlockLengthPair; ///< Block ID/length pair
typedef std::map<unsigned int, std::string> BlockNameMap; ///< Block ID to Block Description map
typedef std::pair<unsigned int, std::string> BlockNamePair; ///< Block ID/Description pair
/// Typedef for mapping block ID to RCT crate.
typedef std::map<unsigned int, unsigned int> BlkToRctCrateMap;
/*! A typedef that holds the inclusive lower and upper bounds of pipeline
* gct trigger object pair number for isolated EM candidates.
* I.e. if the first and second trig object pair in the pipeline payload
* are isolated cands (4 iso in total), then the IsoBoundaryPair would
* be (0,1). */
typedef std::pair<unsigned int, unsigned int> IsoBoundaryPair;
/// A typdef for mapping Block IDs to IsoBoundaryPairs.
typedef std::map<unsigned int, IsoBoundaryPair> BlockIdToEmCandIsoBoundMap;
/* PROTECTED METHODS */
/* Static data member access methods */
virtual const BlockLengthMap& blockLengthMap() const = 0; ///< get the static block ID to block-length map.
virtual const BlockNameMap& blockNameMap() const = 0; ///< get the static block ID to blockname map.
virtual const BlkToRctCrateMap& rctEmCrateMap()
const = 0; ///< get static the block ID to RCT crate map for electrons.
virtual const BlkToRctCrateMap& rctJetCrateMap() const = 0; ///< get the static block ID to RCT crate map for jets
virtual const BlockIdToEmCandIsoBoundMap& internEmIsoBounds()
const = 0; ///< get the static intern EM cand isolated boundary map.
/* Data member access methods */
GctUnpackCollections* const colls() const {
return m_collections;
} ///< Protected access to the GCT Unpack Collections.
bool hltMode() const { return m_hltMode; } ///< Protected interface to get HLT optimisation mode flag.
bool unpackSharedRegions() const {
return m_unpackSharedRegions;
} /// Protected interface to the unpackSharedRegions commissioning option.
const SourceCardRouting& srcCardRouting() const {
return m_srcCardRouting;
} ///< Protected access to SourceCardRouting.
const uint32_t packingBxId() const { return m_packingBxId; } ///< Get the BxId to be used when packing data.
const uint32_t packingEventId() const { return m_packingEventId; } ///< Get the EventId to be used when packing data.
/* Other general methods */
/// Get a specific jet candandiate collection using the JetCandCategory enumeration.
L1GctJetCandCollection* const gctJets(const unsigned cat) const;
/// Returns a raw 32-bit header word generated from the blockId, number of time samples, bunch-crossing and event IDs.
virtual uint32_t generateRawHeader(const uint32_t blockId,
const uint32_t nSamples,
const uint32_t bxId,
const uint32_t eventId) const = 0;
/// Writes a raw block header into the raw data array for a given block ID and number of time-samples.
/*! BxId and EventId values for the raw header are set via the setPackingBxId() and setPackingEventId() methods. */
void writeRawHeader(unsigned char* data, uint32_t blockId, uint32_t nSamples) const;
/// Performs checks on the block header to see if the block is possible to unpack or not.
bool checkBlock(const GctBlockHeader& hdr) const;
/// The null unpack function - obviously common to all formats.
void blockDoNothing(const unsigned char* d, const GctBlockHeader& hdr) {}
private:
/* PRIVATE STATIC CONSTS */
static const std::string INVALID_BLOCK_HEADER_STR;
/* PRIVATE MEMBER DATA */
/// Pointer to the output collections object.
GctUnpackCollections* m_collections;
/// If true, unpack only BX zero and GCT output data (i.e. to run as quickly as possible)
bool m_hltMode;
/// If true, the shared RCT Calo regions will be unpacked also
/*! This is a commissioning option only - may not be relevant to all concrete implementations! */
bool m_unpackSharedRegions;
/// Source card mapping info
SourceCardRouting m_srcCardRouting;
/// The bunch-crossing ID to be used by the data packing methods
uint32_t m_packingBxId;
/// The event ID to be used by the data packing methods
uint32_t m_packingEventId;
};
#endif /* GctFormatTranslateBase_h_ */
|