Utilities/interface/DAQSourceModelsScouting.h

0001 #ifndef EventFilter_Utilities_DAQSourceModelsScouting_h
0002 #define EventFilter_Utilities_DAQSourceModelsScouting_h
0003
0004 #include <memory>
0005
0006 #include "EventFilter/Utilities/interface/DAQSourceModels.h"
0007 #include "DataFormats/L1Trigger/interface/Muon.h"
0008 #include "DataFormats/L1Trigger/interface/BXVector.h"
0009
0010 namespace scouting {
0011   struct muon {
0012     uint32_t f;
0013     uint32_t s;
0014   };
0015
0016   struct block {
0017     uint32_t bx;
0018     uint32_t orbit;
0019     muon mu[16];
0020   };
0021
0022   struct masks {
0023     static constexpr uint32_t phiext = 0x3ff;
0024     static constexpr uint32_t pt = 0x1ff;
0025     static constexpr uint32_t qual = 0xf;
0026     static constexpr uint32_t etaext = 0x1ff;
0027     static constexpr uint32_t etaextv = 0xff;
0028     static constexpr uint32_t etaexts = 0x100;
0029     static constexpr uint32_t iso = 0x3;
0030     static constexpr uint32_t chrg = 0x1;
0031     static constexpr uint32_t chrgv = 0x1;
0032     static constexpr uint32_t index = 0x7f;
0033     static constexpr uint32_t phi = 0x3ff;
0034     static constexpr uint32_t eta = 0x1ff;
0035     static constexpr uint32_t etav = 0xff;
0036     static constexpr uint32_t etas = 0x100;
0037     static constexpr uint32_t phiv = 0x1ff;
0038     static constexpr uint32_t phis = 0x200;
0039     static constexpr uint32_t sv = 0x3;
0040   };
0041
0042   struct shifts {
0043     static constexpr uint32_t phiext = 0;
0044     static constexpr uint32_t pt = 10;
0045     static constexpr uint32_t qual = 19;
0046     static constexpr uint32_t etaext = 23;
0047     static constexpr uint32_t iso = 0;
0048     static constexpr uint32_t chrg = 2;
0049     static constexpr uint32_t chrgv = 3;
0050     static constexpr uint32_t index = 4;
0051     static constexpr uint32_t phi = 11;
0052     static constexpr uint32_t eta = 21;
0053     static constexpr uint32_t rsv = 30;
0054   };
0055
0056   struct gmt_scales {
0057     static constexpr float pt_scale = 0.5;
0058     static constexpr float phi_scale = 2. * M_PI / 576.;
0059     static constexpr float eta_scale = 0.0870 / 8;  //9th MS bit is sign
0060     static constexpr float phi_range = M_PI;
0061   };
0062
0063   struct header_shifts {
0064     static constexpr uint32_t bxmatch = 24;
0065     static constexpr uint32_t mAcount = 16;
0066     static constexpr uint32_t orbitmatch = 8;
0067     static constexpr uint32_t mBcount = 0;
0068   };
0069
0070   struct header_masks {
0071     static constexpr uint32_t bxmatch = 0xff << header_shifts::bxmatch;
0072     static constexpr uint32_t mAcount = 0xf << header_shifts::mAcount;
0073     static constexpr uint32_t orbitmatch = 0xff << header_shifts::orbitmatch;
0074     static constexpr uint32_t mBcount = 0xf;
0075   };
0076
0077 }  //namespace scouting
0078
0079 class DataModeScoutingRun2Muon : public DataMode {
0080 public:
0081   DataModeScoutingRun2Muon(DAQSource* daqSource) : DataMode(daqSource) {
0082     dummyLVec_ = std::make_unique<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double>>>();
0083   }
0084
0085   ~DataModeScoutingRun2Muon() override{};
0086
0087   std::vector<std::shared_ptr<const edm::DaqProvenanceHelper>>& makeDaqProvenanceHelpers() override;
0088   void readEvent(edm::EventPrincipal& eventPrincipal) override;
0089
0090   int dataVersion() const override { return detectedFRDversion_; }
0091   void detectVersion(unsigned char* fileBuf, uint32_t fileHeaderOffset) override {
0092     detectedFRDversion_ = *((uint16_t*)(fileBuf + fileHeaderOffset));
0093   }
0094
0095   uint32_t headerSize() const override { return FRDHeaderVersionSize[detectedFRDversion_]; }
0096
0097   bool versionCheck() const override { return detectedFRDversion_ <= FRDHeaderMaxVersion; }
0098
0099   uint64_t dataBlockSize() const override { return event_->size(); }
0100
0101   void makeDataBlockView(unsigned char* addr,
0102                          size_t maxSize,
0103                          std::vector<uint64_t> const& fileSizes,
0104                          size_t fileHeaderSize) override {
0105     dataBlockAddr_ = addr;
0106     dataBlockMax_ = maxSize;
0107     eventCached_ = false;
0108     nextEventView();
0109     eventCached_ = true;
0110   }
0111
0112   bool nextEventView() override;
0113   bool checksumValid() override;
0114   std::string getChecksumError() const override;
0115
0116   bool isRealData() const override { return event_->isRealData(); }
0117
0118   uint32_t run() const override { return event_->run(); }
0119
0120   //true for scouting muon
0121   bool dataBlockCompleted() const override { return true; }
0122
0123   bool requireHeader() const override { return true; }
0124
0125   bool fitToBuffer() const override { return true; }
0126
0127   bool dataBlockInitialized() const override { return true; }
0128
0129   void setDataBlockInitialized(bool) override{};
0130
0131   void setTCDSSearchRange(uint16_t MINTCDSuTCAFEDID, uint16_t MAXTCDSuTCAFEDID) override { return; }
0132
0133   void makeDirectoryEntries(std::vector<std::string> const& baseDirs, std::string const& runDir) override {}
0134
0135   std::pair<bool, std::vector<std::string>> defineAdditionalFiles(std::string const& primaryName, bool) const override {
0136     return std::make_pair(true, std::vector<std::string>());
0137   }
0138
0139   char* readPayloadPos() { return (char*)event_->payload(); }
0140
0141 private:
0142   void unpackOrbit(BXVector<l1t::Muon>* muons, char* buf, size_t len);
0143
0144   std::vector<std::shared_ptr<const edm::DaqProvenanceHelper>> daqProvenanceHelpers_;
0145   uint16_t detectedFRDversion_ = 0;
0146   size_t headerSize_ = 0;
0147   std::unique_ptr<FRDEventMsgView> event_;
0148
0149   std::unique_ptr<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double>>> dummyLVec_;
0150
0151   unsigned char* dataBlockAddr_ = nullptr;
0152   size_t dataBlockMax_ = 0;
0153   bool eventCached_ = false;
0154 };
0155
0156 class DataModeScoutingRun2Multi : public DataMode {
0157 public:
0158   DataModeScoutingRun2Multi(DAQSource* daqSource) : DataMode(daqSource) {
0159     dummyLVec_ = std::make_unique<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double>>>();
0160   }
0161
0162   ~DataModeScoutingRun2Multi() override{};
0163
0164   std::vector<std::shared_ptr<const edm::DaqProvenanceHelper>>& makeDaqProvenanceHelpers() override;
0165   void readEvent(edm::EventPrincipal& eventPrincipal) override;
0166
0167   int dataVersion() const override { return detectedFRDversion_; }
0168   void detectVersion(unsigned char* fileBuf, uint32_t fileHeaderOffset) override {
0169     detectedFRDversion_ = *((uint16_t*)(fileBuf + fileHeaderOffset));
0170   }
0171
0172   uint32_t headerSize() const override { return FRDHeaderVersionSize[detectedFRDversion_]; }
0173
0174   bool versionCheck() const override { return detectedFRDversion_ <= FRDHeaderMaxVersion; }
0175
0176   uint64_t dataBlockSize() const override {
0177     //TODO: adjust to multiple objects
0178     return events_[0]->size();
0179   }
0180
0181   void makeDataBlockView(unsigned char* addr,
0182                          size_t maxSize,
0183                          std::vector<uint64_t> const& fileSizes,
0184                          size_t fileHeaderSize) override {
0185     fileHeaderSize_ = fileHeaderSize;
0186     numFiles_ = fileSizes.size();
0187     //add offset address for each file payload
0188     startAddrs_.clear();
0189     startAddrs_.push_back(addr);
0190     dataBlockAddrs_.clear();
0191     dataBlockAddrs_.push_back(addr);
0192     dataBlockMaxAddrs_.clear();
0193     dataBlockMaxAddrs_.push_back(addr + fileSizes[0] - fileHeaderSize);
0194     auto fileAddr = addr;
0195     for (unsigned int i = 1; i < fileSizes.size(); i++) {
0196       fileAddr += fileSizes[i - 1];
0197       startAddrs_.push_back(fileAddr);
0198       dataBlockAddrs_.push_back(fileAddr);
0199       dataBlockMaxAddrs_.push_back(fileAddr + fileSizes[i] - fileHeaderSize);
0200     }
0201
0202     dataBlockMax_ = maxSize;
0203     blockCompleted_ = false;
0204     //set event cached as we set initial address here
0205     bool result = makeEvents();
0206     assert(result);
0207     eventCached_ = true;
0208     setDataBlockInitialized(true);
0209   }
0210
0211   bool nextEventView() override;
0212   bool checksumValid() override;
0213   std::string getChecksumError() const override;
0214
0215   bool isRealData() const override {
0216     assert(!events_.empty());
0217     return events_[0]->isRealData();
0218   }
0219
0220   uint32_t run() const override {
0221     assert(!events_.empty());
0222     return events_[0]->run();
0223   }
0224
0225   //true for DAQ3 FRD
0226   bool dataBlockCompleted() const override { return blockCompleted_; }
0227
0228   bool requireHeader() const override { return true; }
0229
0230   bool dataBlockInitialized() const override { return dataBlockInitialized_; }
0231
0232   void setDataBlockInitialized(bool val) override { dataBlockInitialized_ = val; };
0233
0234   void setTCDSSearchRange(uint16_t MINTCDSuTCAFEDID, uint16_t MAXTCDSuTCAFEDID) override { return; }
0235
0236   void makeDirectoryEntries(std::vector<std::string> const& baseDirs, std::string const& runDir) override {
0237     //receive directory paths for multiple input files ('striped')
0238   }
0239
0240   std::pair<bool, std::vector<std::string>> defineAdditionalFiles(std::string const& primaryName,
0241                                                                   bool fileListMode) const override;
0242
0243 private:
0244   bool makeEvents();
0245   void unpackMuonOrbit(BXVector<l1t::Muon>* muons, char* buf, size_t len);
0246
0247   std::vector<std::shared_ptr<const edm::DaqProvenanceHelper>> daqProvenanceHelpers_;
0248   uint16_t detectedFRDversion_ = 0;
0249   size_t headerSize_ = 0;
0250   std::vector<std::unique_ptr<FRDEventMsgView>> events_;
0251
0252   std::unique_ptr<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double>>> dummyLVec_;
0253
0254   unsigned char* dataBlockAddr_ = nullptr;
0255
0256   //debugging
0257   std::vector<unsigned char*> startAddrs_;
0258   std::vector<unsigned char*> dataBlockAddrs_;
0259   std::vector<unsigned char*> dataBlockMaxAddrs_;
0260   size_t dataBlockMax_ = 0;
0261   size_t fileHeaderSize_ = 0;
0262   short numFiles_ = 0;
0263   bool eventCached_ = false;
0264   bool dataBlockInitialized_ = false;
0265   bool blockCompleted_ = true;
0266 };
0267
0268 #endif  // EventFilter_Utilities_DAQSourceModelsScouting_h