Merge pull request #17 from cms-sw/master

update master

Calibration/TkAlCaRecoProducers/python/ALCARECOPromptCalibProd_cff.py

@@ -15,27 +15,7 @@
 # ------------------------------------------------------------------------------
 # configure the beam-spot production
 from Calibration.TkAlCaRecoProducers.AlcaBeamSpotProducer_cff import *
-alcaBeamSpotProducer.BeamFitter.TrackCollection = 'ALCARECOTkAlMinBias'
-alcaBeamSpotProducer.BeamFitter.MinimumTotalLayers = 6
-alcaBeamSpotProducer.BeamFitter.MinimumPixelLayers = -1
-alcaBeamSpotProducer.BeamFitter.MaximumNormChi2 = 10
-alcaBeamSpotProducer.BeamFitter.MinimumInputTracks = 50
-alcaBeamSpotProducer.BeamFitter.MinimumPt = 1.0
-alcaBeamSpotProducer.BeamFitter.MaximumImpactParameter = 1.0
-alcaBeamSpotProducer.BeamFitter.TrackAlgorithm =  cms.untracked.vstring()
-#alcaBeamSpotProducer.BeamFitter.Debug = True
-alcaBeamSpotProducer.PVFitter.Apply3DFit = True
-alcaBeamSpotProducer.PVFitter.minNrVerticesForFit = 10 
 
-# fit as function of lumi sections
-alcaBeamSpotProducer.AlcaBeamSpotProducerParameters.fitEveryNLumi = 1
-alcaBeamSpotProducer.AlcaBeamSpotProducerParameters.resetEveryNLumi = 1
-
-# alcaBeamSpotProducer.AlcaBeamSpotProducerParameters.TrackCollection = cms.untracked.InputTag('ALCARECOTkAlMinBias')
-# alcaBeamSpotProducer.AlcaBeamSpotProducerParameters.fitEveryNLumi = cms.untracked.int32(1)
-# alcaBeamSpotProducer.AlcaBeamSpotProducerParameters.resetEveryNLumi = cms.untracked.int32(1)
-# alcaBeamSpotProducer.AlcaBeamSpotProducerParameters.TrackCollection = cms.untracked.InputTag('ALCARECOTkAlMinBias')
-# alcaBeamSpotProducer.BeamFitter.TrackCollection = cms.untracked.InputTag('ALCARECOTkAlMinBias')
 
 # ------------------------------------------------------------------------------
 # this is for filtering on L1 technical trigger bit
@@ -51,38 +31,6 @@
     throw = False # tolerate triggers stated above, but not available
     )
 
-
-#from L1TriggerConfig.L1GtConfigProducers.L1GtTriggerMaskTechTrigConfig_cff import *
-#from HLTrigger.HLTfilters.hltLevel1GTSeed_cfi import hltLevel1GTSeed
-#L1CollTrigger = hltLevel1GTSeed.clone()
-
-#L1CollTrigger.L1TechTriggerSeeding = cms.bool(True)
-#L1CollTrigger.L1SeedsLogicalExpression = cms.string('0 AND ( 40 OR 41 ) AND NOT (36 OR 37 OR 38 OR 39)')
-
-
-# ------------------------------------------------------------------------------
-# configuration to reproduce offlinePrimaryVertices
-# FIXME: needs to be moved in the TkAlMinBias definition
-# from RecoVertex.BeamSpotProducer.BeamSpot_cfi import *
-# offlineBeamSpotForBS = offlineBeamSpot.clone()
-# from RecoVertex.PrimaryVertexProducer.OfflinePrimaryVertices_cfi import *
-
-# # overwrite some defaults for PV producer
-# offlinePrimaryVerticesForBS = offlinePrimaryVertices.clone()
-# offlinePrimaryVerticesForBS.TrackLabel = cms.InputTag("ALCARECOTkAlMinBias")
-# offlinePrimaryVerticesForBS.beamSpotLabel = cms.InputTag("offlineBeamSpotForBS")
-# offlinePrimaryVerticesForBS.PVSelParameters.maxDistanceToBeam = 2
-# offlinePrimaryVerticesForBS.TkFilterParameters.maxNormalizedChi2 = 20
-# offlinePrimaryVerticesForBS.TkFilterParameters.minSiliconLayersWithHits = 5
-# offlinePrimaryVerticesForBS.TkFilterParameters.maxD0Significance = 100
-# offlinePrimaryVerticesForBS.TkFilterParameters.minPixelLayersWithHits = 1
-# offlinePrimaryVerticesForBS.TkClusParameters.TkGapClusParameters.zSeparation = 1
-# alcaBeamSpotProducer.PVFitter.VertexCollection = "offlinePrimaryVerticesForBS"
-
 seqALCARECOPromptCalibProd = cms.Sequence(ALCARECOTkAlMinBiasFilterForBS *
                                           ALCARECOHltFilterForBS *
-#                                           offlineBeamSpotForBS +
-#                                           offlinePrimaryVerticesForBS +
                                           alcaBeamSpotProducer)
-
-#process.bsProductionPath = cms.Path(process.TkAlMinBiasFilterForBS+process.alcaBeamSpotProducer)

Calibration/TkAlCaRecoProducers/python/AlcaBeamSpotProducerHP_cfi.py

@@ -48,7 +48,7 @@
         minVertexMeanWeight = cms.untracked.double(0.5),
         maxVertexR = cms.untracked.double(2),
         maxVertexZ = cms.untracked.double(10),
-        errorScale = cms.untracked.double(1.1),
+        errorScale = cms.untracked.double(1.0),
         nSigmaCut = cms.untracked.double(50.),
         FitPerBunchCrossing = cms.untracked.bool(False),
         useOnlyFirstPV = cms.untracked.bool(True),

Calibration/TkAlCaRecoProducers/python/AlcaBeamSpotProducer_cfi.py

@@ -5,12 +5,12 @@
         RunAllFitters = cms.bool(False), ## False: run only default fitter
 	RunBeamWidthFit = cms.bool(False), 
         WriteToDB = cms.bool(False), ## do not write results to DB
-	fitEveryNLumi = cms.untracked.int32( -1 ),
-	resetEveryNLumi = cms.untracked.int32( -1 )
+	fitEveryNLumi = cms.untracked.int32( 1 ),
+	resetEveryNLumi = cms.untracked.int32( 1 )
     ),
     BeamFitter = cms.PSet(
 	Debug = cms.untracked.bool(False),
-	TrackCollection = cms.untracked.InputTag('generalTracks'),
+	TrackCollection = cms.untracked.InputTag('ALCARECOTkAlMinBias'),
         IsMuonCollection = cms.untracked.bool(False),
         WriteAscii = cms.untracked.bool(False),
 	AsciiFileName = cms.untracked.string('BeamFit.txt'), ## all results
@@ -21,34 +21,34 @@
 	SaveFitResults = cms.untracked.bool(False),
         SavePVVertices = cms.untracked.bool(False),
 	OutputFileName = cms.untracked.string('analyze_d0_phi.root'),
-	MinimumPt = cms.untracked.double(1.2),
+	MinimumPt = cms.untracked.double(1.0),
 	MaximumEta = cms.untracked.double(2.4),
-	MaximumImpactParameter = cms.untracked.double(5),
+	MaximumImpactParameter = cms.untracked.double(1.0),
 	MaximumZ = cms.untracked.double(60),
-	MinimumTotalLayers = cms.untracked.int32(11),
-	MinimumPixelLayers = cms.untracked.int32(3),
-	MaximumNormChi2 = cms.untracked.double(2.0),
-	TrackAlgorithm = cms.untracked.vstring('initialStep'), ## ctf,rs,cosmics,initialStep,lowPtTripletStep...; for all algos, leave it blank
+	MinimumTotalLayers = cms.untracked.int32(6),
+	MinimumPixelLayers = cms.untracked.int32(-1),
+	MaximumNormChi2 = cms.untracked.double(10.0),
+	TrackAlgorithm = cms.untracked.vstring(), ## ctf,rs,cosmics,initialStep,lowPtTripletStep...; for all algos, leave it blank
 	TrackQuality = cms.untracked.vstring(), ## loose, tight, highPurity...; for all qualities, leave it blank
         InputBeamWidth = cms.untracked.double(-1.0), ## if -1 use the value calculated by the analyzer
 	FractionOfFittedTrks = cms.untracked.double(0.9),
-	MinimumInputTracks = cms.untracked.int32(100)
+	MinimumInputTracks = cms.untracked.int32(50)
      ),
      PVFitter = cms.PSet(
         Debug = cms.untracked.bool(False),
-	Apply3DFit = cms.untracked.bool(False),
+        Apply3DFit = cms.untracked.bool(True),
         VertexCollection = cms.untracked.InputTag('offlinePrimaryVertices'),
         #WriteAscii = cms.untracked.bool(True),
         #AsciiFileName = cms.untracked.string('PVFit.txt'),
         maxNrStoredVertices = cms.untracked.uint32(10000),
-        minNrVerticesForFit = cms.untracked.uint32(100),
+        minNrVerticesForFit = cms.untracked.uint32(10),
         minVertexNdf = cms.untracked.double(10.),
         maxVertexNormChi2 = cms.untracked.double(10.),
         minVertexNTracks = cms.untracked.uint32(0),
         minVertexMeanWeight = cms.untracked.double(0.5),
         maxVertexR = cms.untracked.double(2),
         maxVertexZ = cms.untracked.double(10),
-        errorScale = cms.untracked.double(0.9),
+        errorScale = cms.untracked.double(1.0),
         nSigmaCut = cms.untracked.double(50.),
         FitPerBunchCrossing = cms.untracked.bool(False),
         useOnlyFirstPV = cms.untracked.bool(False),

CondCore/Utilities/test/BuildFile.xml

@@ -1,3 +1,6 @@
+<ifrelease name="_ASAN_">
+  <flags NO_TEST_PREFIX="1"/>
+</ifrelease>
 <use name="CondCore/CondDB"/>
 <use name="CondCore/Utilities"/>
 <use name="CondFormats/Common"/>

CondFormats/RPCObjects/test/RPCReadOutMapBuilder.cc

@@ -32,7 +32,7 @@ class RPCReadOutMapBuilder : public edm::one::EDAnalyzer<> {
   void endJob() override;
 
 private:
-  RPCReadOutMapping* cabling;
+  RPCReadOutMapping cabling;
   string m_record;
 };
 
@@ -56,10 +56,9 @@ void RPCReadOutMapBuilder::endJob() {
 
   try {
     if (mydbservice->isNewTagRequest(m_record)) {
-      mydbservice->createNewIOV<RPCReadOutMapping>(
-          cabling, mydbservice->beginOfTime(), mydbservice->endOfTime(), m_record);
+      mydbservice->createOneIOV(cabling, mydbservice->beginOfTime(), m_record);
     } else {
-      mydbservice->appendSinceTime<RPCReadOutMapping>(cabling, mydbservice->currentTime(), m_record);
+      mydbservice->appendOneIOV(cabling, mydbservice->currentTime(), m_record);
     }
   } catch (std::exception& e) {
     cout << "std::exception:  " << e.what();
@@ -73,7 +72,7 @@ void RPCReadOutMapBuilder::endJob() {
 void RPCReadOutMapBuilder::beginJob() {
   cout << "BeginJob method " << endl;
   cout << "Building RPC Cabling" << endl;
-  cabling = new RPCReadOutMapping("My map V-TEST");
+  RPCReadOutMapping cabling;
   {
     DccSpec dcc(790);
     for (int idtb = 1; idtb <= 68; idtb++) {
@@ -103,7 +102,7 @@ void RPCReadOutMapBuilder::beginJob() {
       }
       dcc.add(tb);
     }
-    cabling->add(dcc);
+    cabling.add(dcc);
   }
 }
 

CondTools/CTPPS/plugins/PPSTimingCalibrationWriter.cc

@@ -38,12 +38,11 @@ class PPSTimingCalibrationWriter : public edm::one::EDAnalyzer<> {
 
 void PPSTimingCalibrationWriter::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
   // get timing calibration parameters
-  edm::ESHandle<PPSTimingCalibration> hTimingCalib = iSetup.getHandle(tokenCalibration_);
-
+  const auto& hTimingCalib = iSetup.getData(tokenCalibration_);
   // store the calibration into a DB object
   edm::Service<cond::service::PoolDBOutputService> poolDbService;
   if (poolDbService.isAvailable())
-    poolDbService->writeOneIOV(*hTimingCalib.product(), poolDbService->currentTime(), "PPSTimingCalibrationRcd");
+    poolDbService->writeOneIOV(hTimingCalib, poolDbService->currentTime(), "PPSTimingCalibrationRcd");
   else
     throw cms::Exception("PPSTimingCalibrationWriter") << "PoolDBService required.";
 }

CondTools/CTPPS/plugins/WriteCTPPSBeamParameters.cc

@@ -49,11 +49,7 @@ class WriteCTPPSBeamParameters : public edm::one::EDAnalyzer<> {
 //---------------------------------------------------------------------------------------
 
 void WriteCTPPSBeamParameters::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
-  edm::ESHandle<CTPPSBeamParameters> bp = iSetup.getHandle(tokenBeamParameters_);
-
-  // Pointer for the conditions data object
-  const CTPPSBeamParameters* p = bp.product();
-
+  const auto& beamParam = iSetup.getData(tokenBeamParameters_);
   // Using "lumiid" as IOV
   const edm::LuminosityBlock& iLBlock = iEvent.getLuminosityBlock();
   edm::LuminosityBlockID lu(iLBlock.run(), iLBlock.id().luminosityBlock());
@@ -67,8 +63,7 @@ void WriteCTPPSBeamParameters::analyze(const edm::Event& iEvent, const edm::Even
   // Write to database or sqlite file
   edm::Service<cond::service::PoolDBOutputService> poolDbService;
   if (poolDbService.isAvailable())
-    poolDbService->writeOneIOV(*p, ilumi, "CTPPSBeamParametersRcd");
-  // poolDbService->writeOne( p, poolDbService->currentTime(), "CTPPSBeamParametersRcd"  );
+    poolDbService->writeOneIOV(beamParam, ilumi, "CTPPSBeamParametersRcd");
   else
     throw std::runtime_error("PoolDBService required.");
 }

CondTools/CTPPS/src/CTPPSRPAlignmentInfoAnalyzer.cc

@@ -72,20 +72,25 @@ CTPPSRPAlignmentInfoAnalyzer::CTPPSRPAlignmentInfoAnalyzer(const edm::ParameterS
 //----------------------------------------------------------------------------------------------------
 
 void CTPPSRPAlignmentInfoAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
-  edm::ESHandle<CTPPSRPAlignmentCorrectionsData> alignments;
+  const auto alignments = [&r = record_,
+                           &eS = iSetup,
+                           &tAI = tokenAlignmentIdeal_,
+                           &tAR = tokenAlignmentReal_,
+                           &tAM = tokenAlignmentMisaligned_]() -> const CTPPSRPAlignmentCorrectionsData* {
+    if (r == "CTPPSRPAlignmentCorrectionsDataRcd") {
+      return &eS.getData(tAI);
+    } else if (r == "RPRealAlignmentRecord") {
+      return &eS.getData(tAR);
+    } else {
+      return &eS.getData(tAM);
+    }
+  }();
 
-  if (strcmp(record_.c_str(), "CTPPSRPAlignmentCorrectionsDataRcd") == 0) {
-    alignments = iSetup.getHandle(tokenAlignmentIdeal_);
-  } else if (strcmp(record_.c_str(), "RPRealAlignmentRecord") == 0) {
-    alignments = iSetup.getHandle(tokenAlignmentReal_);
-  } else {
-    alignments = iSetup.getHandle(tokenAlignmentMisaligned_);
-  }
-
-  const CTPPSRPAlignmentCorrectionsData* pCTPPSRPAlignmentCorrectionsData = alignments.product();
   edm::Service<cond::service::PoolDBOutputService> poolDbService;
-  if (poolDbService.isAvailable()) {
-    poolDbService->writeOneIOV(*pCTPPSRPAlignmentCorrectionsData, iov_, record_);
+  if (!poolDbService.isAvailable()) {
+    edm::LogError("CTPPSAlignmentInfoAnalyzer") << " DbService not available ";
+  } else {
+    poolDbService->writeOneIOV(alignments, iov_, record_);
   }
 }
 

CondTools/CTPPS/src/WriteCTPPSPixGainCalibrations.cc

@@ -188,8 +188,8 @@ void WriteCTPPSPixGainCalibrations::getHistos() {
 }
 
 void WriteCTPPSPixGainCalibrations::fillDB() {
-  CTPPSPixelGainCalibrations* gainCalibsTest = new CTPPSPixelGainCalibrations();
-  CTPPSPixelGainCalibrations* gainCalibsTest1 = new CTPPSPixelGainCalibrations();
+  CTPPSPixelGainCalibrations gainCalibsTest;
+  CTPPSPixelGainCalibrations gainCalibsTest1;
 
   //  std::cout<<"Here! "<<std::endl;
 
@@ -225,9 +225,9 @@ void WriteCTPPSPixGainCalibrations::fillDB() {
       setDummyFullPlane(orderedPeds, orderedGains, 6 * 52 * 80);
     }
 
-    gainCalibsTest->setGainCalibration(tempdetid, orderedPeds, orderedGains);
+    gainCalibsTest.setGainCalibration(tempdetid, orderedPeds, orderedGains);
     //	 std::cout << "Here detid = "<<tempdetid <<std::endl;
-    gainCalibsTest1->setGainCalibration(tempdetid, tempPGCalib);
+    gainCalibsTest1.setGainCalibration(tempdetid, tempPGCalib);
     //	 std::cout << "Here again"<<std::endl;
   }
   //  std::cout<<" Here 3!"<<std::endl;
@@ -236,7 +236,7 @@ void WriteCTPPSPixGainCalibrations::fillDB() {
     edm::LogError("CTPPSPixGainsCalibrationWriter") << "Db Service Unavailable";
     return;
   }
-  mydbservice->writeOne(gainCalibsTest, mydbservice->currentTime(), m_record);
+  mydbservice->writeOneIOV(gainCalibsTest, mydbservice->currentTime(), m_record);
 }
 
 void WriteCTPPSPixGainCalibrations::setDummyFullPlane(std::vector<float>& peds,

CondTools/CTPPS/src/WriteCTPPSPixelAnalysisMask.cc

@@ -58,9 +58,6 @@ WriteCTPPSPixelAnalysisMask::WriteCTPPSPixelAnalysisMask(const edm::ParameterSet
       tokenAnalysisMask_(esConsumes<CTPPSPixelAnalysisMask, CTPPSPixelAnalysisMaskRcd>(edm::ESInputTag("", label_))) {}
 
 void WriteCTPPSPixelAnalysisMask::analyze(const edm::Event &, edm::EventSetup const &es) {
-  // get analysis mask to mask channels
-  ESHandle<CTPPSPixelAnalysisMask> hAnalysisMask = es.getHandle(tokenAnalysisMask_);
-
   /*// print analysisMask
   printf("* mask\n");
   for (const auto &p : analysisMask->analysisMask)
@@ -70,10 +67,11 @@ void WriteCTPPSPixelAnalysisMask::analyze(const edm::Event &, edm::EventSetup co
   */
 
   // Write Analysis Mask to sqlite file:
-  const CTPPSPixelAnalysisMask *pCTPPSPixelAnalysisMask = hAnalysisMask.product();  // Analysis Mask
+
+  const auto &analysisMask = es.getData(tokenAnalysisMask_);
   edm::Service<cond::service::PoolDBOutputService> poolDbService;
   if (poolDbService.isAvailable()) {
-    poolDbService->writeOneIOV(*pCTPPSPixelAnalysisMask, analysismaskiov_, /*m_record*/ record_);
+    poolDbService->writeOneIOV(analysisMask, analysismaskiov_, record_);
   }
 }
 

CondTools/CTPPS/src/WriteCTPPSPixelDAQMapping.cc

@@ -59,20 +59,19 @@ WriteCTPPSPixelDAQMapping::WriteCTPPSPixelDAQMapping(const edm::ParameterSet &ps
       tokenMapping_(esConsumes<CTPPSPixelDAQMapping, CTPPSPixelDAQMappingRcd>(edm::ESInputTag("", label_))) {}
 
 void WriteCTPPSPixelDAQMapping::analyze(const edm::Event &, edm::EventSetup const &es) {
-  // get DAQ mapping
-  edm::ESHandle<CTPPSPixelDAQMapping> hMapping = es.getHandle(tokenMapping_);
-
   // print mapping
   /*printf("* DAQ mapping\n");
   for (const auto &p : mapping->ROCMapping)
     cout << "    " << p.first << " -> " << p.second << endl;
   */
 
   // Write DAQ Mapping to sqlite file:
-  const CTPPSPixelDAQMapping *pCTPPSPixelDAQMapping = hMapping.product();  // DAQ Mapping
+
+  const auto &mapping = es.getData(tokenMapping_);
+
   edm::Service<cond::service::PoolDBOutputService> poolDbService;
   if (poolDbService.isAvailable()) {
-    poolDbService->writeOneIOV(*pCTPPSPixelDAQMapping, daqmappingiov_, /*m_record*/ record_);
+    poolDbService->writeOneIOV(mapping, daqmappingiov_, record_);
   }
 }
 

CondTools/Geometry/plugins/PPSGeometryBuilder.cc

@@ -78,20 +78,19 @@ void PPSGeometryBuilder::analyze(const edm::Event& iEvent, const edm::EventSetup
   }
 
   // Build persistent geometry data from geometry
-  PDetGeomDesc* serializableData =
-      new PDetGeomDesc();  // cond::service::PoolDBOutputService::writeOne interface requires raw pointer.
+  PDetGeomDesc serializableData;  // cond::service::PoolDBOutputService::writeOne interface requires raw pointer.
   int counter = 0;
   if (geoInfoRoot) {
-    buildSerializableDataFromGeoInfo(serializableData, geoInfoRoot.get(), counter);
+    buildSerializableDataFromGeoInfo(&serializableData, geoInfoRoot.get(), counter);
   }
 
   // Save geometry in the database
-  if (serializableData->container_.empty()) {
+  if (serializableData.container_.empty()) {
     throw cms::Exception("PPSGeometryBuilder") << "PDetGeomDesc is empty, no geometry to save in the database.";
   } else {
     if (dbService_.isAvailable()) {
-      dbService_->writeOne(serializableData, dbService_->beginOfTime(), "VeryForwardIdealGeometryRecord");
-      edm::LogInfo("PPSGeometryBuilder") << "Successfully wrote DB, with " << serializableData->container_.size()
+      dbService_->writeOneIOV(serializableData, dbService_->beginOfTime(), "VeryForwardIdealGeometryRecord");
+      edm::LogInfo("PPSGeometryBuilder") << "Successfully wrote DB, with " << serializableData.container_.size()
                                          << " PDetGeomDesc items.";
     } else {
       throw cms::Exception("PPSGeometryBuilder") << "PoolDBService required.";

CondTools/HLT/plugins/AlCaRecoTriggerBitsRcdRead.cc

@@ -44,7 +44,8 @@ class AlCaRecoTriggerBitsRcdRead : public edm::one::EDAnalyzer<edm::one::WatchRu
 
   void analyze(const edm::Event &evt, const edm::EventSetup &evtSetup) override {}
   void beginRun(const edm::Run &run, const edm::EventSetup &evtSetup) override;
-  void endRun(edm::Run const &, edm::EventSetup const &) override;
+  void endRun(edm::Run const &, edm::EventSetup const &) override {}
+  void endJob() override;
 
   static void fillDescriptions(edm::ConfigurationDescriptions &descriptions);
 
@@ -125,6 +126,7 @@ AlCaRecoTriggerBitsRcdRead::OutputType AlCaRecoTriggerBitsRcdRead::stringToEnum(
 ///////////////////////////////////////////////////////////////////////
 void AlCaRecoTriggerBitsRcdRead::beginRun(const edm::Run &run, const edm::EventSetup &iSetup) {
   if (watcher_.check(iSetup)) {  // new IOV for this run
+    edm::LogPrint("AlCaRecoTriggerBitsRcdRead") << "new IOV: " << firstRun_ << "-" << lastRun_;
     // Print last IOV - if there has already been one:
     if (lastRun_ != 0)
       this->printMap(firstRun_, lastRun_, lastTriggerBits_);
@@ -139,7 +141,7 @@ void AlCaRecoTriggerBitsRcdRead::beginRun(const edm::Run &run, const edm::EventS
 }
 
 ///////////////////////////////////////////////////////////////////////
-void AlCaRecoTriggerBitsRcdRead::endRun(edm::Run const &, edm::EventSetup const &) {
+void AlCaRecoTriggerBitsRcdRead::endJob() {
   // Print for very last IOV, not treated yet in beginRun(..):
   this->printMap(firstRun_, lastRun_, lastTriggerBits_);
 }