diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaDiJetsProducer.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaDiJetsProducer.cc
index a46b0d79ed310..772b6dbe9f8e4 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaDiJetsProducer.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaDiJetsProducer.cc
@@ -33,24 +33,24 @@
 #include "Geometry/Records/interface/CaloGeometryRecord.h"
 #include <iostream>
 
-namespace alcaHcalDiJet {
+namespace alCaHcalDiJetsProducer {
   struct Counters {
     Counters() : nAll_(0), nSelect_(0) {}
     mutable std::atomic<unsigned int> nAll_, nSelect_;
   };
-}  // namespace alcaHcalDiJet
+}  // namespace alCaHcalDiJetsProducer
 
 //
 // class declaration
 //
 
-class AlCaDiJetsProducer : public edm::global::EDProducer<edm::RunCache<alcaHcalDiJet::Counters>> {
+class AlCaDiJetsProducer : public edm::global::EDProducer<edm::RunCache<alCaHcalDiJetsProducer::Counters>> {
 public:
   explicit AlCaDiJetsProducer(const edm::ParameterSet&);
   ~AlCaDiJetsProducer() override = default;
 
-  std::shared_ptr<alcaHcalDiJet::Counters> globalBeginRun(edm::Run const&, edm::EventSetup const&) const override {
-    return std::make_shared<alcaHcalDiJet::Counters>();
+  std::shared_ptr<alCaHcalDiJetsProducer::Counters> globalBeginRun(edm::Run const&, edm::EventSetup const&) const override {
+    return std::make_shared<alCaHcalDiJetsProducer::Counters>();
   }
   void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override;
   void globalEndRun(edm::Run const& iRun, edm::EventSetup const&) const override;
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaGammaJetSelector.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaGammaJetSelector.cc
index d0554c4728ac2..836e9d9100a0c 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaGammaJetSelector.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaGammaJetSelector.cc
@@ -38,26 +38,26 @@
 // class declaration
 //
 
-namespace AlCaGammaJet {
+namespace alCaGammaJetSelector {
   struct Counters {
     Counters() : nProcessed_(0), nSelected_(0) {}
     mutable std::atomic<unsigned int> nProcessed_, nSelected_;
   };
-}  // namespace AlCaGammaJet
+}  // namespace alCaGammaJetSelector
 
-class AlCaGammaJetSelector : public edm::stream::EDFilter<edm::GlobalCache<AlCaGammaJet::Counters> > {
+class AlCaGammaJetSelector : public edm::stream::EDFilter<edm::GlobalCache<alCaGammaJetSelector::Counters> > {
 public:
-  explicit AlCaGammaJetSelector(const edm::ParameterSet&, const AlCaGammaJet::Counters* count);
+  explicit AlCaGammaJetSelector(const edm::ParameterSet&, const alCaGammaJetSelector::Counters* count);
   ~AlCaGammaJetSelector() override = default;
 
-  static std::unique_ptr<AlCaGammaJet::Counters> initializeGlobalCache(edm::ParameterSet const&) {
-    return std::make_unique<AlCaGammaJet::Counters>();
+  static std::unique_ptr<alCaGammaJetSelector::Counters> initializeGlobalCache(edm::ParameterSet const&) {
+    return std::make_unique<alCaGammaJetSelector::Counters>();
   }
 
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
   bool filter(edm::Event&, const edm::EventSetup&) override;
   void endStream() override;
-  static void globalEndJob(const AlCaGammaJet::Counters* counters);
+  static void globalEndJob(const alCaGammaJetSelector::Counters* counters);
 
 private:
   void beginRun(edm::Run const&, edm::EventSetup const&) override {}
@@ -87,7 +87,7 @@ class AlCaGammaJetSelector : public edm::stream::EDFilter<edm::GlobalCache<AlCaG
 //
 // constructors and destructor
 //
-AlCaGammaJetSelector::AlCaGammaJetSelector(const edm::ParameterSet& iConfig, const AlCaGammaJet::Counters* counters) {
+AlCaGammaJetSelector::AlCaGammaJetSelector(const edm::ParameterSet& iConfig, const alCaGammaJetSelector::Counters* counters) {
   nProcessed_ = 0;
   nSelected_ = 0;
 
@@ -153,7 +153,7 @@ void AlCaGammaJetSelector::endStream() {
 
 // ------------ method called once each job just after ending the event loop  ------------
 
-void AlCaGammaJetSelector::globalEndJob(const AlCaGammaJet::Counters* count) {
+void AlCaGammaJetSelector::globalEndJob(const alCaGammaJetSelector::Counters* count) {
   edm::LogWarning("AlCaGammaJet") << "Finds " << count->nSelected_ << " good events out of " << count->nProcessed_;
 }
 
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonFilter.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonFilter.cc
index c49175030a2c4..d1eab335ab2de 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonFilter.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonFilter.cc
@@ -38,25 +38,25 @@
 // class declaration
 //
 
-namespace AlCaHBHEMuons {
+namespace alCaHBHEMuonFilter {
   struct Counters {
     Counters() : nAll_(0), nGood_(0), nFinal_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_, nFinal_;
   };
-}  // namespace AlCaHBHEMuons
+}  // namespace alCaHBHEMuonFilter
 
-class AlCaHBHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<AlCaHBHEMuons::Counters> > {
+class AlCaHBHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<alCaHBHEMuonFilter::Counters> > {
 public:
-  explicit AlCaHBHEMuonFilter(edm::ParameterSet const&, const AlCaHBHEMuons::Counters* count);
-  ~AlCaHBHEMuonFilter() override;
+  explicit AlCaHBHEMuonFilter(edm::ParameterSet const&, const alCaHBHEMuonFilter::Counters* count);
+  ~AlCaHBHEMuonFilter() override = default;
 
-  static std::unique_ptr<AlCaHBHEMuons::Counters> initializeGlobalCache(edm::ParameterSet const&) {
-    return std::make_unique<AlCaHBHEMuons::Counters>();
+  static std::unique_ptr<alCaHBHEMuonFilter::Counters> initializeGlobalCache(edm::ParameterSet const&) {
+    return std::make_unique<alCaHBHEMuonFilter::Counters>();
   }
 
   bool filter(edm::Event&, edm::EventSetup const&) override;
   void endStream() override;
-  static void globalEndJob(const AlCaHBHEMuons::Counters* counters);
+  static void globalEndJob(const alCaHBHEMuonFilter::Counters* counters);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
@@ -91,7 +91,7 @@ class AlCaHBHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<AlCaHBH
 //
 // constructors and destructor
 //
-AlCaHBHEMuonFilter::AlCaHBHEMuonFilter(edm::ParameterSet const& iConfig, const AlCaHBHEMuons::Counters* count)
+AlCaHBHEMuonFilter::AlCaHBHEMuonFilter(edm::ParameterSet const& iConfig, const alCaHBHEMuonFilter::Counters* count)
     : nRun_(0),
       nAll_(0),
       nGood_(0),
@@ -121,8 +121,6 @@ AlCaHBHEMuonFilter::AlCaHBHEMuonFilter(edm::ParameterSet const& iConfig, const A
     edm::LogVerbatim("HBHEMuon") << "Trigger[" << k << "] " << trigNames_[k] << "\n";
 }  // AlCaHBHEMuonFilter::AlCaHBHEMuonFilter  constructor
 
-AlCaHBHEMuonFilter::~AlCaHBHEMuonFilter() {}
-
 //
 // member functions
 //
@@ -236,7 +234,7 @@ void AlCaHBHEMuonFilter::endStream() {
   globalCache()->nFinal_ += nFinal_;
 }
 
-void AlCaHBHEMuonFilter::globalEndJob(const AlCaHBHEMuons::Counters* count) {
+void AlCaHBHEMuonFilter::globalEndJob(const alCaHBHEMuonFilter::Counters* count) {
   edm::LogVerbatim("HBHEMuon") << "Selects " << count->nFinal_ << " out of " << count->nGood_ << " good events out of "
                                << count->nAll_ << " total # of events\n";
 }
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonProducer.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonProducer.cc
index 6fa8a5b036205..e5839908ff58f 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonProducer.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonProducer.cc
@@ -38,25 +38,25 @@
 // class declaration
 //
 
-namespace AlCaHBHEMuons {
+namespace alCaHBHEMuonProducer {
   struct Counters {
     Counters() : nAll_(0), nGood_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_;
   };
-}  // namespace AlCaHBHEMuons
+}  // namespace alCaHBHEMuonProducer
 
-class AlCaHBHEMuonProducer : public edm::stream::EDProducer<edm::GlobalCache<AlCaHBHEMuons::Counters> > {
+class AlCaHBHEMuonProducer : public edm::stream::EDProducer<edm::GlobalCache<alCaHBHEMuonProducer::Counters> > {
 public:
-  explicit AlCaHBHEMuonProducer(edm::ParameterSet const&, const AlCaHBHEMuons::Counters* count);
+  explicit AlCaHBHEMuonProducer(edm::ParameterSet const&, const alCaHBHEMuonProducer::Counters* count);
   ~AlCaHBHEMuonProducer() override;
 
-  static std::unique_ptr<AlCaHBHEMuons::Counters> initializeGlobalCache(edm::ParameterSet const&) {
-    return std::make_unique<AlCaHBHEMuons::Counters>();
+  static std::unique_ptr<alCaHBHEMuonProducer::Counters> initializeGlobalCache(edm::ParameterSet const&) {
+    return std::make_unique<alCaHBHEMuonProducer::Counters>();
   }
 
   void produce(edm::Event&, const edm::EventSetup&) override;
   void endStream() override;
-  static void globalEndJob(const AlCaHBHEMuons::Counters* counters);
+  static void globalEndJob(const alCaHBHEMuonProducer::Counters* counters);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
@@ -78,7 +78,7 @@ class AlCaHBHEMuonProducer : public edm::stream::EDProducer<edm::GlobalCache<AlC
   edm::EDGetTokenT<reco::MuonCollection> tok_Muon_;
 };
 
-AlCaHBHEMuonProducer::AlCaHBHEMuonProducer(edm::ParameterSet const& iConfig, const AlCaHBHEMuons::Counters* count)
+AlCaHBHEMuonProducer::AlCaHBHEMuonProducer(edm::ParameterSet const& iConfig, const alCaHBHEMuonProducer::Counters* count)
     : nRun_(0),
       nAll_(0),
       nGood_(0),
@@ -216,7 +216,7 @@ void AlCaHBHEMuonProducer::endStream() {
   globalCache()->nGood_ += nGood_;
 }
 
-void AlCaHBHEMuonProducer::globalEndJob(const AlCaHBHEMuons::Counters* count) {
+void AlCaHBHEMuonProducer::globalEndJob(const alCaHBHEMuonProducer::Counters* count) {
   edm::LogVerbatim("HcalHBHEMuon") << "Finds " << count->nGood_ << " good tracks in " << count->nAll_ << " events";
 }
 
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHEMuonFilter.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHEMuonFilter.cc
index 2a602eba1fde9..7428bf55b622e 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHEMuonFilter.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHEMuonFilter.cc
@@ -38,25 +38,25 @@
 // class declaration
 //
 
-namespace AlCaHEMuons {
+namespace alCaHEMuonFilter {
   struct Counters {
     Counters() : nAll_(0), nGood_(0), nFinal_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_, nFinal_;
   };
-}  // namespace AlCaHEMuons
+}  // namespace alCaHEMuonFilter
 
-class AlCaHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<AlCaHEMuons::Counters> > {
+class AlCaHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<alCaHEMuonFilter::Counters> > {
 public:
-  explicit AlCaHEMuonFilter(edm::ParameterSet const&, const AlCaHEMuons::Counters* count);
+  explicit AlCaHEMuonFilter(edm::ParameterSet const&, const alCaHEMuonFilter::Counters* count);
   ~AlCaHEMuonFilter() override;
 
-  static std::unique_ptr<AlCaHEMuons::Counters> initializeGlobalCache(edm::ParameterSet const&) {
-    return std::make_unique<AlCaHEMuons::Counters>();
+  static std::unique_ptr<alCaHEMuonFilter::Counters> initializeGlobalCache(edm::ParameterSet const&) {
+    return std::make_unique<alCaHEMuonFilter::Counters>();
   }
 
   bool filter(edm::Event&, edm::EventSetup const&) override;
   void endStream() override;
-  static void globalEndJob(const AlCaHEMuons::Counters* counters);
+  static void globalEndJob(const alCaHEMuonFilter::Counters* counters);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
@@ -89,7 +89,7 @@ class AlCaHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<AlCaHEMuo
 //
 // constructors and destructor
 //
-AlCaHEMuonFilter::AlCaHEMuonFilter(edm::ParameterSet const& iConfig, const AlCaHEMuons::Counters* count)
+AlCaHEMuonFilter::AlCaHEMuonFilter(edm::ParameterSet const& iConfig, const alCaHEMuonFilter::Counters* count)
     : nRun_(0),
       nAll_(0),
       nGood_(0),
@@ -226,7 +226,7 @@ void AlCaHEMuonFilter::endStream() {
   globalCache()->nFinal_ += nFinal_;
 }
 
-void AlCaHEMuonFilter::globalEndJob(const AlCaHEMuons::Counters* count) {
+void AlCaHEMuonFilter::globalEndJob(const alCaHEMuonFilter::Counters* count) {
   edm::LogVerbatim("HEMuon") << "Selects " << count->nFinal_ << " out of " << count->nGood_ << " good events out of "
                              << count->nAll_ << " total # of events\n";
 }
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalHEMuonFilter.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalHEMuonFilter.cc
index 4dc2863d0cbc7..769e3ccbf84f4 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalHEMuonFilter.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalHEMuonFilter.cc
@@ -22,19 +22,19 @@
 // class declaration
 //
 
-namespace alcaHcalHBHEMuon {
+namespace alCaHcalHEMuonFilter {
   struct Counters {
     Counters() : nAll_(0), nGood_(0), nFinal_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_, nFinal_;
   };
-}  // namespace alcaHcalHBHEMuon
+}  // namespace alCaHcalHEMuonFilter
 
-class AlCaHcalHEMuonFilter : public edm::global::EDFilter<edm::RunCache<alcaHcalHBHEMuon::Counters> > {
+class AlCaHcalHEMuonFilter : public edm::global::EDFilter<edm::RunCache<alCaHcalHEMuonFilter::Counters> > {
 public:
   AlCaHcalHEMuonFilter(edm::ParameterSet const&);
   ~AlCaHcalHEMuonFilter() override = default;
 
-  std::shared_ptr<alcaHcalHBHEMuon::Counters> globalBeginRun(edm::Run const&, edm::EventSetup const&) const override;
+  std::shared_ptr<alCaHcalHEMuonFilter::Counters> globalBeginRun(edm::Run const&, edm::EventSetup const&) const override;
 
   bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override;
   void globalEndRun(edm::Run const& iRun, edm::EventSetup const&) const override;
@@ -112,10 +112,10 @@ bool AlCaHcalHEMuonFilter::filter(edm::StreamID, edm::Event& iEvent, edm::EventS
 }  // AlCaHcalHEMuonFilter::filter
 
 // ------------ method called when starting to processes a run  ------------
-std::shared_ptr<alcaHcalHBHEMuon::Counters> AlCaHcalHEMuonFilter::globalBeginRun(edm::Run const& iRun,
+std::shared_ptr<alCaHcalHEMuonFilter::Counters> AlCaHcalHEMuonFilter::globalBeginRun(edm::Run const& iRun,
                                                                                  edm::EventSetup const&) const {
   edm::LogVerbatim("HBHEMuon") << "Start the Run " << iRun.run();
-  return std::make_shared<alcaHcalHBHEMuon::Counters>();
+  return std::make_shared<alCaHcalHEMuonFilter::Counters>();
 }
 
 // ------------ method called when ending the processing of a run  ------------
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalIsotrkFilter.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalIsotrkFilter.cc
index ab72e34e345b1..d925a6b135aa8 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalIsotrkFilter.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalIsotrkFilter.cc
@@ -23,19 +23,19 @@
 // class declaration
 //
 
-namespace alcaHcalIsoTrk {
+namespace alCaHcalIsoTrkFilter {
   struct Counters {
     Counters() : nAll_(0), nGood_(0), nLow_(0), nHigh_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_, nLow_, nHigh_;
   };
-}  // namespace alcaHcalIsoTrk
+}  // namespace alCaHcalIsoTrkFilter
 
-class AlCaHcalIsotrkFilter : public edm::global::EDFilter<edm::RunCache<alcaHcalIsoTrk::Counters>> {
+class AlCaHcalIsotrkFilter : public edm::global::EDFilter<edm::RunCache<alCaHcalIsoTrkFilter::Counters>> {
 public:
   AlCaHcalIsotrkFilter(edm::ParameterSet const&);
   ~AlCaHcalIsotrkFilter() override = default;
 
-  std::shared_ptr<alcaHcalIsoTrk::Counters> globalBeginRun(edm::Run const&, edm::EventSetup const&) const override;
+  std::shared_ptr<alCaHcalIsoTrkFilter::Counters> globalBeginRun(edm::Run const&, edm::EventSetup const&) const override;
 
   bool filter(edm::StreamID, edm::Event&, edm::EventSetup const&) const override;
   void globalEndRun(edm::Run const& iRun, edm::EventSetup const&) const override;
@@ -146,10 +146,10 @@ bool AlCaHcalIsotrkFilter::filter(edm::StreamID, edm::Event& iEvent, edm::EventS
 }  // AlCaHcalIsotrkFilter::filter
 
 // ------------ method called when starting to processes a run  ------------
-std::shared_ptr<alcaHcalIsoTrk::Counters> AlCaHcalIsotrkFilter::globalBeginRun(edm::Run const& iRun,
+std::shared_ptr<alCaHcalIsoTrkFilter::Counters> AlCaHcalIsotrkFilter::globalBeginRun(edm::Run const& iRun,
                                                                                edm::EventSetup const&) const {
   edm::LogVerbatim("HcalIsoTrack") << "Start the Run " << iRun.run();
-  return std::make_shared<alcaHcalIsoTrk::Counters>();
+  return std::make_shared<alCaHcalIsoTrkFilter::Counters>();
 }
 
 // ------------ method called when ending the processing of a run  ------------
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalIsotrkProducer.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalIsotrkProducer.cc
index 3a581bef0dc73..a43102a0717c4 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalIsotrkProducer.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaHcalIsotrkProducer.cc
@@ -83,25 +83,25 @@
 // class declaration
 //
 
-namespace alcaHcalIsoTracks {
+namespace alCaHcalIsotrkProducer {
   struct Counters {
     Counters() : nAll_(0), nGood_(0), nRange_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_, nRange_;
   };
-}  // namespace alcaHcalIsoTracks
+}  // namespace alCaHcalIsotrkProducer
 
-class AlCaHcalIsotrkProducer : public edm::stream::EDProducer<edm::GlobalCache<alcaHcalIsoTracks::Counters>> {
+class AlCaHcalIsotrkProducer : public edm::stream::EDProducer<edm::GlobalCache<alCaHcalIsotrkProducer::Counters>> {
 public:
-  explicit AlCaHcalIsotrkProducer(edm::ParameterSet const&, const alcaHcalIsoTracks::Counters*);
+  explicit AlCaHcalIsotrkProducer(edm::ParameterSet const&, const alCaHcalIsotrkProducer::Counters*);
   ~AlCaHcalIsotrkProducer() override = default;
 
-  static std::unique_ptr<alcaHcalIsoTracks::Counters> initializeGlobalCache(edm::ParameterSet const&) {
-    return std::make_unique<alcaHcalIsoTracks::Counters>();
+  static std::unique_ptr<alCaHcalIsotrkProducer::Counters> initializeGlobalCache(edm::ParameterSet const&) {
+    return std::make_unique<alCaHcalIsotrkProducer::Counters>();
   }
 
   void produce(edm::Event&, edm::EventSetup const&) override;
   void endStream() override;
-  static void globalEndJob(const alcaHcalIsoTracks::Counters* counters);
+  static void globalEndJob(const alCaHcalIsotrkProducer::Counters* counters);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
@@ -211,7 +211,7 @@ class AlCaHcalIsotrkProducer : public edm::stream::EDProducer<edm::GlobalCache<a
 };
 
 AlCaHcalIsotrkProducer::AlCaHcalIsotrkProducer(edm::ParameterSet const& iConfig,
-                                               const alcaHcalIsoTracks::Counters* counters)
+                                               const alCaHcalIsotrkProducer::Counters* counters)
     : nRun_(0),
       nAll_(0),
       nGood_(0),
@@ -744,7 +744,7 @@ void AlCaHcalIsotrkProducer::endStream() {
   globalCache()->nRange_ += nRange_;
 }
 
-void AlCaHcalIsotrkProducer::globalEndJob(const alcaHcalIsoTracks::Counters* count) {
+void AlCaHcalIsotrkProducer::globalEndJob(const alCaHcalIsotrkProducer::Counters* count) {
   edm::LogVerbatim("HcalIsoTrack") << "Finds " << count->nGood_ << " good tracks in " << count->nAll_ << " events and "
                                    << count->nRange_ << " events in the momentum range";
 }
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsoTracksProducerFilter.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsoTracksProducerFilter.cc
index be0480e0d94b1..ae8bda2d6c04d 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsoTracksProducerFilter.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsoTracksProducerFilter.cc
@@ -28,25 +28,25 @@
 // class declaration
 //
 
-namespace alCaIsoTracksProdFilter {
+namespace alCaIsoTracksProducerFilter {
   struct Counters {
     Counters() : nAll_(0), nGood_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_;
   };
-}  // namespace alCaIsoTracksProdFilter
+}  // namespace alCaIsoTracksProducerFilter
 
-class AlCaIsoTracksProducerFilter : public edm::stream::EDFilter<edm::GlobalCache<alCaIsoTracksProdFilter::Counters> > {
+class AlCaIsoTracksProducerFilter : public edm::stream::EDFilter<edm::GlobalCache<alCaIsoTracksProducerFilter::Counters> > {
 public:
-  explicit AlCaIsoTracksProducerFilter(edm::ParameterSet const&, const alCaIsoTracksProdFilter::Counters* count);
+  explicit AlCaIsoTracksProducerFilter(edm::ParameterSet const&, const alCaIsoTracksProducerFilter::Counters* count);
   ~AlCaIsoTracksProducerFilter() override;
 
-  static std::unique_ptr<alCaIsoTracksProdFilter::Counters> initializeGlobalCache(edm::ParameterSet const& iConfig) {
-    return std::make_unique<alCaIsoTracksProdFilter::Counters>();
+  static std::unique_ptr<alCaIsoTracksProducerFilter::Counters> initializeGlobalCache(edm::ParameterSet const& iConfig) {
+    return std::make_unique<alCaIsoTracksProducerFilter::Counters>();
   }
 
   bool filter(edm::Event&, edm::EventSetup const&) override;
   void endStream() override;
-  static void globalEndJob(const alCaIsoTracksProdFilter::Counters* counters);
+  static void globalEndJob(const alCaIsoTracksProducerFilter::Counters* counters);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
@@ -63,7 +63,7 @@ class AlCaIsoTracksProducerFilter : public edm::stream::EDFilter<edm::GlobalCach
 };
 
 AlCaIsoTracksProducerFilter::AlCaIsoTracksProducerFilter(const edm::ParameterSet& iConfig,
-                                                         const alCaIsoTracksProdFilter::Counters* count)
+                                                         const alCaIsoTracksProducerFilter::Counters* count)
     : nRun_(0),
       nAll_(0),
       nGood_(0),
@@ -127,7 +127,7 @@ void AlCaIsoTracksProducerFilter::endStream() {
   globalCache()->nGood_ += nGood_;
 }
 
-void AlCaIsoTracksProducerFilter::globalEndJob(const alCaIsoTracksProdFilter::Counters* count) {
+void AlCaIsoTracksProducerFilter::globalEndJob(const alCaIsoTracksProducerFilter::Counters* count) {
   edm::LogVerbatim("HcalIsoTrack") << "Selects " << count->nGood_ << " in " << count->nAll_ << " events " << std::endl;
 }
 
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsolatedBunchFilter.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsolatedBunchFilter.cc
index a28f39de22f31..3e3f8ac0625e4 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsolatedBunchFilter.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsolatedBunchFilter.cc
@@ -27,25 +27,25 @@
 
 //#define EDM_ML_DEBUG
 
-namespace AlCaIsolatedBunch {
+namespace alCaIsolatedBunchFilter {
   struct Counters {
     Counters() : nAll_(0), nGood_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_;
   };
-}  // namespace AlCaIsolatedBunch
+}  // namespace alCaIsolatedBunchFilter
 
-class AlCaIsolatedBunchFilter : public edm::stream::EDFilter<edm::GlobalCache<AlCaIsolatedBunch::Counters> > {
+class AlCaIsolatedBunchFilter : public edm::stream::EDFilter<edm::GlobalCache<alCaIsolatedBunchFilter::Counters> > {
 public:
-  explicit AlCaIsolatedBunchFilter(edm::ParameterSet const&, const AlCaIsolatedBunch::Counters* count);
+  explicit AlCaIsolatedBunchFilter(edm::ParameterSet const&, const alCaIsolatedBunchFilter::Counters* count);
   ~AlCaIsolatedBunchFilter() override;
 
-  static std::unique_ptr<AlCaIsolatedBunch::Counters> initializeGlobalCache(edm::ParameterSet const& iConfig) {
-    return std::make_unique<AlCaIsolatedBunch::Counters>();
+  static std::unique_ptr<alCaIsolatedBunchFilter::Counters> initializeGlobalCache(edm::ParameterSet const& iConfig) {
+    return std::make_unique<alCaIsolatedBunchFilter::Counters>();
   }
 
   bool filter(edm::Event&, edm::EventSetup const&) override;
   void endStream() override;
-  static void globalEndJob(const AlCaIsolatedBunch::Counters* counters);
+  static void globalEndJob(const alCaIsolatedBunchFilter::Counters* counters);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
@@ -65,7 +65,7 @@ class AlCaIsolatedBunchFilter : public edm::stream::EDFilter<edm::GlobalCache<Al
 // constructors and destructor
 //
 AlCaIsolatedBunchFilter::AlCaIsolatedBunchFilter(const edm::ParameterSet& iConfig,
-                                                 const AlCaIsolatedBunch::Counters* count)
+                                                 const alCaIsolatedBunchFilter::Counters* count)
     : nRun_(0),
       nAll_(0),
       nGood_(0),
@@ -159,7 +159,7 @@ void AlCaIsolatedBunchFilter::endStream() {
   globalCache()->nGood_ += nGood_;
 }
 
-void AlCaIsolatedBunchFilter::globalEndJob(const AlCaIsolatedBunch::Counters* count) {
+void AlCaIsolatedBunchFilter::globalEndJob(const alCaIsolatedBunchFilter::Counters* count) {
   edm::LogVerbatim("AlCaIsoBunch") << "Selects " << count->nGood_ << " in " << count->nAll_ << " events" << std::endl;
 }
 
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsolatedBunchSelector.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsolatedBunchSelector.cc
index cec5376c43df4..a805c5bb24350 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsolatedBunchSelector.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaIsolatedBunchSelector.cc
@@ -27,25 +27,25 @@
 
 //#define EDM_ML_DEBUG
 
-namespace AlCaIsolatedBunch {
+namespace alCaIsolatedBunchSelector {
   struct Counters {
     Counters() : nAll_(0), nGood_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_;
   };
-}  // namespace AlCaIsolatedBunch
+}  // namespace alCaIsolatedBunchSelector
 
-class AlCaIsolatedBunchSelector : public edm::stream::EDFilter<edm::GlobalCache<AlCaIsolatedBunch::Counters> > {
+class AlCaIsolatedBunchSelector : public edm::stream::EDFilter<edm::GlobalCache<alCaIsolatedBunchSelector::Counters> > {
 public:
-  explicit AlCaIsolatedBunchSelector(edm::ParameterSet const&, const AlCaIsolatedBunch::Counters* count);
+  explicit AlCaIsolatedBunchSelector(edm::ParameterSet const&, const alCaIsolatedBunchSelector::Counters* count);
   ~AlCaIsolatedBunchSelector() override;
 
-  static std::unique_ptr<AlCaIsolatedBunch::Counters> initializeGlobalCache(edm::ParameterSet const& iConfig) {
-    return std::make_unique<AlCaIsolatedBunch::Counters>();
+  static std::unique_ptr<alCaIsolatedBunchSelector::Counters> initializeGlobalCache(edm::ParameterSet const& iConfig) {
+    return std::make_unique<alCaIsolatedBunchSelector::Counters>();
   }
 
   bool filter(edm::Event&, edm::EventSetup const&) override;
   void endStream() override;
-  static void globalEndJob(const AlCaIsolatedBunch::Counters* counters);
+  static void globalEndJob(const alCaIsolatedBunchSelector::Counters* counters);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
@@ -65,7 +65,7 @@ class AlCaIsolatedBunchSelector : public edm::stream::EDFilter<edm::GlobalCache<
 // constructors and destructor
 //
 AlCaIsolatedBunchSelector::AlCaIsolatedBunchSelector(const edm::ParameterSet& iConfig,
-                                                     const AlCaIsolatedBunch::Counters* count)
+                                                     const alCaIsolatedBunchSelector::Counters* count)
     : nRun_(0),
       nAll_(0),
       nGood_(0),
@@ -124,7 +124,7 @@ void AlCaIsolatedBunchSelector::endStream() {
   globalCache()->nGood_ += nGood_;
 }
 
-void AlCaIsolatedBunchSelector::globalEndJob(const AlCaIsolatedBunch::Counters* count) {
+void AlCaIsolatedBunchSelector::globalEndJob(const alCaIsolatedBunchSelector::Counters* count) {
   edm::LogVerbatim("AlCaIsoBunch") << "Selects " << count->nGood_ << " in " << count->nAll_ << " events" << std::endl;
 }
 
diff --git a/Calibration/HcalAlCaRecoProducers/plugins/AlCaLowPUHBHEMuonFilter.cc b/Calibration/HcalAlCaRecoProducers/plugins/AlCaLowPUHBHEMuonFilter.cc
index 4d0a80172548d..0d2f1993a7604 100644
--- a/Calibration/HcalAlCaRecoProducers/plugins/AlCaLowPUHBHEMuonFilter.cc
+++ b/Calibration/HcalAlCaRecoProducers/plugins/AlCaLowPUHBHEMuonFilter.cc
@@ -38,25 +38,25 @@
 // class declaration
 //
 
-namespace AlCaLowPUHBHEMuons {
+namespace alCaLowPUHBHEMuonFilter {
   struct Counters {
     Counters() : nAll_(0), nGood_(0) {}
     mutable std::atomic<unsigned int> nAll_, nGood_;
   };
-}  // namespace AlCaLowPUHBHEMuons
+}  // namespace alCaLowPUHBHEMuonFilter
 
-class AlCaLowPUHBHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<AlCaLowPUHBHEMuons::Counters> > {
+class AlCaLowPUHBHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<alCaLowPUHBHEMuonFilter::Counters> > {
 public:
-  explicit AlCaLowPUHBHEMuonFilter(edm::ParameterSet const&, const AlCaLowPUHBHEMuons::Counters* count);
+  explicit AlCaLowPUHBHEMuonFilter(edm::ParameterSet const&, const alCaLowPUHBHEMuonFilter::Counters* count);
   ~AlCaLowPUHBHEMuonFilter() override;
 
-  static std::unique_ptr<AlCaLowPUHBHEMuons::Counters> initializeGlobalCache(edm::ParameterSet const&) {
-    return std::make_unique<AlCaLowPUHBHEMuons::Counters>();
+  static std::unique_ptr<alCaLowPUHBHEMuonFilter::Counters> initializeGlobalCache(edm::ParameterSet const&) {
+    return std::make_unique<alCaLowPUHBHEMuonFilter::Counters>();
   }
 
   bool filter(edm::Event&, edm::EventSetup const&) override;
   void endStream() override;
-  static void globalEndJob(const AlCaLowPUHBHEMuons::Counters* counters);
+  static void globalEndJob(const alCaLowPUHBHEMuonFilter::Counters* counters);
   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
 
 private:
@@ -91,7 +91,7 @@ class AlCaLowPUHBHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<Al
 // constructors and destructor
 //
 AlCaLowPUHBHEMuonFilter::AlCaLowPUHBHEMuonFilter(edm::ParameterSet const& iConfig,
-                                                 const AlCaLowPUHBHEMuons::Counters* count)
+                                                 const alCaLowPUHBHEMuonFilter::Counters* count)
     : nRun_(0), nAll_(0), nGood_(0) {
   //now do what ever initialization is needed
   trigNames_ = iConfig.getParameter<std::vector<std::string> >("triggers");
@@ -218,7 +218,7 @@ void AlCaLowPUHBHEMuonFilter::endStream() {
   globalCache()->nGood_ += nGood_;
 }
 
-void AlCaLowPUHBHEMuonFilter::globalEndJob(const AlCaLowPUHBHEMuons::Counters* count) {
+void AlCaLowPUHBHEMuonFilter::globalEndJob(const alCaLowPUHBHEMuonFilter::Counters* count) {
   edm::LogVerbatim("LowPUHBHEMuon") << "Selects " << count->nGood_ << " good events out of " << count->nAll_
                                     << " total # of events";
 }