Primitive RPC trigger

L1Trigger/RPCTriggerPrimitives/README.md

@@ -0,0 +1,61 @@
+# RPCTriggerPrimitives
+
+This is the first version of the RPCTriggerPrimitives for the RPC detector. Which uses as an input the RPCDigis as an input and the RPCRecHits (New collection) as an output. The output of this module is an edm branch named RPCPrimitivesDigis, following the RPCRecHit format already committed in CMSSW_10_6_0. We apply the cluster size cut and emulate max two clusters per link board. The module can be tuned by the parameters LinkBoardCut and ClusterSizeCut for phaseII. 
+
+#  Out of the box instructions
+
+```
+ssh -XY username@lxplus7.cern.ch
+SCRAM_ARCH=slc7_amd64_gcc700; export SCRAM_ARCH   (in .bashrc file)
+scram list CMSSW_10_6_0
+cmsrel CMSSW_10_6_0
+cd CMSSW_10_6_0/src
+cmsenv
+```
+
+```
+You need to do a fork from your githut repository to cmssw-offline repository. The url is:
+https://github.com/cms-sw/cmssw
+```
+
+
+```
+git cms-init
+git cms-addpkg L1Trigger/L1TMuonEndCap
+git cms-addpkg CondTools/RPC
+
+cd CondTools/RPC
+cp /eos/cms/store/group/dpg_rpc/comm_rpc/Run-II/cppf_payloads/RPCLinkMap.db data
+for analyser in test/RPC*LinkMapPopConAnalyzer_cfg.py; do 
+  cmsRun $analyser
+done; # <- this produces RPCLinkMap.db sqlite file yourself
+cd -
+
+git remote add YourGitHubName git@github.com:YourGitHubName/cmssw.git
+git fetch YourGitHubName
+git checkout -b PrimitiveTrigger
+scram b -j6
+
+```
+
+## Set your environment with my branch
+
+```
+git remote add maseguracern git@github.com:maseguracern/cmssw.git
+git cms-merge-topic -u maseguracern:PrimitiveTrigger 
+scram b -j6
+```
+
+# Run test producer
+```
+cd test
+cmsRun rpcprimitive_MC.py
+```
+
+## Modifying files
+```
+git add <Modified files>
+git commit -m "Commit message"
+git push my-cmssw YourBranchName
+```
+

L1Trigger/RPCTriggerPrimitives/plugins/BuildFile.xml

@@ -0,0 +1,21 @@
+<library file="*.cc" name="L1TriggerRPCTriggerPrimitivesPlugins">
+  <use name="L1Trigger/RPCTriggerPrimitives"/>
+  <use name="FWCore/MessageLogger"/>
+  <use name="FWCore/Framework"/>
+  <use name="FWCore/ParameterSet"/>
+  <use name="FWCore/PluginManager"/>
+  <use name="FWCore/Utilities"/>
+  <use name="DataFormats/Common"/>
+  <use name="DataFormats/DetId"/>
+  <use name="DataFormats/MuonDetId"/>
+  <use name="DataFormats/RPCRecHit"/>
+  <use name="DataFormats/TrackingRecHit"/>
+  <use name="CondFormats/RPCObjects"/>
+  <use name="CondFormats/DataRecord"/>
+  <use name="Geometry/RPCGeometry"/>
+  <use name="Geometry/Records"/>
+  <use name="TrackingTools/TrackRefitter"/>
+  <flags EDM_PLUGIN="1"/>
+</library>
+
+

L1Trigger/RPCTriggerPrimitives/plugins/L1TMuonRPCTriggerPrimitivesProducer.cc

@@ -0,0 +1,28 @@
+// RPCTriggerPrimitives producer for RPPRecHits in L1T Level
+// Author Alejandro Segura -- Universidad de los Andes
+
+#include "L1TMuonRPCTriggerPrimitivesProducer.h"
+
+L1TMuonRPCTriggerPrimitivesProducer::L1TMuonRPCTriggerPrimitivesProducer(const edm::ParameterSet& iConfig)
+    : preprocess_pointer_(std::make_unique<PrimitivePreprocess>(iConfig, consumesCollector())) {
+  produces<RPCRecHitCollection>();
+}
+
+L1TMuonRPCTriggerPrimitivesProducer::~L1TMuonRPCTriggerPrimitivesProducer() {}
+
+void L1TMuonRPCTriggerPrimitivesProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
+  // Create pointers to the collections which will store the new primitive digis
+  auto Tprimitive_digis = std::make_unique<RPCRecHitCollection>();
+
+  preprocess_pointer_->beginRun(iSetup);
+  preprocess_pointer_->Preprocess(iEvent, iSetup, *Tprimitive_digis);
+  // Fill the output collections
+  iEvent.put(std::move(Tprimitive_digis));
+}
+
+void L1TMuonRPCTriggerPrimitivesProducer::beginStream(edm::StreamID iID) {}
+
+void L1TMuonRPCTriggerPrimitivesProducer::endStream() {}
+
+// Define this as a plug-in
+DEFINE_FWK_MODULE(L1TMuonRPCTriggerPrimitivesProducer);

L1Trigger/RPCTriggerPrimitives/plugins/L1TMuonRPCTriggerPrimitivesProducer.h

@@ -0,0 +1,37 @@
+#ifndef L1Trigger_RPCTriggerPrimitives_L1TMuonRPCTriggerPrimitivesProducer_h
+#define L1Trigger_RPCTriggerPrimitives_L1TMuonRPCTriggerPrimitivesProducer_h
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/stream/EDProducer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Utilities/interface/InputTag.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include "DataFormats/MuonDetId/interface/RPCDetId.h"
+#include "DataFormats/RPCDigi/interface/RPCDigiCollection.h"
+
+#include "DataFormats/RPCRecHit/interface/RPCRecHit.h"
+#include "DataFormats/RPCRecHit/interface/RPCRecHitCollection.h"
+
+#include "TVector3.h"
+
+#include "L1Trigger/RPCTriggerPrimitives/plugins/PrimitivePreprocess.h"
+
+// Class declaration
+
+class L1TMuonRPCTriggerPrimitivesProducer : public edm::stream::EDProducer<> {
+public:
+  explicit L1TMuonRPCTriggerPrimitivesProducer(const edm::ParameterSet&);
+  ~L1TMuonRPCTriggerPrimitivesProducer() override;
+
+private:
+  void beginStream(edm::StreamID) override;
+  void endStream() override;
+  void produce(edm::Event& event, const edm::EventSetup& setup) override;
+
+  std::unique_ptr<PrimitivePreprocess> preprocess_pointer_;
+};
+
+#endif /* #define L1Trigger_RPCTriggerPrimitives_L1TMuonRPCTriggerPrimitivesProducer_h */

L1Trigger/RPCTriggerPrimitives/plugins/PrimitiveAlgoFactory.cc

@@ -0,0 +1,4 @@
+#include "FWCore/PluginManager/interface/PluginFactory.h"
+#include "L1Trigger/RPCTriggerPrimitives/plugins/PrimitiveAlgoFactory.h"
+
+EDM_REGISTER_PLUGINFACTORY(PrimitiveAlgoFactory, "PrimitiveAlgoFactory");

L1Trigger/RPCTriggerPrimitives/plugins/PrimitiveAlgoFactory.h

@@ -0,0 +1,9 @@
+#ifndef L1Trigger_PrimitiveAlgoFactory_H
+#define L1Trigger_PrimitiveAlgoFactory_H
+
+#include "FWCore/PluginManager/interface/PluginFactory.h"
+#include "RecoLocalMuon/RPCRecHit/interface/RPCRecHitBaseAlgo.h"
+
+typedef edmplugin::PluginFactory<RPCRecHitBaseAlgo *(const edm::ParameterSet &)> PrimitiveAlgoFactory;
+
+#endif

L1Trigger/RPCTriggerPrimitives/plugins/PrimitivePreprocess.cc

@@ -0,0 +1,157 @@
+#include "L1Trigger/RPCTriggerPrimitives/plugins/PrimitivePreprocess.h"
+
+PrimitivePreprocess::PrimitivePreprocess(const edm::ParameterSet& iConfig, edm::ConsumesCollector&& iConsumes)
+    : rpcToken_(iConsumes.consumes<RPCDigiCollection>(iConfig.getParameter<edm::InputTag>("Primitiverechitlabel"))),
+      processorvector_(),
+      Mapsource_(iConfig.getParameter<std::string>("Mapsource")),
+      ApplyLinkBoardCut_(iConfig.getParameter<bool>("ApplyLinkBoardCut")),
+      LinkBoardCut_(iConfig.getParameter<int>("LinkBoardCut")),
+      ClusterSizeCut_(iConfig.getParameter<int>("ClusterSizeCut")),
+      theRPCMaskedStripsObj(nullptr),
+      theRPCDeadStripsObj(nullptr),
+      // Get the concrete reconstruction algo from the factory
+      theAlgorithm{PrimitiveAlgoFactory::get()->create(iConfig.getParameter<std::string>("recAlgo"),
+                                                       iConfig.getParameter<edm::ParameterSet>("recAlgoConfig"))},
+      maskSource_(MaskSource::EventSetup),
+      deadSource_(MaskSource::EventSetup) {
+  //Get LUT for linkboard map
+  std::ifstream inputFile(Mapsource_.fullPath().c_str(), std::ios::in);
+
+  if (!inputFile) {
+    throw cms::Exception("No LUT file") << "Error: Linkboard mapping cannot be opened";
+    exit(1);
+  }
+
+  while (inputFile.good()) {
+    RPCProcessor::Map_structure temp;
+    inputFile >> temp.linkboard_ >> temp.linkboard_ID >> temp.chamber1_ >> temp.chamber2_;
+    Final_MapVector.push_back(temp);
+  }
+  Final_MapVector.pop_back();
+
+  inputFile.close();
+
+  const std::string maskSource = iConfig.getParameter<std::string>("maskSource");
+
+  if (maskSource == "File") {
+    maskSource_ = MaskSource::File;
+    edm::FileInPath fp1 = iConfig.getParameter<edm::FileInPath>("maskvecfile");
+    std::ifstream inputFile_1(fp1.fullPath().c_str(), std::ios::in);
+    if (!inputFile_1) {
+      std::cerr << "Masked Strips File cannot not be opened" << std::endl;
+      exit(1);
+    }
+    while (inputFile_1.good()) {
+      RPCMaskedStrips::MaskItem Item;
+      inputFile_1 >> Item.rawId >> Item.strip;
+      if (inputFile_1.good())
+        MaskVec.push_back(Item);
+    }
+    inputFile_1.close();
+  }
+
+  const std::string deadSource = iConfig.getParameter<std::string>("deadSource");
+
+  if (deadSource == "File") {
+    deadSource_ = MaskSource::File;
+    edm::FileInPath fp2 = iConfig.getParameter<edm::FileInPath>("deadvecfile");
+    std::ifstream inputFile_2(fp2.fullPath().c_str(), std::ios::in);
+    if (!inputFile_2) {
+      std::cerr << "Dead Strips File cannot not be opened" << std::endl;
+      exit(1);
+    }
+    while (inputFile_2.good()) {
+      RPCDeadStrips::DeadItem Item;
+      inputFile_2 >> Item.rawId >> Item.strip;
+      if (inputFile_2.good())
+        DeadVec.push_back(Item);
+    }
+    inputFile_2.close();
+  }
+
+  //Closing the input files
+}
+
+PrimitivePreprocess::~PrimitivePreprocess() {}
+
+void PrimitivePreprocess::beginRun(const edm::EventSetup& iSetup) {
+  // Get masked- and dead-strip information
+  theRPCMaskedStripsObj = std::make_unique<RPCMaskedStrips>();
+  theRPCDeadStripsObj = std::make_unique<RPCDeadStrips>();
+
+  // Getting the masked-strip information
+  if (maskSource_ == MaskSource::EventSetup) {
+    edm::ESHandle<RPCMaskedStrips> readoutMaskedStrips;
+    iSetup.get<RPCMaskedStripsRcd>().get(readoutMaskedStrips);
+    const RPCMaskedStrips* tmp_obj = readoutMaskedStrips.product();
+    theRPCMaskedStripsObj->MaskVec = tmp_obj->MaskVec;
+    delete tmp_obj;
+  }
+
+  else if (maskSource_ == MaskSource::File) {
+    std::vector<RPCMaskedStrips::MaskItem>::iterator posVec;
+    for (posVec = MaskVec.begin(); posVec != MaskVec.end(); ++posVec) {
+      RPCMaskedStrips::MaskItem Item;
+      Item.rawId = (*posVec).rawId;
+      Item.strip = (*posVec).strip;
+      theRPCMaskedStripsObj->MaskVec.push_back(Item);
+    }
+  }
+
+  // Getting the dead-strip information
+
+  if (deadSource_ == MaskSource::EventSetup) {
+    edm::ESHandle<RPCDeadStrips> readoutDeadStrips;
+    iSetup.get<RPCDeadStripsRcd>().get(readoutDeadStrips);
+    const RPCDeadStrips* tmp_obj = readoutDeadStrips.product();
+    theRPCDeadStripsObj->DeadVec = tmp_obj->DeadVec;
+    delete tmp_obj;
+  } else if (deadSource_ == MaskSource::File) {
+    std::vector<RPCDeadStrips::DeadItem>::iterator posVec;
+    for (posVec = DeadVec.begin(); posVec != DeadVec.end(); ++posVec) {
+      RPCDeadStrips::DeadItem Item;
+      Item.rawId = (*posVec).rawId;
+      Item.strip = (*posVec).strip;
+      theRPCDeadStripsObj->DeadVec.push_back(Item);
+    }
+  }
+}
+
+void PrimitivePreprocess::Preprocess(const edm::Event& iEvent,
+                                     const edm::EventSetup& iSetup,
+                                     RPCRecHitCollection& primitivedigi) {
+  //loop over rpcdigis and cluster algorithm
+
+  std::map<std::string, std::string> LBName_ChamberID_Map_1;
+  std::map<std::string, std::string> LBID_ChamberID_Map_1;
+  std::map<std::string, std::string> LBName_ChamberID_Map_2;
+  std::map<std::string, std::string> LBID_ChamberID_Map_2;
+
+  std::vector<RPCProcessor::Map_structure>::iterator it;
+  for (it = Final_MapVector.begin(); it != Final_MapVector.end(); it++) {
+    LBName_ChamberID_Map_1[(*it).chamber1_] = (*it).linkboard_;
+    LBID_ChamberID_Map_1[(*it).chamber1_] = (*it).linkboard_ID;
+    if ((*it).chamber2_ != "-") {
+      LBName_ChamberID_Map_2[(*it).chamber2_] = (*it).linkboard_;
+      LBID_ChamberID_Map_2[(*it).chamber2_] = (*it).linkboard_ID;
+    }
+  }
+  // map_2 is only necessary for barrel
+
+  for (auto& iterator_ : processorvector_) {
+    iterator_.Process(iEvent,
+                      iSetup,
+                      rpcToken_,
+                      primitivedigi,
+                      theRPCMaskedStripsObj,
+                      theRPCDeadStripsObj,
+                      theAlgorithm,
+                      LBName_ChamberID_Map_1,
+                      LBID_ChamberID_Map_1,
+                      LBName_ChamberID_Map_2,
+                      LBID_ChamberID_Map_2,
+                      ApplyLinkBoardCut_,
+                      LinkBoardCut_,
+                      ClusterSizeCut_);
+  }
+}

L1Trigger/RPCTriggerPrimitives/plugins/PrimitivePreprocess.h

@@ -0,0 +1,71 @@
+#ifndef L1Trigger_RPCTriggerPrimitives_PrimitivePreprocess_h
+#define L1Trigger_RPCTriggerPrimitives_PrimitivePreprocess_h
+
+#include "DataFormats/MuonDetId/interface/RPCDetId.h"
+#include "DataFormats/RPCDigi/interface/RPCDigiCollection.h"
+#include "DataFormats/RPCRecHit/interface/RPCRecHit.h"
+#include "DataFormats/RPCRecHit/interface/RPCRecHitCollection.h"
+
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+#include "FWCore/Utilities/interface/InputTag.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/PluginManager/interface/PluginFactory.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+#include "CondFormats/RPCObjects/interface/RPCMaskedStrips.h"
+#include "CondFormats/RPCObjects/interface/RPCDeadStrips.h"
+#include "CondFormats/DataRecord/interface/RPCMaskedStripsRcd.h"
+#include "CondFormats/DataRecord/interface/RPCDeadStripsRcd.h"
+
+#include "Geometry/RPCGeometry/interface/RPCRoll.h"
+#include "Geometry/RPCGeometry/interface/RPCGeometry.h"
+#include "Geometry/Records/interface/MuonGeometryRecord.h"
+
+#include "RecoLocalMuon/RPCRecHit/interface/RPCRecHitBaseAlgo.h"
+
+#include "L1Trigger/RPCTriggerPrimitives/plugins/PrimitiveAlgoFactory.h"
+#include "L1Trigger/RPCTriggerPrimitives/plugins/RPCProcessor.h"
+
+#include <string>
+#include <fstream>
+#include <memory>
+
+class PrimitivePreprocess {
+public:
+  explicit PrimitivePreprocess(const edm::ParameterSet& iConfig, edm::ConsumesCollector&& iConsumes);
+
+  ~PrimitivePreprocess();
+
+  void beginRun(const edm::EventSetup&);
+
+  void Preprocess(const edm::Event& iEvent, const edm::EventSetup& iSetup, RPCRecHitCollection& primitivedigi);
+
+private:
+  const edm::EDGetTokenT<RPCDigiCollection> rpcToken_;
+  std::array<RPCProcessor, 1> processorvector_;
+
+  edm::FileInPath Mapsource_;
+  bool ApplyLinkBoardCut_;
+  int LinkBoardCut_;
+  int ClusterSizeCut_;
+
+  std::vector<RPCProcessor::Map_structure> Final_MapVector;
+
+  //masking from rpcrechit module
+
+  std::vector<RPCMaskedStrips::MaskItem> MaskVec;
+  std::vector<RPCDeadStrips::DeadItem> DeadVec;
+
+  std::unique_ptr<RPCMaskedStrips> theRPCMaskedStripsObj;
+  // Object with mask-strips-vector for all the RPC Detectors
+
+  std::unique_ptr<RPCDeadStrips> theRPCDeadStripsObj;
+  // Object with dead-strips-vector for all the RPC Detectors
+
+  // The reconstruction algorithm
+  std::unique_ptr<RPCRecHitBaseAlgo> theAlgorithm;
+
+  enum class MaskSource { File, EventSetup } maskSource_, deadSource_;
+};
+#endif