Merge pull request #15266 from bsunanda/Run2-alca52

bsunanda:Run2-alca52 Add AlCaReo stream for muon events

Calibration/HcalAlCaRecoProducers/plugins/AlCaHBHEMuonFilter.cc

@@ -41,8 +41,8 @@
 
 namespace AlCaHBHEMuons {
   struct Counters {
-    Counters() : nAll_(0), nGood_(0) {}
-    mutable std::atomic<unsigned int> nAll_, nGood_;
+    Counters() : nAll_(0), nGood_(0), nFinal_(0) {}
+    mutable std::atomic<unsigned int> nAll_, nGood_, nFinal_;
   };
 }
 
@@ -69,7 +69,10 @@ class AlCaHBHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<AlCaHBH
   HLTConfigProvider          hltConfig_;
   std::vector<std::string>   trigNames_, HLTNames_;
   std::string                processName_;
-  unsigned int               nRun_, nAll_, nGood_;
+  bool                       pfCut_;
+  double                     trackIsoCut_, caloIsoCut_, pfIsoCut_;
+  int                        preScale_;
+  unsigned int               nRun_, nAll_, nGood_, nFinal_;
   edm::InputTag              triggerResults_, labelMuon_;
   edm::EDGetTokenT<trigger::TriggerEvent>  tok_trigEvt;
   edm::EDGetTokenT<edm::TriggerResults>    tok_trigRes_;
@@ -88,20 +91,28 @@ class AlCaHBHEMuonFilter : public edm::stream::EDFilter<edm::GlobalCache<AlCaHBH
 // constructors and destructor
 //
 AlCaHBHEMuonFilter::AlCaHBHEMuonFilter(edm::ParameterSet const& iConfig, const AlCaHBHEMuons::Counters* count) :
-  nRun_(0), nAll_(0), nGood_(0) {
+  nRun_(0), nAll_(0), nGood_(0), nFinal_(0) {
   //now do what ever initialization is needed
   trigNames_             = iConfig.getParameter<std::vector<std::string> >("Triggers");
   processName_           = iConfig.getParameter<std::string>("ProcessName");
   triggerResults_        = iConfig.getParameter<edm::InputTag>("TriggerResultLabel");
   labelMuon_             = iConfig.getParameter<edm::InputTag>("MuonLabel");
+  pfCut_                 = iConfig.getParameter<bool>("PFCut");
+  pfIsoCut_              = iConfig.getParameter<double>("PFIsolationCut");
+  trackIsoCut_           = iConfig.getParameter<double>("TrackIsolationCut");
+  caloIsoCut_            = iConfig.getParameter<double>("CaloIsolationCut");
+  preScale_              = iConfig.getParameter<int>("PreScale");
+  if (preScale_ < 1) preScale_ = 1;
 
   // define tokens for access
   tok_trigRes_  = consumes<edm::TriggerResults>(triggerResults_);
   tok_Muon_     = consumes<reco::MuonCollection>(labelMuon_);
-  edm::LogInfo("HcalHBHEMuon") << "Parameters read from config file \n" 
-			       << "Process " << processName_;
+  edm::LogInfo("HBHEMuon") << "Parameters read from config file \n" 
+			   << "Process " << processName_ << "  Prescale "
+			   << preScale_ << "  Isolation Cuts " 
+			   << trackIsoCut_ << ":" << caloIsoCut_ << "\n";
   for (unsigned int k=0; k<trigNames_.size(); ++k)
-    edm::LogInfo("HcalHBHEMuon") << "Trigger[" << k << "] " << trigNames_[k];
+    edm::LogInfo("HBHEMuon") << "Trigger[" << k << "] " << trigNames_[k]<<"\n";
 } // AlCaHBHEMuonFilter::AlCaHBHEMuonFilter  constructor
 
 
@@ -116,11 +127,11 @@ bool AlCaHBHEMuonFilter::filter(edm::Event& iEvent, edm::EventSetup const& iSetu
   bool accept(false);
   ++nAll_;
 #ifdef DebugLog
-  edm::LogInfo("HcalHBHEMuon") << "AlCaHBHEMuonFilter::Run " 
-			       << iEvent.id().run() << " Event " 
-			       << iEvent.id().event() << " Luminosity " 
-			       << iEvent.luminosityBlock() << " Bunch " 
-			       << iEvent.bunchCrossing();
+  edm::LogInfo("HBHEMuon") << "AlCaHBHEMuonFilter::Run " 
+			   << iEvent.id().run() << " Event " 
+			   << iEvent.id().event() << " Luminosity " 
+			   << iEvent.luminosityBlock() << " Bunch " 
+			   << iEvent.bunchCrossing() << std::endl;
 #endif
   //Step1: Find if the event passes one of the chosen triggers
   /////////////////////////////TriggerResults
@@ -139,9 +150,9 @@ bool AlCaHBHEMuonFilter::filter(edm::Event& iEvent, edm::EventSetup const& iSetu
 	    ok = true;
 	  }
 #ifdef DebugLog
-	  edm::LogInfo("HcalHBHEMuon") << "AlCaHBHEMuonFilter::Trigger "
-				       << triggerNames_[iHLT] << " Flag " 
-				       << hlt << ":" << ok;
+	  edm::LogInfo("HBHEMuon") << "AlCaHBHEMuonFilter::Trigger "
+				   << triggerNames_[iHLT] << " Flag " 
+				   << hlt << ":" << ok << std::endl;
 #endif
 	}
       }
@@ -161,14 +172,22 @@ bool AlCaHBHEMuonFilter::filter(edm::Event& iEvent, edm::EventSetup const& iSetu
       edm::Handle<reco::MuonCollection> _Muon;
       iEvent.getByToken(tok_Muon_, _Muon);
 #ifdef DebugLog
-      edm::LogInfo("HcalHBHEMuon") << "AlCaHBHEMuonFilter::Muon Handle " 
-				   << _Muon.isValid();
+      edm::LogInfo("HBHEMuon") << "AlCaHBHEMuonFilter::Muon Handle " 
+			       << _Muon.isValid() << std::endl;
 #endif
       if (_Muon.isValid()) { 
 	for (reco::MuonCollection::const_iterator RecMuon = _Muon->begin(); 
 	     RecMuon!= _Muon->end(); ++RecMuon)  {
 #ifdef DebugLog
-	  edm::LogInfo("HcalHBHEMuon") << "AlCaHBHEMuonFilter::Muon:Track " << RecMuon->track().isNonnull() << " innerTrack " << RecMuon->innerTrack().isNonnull() << " outerTrack " << RecMuon->outerTrack().isNonnull() << " globalTrack " << RecMuon->globalTrack().isNonnull();
+	  edm::LogInfo("HBHEMuon") << "AlCaHBHEMuonFilter::Muon:Track " 
+				   << RecMuon->track().isNonnull() 
+				   << " innerTrack " 
+				   << RecMuon->innerTrack().isNonnull() 
+				   << " outerTrack " 
+				   << RecMuon->outerTrack().isNonnull() 
+				   << " globalTrack " 
+				   << RecMuon->globalTrack().isNonnull()
+				   << std::endl;
 #endif
 	  if ((RecMuon->track().isNonnull()) &&
 	      (RecMuon->innerTrack().isNonnull()) &&
@@ -177,11 +196,16 @@ bool AlCaHBHEMuonFilter::filter(edm::Event& iEvent, edm::EventSetup const& iSetu
 	    const reco::Track* pTrack = (RecMuon->innerTrack()).get();
 	    spr::propagatedTrackID trackID = spr::propagateCALO(pTrack, geo, bField, false);
 #ifdef DebugLog
-	    edm::LogInfo("HcalHBHEMuon")<<"AlCaHBHEMuonFilter::Propagate: ECAL "
-					<< trackID.okECAL << " to HCAL " 
-					<< trackID.okHCAL;
+	    edm::LogInfo("HBHEMuon") << "AlCaHBHEMuonFilter::Propagate: ECAL "
+				     << trackID.okECAL << " to HCAL " 
+				     << trackID.okHCAL << std::endl;
 #endif
-	    if ((trackID.okECAL) && (trackID.okHCAL)) {
+	    double trackIso = RecMuon->isolationR03().sumPt;
+	    double caloIso  = RecMuon->isolationR03().emEt + RecMuon->isolationR03().hadEt;
+	    double isolR04  = ((RecMuon->pfIsolationR04().sumChargedHadronPt + std::max(0.,RecMuon->pfIsolationR04().sumNeutralHadronEt + RecMuon->pfIsolationR04().sumPhotonEt - (0.5 *RecMuon->pfIsolationR04().sumPUPt))) / RecMuon->pt());
+	    bool   isoCut   = (pfCut_) ? (isolR04 < pfIsoCut_) :
+	      ((trackIso < trackIsoCut_) && (caloIso < caloIsoCut_));
+	    if ((trackID.okECAL) && (trackID.okHCAL) && isoCut) {
 	      accept = true;
 	      break;
 	    }
@@ -191,34 +215,43 @@ bool AlCaHBHEMuonFilter::filter(edm::Event& iEvent, edm::EventSetup const& iSetu
     }
   }
   // Step 4:  Return the acceptance flag
-  if (accept) ++nGood_;
+  if (accept) {
+    ++nGood_;
+    if (((nGood_-1)%preScale_) != 0) {
+      accept = false;
+    } else {
+      ++nFinal_;
+    }
+  }
   return accept;
 
 }  // AlCaHBHEMuonFilter::filter
 
 // ------------ method called once each job just after ending the event loop  ------------
 void AlCaHBHEMuonFilter::endStream() {
-  globalCache()->nAll_  += nAll_;
-  globalCache()->nGood_ += nGood_;
+  globalCache()->nAll_   += nAll_;
+  globalCache()->nGood_  += nGood_;
+  globalCache()->nFinal_ += nFinal_;
 }
 
 void AlCaHBHEMuonFilter::globalEndJob(const AlCaHBHEMuons::Counters* count) {
-  edm::LogInfo("HcalHBHEMuon") << "Selects " << count->nGood_ << " in " 
-			       << count->nAll_ << " events";
+  edm::LogInfo("HBHEMuon") << "Selects " << count->nFinal_ << " out of "
+			   << count->nGood_ << " good events out of " 
+			   << count->nAll_ << " total # of events\n";
 }
 
 
 // ------------ method called when starting to processes a run  ------------
 void AlCaHBHEMuonFilter::beginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
   bool changed(false);
   bool flag = hltConfig_.init(iRun, iSetup, processName_, changed);
-  edm::LogInfo("HcalHBHEMuon") << "Run[" << nRun_ << "] " << iRun.run() 
-			       << " hltconfig.init " << flag;
+  edm::LogInfo("HBHEMuon") << "Run[" << nRun_ << "] " << iRun.run() 
+			   << " hltconfig.init " << flag << std::endl;
 }
 
 // ------------ method called when ending the processing of a run  ------------
 void AlCaHBHEMuonFilter::endRun(edm::Run const& iRun, edm::EventSetup const&) {
-  edm::LogInfo("HcalHBHEMuon") << "endRun[" << nRun_ << "] " << iRun.run();
+  edm::LogInfo("HBHEMuon") << "endRun[" << nRun_ << "] " << iRun.run() << "\n";
   nRun_++;
 }
 

Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalCalHBHEMuonFilter_Output_cff.py

@@ -0,0 +1,31 @@
+import FWCore.ParameterSet.Config as cms
+
+# output block for alcastream HCAL HBHEMuon
+# output module 
+#  module alcastreamHcalHBHEMuonOutput = PoolOutputModule
+OutALCARECOHcalCalHBHEMuonFilter_noDrop = cms.PSet(
+    # use this in case of filter available
+    SelectEvents = cms.untracked.PSet(
+        SelectEvents = cms.vstring('pathALCARECOHcalCalHBHEMuonFilter')
+        ),
+    outputCommands = cms.untracked.vstring(
+        'keep *_hbhereco_*_*',
+        'keep *_ecalRecHit_*_*',
+        'keep *_offlineBeamSpot_*_*',
+        'keep *_TriggerResults_*_*',
+        'keep recoTracks_globalMuons_*_*',
+        'keep recoTrackExtras_globalMuons_*_*',
+        'keep recoTracks_standAloneMuons_*_*',
+        'keep recoTrackExtras_standAloneMuons_*_*',
+        'keep recoTracks_generalTracks_*_*',
+        'keep recoTrackExtras_generalTracks_*_*',
+        'keep recoTracks_tevMuons_*_*',
+        'keep recoTrackExtras_tevMuons_*_*',
+        'keep *_offlinePrimaryVertices_*_*',
+        'keep *_muons_*_*',
+        )
+    )
+
+import copy
+OutALCARECOHcalCalHBHEMuonFilter=copy.deepcopy(OutALCARECOHcalCalHBHEMuonFilter_noDrop)
+OutALCARECOHcalCalHBHEMuonFilter.outputCommands.insert(0,"drop *")

Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalCalHBHEMuonFilter_cff.py

@@ -0,0 +1,9 @@
+import FWCore.ParameterSet.Config as cms
+
+#-------------------------------------------------
+#AlCaReco filtering for HCAL HBHEMuon:
+#-------------------------------------------------
+
+from Calibration.HcalAlCaRecoProducers.alcaHBHEMuonFilter_cfi import *
+
+seqALCARECOHcalCalHBHEMuonFilter = cms.Sequence(AlcaHBHEMuonFilter)

Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalHBHEMuon_Output_cff.py → Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalCalHBHEMuon_Output_cff.py

@@ -3,11 +3,11 @@
 # output block for alcastream HCAL HBHEMuon
 # output module 
 #  module alcastreamHcalHBHEMuonOutput = PoolOutputModule
-OutALCARECOHcalHBHEMuon_noDrop = cms.PSet(
+OutALCARECOHcalCalHBHEMuon_noDrop = cms.PSet(
     # use this in case of filter available
     SelectEvents = cms.untracked.PSet(
         SelectEvents = cms.vstring('pathALCARECOHcalHBHEMuon')
-    ),
+        ),
     outputCommands = cms.untracked.vstring( 
         'keep edmTriggerResults_*_*_*',
         'keep recoTracks_globalMuons_*_*',
@@ -23,7 +23,7 @@
 )
 
 import copy
-OutALCARECOHcalHBHEMuon=copy.deepcopy(OutALCARECOHcalHBHEMuon_noDrop)
-OutALCARECOHcalHBHEMuon.outputCommands.insert(0,"drop *")
+OutALCARECOHcalCalHBHEMuon=copy.deepcopy(OutALCARECOHcalCalHBHEMuon_noDrop)
+OutALCARECOHcalCalHBHEMuon.outputCommands.insert(0,"drop *")
 
 

Calibration/HcalAlCaRecoProducers/python/alcaHBHEMuonFilter_cfi.py

@@ -5,5 +5,10 @@
                                   TriggerResultLabel= cms.InputTag("TriggerResults","","HLT"),
                                   MuonLabel         = cms.InputTag("muons"),
                                   MinimumMuonP      = cms.double(10.0),
-                                  Triggers           = cms.vstring("HLT_IsoMu17","HLT_IsoMu20","HLT_IsoMu24","HLT_IsoMu27","HLT_Mu45","HLT_Mu50"),
+                                  Triggers          = cms.vstring("HLT_IsoMu","HLT_Mu"),
+                                  PFCut             = cms.bool(True),
+                                  PFIsolationCut    = cms.double(0.12),
+                                  TrackIsolationCut = cms.double(3.0),
+                                  CaloIsolationCut  = cms.double(5.0),
+                                  PreScale          = cms.int32(2),
                                   )

Calibration/HcalCalibAlgos/plugins/HcalHBHEMuonAnalyzer.cc

@@ -85,7 +85,7 @@ class HcalHBHEMuonAnalyzer : public edm::EDAnalyzer {
   edm::InputTag              HLTriggerResults_;
   std::string                labelEBRecHit_, labelEERecHit_;
   std::string                labelVtx_, labelHBHERecHit_, labelMuon_;
-  int                        verbosity_, maxDepth_;
+  int                        verbosity_, maxDepth_, kount_;
   bool                       useRaw_;
 
   edm::EDGetTokenT<edm::TriggerResults>                   tok_trigRes_;
@@ -129,6 +129,7 @@ class HcalHBHEMuonAnalyzer : public edm::EDAnalyzer {
 
 HcalHBHEMuonAnalyzer::HcalHBHEMuonAnalyzer(const edm::ParameterSet& iConfig) {
   //now do what ever initialization is needed
+  kount_            = 0;
   HLTriggerResults_ = iConfig.getParameter<edm::InputTag>("HLTriggerResults");
   labelVtx_         = iConfig.getParameter<std::string>("LabelVertex");
   labelEBRecHit_    = iConfig.getParameter<std::string>("LabelEBRecHit");
@@ -180,7 +181,7 @@ HcalHBHEMuonAnalyzer::~HcalHBHEMuonAnalyzer() {
 
 // ------------ method called for each event  ------------
 void HcalHBHEMuonAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
-
+  ++kount_;
   clearVectors();
   RunNumber   = iEvent.id().run();
   EventNumber = iEvent.id().event();

Calibration/HcalCalibAlgos/python/hcalHBHEMuon_cfi.py

@@ -12,5 +12,5 @@
                                       ProcessName      = cms.untracked.string("AlCaHBHEMuon"),
                                       Verbosity        = cms.untracked.int32(0),
                                       MaxDepth         = cms.untracked.int32(4),
-                                      UseRaw           = cms.untracked.bool(false),
+                                      UseRaw           = cms.untracked.bool(False),
                                       )

Configuration/AlCa/python/autoAlca.py

@@ -16,7 +16,7 @@
                   "NoBPTX"         : "TkAlCosmicsInCollisions",
                   "SingleElectron" : "EcalCalWElectron+EcalUncalWElectron+EcalCalZElectron+EcalUncalZElectron+EcalESAlign+HcalCalIterativePhiSym+HcalCalIsoTrkFilter",
                   "SingleMu"       : "MuAlCalIsolatedMu+MuAlOverlaps+TkAlMuonIsolated+DtCalib+MuAlZMuMu+HcalCalHO",
-                  "SingleMuon"     : "TkAlMuonIsolated+DtCalib+MuAlCalIsolatedMu+MuAlOverlaps+MuAlZMuMu+HcalCalIterativePhiSym",
+                  "SingleMuon"     : "TkAlMuonIsolated+DtCalib+MuAlCalIsolatedMu+MuAlOverlaps+MuAlZMuMu+HcalCalIterativePhiSym+HcalCalHBHEMuonFilter",
                   "SinglePhoton"   : "HcalCalGammaJet",
                   "ZeroBias"       : "SiStripCalZeroBias+TkAlMinBias+LumiPixelsMinBias+SiStripCalMinBias+EcalTrg", 
                   "StreamExpress"  : "SiStripCalZeroBias+TkAlMinBias+SiStripPCLHistos+SiStripCalMinBias+SiStripCalMinBiasAfterAbortGap+DtCalib+Hotline+LumiPixelsMinBias",

Configuration/EventContent/python/AlCaRecoOutput_cff.py

@@ -85,6 +85,8 @@
 # HCAL calibration with isolated bunch
 from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalIsolatedBunchFilter_Output_cff import *
 from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalIsolatedBunchSelector_Output_cff import *
+# HCAL calibration with muons (HB/HE)
+from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalHBHEMuonFilter_Output_cff import *
 ###############################################################
 # Muon Alignment (incl. stream for calibration)
 ###############################################################

Configuration/StandardSequences/python/AlCaRecoStreamsHeavyIons_cff.py

@@ -58,6 +58,8 @@
 # HCAL isolated bunch
 from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalIsolatedBunchFilter_cff import *
 from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalIsolatedBunchSelector_cff import *
+# HCAL calibration with muons in HB/HE
+from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalHBHEMuonFilter_cff import *
 
 ###############################################################
 # Muon alignment
@@ -130,6 +132,7 @@
 pathALCARECOHcalCalNoise = cms.Path(seqALCARECOHcalCalNoise)
 pathALCARECOHcalCalIsolatedBunchFilter = cms.Path(seqALCARECOHcalCalIsolatedBunchFilter)
 pathALCARECOHcalCalIsolatedBunchSelector = cms.Path(seqALCARECOHcalCalIsolatedBunchSelector)
+pathALCARECOHcalCalHBHEMuonFilter = cms.Path(seqALCARECOHcalCalHBHEMuonFilter)
 pathALCARECOMuAlCalIsolatedMu = cms.Path(seqALCARECOMuAlCalIsolatedMu*ALCARECOMuAlCalIsolatedMuDQM*ALCARECODTCalibrationDQM)
 pathALCARECOMuAlZMuMu = cms.Path(seqALCARECOMuAlZMuMu*ALCARECOMuAlZMuMuDQM)
 pathALCARECOMuAlOverlaps = cms.Path(seqALCARECOMuAlOverlaps*ALCARECOMuAlOverlapsDQM)
@@ -331,6 +334,15 @@
 	dataTier = cms.untracked.string('ALCARECO')
 	)
 
+ALCARECOStreamHcalCalHBHEMuonFilter = cms.FilteredStream(
+	responsible = 'Sunanda Banerjee',
+	name = 'HcalCalHBHEMuonFilter',
+	paths  = (pathALCARECOHcalCalHBHEMuonFilter),
+	content = OutALCARECOHcalCalHBHEMuonFilter.outputCommands,
+	selectEvents = OutALCARECOHcalCalHBHEMuonFilter.SelectEvents,
+	dataTier = cms.untracked.string('ALCARECO')
+	)
+
 ALCARECOStreamMuAlCalIsolatedMu = cms.FilteredStream(
 	responsible = 'Javier Fernandez',
 	name = 'MuAlCalIsolatedMu',

Configuration/StandardSequences/python/AlCaRecoStreams_cff.py

@@ -78,6 +78,8 @@
 # HCAL isolated bunch
 from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalIsolatedBunchFilter_cff import *
 from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalIsolatedBunchSelector_cff import *
+# HCAL calibration with muons in HB/HE
+from Calibration.HcalAlCaRecoProducers.ALCARECOHcalCalHBHEMuonFilter_cff import *
 
 
 ###############################################################
@@ -173,6 +175,7 @@
 pathALCARECOHcalCalIterativePhiSym = cms.Path(seqALCARECOHcalCalIterativePhiSym*ALCARECOHcalCalPhisymDQM)
 pathALCARECOHcalCalIsolatedBunchFilter = cms.Path(seqALCARECOHcalCalIsolatedBunchFilter)
 pathALCARECOHcalCalIsolatedBunchSelector = cms.Path(seqALCARECOHcalCalIsolatedBunchSelector)
+pathALCARECOHcalCalHBHEMuonFilter = cms.Path(seqALCARECOHcalCalHBHEMuonFilter)
 pathALCARECOMuAlCalIsolatedMu = cms.Path(seqALCARECOMuAlCalIsolatedMu*ALCARECOMuAlCalIsolatedMuDQM*ALCARECODTCalibrationDQM)
 pathALCARECOMuAlCalIsolatedMuGeneralTracks = cms.Path(seqALCARECOMuAlCalIsolatedMuGeneralTracks)
 pathALCARECOMuAlZMuMu = cms.Path(seqALCARECOMuAlZMuMu*ALCARECOMuAlZMuMuDQM)
@@ -494,6 +497,15 @@
 	dataTier = cms.untracked.string('ALCARECO')
 	)
 
+ALCARECOStreamHcalCalHBHEMuonFilter = cms.FilteredStream(
+	responsible = 'Sunanda Banerjee',
+	name = 'HcalCalHBHEMuonFilter',
+	paths  = (pathALCARECOHcalCalHBHEMuonFilter),
+	content = OutALCARECOHcalCalHBHEMuonFilter.outputCommands,
+	selectEvents = OutALCARECOHcalCalHBHEMuonFilter.SelectEvents,
+	dataTier = cms.untracked.string('ALCARECO')
+	)
+
 ALCARECOStreamMuAlCalIsolatedMu = cms.FilteredStream(
 	responsible = 'Luca Pernie',
 	name = 'MuAlCalIsolatedMu',