diff --git a/Validation/CSCRecHits/python/cscRecHitValidation_cfi.py b/Validation/CSCRecHits/python/cscRecHitValidation_cfi.py
index acea77f68c9d4..b34e85c384a9c 100644
--- a/Validation/CSCRecHits/python/cscRecHitValidation_cfi.py
+++ b/Validation/CSCRecHits/python/cscRecHitValidation_cfi.py
@@ -1,9 +1,11 @@
 import FWCore.ParameterSet.Config as cms
+from Validation.MuonHits.muonSimHitMatcherPSet import *
 from Validation.CSCRecHits.cscRecHitPSet import *
 
 from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
 cscRecHitValidation = DQMEDAnalyzer(
     'CSCRecHitValidation',
+    muonSimHitMatcherPSet,
     cscRecHitPSet,
     doSim = cms.bool(True),
     useGEMs = cms.bool(False),
diff --git a/Validation/MuonCSCDigis/interface/CSCALCTDigiValidation.h b/Validation/MuonCSCDigis/interface/CSCALCTDigiValidation.h
index 32ad4df2f178e..327d4cb1b6d11 100644
--- a/Validation/MuonCSCDigis/interface/CSCALCTDigiValidation.h
+++ b/Validation/MuonCSCDigis/interface/CSCALCTDigiValidation.h
@@ -4,7 +4,6 @@
 #include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include "DQMServices/Core/interface/DQMStore.h"
-#include "DataFormats/CSCDigi/interface/CSCALCTDigi.h"
 #include "DataFormats/CSCDigi/interface/CSCALCTDigiCollection.h"
 #include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
 
@@ -18,9 +17,20 @@ class CSCALCTDigiValidation : public CSCBaseValidation {
 private:
   edm::EDGetTokenT<CSCALCTDigiCollection> alcts_Token_;
   edm::InputTag inputTag_;
-  MonitorElement *theTimeBinPlots[10];
   MonitorElement *theNDigisPerChamberPlots[10];
   MonitorElement *theNDigisPerEventPlot;
+
+  // more diagnostic plots
+  std::vector<std::string> chambers_;
+
+  std::vector<std::string> alctVars_;
+  std::vector<unsigned> alctNBin_;
+  std::vector<double> alctMinBin_;
+  std::vector<double> alctMaxBin_;
+
+  // first key is the chamber number
+  // second key is the variable
+  std::map<uint32_t, std::map<std::string, MonitorElement *> > chamberHistos;
 };
 
 #endif
diff --git a/Validation/MuonCSCDigis/interface/CSCBaseValidation.h b/Validation/MuonCSCDigis/interface/CSCBaseValidation.h
index 077e262f7cda5..428ad47540cdb 100644
--- a/Validation/MuonCSCDigis/interface/CSCBaseValidation.h
+++ b/Validation/MuonCSCDigis/interface/CSCBaseValidation.h
@@ -10,6 +10,7 @@
 #include "DQMServices/Core/interface/DQMStore.h"
 #include "Geometry/CSCGeometry/interface/CSCGeometry.h"
 #include "SimMuon/MCTruth/interface/PSimHitMap.h"
+#include "SimDataFormats/Track/interface/SimTrack.h"
 
 class CSCBaseValidation {
 public:
@@ -23,10 +24,16 @@ class CSCBaseValidation {
   virtual void analyze(const edm::Event &e, const edm::EventSetup &eventSetup) = 0;
 
 protected:
+  bool isSimTrackGood(const SimTrack &t) const;
+
   bool doSim_;
   const CSCLayer *findLayer(int detId) const;
   const PSimHitMap *theSimHitMap;
   const CSCGeometry *theCSCGeometry;
+
+  double simTrackMinPt_;
+  double simTrackMinEta_;
+  double simTrackMaxEta_;
 };
 
 #endif
diff --git a/Validation/MuonCSCDigis/interface/CSCCLCTDigiValidation.h b/Validation/MuonCSCDigis/interface/CSCCLCTDigiValidation.h
index 15c78c8a0af08..c090e5ce38e4c 100644
--- a/Validation/MuonCSCDigis/interface/CSCCLCTDigiValidation.h
+++ b/Validation/MuonCSCDigis/interface/CSCCLCTDigiValidation.h
@@ -4,7 +4,6 @@
 #include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include "DQMServices/Core/interface/DQMStore.h"
-#include "DataFormats/CSCDigi/interface/CSCCLCTDigi.h"
 #include "DataFormats/CSCDigi/interface/CSCCLCTDigiCollection.h"
 #include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
 
@@ -18,9 +17,23 @@ class CSCCLCTDigiValidation : public CSCBaseValidation {
 private:
   edm::EDGetTokenT<CSCCLCTDigiCollection> clcts_Token_;
   edm::InputTag inputTag_;
-  MonitorElement *theTimeBinPlots[10];
   MonitorElement *theNDigisPerChamberPlots[10];
   MonitorElement *theNDigisPerEventPlot;
+
+  // more diagnostic plots
+  std::vector<std::string> chambers_;
+  std::vector<unsigned> chambersRun3_;
+
+  std::vector<std::string> clctVars_;
+  std::vector<unsigned> clctNBin_;
+  std::vector<double> clctMinBin_;
+  std::vector<double> clctMaxBin_;
+
+  bool isRun3_;
+
+  // first key is the chamber number
+  // second key is the variable
+  std::map<uint32_t, std::map<std::string, MonitorElement *> > chamberHistos;
 };
 
 #endif
diff --git a/Validation/MuonCSCDigis/interface/CSCCLCTPreTriggerDigiValidation.h b/Validation/MuonCSCDigis/interface/CSCCLCTPreTriggerDigiValidation.h
new file mode 100644
index 0000000000000..daa3ed9d79692
--- /dev/null
+++ b/Validation/MuonCSCDigis/interface/CSCCLCTPreTriggerDigiValidation.h
@@ -0,0 +1,37 @@
+#ifndef Validation_MuonCSCDigis_CSCCLCTPreTriggerDigiValidation_H
+#define Validation_MuonCSCDigis_CSCCLCTPreTriggerDigiValidation_H
+
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+
+#include "DQMServices/Core/interface/DQMStore.h"
+#include "DataFormats/CSCDigi/interface/CSCCLCTPreTriggerDigiCollection.h"
+#include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
+
+class CSCCLCTPreTriggerDigiValidation : public CSCBaseValidation {
+public:
+  CSCCLCTPreTriggerDigiValidation(const edm::ParameterSet &ps, edm::ConsumesCollector &&iC);
+  ~CSCCLCTPreTriggerDigiValidation() override;
+  void bookHistograms(DQMStore::IBooker &);
+  void analyze(const edm::Event &, const edm::EventSetup &) override;
+
+private:
+  edm::EDGetTokenT<CSCCLCTPreTriggerDigiCollection> preclcts_Token_;
+  edm::InputTag inputTag_;
+
+  // more diagnostic plots
+  std::vector<std::string> chambers_;
+  std::vector<unsigned> chambersRun3_;
+
+  std::vector<std::string> preclctVars_;
+  std::vector<unsigned> preclctNBin_;
+  std::vector<double> preclctMinBin_;
+  std::vector<double> preclctMaxBin_;
+
+  bool isRun3_;
+
+  // first key is the chamber number
+  // second key is the variable
+  std::map<uint32_t, std::map<std::string, MonitorElement *> > chamberHistos;
+};
+
+#endif
diff --git a/Validation/MuonCSCDigis/interface/CSCComparatorDigiValidation.h b/Validation/MuonCSCDigis/interface/CSCComparatorDigiValidation.h
index e33f17b0e88bd..344a323bf1251 100644
--- a/Validation/MuonCSCDigis/interface/CSCComparatorDigiValidation.h
+++ b/Validation/MuonCSCDigis/interface/CSCComparatorDigiValidation.h
@@ -15,6 +15,7 @@ class CSCComparatorDigiValidation : public CSCBaseValidation {
   ~CSCComparatorDigiValidation() override;
   void bookHistograms(DQMStore::IBooker &);
   void analyze(const edm::Event &, const edm::EventSetup &) override;
+  void plotResolution(const PSimHit &hit, int strip, const CSCLayer *layer, int chamberType);
 
 private:
   edm::EDGetTokenT<CSCStripDigiCollection> strips_Token_;
@@ -26,8 +27,8 @@ class CSCComparatorDigiValidation : public CSCBaseValidation {
   MonitorElement *theNDigisPerLayerPlots[10];
   MonitorElement *theStripDigiPlots[10];
   MonitorElement *the3StripPlots[10];
-
   MonitorElement *theNDigisPerEventPlot;
+  MonitorElement *theResolutionPlots[10];
 };
 
 #endif
diff --git a/Validation/MuonCSCDigis/interface/CSCCorrelatedLCTDigiValidation.h b/Validation/MuonCSCDigis/interface/CSCCorrelatedLCTDigiValidation.h
new file mode 100644
index 0000000000000..7208c4de88eff
--- /dev/null
+++ b/Validation/MuonCSCDigis/interface/CSCCorrelatedLCTDigiValidation.h
@@ -0,0 +1,39 @@
+#ifndef Validation_MuonCSCDigis_CSCCorrelatedLCTDigiValidation_H
+#define Validation_MuonCSCDigis_CSCCorrelatedLCTDigiValidation_H
+
+#include "FWCore/Framework/interface/ConsumesCollector.h"
+
+#include "DQMServices/Core/interface/DQMStore.h"
+#include "DataFormats/CSCDigi/interface/CSCCorrelatedLCTDigiCollection.h"
+#include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
+
+class CSCCorrelatedLCTDigiValidation : public CSCBaseValidation {
+public:
+  CSCCorrelatedLCTDigiValidation(const edm::ParameterSet &ps, edm::ConsumesCollector &&iC);
+  ~CSCCorrelatedLCTDigiValidation() override;
+  void bookHistograms(DQMStore::IBooker &);
+  void analyze(const edm::Event &, const edm::EventSetup &) override;
+
+private:
+  edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> lcts_Token_;
+  edm::InputTag inputTag_;
+  MonitorElement *theNDigisPerChamberPlots[10];
+  MonitorElement *theNDigisPerEventPlot;
+
+  // more diagnostic plots
+  std::vector<std::string> chambers_;
+  std::vector<unsigned> chambersRun3_;
+
+  std::vector<std::string> lctVars_;
+  std::vector<unsigned> lctNBin_;
+  std::vector<double> lctMinBin_;
+  std::vector<double> lctMaxBin_;
+
+  bool isRun3_;
+
+  // first key is the chamber number
+  // second key is the variable
+  std::map<uint32_t, std::map<std::string, MonitorElement *> > chamberHistos;
+};
+
+#endif
diff --git a/Validation/MuonCSCDigis/interface/CSCStripDigiValidation.h b/Validation/MuonCSCDigis/interface/CSCStripDigiValidation.h
index 379933cdd2b8a..b66919be4cd46 100644
--- a/Validation/MuonCSCDigis/interface/CSCStripDigiValidation.h
+++ b/Validation/MuonCSCDigis/interface/CSCStripDigiValidation.h
@@ -4,7 +4,6 @@
 #include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include "DQMServices/Core/interface/DQMStore.h"
-#include "DataFormats/CSCDigi/interface/CSCStripDigi.h"
 #include "DataFormats/CSCDigi/interface/CSCStripDigiCollection.h"
 #include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
 
@@ -15,7 +14,6 @@ class CSCStripDigiValidation : public CSCBaseValidation {
 
   void bookHistograms(DQMStore::IBooker &);
   void analyze(const edm::Event &e, const edm::EventSetup &) override;
-  void setGeometry(const CSCGeometry *geom) { theCSCGeometry = geom; }
   void plotResolution(const PSimHit &hit, int strip, const CSCLayer *layer, int chamberType);
 
 private:
@@ -36,7 +34,6 @@ class CSCStripDigiValidation : public CSCBaseValidation {
   MonitorElement *theNDigisPerLayerPlot;
   MonitorElement *theNDigisPerChamberPlot;
   MonitorElement *theNDigisPerEventPlot;
-  MonitorElement *theResolutionPlots[10];
 };
 
 #endif
diff --git a/Validation/MuonCSCDigis/interface/CSCStubEfficiencyValidation.h b/Validation/MuonCSCDigis/interface/CSCStubEfficiencyValidation.h
index 085a5a812407d..37eed0b3a70e6 100644
--- a/Validation/MuonCSCDigis/interface/CSCStubEfficiencyValidation.h
+++ b/Validation/MuonCSCDigis/interface/CSCStubEfficiencyValidation.h
@@ -1,23 +1,11 @@
 #ifndef Validation_MuonCSCDigis_CSCStubEfficiencyValidation_H
 #define Validation_MuonCSCDigis_CSCStubEfficiencyValidation_H
 
-#include "FWCore/Framework/interface/ConsumesCollector.h"
-
-#include "DQMServices/Core/interface/DQMStore.h"
-#include "DataFormats/CSCDigi/interface/CSCALCTDigi.h"
-#include "DataFormats/CSCDigi/interface/CSCALCTDigiCollection.h"
-#include "DataFormats/CSCDigi/interface/CSCCLCTDigi.h"
-#include "DataFormats/CSCDigi/interface/CSCCLCTDigiCollection.h"
-#include "DataFormats/CSCDigi/interface/CSCCorrelatedLCTDigi.h"
-#include "DataFormats/CSCDigi/interface/CSCCorrelatedLCTDigiCollection.h"
 #include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
-#include "Validation/MuonCSCDigis/interface/CSCStubMatcher.h"
 
-#include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
-
-#include <map>
 #include <string>
-#include <tuple>
+
+class CSCStubMatcher;
 
 class CSCStubEfficiencyValidation : public CSCBaseValidation {
 public:
@@ -27,19 +15,8 @@ class CSCStubEfficiencyValidation : public CSCBaseValidation {
   void bookHistograms(DQMStore::IBooker &);
   void analyze(const edm::Event &, const edm::EventSetup &) override;
 
-  // access to the matcher
-  std::shared_ptr<CSCStubMatcher> cscStubMatcher() { return cscStubMatcher_; }
-  void setCSCStubMatcher(std::shared_ptr<CSCStubMatcher> s) { cscStubMatcher_ = s; }
-
 private:
-  bool isSimTrackGood(const SimTrack &t);
-
-  edm::EDGetTokenT<CSCALCTDigiCollection> alcts_Token_;
-  edm::EDGetTokenT<CSCCLCTDigiCollection> clcts_Token_;
-  edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> lcts_Token_;
-  edm::InputTag inputTag_;
-
-  std::shared_ptr<CSCStubMatcher> cscStubMatcher_;
+  std::unique_ptr<CSCStubMatcher> cscStubMatcher_;
 
   // efficiency vs eta for each CSC TP
   MonitorElement *etaALCTNum[10];
@@ -51,9 +28,6 @@ class CSCStubEfficiencyValidation : public CSCBaseValidation {
 
   edm::EDGetTokenT<edm::SimVertexContainer> simVertexInput_;
   edm::EDGetTokenT<edm::SimTrackContainer> simTrackInput_;
-  double simTrackMinPt_;
-  double simTrackMinEta_;
-  double simTrackMaxEta_;
 
   std::vector<double> etaMins_;
   std::vector<double> etaMaxs_;
diff --git a/Validation/MuonCSCDigis/interface/CSCStubMatcher.h b/Validation/MuonCSCDigis/interface/CSCStubMatcher.h
index 3fc335611a58e..788a4c47e4eed 100644
--- a/Validation/MuonCSCDigis/interface/CSCStubMatcher.h
+++ b/Validation/MuonCSCDigis/interface/CSCStubMatcher.h
@@ -11,6 +11,7 @@
 #include "Validation/MuonCSCDigis/interface/CSCDigiMatcher.h"
 #include "Validation/MuonGEMDigis/interface/GEMDigiMatcher.h"
 
+#include "DataFormats/CSCDigi/interface/CSCConstants.h"
 #include "DataFormats/CSCDigi/interface/CSCALCTDigiCollection.h"
 #include "DataFormats/CSCDigi/interface/CSCCLCTDigiCollection.h"
 #include "DataFormats/CSCDigi/interface/CSCCorrelatedLCTDigiCollection.h"
@@ -96,6 +97,11 @@ class CSCStubMatcher {
                     const CSCCorrelatedLCTDigi& lct22,
                     CSCCorrelatedLCTDigiContainer& lctcontainer) const;
 
+  edm::InputTag clctInputTag_;
+  edm::InputTag alctInputTag_;
+  edm::InputTag lctInputTag_;
+  edm::InputTag mplctInputTag_;
+
   edm::EDGetTokenT<CSCCLCTDigiCollection> clctToken_;
   edm::EDGetTokenT<CSCALCTDigiCollection> alctToken_;
   edm::EDGetTokenT<CSCCorrelatedLCTDigiCollection> lctToken_;
diff --git a/Validation/MuonCSCDigis/interface/CSCStubResolutionValidation.h b/Validation/MuonCSCDigis/interface/CSCStubResolutionValidation.h
new file mode 100644
index 0000000000000..dd7c38a835431
--- /dev/null
+++ b/Validation/MuonCSCDigis/interface/CSCStubResolutionValidation.h
@@ -0,0 +1,38 @@
+#ifndef Validation_MuonCSCDigis_CSCStubResolutionValidation_H
+#define Validation_MuonCSCDigis_CSCStubResolutionValidation_H
+
+#include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
+
+#include <string>
+
+class CSCStubMatcher;
+
+class CSCStubResolutionValidation : public CSCBaseValidation {
+public:
+  CSCStubResolutionValidation(const edm::ParameterSet &pset, edm::ConsumesCollector &&iC);
+  ~CSCStubResolutionValidation() override;
+
+  void bookHistograms(DQMStore::IBooker &);
+  void analyze(const edm::Event &, const edm::EventSetup &) override;
+
+private:
+  edm::InputTag inputTag_;
+
+  std::unique_ptr<CSCStubMatcher> cscStubMatcher_;
+
+  // resolution for each CSC TP; 10 CSC stations;
+  MonitorElement *posresCLCT_hs[10];
+  MonitorElement *posresCLCT_qs[10];
+  MonitorElement *posresCLCT_es[10];
+
+  MonitorElement *bendresCLCT[10];
+
+  edm::EDGetTokenT<edm::SimVertexContainer> simVertexInput_;
+  edm::EDGetTokenT<edm::SimTrackContainer> simTrackInput_;
+
+  double simTrackMinPt_;
+  double simTrackMinEta_;
+  double simTrackMaxEta_;
+};
+
+#endif
diff --git a/Validation/MuonCSCDigis/interface/CSCWireDigiValidation.h b/Validation/MuonCSCDigis/interface/CSCWireDigiValidation.h
index 5bf34949ef454..c14900e57bdeb 100644
--- a/Validation/MuonCSCDigis/interface/CSCWireDigiValidation.h
+++ b/Validation/MuonCSCDigis/interface/CSCWireDigiValidation.h
@@ -4,7 +4,6 @@
 #include "FWCore/Framework/interface/ConsumesCollector.h"
 
 #include "DQMServices/Core/interface/DQMStore.h"
-#include "DataFormats/CSCDigi/interface/CSCWireDigi.h"
 #include "DataFormats/CSCDigi/interface/CSCWireDigiCollection.h"
 #include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
 
diff --git a/Validation/MuonCSCDigis/plugins/CSCDigiValidation.cc b/Validation/MuonCSCDigis/plugins/CSCDigiValidation.cc
index e661a5892b6c5..b56518336511d 100644
--- a/Validation/MuonCSCDigis/plugins/CSCDigiValidation.cc
+++ b/Validation/MuonCSCDigis/plugins/CSCDigiValidation.cc
@@ -2,36 +2,34 @@
 #include "FWCore/ServiceRegistry/interface/Service.h"
 #include "Validation/MuonCSCDigis/interface/CSCALCTDigiValidation.h"
 #include "Validation/MuonCSCDigis/interface/CSCCLCTDigiValidation.h"
+#include "Validation/MuonCSCDigis/interface/CSCCLCTPreTriggerDigiValidation.h"
+#include "Validation/MuonCSCDigis/interface/CSCCorrelatedLCTDigiValidation.h"
 #include "Validation/MuonCSCDigis/interface/CSCComparatorDigiValidation.h"
 #include "Validation/MuonCSCDigis/interface/CSCStripDigiValidation.h"
 #include "Validation/MuonCSCDigis/interface/CSCWireDigiValidation.h"
 #include "Validation/MuonCSCDigis/interface/CSCStubEfficiencyValidation.h"
+#include "Validation/MuonCSCDigis/interface/CSCStubResolutionValidation.h"
 #include <iostream>
 #include <memory>
 
 CSCDigiValidation::CSCDigiValidation(const edm::ParameterSet &ps)
-    : doSim_(ps.getParameter<bool>("doSim")),
-      theSimHitMap(ps.getParameter<edm::InputTag>("simHitsTag"), consumesCollector()),
-      theCSCGeometry(nullptr),
-      theStripDigiValidation(nullptr),
-      theWireDigiValidation(nullptr),
-      theComparatorDigiValidation(nullptr),
-      theALCTDigiValidation(nullptr),
-      theCLCTDigiValidation(nullptr),
-      theStubEfficiencyValidation(nullptr) {
+    : doSim_(ps.getParameter<bool>("doSim")), theSimHitMap(nullptr), theCSCGeometry(nullptr) {
   // instantiatethe validation modules
   theStripDigiValidation = std::make_unique<CSCStripDigiValidation>(ps, consumesCollector());
   theWireDigiValidation = std::make_unique<CSCWireDigiValidation>(ps, consumesCollector());
   theComparatorDigiValidation = std::make_unique<CSCComparatorDigiValidation>(ps, consumesCollector());
   theALCTDigiValidation = std::make_unique<CSCALCTDigiValidation>(ps, consumesCollector());
   theCLCTDigiValidation = std::make_unique<CSCCLCTDigiValidation>(ps, consumesCollector());
-  theStubEfficiencyValidation = std::make_unique<CSCStubEfficiencyValidation>(ps, consumesCollector());
-
+  theCLCTPreTriggerDigiValidation = std::make_unique<CSCCLCTPreTriggerDigiValidation>(ps, consumesCollector());
+  theCorrelatedLCTDigiValidation = std::make_unique<CSCCorrelatedLCTDigiValidation>(ps, consumesCollector());
   // set the simhit map for resolution studies
   if (doSim_) {
-    theStripDigiValidation->setSimHitMap(&theSimHitMap);
-    theWireDigiValidation->setSimHitMap(&theSimHitMap);
-    theComparatorDigiValidation->setSimHitMap(&theSimHitMap);
+    theSimHitMap = new PSimHitMap(ps.getParameter<edm::InputTag>("simHitsTag"), consumesCollector());
+    theStripDigiValidation->setSimHitMap(theSimHitMap);
+    theWireDigiValidation->setSimHitMap(theSimHitMap);
+    theComparatorDigiValidation->setSimHitMap(theSimHitMap);
+    theStubEfficiencyValidation = std::make_unique<CSCStubEfficiencyValidation>(ps, consumesCollector());
+    theStubResolutionValidation = std::make_unique<CSCStubResolutionValidation>(ps, consumesCollector());
   }
   geomToken_ = esConsumes<CSCGeometry, MuonGeometryRecord>();
 }
@@ -41,18 +39,22 @@ CSCDigiValidation::~CSCDigiValidation() {}
 void CSCDigiValidation::bookHistograms(DQMStore::IBooker &iBooker,
                                        edm::Run const &iRun,
                                        edm::EventSetup const & /* iSetup */) {
-  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask");
+  // plot directory is set for each submodule
   theStripDigiValidation->bookHistograms(iBooker);
   theWireDigiValidation->bookHistograms(iBooker);
   theComparatorDigiValidation->bookHistograms(iBooker);
   theALCTDigiValidation->bookHistograms(iBooker);
   theCLCTDigiValidation->bookHistograms(iBooker);
-  theStubEfficiencyValidation->bookHistograms(iBooker);
+  theCLCTPreTriggerDigiValidation->bookHistograms(iBooker);
+  theCorrelatedLCTDigiValidation->bookHistograms(iBooker);
+  if (doSim_) {
+    // these plots are split over ALCT, CLCT and LCT
+    theStubEfficiencyValidation->bookHistograms(iBooker);
+    theStubResolutionValidation->bookHistograms(iBooker);
+  }
 }
 
 void CSCDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &eventSetup) {
-  theSimHitMap.fill(e);
-
   // find the geometry & conditions for this event
   const CSCGeometry *pGeom = &eventSetup.getData(geomToken_);
 
@@ -61,12 +63,23 @@ void CSCDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &even
   theComparatorDigiValidation->setGeometry(pGeom);
   theALCTDigiValidation->setGeometry(pGeom);
   theCLCTDigiValidation->setGeometry(pGeom);
-  theStubEfficiencyValidation->setGeometry(pGeom);
+  theCLCTPreTriggerDigiValidation->setGeometry(pGeom);
+  theCorrelatedLCTDigiValidation->setGeometry(pGeom);
+  if (doSim_) {
+    theSimHitMap->fill(e);
+    theStubEfficiencyValidation->setGeometry(pGeom);
+    theStubResolutionValidation->setGeometry(pGeom);
+  }
 
   theStripDigiValidation->analyze(e, eventSetup);
   theWireDigiValidation->analyze(e, eventSetup);
   theComparatorDigiValidation->analyze(e, eventSetup);
   theALCTDigiValidation->analyze(e, eventSetup);
   theCLCTDigiValidation->analyze(e, eventSetup);
-  theStubEfficiencyValidation->analyze(e, eventSetup);
+  theCLCTPreTriggerDigiValidation->analyze(e, eventSetup);
+  theCorrelatedLCTDigiValidation->analyze(e, eventSetup);
+  if (doSim_) {
+    theStubEfficiencyValidation->analyze(e, eventSetup);
+    theStubResolutionValidation->analyze(e, eventSetup);
+  }
 }
diff --git a/Validation/MuonCSCDigis/plugins/CSCDigiValidation.h b/Validation/MuonCSCDigis/plugins/CSCDigiValidation.h
index 9779ce9ce691e..ac8e7d30a04c9 100644
--- a/Validation/MuonCSCDigis/plugins/CSCDigiValidation.h
+++ b/Validation/MuonCSCDigis/plugins/CSCDigiValidation.h
@@ -18,7 +18,10 @@ class CSCWireDigiValidation;
 class CSCComparatorDigiValidation;
 class CSCALCTDigiValidation;
 class CSCCLCTDigiValidation;
+class CSCCLCTPreTriggerDigiValidation;
+class CSCCorrelatedLCTDigiValidation;
 class CSCStubEfficiencyValidation;
+class CSCStubResolutionValidation;
 
 class CSCDigiValidation : public DQMEDAnalyzer {
 public:
@@ -29,8 +32,8 @@ class CSCDigiValidation : public DQMEDAnalyzer {
 
 private:
   bool doSim_;
-  PSimHitMap theSimHitMap;
-  CSCGeometry *theCSCGeometry;
+  PSimHitMap *theSimHitMap;
+  const CSCGeometry *theCSCGeometry;
 
   // validation modules
   std::unique_ptr<CSCStripDigiValidation> theStripDigiValidation;
@@ -38,7 +41,10 @@ class CSCDigiValidation : public DQMEDAnalyzer {
   std::unique_ptr<CSCComparatorDigiValidation> theComparatorDigiValidation;
   std::unique_ptr<CSCALCTDigiValidation> theALCTDigiValidation;
   std::unique_ptr<CSCCLCTDigiValidation> theCLCTDigiValidation;
+  std::unique_ptr<CSCCLCTPreTriggerDigiValidation> theCLCTPreTriggerDigiValidation;
+  std::unique_ptr<CSCCorrelatedLCTDigiValidation> theCorrelatedLCTDigiValidation;
   std::unique_ptr<CSCStubEfficiencyValidation> theStubEfficiencyValidation;
+  std::unique_ptr<CSCStubResolutionValidation> theStubResolutionValidation;
 
   // geometry
   edm::ESGetToken<CSCGeometry, MuonGeometryRecord> geomToken_;
diff --git a/Validation/MuonCSCDigis/plugins/MuonCSCDigisHarvestor.cc b/Validation/MuonCSCDigis/plugins/MuonCSCDigisHarvestor.cc
index ab57c65447c0a..01f1673448e90 100644
--- a/Validation/MuonCSCDigis/plugins/MuonCSCDigisHarvestor.cc
+++ b/Validation/MuonCSCDigis/plugins/MuonCSCDigisHarvestor.cc
@@ -23,25 +23,29 @@ MuonCSCDigisHarvestor::MuonCSCDigisHarvestor(const edm::ParameterSet& pset)
     : MuonGEMBaseHarvestor(pset, "MuonGEMDigisHarvestor") {}
 
 void MuonCSCDigisHarvestor::dqmEndJob(DQMStore::IBooker& booker, DQMStore::IGetter& getter) {
-  std::string eff_folder = "MuonCSCDigisV/CSCDigiTask/Stub/Efficiency/";
-  std::string occ_folder = "MuonCSCDigisV/CSCDigiTask/Stub/Occupancy/";
-
   for (int i = 1; i <= 10; ++i) {
     const std::string cn(CSCDetId::chamberName(i));
-    std::string d1 = occ_folder + "ALCTEtaDenom_" + cn;
-    std::string d2 = occ_folder + "CLCTEtaDenom_" + cn;
-    std::string d3 = occ_folder + "LCTEtaDenom_" + cn;
 
+    std::string occ_folder = "MuonCSCDigisV/CSCDigiTask/ALCT/Occupancy/";
+    std::string d1 = occ_folder + "ALCTEtaDenom_" + cn;
     std::string n1 = occ_folder + "ALCTEtaNum_" + cn;
-    std::string n2 = occ_folder + "CLCTEtaNum_" + cn;
-    std::string n3 = occ_folder + "LCTEtaNum_" + cn;
-
     std::string e1 = "ALCTEtaEff_" + cn;
+
+    occ_folder = "MuonCSCDigisV/CSCDigiTask/CLCT/Occupancy/";
+    std::string d2 = occ_folder + "CLCTEtaDenom_" + cn;
+    std::string n2 = occ_folder + "CLCTEtaNum_" + cn;
     std::string e2 = "CLCTEtaEff_" + cn;
+
+    occ_folder = "MuonCSCDigisV/CSCDigiTask/LCT/Occupancy/";
+    std::string d3 = occ_folder + "LCTEtaDenom_" + cn;
+    std::string n3 = occ_folder + "LCTEtaNum_" + cn;
     std::string e3 = "LCTEtaEff_" + cn;
 
+    std::string eff_folder = "MuonCSCDigisV/CSCDigiTask/ALCT/Efficiency/";
     bookEff1D(booker, getter, n1, d1, eff_folder, e1, cn + " ALCT Efficiency;True Muon |#eta|;Efficiency");
+    eff_folder = "MuonCSCDigisV/CSCDigiTask/CLCT/Efficiency/";
     bookEff1D(booker, getter, n2, d2, eff_folder, e2, cn + " CLCT Efficiency;True Muon |#eta|;Efficiency");
+    eff_folder = "MuonCSCDigisV/CSCDigiTask/LCT/Efficiency/";
     bookEff1D(booker, getter, n3, d3, eff_folder, e3, cn + " LCT Efficiency;True Muon |#eta|;Efficiency");
   }
 }
diff --git a/Validation/MuonCSCDigis/python/cscDigiValidation_cfi.py b/Validation/MuonCSCDigis/python/cscDigiValidation_cfi.py
index 8eeffc88072cd..bf5b6a176b58e 100644
--- a/Validation/MuonCSCDigis/python/cscDigiValidation_cfi.py
+++ b/Validation/MuonCSCDigis/python/cscDigiValidation_cfi.py
@@ -14,15 +14,62 @@
     simHitsTag = cms.InputTag("mix", "g4SimHitsMuonCSCHits"),
     doSim = cms.bool(True),
     useGEMs = cms.bool(False),
-    ## numbering follows the chamberType in CSCDetId
+    # numbering follows the chamberType in CSCDetId
     etaMins = cms.vdouble(2.0, 1.6, 1.2, 0.9, 1.6, 1.0, 1.7, 1.1, 1.8, 1.2),
-    etaMaxs = cms.vdouble(2.4, 2.2, 1.7, 1.1, 2.4, 1.6, 2.4, 1.7, 2.4, 1.8)
+    etaMaxs = cms.vdouble(2.4, 2.2, 1.7, 1.1, 2.4, 1.6, 2.4, 1.7, 2.4, 1.8),
+    # variables for extra diagnostic plots
+    # largely copied from DQM/L1TMonitor/python/L1TdeCSCTPG_cfi.py
+    chambers = cms.vstring("ME11", "ME12", "ME13", "ME21", "ME22",
+                           "ME31", "ME32", "ME41", "ME42"),
+    # which chambers are running the Run-3 algorithm already?
+    # currently ME1/1, ME2/1, ME3/1 and ME4/1
+    # ME1/3 and MEX/2 not configured with Run-3 algorithm from start of data taking
+    chambersRun3 = cms.vuint32(0, 3, 5, 7),
+    alctVars = cms.vstring("quality", "wiregroup", "bx"),
+    alctNBin = cms.vuint32(6, 116, 16),
+    alctMinBin = cms.vdouble(0, 0, 0),
+    alctMaxBin = cms.vdouble(6, 116, 16),
+    clctVars = cms.vstring(
+        # For Run-2 eras
+        "quality", "halfstrip", "pattern", "bend", "bx",
+        # Added in Run-3 eras
+        # The quartstripbit and eighthstripbit are left out to prevent
+        # too many plots being created by the release validation
+        "quartstrip", "eighthstrip", "run3pattern",
+        "slope", "compcode"),
+    clctNBin = cms.vuint32(6, 224, 16, 2, 16, 448, 896, 5, 16, 410),
+    clctMinBin = cms.vdouble(3, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+    clctMaxBin = cms.vdouble(9, 224, 16, 2, 16, 448, 896, 5, 16, 410),
+    preclctVars = cms.vstring(
+        # for pretriggers we look at a reduced set of variables
+        "cfeb", "halfstrip", "bx"),
+    preclctNBin = cms.vuint32(7, 224, 16),
+    preclctMinBin = cms.vdouble(0, 0, 0),
+    preclctMaxBin = cms.vdouble(7, 224, 16),
+    lctVars = cms.vstring(
+        # For Run-2 eras
+        "quality", "wiregroup", "halfstrip", "pattern", "bend", "bx",
+        # Added in Run-3 eras
+        # The quartstripbit and eighthstripbit are left out to prevent
+        # too many plots being created by the release validation
+        "quartstrip", "eighthstrip", "run3pattern", "slope"),
+    lctNBin = cms.vuint32(16, 116, 224, 16, 2, 16, 448, 896, 5, 16),
+    lctMinBin = cms.vdouble(0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+    lctMaxBin = cms.vdouble(16, 116, 224, 16, 2, 16, 448, 896, 5, 16),
+    isRun3 = cms.bool(False),
+)
+
+from Configuration.Eras.Modifier_run3_common_cff import run3_common
+run3_common.toModify(cscDigiValidation,
+                     isRun3 = True
 )
 
 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
-run3_GEM.toModify(cscDigiValidation, useGEMs = True)
+run3_GEM.toModify(cscDigiValidation,
+                  useGEMs = True
+)
 
-## do not run GEMs in fastsim sequences
+# do not run GEMs in fastsim sequences
 from Configuration.Eras.Modifier_fastSim_cff import fastSim
 fastSim.toModify(cscDigiValidation,
                  simHitsTag = "mix:MuonSimHitsMuonCSCHits",
diff --git a/Validation/MuonCSCDigis/python/muonCSCStubPSet.py b/Validation/MuonCSCDigis/python/muonCSCStubPSet.py
index 86dae65fddb56..5363089615c55 100644
--- a/Validation/MuonCSCDigis/python/muonCSCStubPSet.py
+++ b/Validation/MuonCSCDigis/python/muonCSCStubPSet.py
@@ -1,6 +1,14 @@
 import FWCore.ParameterSet.Config as cms
 
 muonCSCStubPSet = cms.PSet(
+    #csc CLCT pre-trigger
+    cscCLCTPreTrigger = cms.PSet(
+        verbose = cms.int32(0),
+        inputTag = cms.InputTag("simCscTriggerPrimitiveDigis"),
+        minBX = cms.int32(6),
+        maxBX = cms.int32(8),
+        minNHitsChamber = cms.int32(3),
+    ),
     #csc CLCT, central BX 7
     cscCLCT = cms.PSet(
         verbose = cms.int32(0),
diff --git a/Validation/MuonCSCDigis/src/CSCALCTDigiValidation.cc b/Validation/MuonCSCDigis/src/CSCALCTDigiValidation.cc
index 79fddd684a516..d75130f3be65c 100644
--- a/Validation/MuonCSCDigis/src/CSCALCTDigiValidation.cc
+++ b/Validation/MuonCSCDigis/src/CSCALCTDigiValidation.cc
@@ -7,7 +7,15 @@
 #include "Geometry/CSCGeometry/interface/CSCLayerGeometry.h"
 
 CSCALCTDigiValidation::CSCALCTDigiValidation(const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)
-    : CSCBaseValidation(ps), theTimeBinPlots(), theNDigisPerChamberPlots() {
+    : CSCBaseValidation(ps),
+      theNDigisPerChamberPlots(),
+      chambers_(ps.getParameter<std::vector<std::string>>("chambers")),
+      // variables
+      alctVars_(ps.getParameter<std::vector<std::string>>("alctVars")),
+      // binning
+      alctNBin_(ps.getParameter<std::vector<unsigned>>("alctNBin")),
+      alctMinBin_(ps.getParameter<std::vector<double>>("alctMinBin")),
+      alctMaxBin_(ps.getParameter<std::vector<double>>("alctMaxBin")) {
   const auto &pset = ps.getParameterSet("cscALCT");
   inputTag_ = pset.getParameter<edm::InputTag>("inputTag");
   alcts_Token_ = iC.consumes<CSCALCTDigiCollection>(inputTag_);
@@ -16,15 +24,33 @@ CSCALCTDigiValidation::CSCALCTDigiValidation(const edm::ParameterSet &ps, edm::C
 CSCALCTDigiValidation::~CSCALCTDigiValidation() {}
 
 void CSCALCTDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
+  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/ALCT/Occupancy/");
+
   theNDigisPerEventPlot = iBooker.book1D(
       "CSCALCTDigisPerEvent", "ALCT trigger primitives per event; Number of ALCTs; Entries", 100, 0, 100);
   for (int i = 1; i <= 10; ++i) {
-    const std::string t1("CSCALCTDigiTime_" + CSCDetId::chamberName(i));
     const std::string t2("CSCALCTDigisPerChamber_" + CSCDetId::chamberName(i));
-    theTimeBinPlots[i - 1] = iBooker.book1D(t1, "ALCT BX " + CSCDetId::chamberName(i) + ";ALCT BX; Entries", 16, 0, 16);
     theNDigisPerChamberPlots[i - 1] = iBooker.book1D(
         t2, "Number of ALCTs per chamber " + CSCDetId::chamberName(i) + ";Number of ALCTs per chamber;Entries", 4, 0, 4);
   }
+
+  // chamber type
+  for (unsigned iType = 0; iType < chambers_.size(); iType++) {
+    // consider CSC+ and CSC- separately
+    for (unsigned iEndcap = 0; iEndcap < 2; iEndcap++) {
+      const std::string eSign(iEndcap == 0 ? "+" : "-");
+      // alct variable
+      for (unsigned iVar = 0; iVar < alctVars_.size(); iVar++) {
+        const std::string key("alct_" + alctVars_[iVar]);
+        const std::string histName(key + "_" + chambers_[iType] + eSign);
+        const std::string histTitle(chambers_[iType] + eSign + " ALCT " + alctVars_[iVar]);
+        const unsigned iTypeCorrected(iEndcap == 0 ? iType : iType + chambers_.size());
+        chamberHistos[iTypeCorrected][key] =
+            iBooker.book1D(histName, histTitle, alctNBin_[iVar], alctMinBin_[iVar], alctMaxBin_[iVar]);
+        chamberHistos[iTypeCorrected][key]->getTH1()->SetMinimum(0);
+      }
+    }
+  }
 }
 
 void CSCALCTDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &) {
@@ -38,14 +64,21 @@ void CSCALCTDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &
   for (auto j = alcts->begin(); j != alcts->end(); j++) {
     auto beginDigi = (*j).second.first;
     auto endDigi = (*j).second.second;
-    CSCDetId detId((*j).first.rawId());
+    const CSCDetId &detId((*j).first);
     int chamberType = detId.iChamberType();
     int nDigis = endDigi - beginDigi;
     nDigisPerEvent += nDigis;
     theNDigisPerChamberPlots[chamberType - 1]->Fill(nDigis);
 
-    for (auto digiItr = beginDigi; digiItr != endDigi; ++digiItr) {
-      theTimeBinPlots[chamberType - 1]->Fill(digiItr->getBX());
+    auto range = alcts->get((*j).first);
+    // 1=forward (+Z); 2=backward (-Z)
+    const unsigned typeCorrected(detId.endcap() == 1 ? chamberType - 2 : chamberType - 2 + chambers_.size());
+    for (auto alct = range.first; alct != range.second; alct++) {
+      if (alct->isValid()) {
+        chamberHistos[typeCorrected]["alct_quality"]->Fill(alct->getQuality());
+        chamberHistos[typeCorrected]["alct_wiregroup"]->Fill(alct->getKeyWG());
+        chamberHistos[typeCorrected]["alct_bx"]->Fill(alct->getBX());
+      }
     }
   }
   theNDigisPerEventPlot->Fill(nDigisPerEvent);
diff --git a/Validation/MuonCSCDigis/src/CSCBaseValidation.cc b/Validation/MuonCSCDigis/src/CSCBaseValidation.cc
index f201f7cf65e9e..088dfe85c1015 100644
--- a/Validation/MuonCSCDigis/src/CSCBaseValidation.cc
+++ b/Validation/MuonCSCDigis/src/CSCBaseValidation.cc
@@ -2,10 +2,34 @@
 #include "Validation/MuonCSCDigis/interface/CSCBaseValidation.h"
 
 CSCBaseValidation::CSCBaseValidation(const edm::ParameterSet &ps)
-    : doSim_(ps.getParameter<bool>("doSim")), theSimHitMap(nullptr), theCSCGeometry(nullptr) {}
+    : doSim_(ps.getParameter<bool>("doSim")), theSimHitMap(nullptr), theCSCGeometry(nullptr) {
+  const auto &simTrack = ps.getParameter<edm::ParameterSet>("simTrack");
+  simTrackMinPt_ = simTrack.getParameter<double>("minPt");
+  simTrackMinEta_ = simTrack.getParameter<double>("minEta");
+  simTrackMaxEta_ = simTrack.getParameter<double>("maxEta");
+}
 
 const CSCLayer *CSCBaseValidation::findLayer(int detId) const {
   assert(theCSCGeometry != nullptr);
   const GeomDetUnit *detUnit = theCSCGeometry->idToDetUnit(CSCDetId(detId));
   return dynamic_cast<const CSCLayer *>(detUnit);
 }
+
+bool CSCBaseValidation::isSimTrackGood(const SimTrack &t) const {
+  // SimTrack selection
+  if (t.noVertex())
+    return false;
+  if (t.noGenpart())
+    return false;
+  // only muons
+  if (std::abs(t.type()) != 13)
+    return false;
+  // pt selection
+  if (t.momentum().pt() < simTrackMinPt_)
+    return false;
+  // eta selection
+  const float eta(std::abs(t.momentum().eta()));
+  if (eta > simTrackMaxEta_ || eta < simTrackMinEta_)
+    return false;
+  return true;
+}
diff --git a/Validation/MuonCSCDigis/src/CSCCLCTDigiValidation.cc b/Validation/MuonCSCDigis/src/CSCCLCTDigiValidation.cc
index 5d11ecf8830c6..392a5545504f5 100644
--- a/Validation/MuonCSCDigis/src/CSCCLCTDigiValidation.cc
+++ b/Validation/MuonCSCDigis/src/CSCCLCTDigiValidation.cc
@@ -7,7 +7,17 @@
 #include "Geometry/CSCGeometry/interface/CSCLayerGeometry.h"
 
 CSCCLCTDigiValidation::CSCCLCTDigiValidation(const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)
-    : CSCBaseValidation(ps), theTimeBinPlots(), theNDigisPerChamberPlots() {
+    : CSCBaseValidation(ps),
+      theNDigisPerChamberPlots(),
+      chambers_(ps.getParameter<std::vector<std::string>>("chambers")),
+      chambersRun3_(ps.getParameter<std::vector<unsigned>>("chambersRun3")),
+      // variables
+      clctVars_(ps.getParameter<std::vector<std::string>>("clctVars")),
+      // binning
+      clctNBin_(ps.getParameter<std::vector<unsigned>>("clctNBin")),
+      clctMinBin_(ps.getParameter<std::vector<double>>("clctMinBin")),
+      clctMaxBin_(ps.getParameter<std::vector<double>>("clctMaxBin")),
+      isRun3_(ps.getParameter<bool>("isRun3")) {
   const auto &pset = ps.getParameterSet("cscCLCT");
   inputTag_ = pset.getParameter<edm::InputTag>("inputTag");
   clcts_Token_ = iC.consumes<CSCCLCTDigiCollection>(inputTag_);
@@ -16,15 +26,42 @@ CSCCLCTDigiValidation::CSCCLCTDigiValidation(const edm::ParameterSet &ps, edm::C
 CSCCLCTDigiValidation::~CSCCLCTDigiValidation() {}
 
 void CSCCLCTDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
+  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/CLCT/Occupancy/");
+
   theNDigisPerEventPlot = iBooker.book1D(
       "CSCCLCTDigisPerEvent", "CLCT trigger primitives per event; Number of CLCTs; Entries", 100, 0, 100);
   for (int i = 1; i <= 10; ++i) {
-    const std::string t1("CSCCLCTDigiTime_" + CSCDetId::chamberName(i));
     const std::string t2("CSCCLCTDigisPerChamber_" + CSCDetId::chamberName(i));
-    theTimeBinPlots[i - 1] = iBooker.book1D(t1, "CLCT BX " + CSCDetId::chamberName(i) + ";CLCT BX; Entries", 16, 0, 16);
     theNDigisPerChamberPlots[i - 1] = iBooker.book1D(
         t2, "Number of CLCTs per chamber " + CSCDetId::chamberName(i) + ";Number of CLCTs per chamber;Entries", 4, 0, 4);
   }
+
+  // do not analyze Run-3 properties in Run-1 and Run-2 eras
+  if (!isRun3_) {
+    clctVars_.resize(5);
+  }
+
+  // chamber type
+  for (unsigned iType = 0; iType < chambers_.size(); iType++) {
+    // consider CSC+ and CSC- separately
+    for (unsigned iEndcap = 0; iEndcap < 2; iEndcap++) {
+      const std::string eSign(iEndcap == 0 ? "+" : "-");
+      // clct variable
+      for (unsigned iVar = 0; iVar < clctVars_.size(); iVar++) {
+        if (std::find(chambersRun3_.begin(), chambersRun3_.end(), iType) == chambersRun3_.end()) {
+          if (iVar > 4)
+            continue;
+        }
+        const std::string key("clct_" + clctVars_[iVar]);
+        const std::string histName(key + "_" + chambers_[iType] + eSign);
+        const std::string histTitle(chambers_[iType] + eSign + " CLCT " + clctVars_[iVar]);
+        const unsigned iTypeCorrected(iEndcap == 0 ? iType : iType + chambers_.size());
+        chamberHistos[iTypeCorrected][key] =
+            iBooker.book1D(histName, histTitle, clctNBin_[iVar], clctMinBin_[iVar], clctMaxBin_[iVar]);
+        chamberHistos[iTypeCorrected][key]->getTH1()->SetMinimum(0);
+      }
+    }
+  }
 }
 
 void CSCCLCTDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &) {
@@ -39,15 +76,33 @@ void CSCCLCTDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &
   for (auto j = clcts->begin(); j != clcts->end(); j++) {
     auto beginDigi = (*j).second.first;
     auto endDigi = (*j).second.second;
-    CSCDetId detId((*j).first.rawId());
+    const CSCDetId &detId((*j).first);
     int chamberType = detId.iChamberType();
-
     int nDigis = endDigi - beginDigi;
     nDigisPerEvent += nDigis;
     theNDigisPerChamberPlots[chamberType - 1]->Fill(nDigis);
 
-    for (auto digiItr = beginDigi; digiItr != endDigi; ++digiItr) {
-      theTimeBinPlots[chamberType - 1]->Fill(digiItr->getBX());
+    auto range = clcts->get((*j).first);
+    // 1=forward (+Z); 2=backward (-Z)
+    const unsigned typeCorrected(detId.endcap() == 1 ? chamberType - 2 : chamberType - 2 + chambers_.size());
+    for (auto clct = range.first; clct != range.second; clct++) {
+      if (clct->isValid()) {
+        chamberHistos[typeCorrected]["clct_pattern"]->Fill(clct->getPattern());
+        chamberHistos[typeCorrected]["clct_quality"]->Fill(clct->getQuality());
+        chamberHistos[typeCorrected]["clct_halfstrip"]->Fill(clct->getKeyStrip());
+        chamberHistos[typeCorrected]["clct_bend"]->Fill(clct->getBend());
+        chamberHistos[typeCorrected]["clct_bx"]->Fill(clct->getBX());
+        if (isRun3_) {
+          // ignore these fields for chambers that do not enable the Run-3 algorithm
+          if (std::find(chambersRun3_.begin(), chambersRun3_.end(), chamberType - 2) == chambersRun3_.end())
+            continue;
+          chamberHistos[typeCorrected]["clct_run3pattern"]->Fill(clct->getRun3Pattern());
+          chamberHistos[typeCorrected]["clct_quartstrip"]->Fill(clct->getKeyStrip(4));
+          chamberHistos[typeCorrected]["clct_eighthstrip"]->Fill(clct->getKeyStrip(8));
+          chamberHistos[typeCorrected]["clct_slope"]->Fill(clct->getSlope());
+          chamberHistos[typeCorrected]["clct_compcode"]->Fill(clct->getCompCode());
+        }
+      }
     }
   }
   theNDigisPerEventPlot->Fill(nDigisPerEvent);
diff --git a/Validation/MuonCSCDigis/src/CSCCLCTPreTriggerDigiValidation.cc b/Validation/MuonCSCDigis/src/CSCCLCTPreTriggerDigiValidation.cc
new file mode 100644
index 0000000000000..472243c6fccc2
--- /dev/null
+++ b/Validation/MuonCSCDigis/src/CSCCLCTPreTriggerDigiValidation.cc
@@ -0,0 +1,70 @@
+#include "DataFormats/Common/interface/Handle.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "Validation/MuonCSCDigis/interface/CSCCLCTPreTriggerDigiValidation.h"
+
+#include "DQMServices/Core/interface/DQMStore.h"
+#include "Geometry/CSCGeometry/interface/CSCGeometry.h"
+#include "Geometry/CSCGeometry/interface/CSCLayerGeometry.h"
+
+CSCCLCTPreTriggerDigiValidation::CSCCLCTPreTriggerDigiValidation(const edm::ParameterSet &ps,
+                                                                 edm::ConsumesCollector &&iC)
+    : CSCBaseValidation(ps),
+      chambers_(ps.getParameter<std::vector<std::string>>("chambers")),
+      // variables
+      preclctVars_(ps.getParameter<std::vector<std::string>>("preclctVars")),
+      // binning
+      preclctNBin_(ps.getParameter<std::vector<unsigned>>("preclctNBin")),
+      preclctMinBin_(ps.getParameter<std::vector<double>>("preclctMinBin")),
+      preclctMaxBin_(ps.getParameter<std::vector<double>>("preclctMaxBin")) {
+  const auto &pset = ps.getParameterSet("cscCLCTPreTrigger");
+  inputTag_ = pset.getParameter<edm::InputTag>("inputTag");
+  preclcts_Token_ = iC.consumes<CSCCLCTPreTriggerDigiCollection>(inputTag_);
+}
+
+CSCCLCTPreTriggerDigiValidation::~CSCCLCTPreTriggerDigiValidation() {}
+
+void CSCCLCTPreTriggerDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
+  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/PreCLCT/Occupancy/");
+
+  // chamber type
+  for (unsigned iType = 0; iType < chambers_.size(); iType++) {
+    // consider CSC+ and CSC- separately
+    for (unsigned iEndcap = 0; iEndcap < 2; iEndcap++) {
+      const std::string eSign(iEndcap == 0 ? "+" : "-");
+      // preclct variable
+      for (unsigned iVar = 0; iVar < preclctVars_.size(); iVar++) {
+        const std::string key("preclct_" + preclctVars_[iVar]);
+        const std::string histName(key + "_" + chambers_[iType] + eSign);
+        const std::string histTitle(chambers_[iType] + eSign + " CLCTPreTrigger " + preclctVars_[iVar]);
+        const unsigned iTypeCorrected(iEndcap == 0 ? iType : iType + chambers_.size());
+        chamberHistos[iTypeCorrected][key] =
+            iBooker.book1D(histName, histTitle, preclctNBin_[iVar], preclctMinBin_[iVar], preclctMaxBin_[iVar]);
+        chamberHistos[iTypeCorrected][key]->getTH1()->SetMinimum(0);
+      }
+    }
+  }
+}
+
+void CSCCLCTPreTriggerDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &) {
+  edm::Handle<CSCCLCTPreTriggerDigiCollection> preclcts;
+  e.getByToken(preclcts_Token_, preclcts);
+  if (!preclcts.isValid()) {
+    edm::LogError("CSCCLCTPreTriggerDigiValidation") << "Cannot get CLCTPreTriggers by label " << inputTag_.encode();
+  }
+
+  for (auto j = preclcts->begin(); j != preclcts->end(); j++) {
+    const CSCDetId &detId((*j).first);
+    int chamberType = detId.iChamberType();
+
+    auto range = preclcts->get((*j).first);
+    // 1=forward (+Z); 2=backward (-Z)
+    const unsigned typeCorrected(detId.endcap() == 1 ? chamberType - 2 : chamberType - 2 + chambers_.size());
+    for (auto preclct = range.first; preclct != range.second; preclct++) {
+      if (preclct->isValid()) {
+        chamberHistos[typeCorrected]["preclct_cfeb"]->Fill(preclct->getCFEB());
+        chamberHistos[typeCorrected]["preclct_halfstrip"]->Fill(preclct->getKeyStrip());
+        chamberHistos[typeCorrected]["preclct_bx"]->Fill(preclct->getBX());
+      }
+    }
+  }
+}
diff --git a/Validation/MuonCSCDigis/src/CSCComparatorDigiValidation.cc b/Validation/MuonCSCDigis/src/CSCComparatorDigiValidation.cc
index 40ab78fbd0c67..9cc9ba8b79d8e 100644
--- a/Validation/MuonCSCDigis/src/CSCComparatorDigiValidation.cc
+++ b/Validation/MuonCSCDigis/src/CSCComparatorDigiValidation.cc
@@ -2,6 +2,7 @@
 #include "DataFormats/Common/interface/Handle.h"
 #include "FWCore/MessageLogger/interface/MessageLogger.h"
 #include "Validation/MuonCSCDigis/interface/CSCComparatorDigiValidation.h"
+#include "DataFormats/CSCDigi/interface/CSCConstants.h"
 
 CSCComparatorDigiValidation::CSCComparatorDigiValidation(const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)
     : CSCBaseValidation(ps), theTimeBinPlots(), theNDigisPerLayerPlots(), theStripDigiPlots(), the3StripPlots() {
@@ -17,6 +18,8 @@ CSCComparatorDigiValidation::CSCComparatorDigiValidation(const edm::ParameterSet
 CSCComparatorDigiValidation::~CSCComparatorDigiValidation() {}
 
 void CSCComparatorDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
+  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/Comparator/Occupancy/");
+
   theNDigisPerEventPlot = iBooker.book1D("CSCComparatorDigisPerEvent",
                                          "CSC Comparator Digis per event;CSC Comparator Digis per event;Entries",
                                          100,
@@ -45,6 +48,18 @@ void CSCComparatorDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
         0,
         1000);
   }
+  if (doSim_) {
+    iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/Comparator/Resolution/");
+    for (int i = 1; i <= 10; ++i) {
+      const std::string t1("CSCComparatorPosResolution_" + CSCDetId::chamberName(i));
+      theResolutionPlots[i - 1] = iBooker.book1D(t1,
+                                                 "Comparator X Position Resolution " + CSCDetId::chamberName(i) +
+                                                     ";Comparator X Position Resolution [cm]; Entries",
+                                                 100,
+                                                 -5,
+                                                 5);
+    }
+  }
 }
 
 void CSCComparatorDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &) {
@@ -69,9 +84,19 @@ void CSCComparatorDigiValidation::analyze(const edm::Event &e, const edm::EventS
     CSCDetId detId((*j).first);
     const CSCLayer *layer = findLayer(detId.rawId());
     int chamberType = layer->chamber()->specs()->chamberType();
+    int nDigis = last - digiItr;
 
     theNDigisPerLayerPlots[chamberType - 1]->Fill(last - digiItr);
 
+    // require exactly one comparator digi per layer
+    if (doSim_) {
+      const edm::PSimHitContainer &simHits = theSimHitMap->hits(detId);
+      if (nDigis == 1 && simHits.size() == 1) {
+        const int fullStrip(digiItr->getStrip() + digiItr->getCFEB() * CSCConstants::NUM_STRIPS_PER_CFEB);
+        plotResolution(simHits[0], fullStrip, layer, chamberType);
+      }
+    }
+
     for (auto stripRange = stripDigis->get(detId); digiItr != last; ++digiItr) {
       ++nDigisPerEvent;
       theTimeBinPlots[chamberType - 1]->Fill(digiItr->getTimeBin());
@@ -98,3 +123,10 @@ void CSCComparatorDigiValidation::analyze(const edm::Event &e, const edm::EventS
   }
   theNDigisPerEventPlot->Fill(nDigisPerEvent);
 }
+
+void CSCComparatorDigiValidation::plotResolution(const PSimHit &hit, int strip, const CSCLayer *layer, int chamberType) {
+  double hitX = hit.localPosition().x();
+  double hitY = hit.localPosition().y();
+  double digiX = layer->geometry()->xOfStrip(strip, hitY);
+  theResolutionPlots[chamberType - 1]->Fill(digiX - hitX);
+}
diff --git a/Validation/MuonCSCDigis/src/CSCCorrelatedLCTDigiValidation.cc b/Validation/MuonCSCDigis/src/CSCCorrelatedLCTDigiValidation.cc
new file mode 100644
index 0000000000000..c609e959b5caa
--- /dev/null
+++ b/Validation/MuonCSCDigis/src/CSCCorrelatedLCTDigiValidation.cc
@@ -0,0 +1,118 @@
+#include "DataFormats/Common/interface/Handle.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "Validation/MuonCSCDigis/interface/CSCCorrelatedLCTDigiValidation.h"
+
+#include "DQMServices/Core/interface/DQMStore.h"
+#include "Geometry/CSCGeometry/interface/CSCGeometry.h"
+#include "Geometry/CSCGeometry/interface/CSCLayerGeometry.h"
+
+CSCCorrelatedLCTDigiValidation::CSCCorrelatedLCTDigiValidation(const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)
+    : CSCBaseValidation(ps),
+      theNDigisPerChamberPlots(),
+      chambers_(ps.getParameter<std::vector<std::string>>("chambers")),
+      chambersRun3_(ps.getParameter<std::vector<unsigned>>("chambersRun3")),
+      // variables
+      lctVars_(ps.getParameter<std::vector<std::string>>("lctVars")),
+      // binning
+      lctNBin_(ps.getParameter<std::vector<unsigned>>("lctNBin")),
+      lctMinBin_(ps.getParameter<std::vector<double>>("lctMinBin")),
+      lctMaxBin_(ps.getParameter<std::vector<double>>("lctMaxBin")),
+      isRun3_(ps.getParameter<bool>("isRun3")) {
+  const auto &pset = ps.getParameterSet("cscMPLCT");
+  inputTag_ = pset.getParameter<edm::InputTag>("inputTag");
+  lcts_Token_ = iC.consumes<CSCCorrelatedLCTDigiCollection>(inputTag_);
+}
+
+CSCCorrelatedLCTDigiValidation::~CSCCorrelatedLCTDigiValidation() {}
+
+void CSCCorrelatedLCTDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
+  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/LCT/Occupancy/");
+
+  theNDigisPerEventPlot =
+      iBooker.book1D("CSCCorrelatedLCTDigisPerEvent",
+                     "CorrelatedLCT trigger primitives per event; Number of CorrelatedLCTs; Entries",
+                     100,
+                     0,
+                     100);
+  for (int i = 1; i <= 10; ++i) {
+    const std::string t2("CSCCorrelatedLCTDigisPerChamber_" + CSCDetId::chamberName(i));
+    theNDigisPerChamberPlots[i - 1] =
+        iBooker.book1D(t2,
+                       "Number of CorrelatedLCTs per chamber " + CSCDetId::chamberName(i) +
+                           ";Number of CorrelatedLCTs per chamber;Entries",
+                       4,
+                       0,
+                       4);
+  }
+
+  // do not analyze Run-3 properties in Run-1 and Run-2 eras
+  if (!isRun3_) {
+    lctVars_.resize(6);
+  }
+
+  // chamber type
+  for (unsigned iType = 0; iType < chambers_.size(); iType++) {
+    // consider CSC+ and CSC- separately
+    for (unsigned iEndcap = 0; iEndcap < 2; iEndcap++) {
+      const std::string eSign(iEndcap == 0 ? "+" : "-");
+      // lct variable
+      for (unsigned iVar = 0; iVar < lctVars_.size(); iVar++) {
+        if (std::find(chambersRun3_.begin(), chambersRun3_.end(), iType) == chambersRun3_.end()) {
+          if (iVar > 5)
+            continue;
+        }
+        const std::string key("lct_" + lctVars_[iVar]);
+        const std::string histName(key + "_" + chambers_[iType] + eSign);
+        const std::string histTitle(chambers_[iType] + eSign + " LCT " + lctVars_[iVar]);
+        const unsigned iTypeCorrected(iEndcap == 0 ? iType : iType + chambers_.size());
+        chamberHistos[iTypeCorrected][key] =
+            iBooker.book1D(histName, histTitle, lctNBin_[iVar], lctMinBin_[iVar], lctMaxBin_[iVar]);
+        chamberHistos[iTypeCorrected][key]->getTH1()->SetMinimum(0);
+      }
+    }
+  }
+}
+
+void CSCCorrelatedLCTDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &) {
+  edm::Handle<CSCCorrelatedLCTDigiCollection> lcts;
+  e.getByToken(lcts_Token_, lcts);
+  if (!lcts.isValid()) {
+    edm::LogError("CSCDigiDump") << "Cannot get CorrelatedLCTs by label " << inputTag_.encode();
+  }
+
+  unsigned nDigisPerEvent = 0;
+
+  for (auto j = lcts->begin(); j != lcts->end(); j++) {
+    auto beginDigi = (*j).second.first;
+    auto endDigi = (*j).second.second;
+    const CSCDetId &detId((*j).first);
+    int chamberType = detId.iChamberType();
+    int nDigis = endDigi - beginDigi;
+    nDigisPerEvent += nDigis;
+    theNDigisPerChamberPlots[chamberType - 1]->Fill(nDigis);
+
+    auto range = lcts->get((*j).first);
+    // 1=forward (+Z); 2=backward (-Z)
+    const unsigned typeCorrected(detId.endcap() == 1 ? chamberType - 2 : chamberType - 2 + chambers_.size());
+    for (auto lct = range.first; lct != range.second; lct++) {
+      if (lct->isValid()) {
+        chamberHistos[typeCorrected]["lct_pattern"]->Fill(lct->getPattern());
+        chamberHistos[typeCorrected]["lct_quality"]->Fill(lct->getQuality());
+        chamberHistos[typeCorrected]["lct_wiregroup"]->Fill(lct->getKeyWG());
+        chamberHistos[typeCorrected]["lct_halfstrip"]->Fill(lct->getStrip());
+        chamberHistos[typeCorrected]["lct_bend"]->Fill(lct->getBend());
+        chamberHistos[typeCorrected]["lct_bx"]->Fill(lct->getBX());
+        if (isRun3_) {
+          // ignore these fields for chambers that do not enable the Run-3 algorithm
+          if (std::find(chambersRun3_.begin(), chambersRun3_.end(), chamberType - 2) == chambersRun3_.end())
+            continue;
+          chamberHistos[typeCorrected]["lct_run3pattern"]->Fill(lct->getRun3Pattern());
+          chamberHistos[typeCorrected]["lct_slope"]->Fill(lct->getSlope());
+          chamberHistos[typeCorrected]["lct_quartstrip"]->Fill(lct->getStrip(4));
+          chamberHistos[typeCorrected]["lct_eighthstrip"]->Fill(lct->getStrip(8));
+        }
+      }
+    }
+  }
+  theNDigisPerEventPlot->Fill(nDigisPerEvent);
+}
diff --git a/Validation/MuonCSCDigis/src/CSCStripDigiValidation.cc b/Validation/MuonCSCDigis/src/CSCStripDigiValidation.cc
index d6625438f65a8..7fb38e22f406b 100644
--- a/Validation/MuonCSCDigis/src/CSCStripDigiValidation.cc
+++ b/Validation/MuonCSCDigis/src/CSCStripDigiValidation.cc
@@ -19,6 +19,8 @@ CSCStripDigiValidation::CSCStripDigiValidation(const edm::ParameterSet &ps, edm:
 CSCStripDigiValidation::~CSCStripDigiValidation() {}
 
 void CSCStripDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
+  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/Strip/Occupancy");
+
   thePedestalPlot = iBooker.book1D("CSCPedestal", "CSC Pedestal;ADC Counts;Entries", 400, 550, 650);
   theAmplitudePlot = iBooker.book1D("CSCStripAmplitude", "CSC Strip Amplitude;Strip Amplitude;Entries", 200, 0, 2000);
   theRatio4to5Plot = iBooker.book1D("CSCStrip4to5", "CSC Strip Ratio tbin 4 to tbin 5;Strip Ratio;Entries", 100, 0, 1);
@@ -36,18 +38,6 @@ void CSCStripDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
                      100,
                      0,
                      500);
-
-  if (doSim_) {
-    for (int i = 1; i <= 10; ++i) {
-      const std::string t1("CSCStripPosResolution_" + CSCDetId::chamberName(i));
-      theResolutionPlots[i - 1] = iBooker.book1D(
-          t1,
-          "Strip X Position Resolution " + CSCDetId::chamberName(i) + ";Strip X Position Resolution; Entries",
-          100,
-          -5,
-          5);
-    }
-  }
 }
 
 void CSCStripDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &) {
@@ -62,23 +52,13 @@ void CSCStripDigiValidation::analyze(const edm::Event &e, const edm::EventSetup
   for (auto j = strips->begin(); j != strips->end(); j++) {
     auto digiItr = (*j).second.first;
     auto last = (*j).second.second;
-    int detId = (*j).first.rawId();
 
-    const CSCLayer *layer = findLayer(detId);
-    int chamberType = layer->chamber()->specs()->chamberType();
     int nDigis = last - digiItr;
     nDigisPerEvent += nDigis;
     theNDigisPerLayerPlot->Fill(nDigis);
 
     double maxAmplitude = 0.;
 
-    if (doSim_) {
-      const edm::PSimHitContainer simHits = theSimHitMap->hits(detId);
-      if (nDigis == 1 && simHits.size() == 1) {
-        plotResolution(simHits[0], digiItr->getStrip(), layer, chamberType);
-      }
-    }
-
     for (; digiItr != last; ++digiItr) {
       // average up the pedestals
       std::vector<int> adcCounts = digiItr->getADCCounts();
@@ -118,10 +98,3 @@ void CSCStripDigiValidation::fillSignalPlots(const CSCStripDigi &digi) {
   theRatio4to5Plot->Fill((adcCounts[3] - pedestal) / (adcCounts[4] - pedestal));
   theRatio6to5Plot->Fill((adcCounts[5] - pedestal) / (adcCounts[4] - pedestal));
 }
-
-void CSCStripDigiValidation::plotResolution(const PSimHit &hit, int strip, const CSCLayer *layer, int chamberType) {
-  double hitX = hit.localPosition().x();
-  double hitY = hit.localPosition().y();
-  double digiX = layer->geometry()->xOfStrip(strip, hitY);
-  theResolutionPlots[chamberType - 1]->Fill(digiX - hitX);
-}
diff --git a/Validation/MuonCSCDigis/src/CSCStubEfficiencyValidation.cc b/Validation/MuonCSCDigis/src/CSCStubEfficiencyValidation.cc
index 46b2c8e2d5bfe..39879f724f9ee 100644
--- a/Validation/MuonCSCDigis/src/CSCStubEfficiencyValidation.cc
+++ b/Validation/MuonCSCDigis/src/CSCStubEfficiencyValidation.cc
@@ -1,10 +1,7 @@
-#include "DataFormats/Common/interface/Handle.h"
-#include "FWCore/MessageLogger/interface/MessageLogger.h"
-#include "Validation/MuonCSCDigis/interface/CSCStubEfficiencyValidation.h"
+#include <memory>
 
-#include "DQMServices/Core/interface/DQMStore.h"
-#include "Geometry/CSCGeometry/interface/CSCGeometry.h"
-#include "Geometry/CSCGeometry/interface/CSCLayerGeometry.h"
+#include "Validation/MuonCSCDigis/interface/CSCStubEfficiencyValidation.h"
+#include "Validation/MuonCSCDigis/interface/CSCStubMatcher.h"
 
 CSCStubEfficiencyValidation::CSCStubEfficiencyValidation(const edm::ParameterSet& pset, edm::ConsumesCollector&& iC)
     : CSCBaseValidation(pset) {
@@ -12,19 +9,9 @@ CSCStubEfficiencyValidation::CSCStubEfficiencyValidation(const edm::ParameterSet
   simVertexInput_ = iC.consumes<edm::SimVertexContainer>(simVertex.getParameter<edm::InputTag>("inputTag"));
   const auto& simTrack = pset.getParameter<edm::ParameterSet>("simTrack");
   simTrackInput_ = iC.consumes<edm::SimTrackContainer>(simTrack.getParameter<edm::InputTag>("inputTag"));
-  simTrackMinPt_ = simTrack.getParameter<double>("minPt");
-  simTrackMinEta_ = simTrack.getParameter<double>("minEta");
-  simTrackMaxEta_ = simTrack.getParameter<double>("maxEta");
-
-  // all CSC TPs have the same label
-  const auto& stubConfig = pset.getParameterSet("cscALCT");
-  inputTag_ = stubConfig.getParameter<edm::InputTag>("inputTag");
-  alcts_Token_ = iC.consumes<CSCALCTDigiCollection>(inputTag_);
-  clcts_Token_ = iC.consumes<CSCCLCTDigiCollection>(inputTag_);
-  lcts_Token_ = iC.consumes<CSCCorrelatedLCTDigiCollection>(inputTag_);
 
   // Initialize stub matcher
-  cscStubMatcher_.reset(new CSCStubMatcher(pset, std::move(iC)));
+  cscStubMatcher_ = std::make_unique<CSCStubMatcher>(pset, std::move(iC));
 
   // get the eta ranges
   etaMins_ = pset.getParameter<std::vector<double>>("etaMins");
@@ -34,8 +21,6 @@ CSCStubEfficiencyValidation::CSCStubEfficiencyValidation(const edm::ParameterSet
 CSCStubEfficiencyValidation::~CSCStubEfficiencyValidation() {}
 
 void CSCStubEfficiencyValidation::bookHistograms(DQMStore::IBooker& iBooker) {
-  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/Stub/Occupancy/");
-
   for (int i = 1; i <= 10; ++i) {
     int j = i - 1;
     const std::string cn(CSCDetId::chamberName(i));
@@ -44,24 +29,25 @@ void CSCStubEfficiencyValidation::bookHistograms(DQMStore::IBooker& iBooker) {
     std::string t2 = "CLCTEtaDenom_" + cn;
     std::string t3 = "LCTEtaDenom_" + cn;
 
+    iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/ALCT/Occupancy/");
     etaALCTDenom[j] = iBooker.book1D(t1, t1 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
-    etaCLCTDenom[j] = iBooker.book1D(t2, t2 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
-    etaLCTDenom[j] = iBooker.book1D(t3, t3 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
-
     etaALCTDenom[j]->getTH1()->SetMinimum(0);
-    etaCLCTDenom[j]->getTH1()->SetMinimum(0);
-    etaLCTDenom[j]->getTH1()->SetMinimum(0);
-
     t1 = "ALCTEtaNum_" + cn;
-    t2 = "CLCTEtaNum_" + cn;
-    t3 = "LCTEtaNum_" + cn;
-
     etaALCTNum[j] = iBooker.book1D(t1, t1 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
-    etaCLCTNum[j] = iBooker.book1D(t2, t2 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
-    etaLCTNum[j] = iBooker.book1D(t3, t3 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
-
     etaALCTNum[j]->getTH1()->SetMinimum(0);
+
+    iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/CLCT/Occupancy/");
+    etaCLCTDenom[j] = iBooker.book1D(t2, t2 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
+    etaCLCTDenom[j]->getTH1()->SetMinimum(0);
+    t2 = "CLCTEtaNum_" + cn;
+    etaCLCTNum[j] = iBooker.book1D(t2, t2 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
     etaCLCTNum[j]->getTH1()->SetMinimum(0);
+
+    iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/LCT/Occupancy/");
+    etaLCTDenom[j] = iBooker.book1D(t3, t3 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
+    etaLCTDenom[j]->getTH1()->SetMinimum(0);
+    t3 = "LCTEtaNum_" + cn;
+    etaLCTNum[j] = iBooker.book1D(t3, t3 + ";True Muon |#eta|; Entries", 50, etaMins_[j], etaMaxs_[j]);
     etaLCTNum[j]->getTH1()->SetMinimum(0);
   }
 }
@@ -70,16 +56,10 @@ void CSCStubEfficiencyValidation::analyze(const edm::Event& e, const edm::EventS
   // Define handles
   edm::Handle<edm::SimTrackContainer> sim_tracks;
   edm::Handle<edm::SimVertexContainer> sim_vertices;
-  edm::Handle<CSCALCTDigiCollection> alcts;
-  edm::Handle<CSCCLCTDigiCollection> clcts;
-  edm::Handle<CSCCorrelatedLCTDigiCollection> lcts;
 
   // Use token to retreive event information
   e.getByToken(simTrackInput_, sim_tracks);
   e.getByToken(simVertexInput_, sim_vertices);
-  e.getByToken(alcts_Token_, alcts);
-  e.getByToken(clcts_Token_, clcts);
-  e.getByToken(lcts_Token_, lcts);
 
   // Initialize StubMatcher
   cscStubMatcher_->init(e, eventSetup);
@@ -87,16 +67,6 @@ void CSCStubEfficiencyValidation::analyze(const edm::Event& e, const edm::EventS
   const edm::SimTrackContainer& sim_track = *sim_tracks.product();
   const edm::SimVertexContainer& sim_vert = *sim_vertices.product();
 
-  if (!alcts.isValid()) {
-    edm::LogError("CSCStubEfficiencyValidation") << "Cannot get ALCTs by label " << inputTag_.encode();
-  }
-  if (!clcts.isValid()) {
-    edm::LogError("CSCStubEfficiencyValidation") << "Cannot get CLCTs by label " << inputTag_.encode();
-  }
-  if (!lcts.isValid()) {
-    edm::LogError("CSCStubEfficiencyValidation") << "Cannot get LCTs by label " << inputTag_.encode();
-  }
-
   // select simtracks for true muons
   edm::SimTrackContainer sim_track_selected;
   for (const auto& t : sim_track) {
@@ -160,22 +130,3 @@ void CSCStubEfficiencyValidation::analyze(const edm::Event& e, const edm::EventS
     }
   }
 }
-
-bool CSCStubEfficiencyValidation::isSimTrackGood(const SimTrack& t) {
-  // SimTrack selection
-  if (t.noVertex())
-    return false;
-  if (t.noGenpart())
-    return false;
-  // only muons
-  if (std::abs(t.type()) != 13)
-    return false;
-  // pt selection
-  if (t.momentum().pt() < simTrackMinPt_)
-    return false;
-  // eta selection
-  const float eta(std::abs(t.momentum().eta()));
-  if (eta > simTrackMaxEta_ || eta < simTrackMinEta_)
-    return false;
-  return true;
-}
diff --git a/Validation/MuonCSCDigis/src/CSCStubMatcher.cc b/Validation/MuonCSCDigis/src/CSCStubMatcher.cc
index 10862a87808ea..2bbe013a2b391 100644
--- a/Validation/MuonCSCDigis/src/CSCStubMatcher.cc
+++ b/Validation/MuonCSCDigis/src/CSCStubMatcher.cc
@@ -36,10 +36,15 @@ CSCStubMatcher::CSCStubMatcher(const edm::ParameterSet& pSet, edm::ConsumesColle
     gemDigiMatcher_.reset(new GEMDigiMatcher(pSet, std::move(iC)));
   cscDigiMatcher_.reset(new CSCDigiMatcher(pSet, std::move(iC)));
 
-  clctToken_ = iC.consumes<CSCCLCTDigiCollection>(cscCLCT.getParameter<edm::InputTag>("inputTag"));
-  alctToken_ = iC.consumes<CSCALCTDigiCollection>(cscALCT.getParameter<edm::InputTag>("inputTag"));
-  lctToken_ = iC.consumes<CSCCorrelatedLCTDigiCollection>(cscLCT.getParameter<edm::InputTag>("inputTag"));
-  mplctToken_ = iC.consumes<CSCCorrelatedLCTDigiCollection>(cscMPLCT.getParameter<edm::InputTag>("inputTag"));
+  clctInputTag_ = cscCLCT.getParameter<edm::InputTag>("inputTag");
+  alctInputTag_ = cscALCT.getParameter<edm::InputTag>("inputTag");
+  lctInputTag_ = cscLCT.getParameter<edm::InputTag>("inputTag");
+  mplctInputTag_ = cscMPLCT.getParameter<edm::InputTag>("inputTag");
+
+  clctToken_ = iC.consumes<CSCCLCTDigiCollection>(clctInputTag_);
+  alctToken_ = iC.consumes<CSCALCTDigiCollection>(alctInputTag_);
+  lctToken_ = iC.consumes<CSCCorrelatedLCTDigiCollection>(lctInputTag_);
+  mplctToken_ = iC.consumes<CSCCorrelatedLCTDigiCollection>(mplctInputTag_);
 
   geomToken_ = iC.esConsumes<CSCGeometry, MuonGeometryRecord>();
 }
@@ -72,10 +77,29 @@ void CSCStubMatcher::match(const SimTrack& t, const SimVertex& v) {
   // clear collections
   clear();
 
-  matchCLCTsToSimTrack(clcts);
-  matchALCTsToSimTrack(alcts);
-  matchLCTsToSimTrack(lcts);
-  matchMPLCTsToSimTrack(mplcts);
+  if (!alctsH_.isValid()) {
+    edm::LogError("CSCStubMatcher") << "Cannot get ALCTs with label " << alctInputTag_.encode();
+  } else {
+    matchALCTsToSimTrack(alcts);
+  }
+
+  if (!clctsH_.isValid()) {
+    edm::LogError("CSCStubMatcher") << "Cannot get CLCTs with label " << clctInputTag_.encode();
+  } else {
+    matchCLCTsToSimTrack(clcts);
+  }
+
+  if (!lctsH_.isValid()) {
+    edm::LogError("CSCStubMatcher") << "Cannot get LCTs with label " << lctInputTag_.encode();
+  } else {
+    matchLCTsToSimTrack(lcts);
+  }
+
+  if (!mplctsH_.isValid()) {
+    edm::LogError("CSCStubMatcher") << "Cannot get MPLCTs with label " << mplctInputTag_.encode();
+  } else {
+    matchMPLCTsToSimTrack(mplcts);
+  }
 }
 
 void CSCStubMatcher::matchCLCTsToSimTrack(const CSCCLCTDigiCollection& clcts) {
diff --git a/Validation/MuonCSCDigis/src/CSCStubResolutionValidation.cc b/Validation/MuonCSCDigis/src/CSCStubResolutionValidation.cc
new file mode 100644
index 0000000000000..5c832d64930cc
--- /dev/null
+++ b/Validation/MuonCSCDigis/src/CSCStubResolutionValidation.cc
@@ -0,0 +1,148 @@
+#include <memory>
+
+#include "Validation/MuonCSCDigis/interface/CSCStubResolutionValidation.h"
+#include "Validation/MuonCSCDigis/interface/CSCStubMatcher.h"
+
+CSCStubResolutionValidation::CSCStubResolutionValidation(const edm::ParameterSet& pset, edm::ConsumesCollector&& iC)
+    : CSCBaseValidation(pset) {
+  const auto& simVertex = pset.getParameter<edm::ParameterSet>("simVertex");
+  simVertexInput_ = iC.consumes<edm::SimVertexContainer>(simVertex.getParameter<edm::InputTag>("inputTag"));
+  const auto& simTrack = pset.getParameter<edm::ParameterSet>("simTrack");
+  simTrackInput_ = iC.consumes<edm::SimTrackContainer>(simTrack.getParameter<edm::InputTag>("inputTag"));
+
+  // Initialize stub matcher
+  cscStubMatcher_ = std::make_unique<CSCStubMatcher>(pset, std::move(iC));
+}
+
+CSCStubResolutionValidation::~CSCStubResolutionValidation() {}
+
+//create folder for resolution histograms and book them
+void CSCStubResolutionValidation::bookHistograms(DQMStore::IBooker& iBooker) {
+  for (int i = 1; i <= 10; ++i) {
+    int j = i - 1;
+    const std::string cn(CSCDetId::chamberName(i));
+
+    //Position resolution; CLCT
+    std::string t1 = "CLCTPosRes_hs_" + cn;
+    std::string t2 = "CLCTPosRes_qs_" + cn;
+    std::string t3 = "CLCTPosRes_es_" + cn;
+
+    iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/CLCT/Resolution/");
+    posresCLCT_hs[j] = iBooker.book1D(
+        t1, cn + " CLCT Position Resolution (1/2-strip prec.); Strip_{L1T} - Strip_{SIM}; Entries", 50, -1, 1);
+    posresCLCT_qs[j] = iBooker.book1D(
+        t2, cn + " CLCT Position Resolution (1/4-strip prec.); Strip_{L1T} - Strip_{SIM}; Entries", 50, -1, 1);
+    posresCLCT_es[j] = iBooker.book1D(
+        t3, cn + " CLCT Position Resolution (1/8-strip prec.); Strip_{L1T} - Strip_{SIM}; Entries", 50, -1, 1);
+
+    //Slope resolution; CLCT
+    std::string t4 = "CLCTBendRes_" + cn;
+
+    bendresCLCT[j] =
+        iBooker.book1D(t4, cn + " CLCT Bend Resolution; Slope_{L1T} - Slope_{SIM}; Entries", 50, -0.5, 0.5);
+  }
+}
+
+void CSCStubResolutionValidation::analyze(const edm::Event& e, const edm::EventSetup& eventSetup) {
+  // Define handles
+  edm::Handle<edm::SimTrackContainer> sim_tracks;
+  edm::Handle<edm::SimVertexContainer> sim_vertices;
+
+  // Use token to retreive event information
+  e.getByToken(simTrackInput_, sim_tracks);
+  e.getByToken(simVertexInput_, sim_vertices);
+
+  // Initialize StubMatcher
+  cscStubMatcher_->init(e, eventSetup);
+
+  const edm::SimTrackContainer& sim_track = *sim_tracks.product();
+  const edm::SimVertexContainer& sim_vert = *sim_vertices.product();
+
+  // select simtracks for true muons
+  edm::SimTrackContainer sim_track_selected;
+  for (const auto& t : sim_track) {
+    if (!isSimTrackGood(t))
+      continue;
+    sim_track_selected.push_back(t);
+  }
+
+  // Skip events with no selected simtracks
+  if (sim_track_selected.empty())
+    return;
+
+  // Loop through good tracks, use corresponding vertex to match stubs, then fill hists of chambers where the stub appears.
+  for (const auto& t : sim_track_selected) {
+    std::vector<bool> hitCLCT(10);
+
+    std::vector<float> delta_fhs_clct(10);
+    std::vector<float> delta_fqs_clct(10);
+    std::vector<float> delta_fes_clct(10);
+
+    std::vector<float> dslope_clct(10);
+
+    // Match track to stubs with appropriate vertex
+    cscStubMatcher_->match(t, sim_vert[t.vertIndex()]);
+
+    // Store matched stubs.
+    // Key: ChamberID, Value : CSCStubDigiContainer
+    const auto& clcts = cscStubMatcher_->clcts();
+
+    // CLCTs
+    for (auto& [id, container] : clcts) {
+      const CSCDetId cscId(id);
+      const unsigned chamberType(cscId.iChamberType());
+
+      // get the best clct in chamber
+      const auto& clct = cscStubMatcher_->bestClctInChamber(id);
+      if (!clct.isValid())
+        continue;
+
+      hitCLCT[chamberType - 1] = true;
+
+      // calculate deltastrip for ME1/a. Basically, we need to subtract 64 from the CLCT key strip to
+      // compare with key strip as obtained through the fit to simhits positions.
+      int deltaStrip = 0;
+      if (cscId.station() == 1 and cscId.ring() == 4 and clct.getKeyStrip() > CSCConstants::MAX_HALF_STRIP_ME1B)
+        deltaStrip = CSCConstants::NUM_STRIPS_ME1B;
+
+      // fractional strip
+      const float fhs_clct = clct.getFractionalStrip(2);
+      const float fqs_clct = clct.getFractionalStrip(4);
+      const float fes_clct = clct.getFractionalStrip(8);
+
+      // in half-strips per layer
+      const float slopeHalfStrip(clct.getFractionalSlope());
+      const float slopeStrip(slopeHalfStrip / 2.);
+
+      // get the fit hits in chamber for true value
+      float stripIntercept, stripSlope;
+      cscStubMatcher_->cscDigiMatcher()->muonSimHitMatcher()->fitHitsInChamber(id, stripIntercept, stripSlope);
+
+      // add offset of +0.25 strips for non-ME1/1 chambers
+      const bool isME11(cscId.station() == 1 and (cscId.ring() == 4 or cscId.ring() == 1));
+      if (!isME11) {
+        stripIntercept -= 0.25;
+      }
+
+      const float strip_csc_sh = stripIntercept;
+      const float bend_csc_sh = stripSlope;
+
+      delta_fhs_clct[chamberType - 1] = fhs_clct - deltaStrip - strip_csc_sh;
+      delta_fqs_clct[chamberType - 1] = fqs_clct - deltaStrip - strip_csc_sh;
+      delta_fes_clct[chamberType - 1] = fes_clct - deltaStrip - strip_csc_sh;
+
+      dslope_clct[chamberType - 1] = slopeStrip - bend_csc_sh;
+    }
+
+    for (int i = 0; i < 10; i++) {
+      if (hitCLCT[i]) {
+        //fill histograms
+        posresCLCT_hs[i]->Fill(delta_fhs_clct[i]);
+        posresCLCT_qs[i]->Fill(delta_fqs_clct[i]);
+        posresCLCT_es[i]->Fill(delta_fes_clct[i]);
+
+        bendresCLCT[i]->Fill(dslope_clct[i]);
+      }
+    }
+  }
+}
diff --git a/Validation/MuonCSCDigis/src/CSCWireDigiValidation.cc b/Validation/MuonCSCDigis/src/CSCWireDigiValidation.cc
index 25071d5516a28..5e2146a6843bf 100644
--- a/Validation/MuonCSCDigis/src/CSCWireDigiValidation.cc
+++ b/Validation/MuonCSCDigis/src/CSCWireDigiValidation.cc
@@ -16,19 +16,24 @@ CSCWireDigiValidation::CSCWireDigiValidation(const edm::ParameterSet &ps, edm::C
 CSCWireDigiValidation::~CSCWireDigiValidation() {}
 
 void CSCWireDigiValidation::bookHistograms(DQMStore::IBooker &iBooker) {
+  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/Wire/Occupancy/");
   theNDigisPerEventPlot =
       iBooker.book1D("CSCWireDigisPerEvent", "CSC Wire Digis per event;CSC Wire Digis per event;Entries", 100, 0, 100);
   for (int i = 1; i <= 10; ++i) {
     const std::string t1("CSCWireDigiTime_" + CSCDetId::chamberName(i));
     const std::string t2("CSCWireDigisPerLayer_" + CSCDetId::chamberName(i));
-    const std::string t3("CSCWireDigiResolution_" + CSCDetId::chamberName(i));
     theTimeBinPlots[i - 1] =
         iBooker.book1D(t1, "Wire Time Bin " + CSCDetId::chamberName(i) + ";Wire Time Bin; Entries", 16, 0, 16);
     theNDigisPerLayerPlots[i - 1] = iBooker.book1D(
         t2, "Number of Wire Digis " + CSCDetId::chamberName(i) + ";Number of Wire Digis; Entries", 100, 0, 20);
+  }
+
+  iBooker.setCurrentFolder("MuonCSCDigisV/CSCDigiTask/Wire/Resolution/");
+  for (int i = 1; i <= 10; ++i) {
+    const std::string t3("CSCWireDigiResolution_" + CSCDetId::chamberName(i));
     theResolutionPlots[i - 1] = iBooker.book1D(
         t3,
-        "Wire Y Position Resolution " + CSCDetId::chamberName(i) + ";Wire Y Position Resolution; Entries",
+        "Wire Y Position Resolution " + CSCDetId::chamberName(i) + ";Wire Y Position Resolution [cm]; Entries",
         100,
         -10,
         10);
@@ -62,7 +67,7 @@ void CSCWireDigiValidation::analyze(const edm::Event &e, const edm::EventSetup &
     }
 
     if (doSim_) {
-      const edm::PSimHitContainer simHits = theSimHitMap->hits(detId);
+      const edm::PSimHitContainer &simHits = theSimHitMap->hits(detId);
       if (nDigis == 1 && simHits.size() == 1) {
         plotResolution(simHits[0], *beginDigi, layer, chamberType);
       }
diff --git a/Validation/MuonCSCDigis/test/runCSCDigiHarvesting_cfg.py b/Validation/MuonCSCDigis/test/runCSCDigiHarvesting_cfg.py
index 393bc3e2a3de1..b0d6fe7b3736a 100644
--- a/Validation/MuonCSCDigis/test/runCSCDigiHarvesting_cfg.py
+++ b/Validation/MuonCSCDigis/test/runCSCDigiHarvesting_cfg.py
@@ -1,7 +1,14 @@
 import FWCore.ParameterSet.Config as cms
-
+from FWCore.ParameterSet.VarParsing import VarParsing
 from Configuration.Eras.Era_Run3_cff import Run3
 
+options = VarParsing('analysis')
+options.register("doSim", True, VarParsing.multiplicity.singleton, VarParsing.varType.bool)
+options.register("cmssw", "CMSSW_X_Y_Z", VarParsing.multiplicity.singleton, VarParsing.varType.string)
+options.register("globalTag", "tag", VarParsing.multiplicity.singleton, VarParsing.varType.string)
+options.register("dataSetTag", "sample", VarParsing.multiplicity.singleton, VarParsing.varType.string)
+options.parseArguments()
+
 process = cms.Process('HARVESTING',Run3)
 
 # import of standard configurations
@@ -31,13 +38,17 @@
 process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase1_2021_realistic', '')
 
 # Path and EndPath definitions
-process.harvesting_step = cms.Path(process.cscDigiHarvesting)
+if options.doSim:
+    process.harvesting_step = cms.Path(process.cscDigiHarvesting)
 process.dqmsave_step = cms.Path(process.DQMSaver)
 process.endjob_step = cms.EndPath(process.endOfProcess)
 
+process.dqmSaver.workflow = '/{}/{}/{}'.format(options.dataSetTag,options.globalTag,options.cmssw)
+
 # Schedule definition
-process.schedule = cms.Schedule(
-    process.harvesting_step,
-    process.endjob_step,
-    process.dqmsave_step
-)
+process.schedule = cms.Schedule()
+
+if options.doSim:
+    process.schedule.extend([process.harvesting_step])
+
+process.schedule.extend([process.endjob_step, process.dqmsave_step])
diff --git a/Validation/MuonCSCDigis/test/runCSCDigiValidation_cfg.py b/Validation/MuonCSCDigis/test/runCSCDigiValidation_cfg.py
index c5e805acefcad..c28f2c200105f 100644
--- a/Validation/MuonCSCDigis/test/runCSCDigiValidation_cfg.py
+++ b/Validation/MuonCSCDigis/test/runCSCDigiValidation_cfg.py
@@ -1,7 +1,11 @@
 import FWCore.ParameterSet.Config as cms
-
+from FWCore.ParameterSet.VarParsing import VarParsing
 from Configuration.Eras.Era_Run3_cff import Run3
 
+options = VarParsing('analysis')
+options.register ("doSim", True, VarParsing.multiplicity.singleton, VarParsing.varType.bool)
+options.parseArguments()
+
 process = cms.Process('VALIDATION',Run3)
 
 # import of standard configurations
@@ -47,7 +51,12 @@
 )
 
 # Path and EndPath definitions
-process.validation_step = cms.Path(process.mix * process.cscDigiValidation)
+process.cscDigiValidation.doSim = options.doSim
+if options.doSim:
+    process.validation_step = cms.Path(process.mix *
+                                       process.cscDigiValidation)
+else:
+    process.validation_step = cms.Path(process.cscDigiValidation)
 process.endjob_step = cms.EndPath(process.endOfProcess)
 process.DQMoutput_step = cms.EndPath(process.DQMoutput)