diff --git a/.gitignore b/.gitignore index 89543e26bf3d1..94c192b99644d 100644 --- a/.gitignore +++ b/.gitignore @@ -13,3 +13,18 @@ __init__.py # ignore files under the top level $CMSSW_BASE/src directory, but not its subdirectories /* !/*/ + +harvester_log_*.txt +Logs/* +worker_log_*.txt +DQM_V* +OutputFiles/* + +*.root +run_output.root +Analyzer/DiamondTimingAnalyzer/run_output.root +crab_DiamondTimingRes* +*.log +temp_rollingcalib/ +calib.json +test_* \ No newline at end of file diff --git a/Analyzer/DiamondTimingAnalyzer/BuildFile.xml b/Analyzer/DiamondTimingAnalyzer/BuildFile.xml index 2bc1f4d3c03ea..bbf480cb70ec4 100644 --- a/Analyzer/DiamondTimingAnalyzer/BuildFile.xml +++ b/Analyzer/DiamondTimingAnalyzer/BuildFile.xml @@ -9,6 +9,7 @@ + \ No newline at end of file diff --git a/Analyzer/DiamondTimingAnalyzer/JUST_SHIFT_357440_maxEv90000_4_diamondDQM_chrys/try1/reco_cfg_4_diamondDQM_test.py b/Analyzer/DiamondTimingAnalyzer/JUST_SHIFT_357440_maxEv90000_4_diamondDQM_chrys/try1/reco_cfg_4_diamondDQM_test.py new file mode 100644 index 0000000000000..27f6d393a688e --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/JUST_SHIFT_357440_maxEv90000_4_diamondDQM_chrys/try1/reco_cfg_4_diamondDQM_test.py @@ -0,0 +1,145 @@ +import FWCore.ParameterSet.Config as cms +from Configuration.Eras.Era_Run3_cff import Run3 + +process = cms.Process('RECODQM', Run3) + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(90000) ) +process.verbosity = cms.untracked.PSet( input = cms.untracked.int32(10) ) + +# minimum of logs +process.MessageLogger = cms.Service("MessageLogger", + cerr = cms.untracked.PSet( + threshold = cms.untracked.string('INFO') + ) +) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +# load DQM framework +process.load("DQM.Integration.config.environment_cfi") +process.dqmEnv.subSystemFolder = "CTPPS" +process.dqmEnv.eventInfoFolder = "EventInfo" +process.dqmSaver.path = "" +process.dqmSaver.tag = "CTPPS" +#process.dqmSaver.runNumber = 999999 + + +# raw data source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( +#'file:/eos/cms/store/data/Run2022B/AlCaPPS/RAW/v1/000/355/207/00000/c23440f4-49c0-44aa-b8f6-f40598fb4705.root', +#'file:/eos/cms/store/group/dpg_ctpps/comm_ctpps/ALCAPPS-RAW/000/355/988/00000/7728d214-b404-4578-b781-b0c207cfb875.root', +#'/store/data/Run2022D/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v2/000/357/900/00000/0434a2eb-2cea-4d83-8b21-fe91b755e62e.root', +# RUN 440 - "357440": [[1,354]], +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/53746080-d21b-4fdf-9d19-67c6dae347ac.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/b8d3f012-0b59-43b4-adbc-811bcb59c9c4.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/cfa9f82a-5296-49cf-8353-11f8761b675c.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/db3c6c33-9ad0-4d61-9a64-a1aa9578550e.root" ), +) + + + +from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_hlt_relval', '') +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_Prompt_frozen_v4', '') +process.GlobalTag.toGet = cms.VPSet() +process.GlobalTag.toGet.append( + cms.PSet(record = cms.string("PPSTimingCalibrationRcd"), + tag = cms.string("PPSDiamondTimingCalibration_Run3_recovered_v1"), + label = cms.untracked.string('PPSTestCalibration'), + connect = cms.string("frontier://FrontierPrep/CMS_CONDITIONS") + ) +) + + +# raw-to-digi conversion +process.load("EventFilter.CTPPSRawToDigi.ctppsRawToDigi_cff") + +process.ctppsPixelDigis.inputLabel = cms.InputTag("hltPPSCalibrationRaw") +process.ctppsDiamondRawToDigi.rawDataTag = cms.InputTag("hltPPSCalibrationRaw") +process.totemRPRawToDigi.rawDataTag = cms.InputTag("hltPPSCalibrationRaw") +process.totemTimingRawToDigi.rawDataTag = cms.InputTag("hltPPSCalibrationRaw") + + +# local RP reconstruction chain with standard settings +process.load("RecoPPS.Configuration.recoCTPPS_cff") +process.ctppsDiamondRecHits.digiTag=cms.InputTag('ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond') +process.ctppsDiamondRecHits.timingCalibrationTag=cms.string("GlobalTag:PPSTestCalibration") + +#process.load('CondCore.CondDB.CondDB_cfi') +#process.CondDB.connect = 'sqlite_file:ppsDiamondTiming_calibration.sqlite' # SQLite input +#process.PoolDBESSource = cms.ESSource('PoolDBESSource', +# process.CondDB, +# DumpStats = cms.untracked.bool(True), +# toGet = cms.VPSet( +# cms.PSet( +# record = cms.string('PPSTimingCalibrationRcd'), +# tag = cms.string('DiamondTimingCalibration') +# ) +# ) +# ) + +#process.load('Geometry.VeryForwardGeometry.geometryRPFromDD_2021_cfi') +# CTPPS DQM modules +process.load("DQM.CTPPS.ctppsDQM_cff") +process.ctppsDiamondDQMSource.tagDigi=cms.InputTag('ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond') +process.ctppsDiamondDQMSource.tagFEDInfo=cms.InputTag('ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond') +process.ctppsDiamondDQMSource.tagStatus=cms.InputTag('ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond') +process.ctppsDiamondDQMSource.tagPixelLocalTracks=cms.InputTag('ctppsPixelLocalTracksAlCaRecoProducer') +#process.ctppsDiamondDQMSource.excludeMultipleHits = cms.bool(True) +process.ctppsDiamondDQMSource.plotOnline = cms.untracked.bool(True) +process.ctppsDiamondDQMSource.plotOffline = cms.untracked.bool(False) + +process.content = cms.EDAnalyzer("EventContentAnalyzer") + +from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer +process.tdcCalibShiftDQM = DQMEDAnalyzer('TdcCalibShiftDQM') +process.path = cms.Path( + #process.ctppsRawToDigi* + #process.recoCTPPS* + #process.ctppsDQMOnlineSource* + ##process.ctppsDiamondDQMSource* + #process.ctppsDQMOnlineHarvest + #process.tdcCalibShiftDQM + + #process.content* + process.ctppsDiamondRecHits * + process.ctppsDiamondLocalTracks * + #process.ctppsLocalTrackLiteProducer * + #process.ctppsProtons * + process.ctppsDiamondDQMSource* + process.ctppsDQMOnlineHarvest +) + +process.output = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string("file:test.root"), + outputCommands = cms.untracked.vstring( + 'drop *', + 'keep *_ctpps*_*_*', + ), +) + + +process.end_path = cms.EndPath( + #process.output + process.dqmEnv + + process.dqmSaver +) + +process.schedule = cms.Schedule( + process.path, + process.end_path +) + +#process.output = cms.OutputModule("PoolOutputModule", +# fileName = cms.untracked.string("AOD.root"), +# outputCommands = cms.untracked.vstring( +# 'drop *', +# 'keep *_ctpps*_*_*', +# ), +#) +#process.outpath = cms.EndPath(process.output) \ No newline at end of file diff --git a/Analyzer/DiamondTimingAnalyzer/README.md b/Analyzer/DiamondTimingAnalyzer/README.md new file mode 100644 index 0000000000000..ff1087f511e0e --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/README.md @@ -0,0 +1,46 @@ +## Project setup +Instruction on how to setup and run efficiency suite in CMSSW_12_4_0 environment: + +1. Preprare CMSSW_12_4_0 environment with: `cmsrel CMSSW_12_4_0` +2. Go to newly created directory: `cd CMSSW_12_4_0` +3. Setup cms environmental variables(repeat every time you log in): `cmsenv` +4. Merge with the main branch containing efficiency suite: `git cms-merge-checkout CTPPS:MO/timing/migration_to_CMSSW_12_4_6_clean_branch` #(TODO change it to the main ) +5. Compile the solution `scram b -j10` +6. Switch directory to the one containing the source code: `cd src/Analyzer/DiamondTimingAnalyzer` + +## Run rolling calibrations: + + +## More Details: +### Applying time shift +### Finding Test File + + +## Project Structure +### Config.json +Config.json describes the structure of detectors. +- Sector - left of right arm +- station - the pot in which the detector are located +- plane - the detector contains planes - +- channel - each plane is divided into channels. They are counted in U-shape, due to the phisical connection structure. +## Manual tests +1. Running worker + +```bash +cmsRun python/worker.py +``` + +2. Running harvester +```bash +cmsRun python/harvester.py rootFiles=file:run_output.root +``` + +Tip - logs to file - append: +``` + 2>&1 | tee Logs/worker_log_5.txt +``` + +3. Submit to CRAB: +```cmsemv``` +```voms-proxy-init -voms cms -rfc -valid 192:00``` +```crab submit submitTimingToCRAB.py ``` diff --git a/Analyzer/DiamondTimingAnalyzer/interface/DiamondDetectorClass.h b/Analyzer/DiamondTimingAnalyzer/interface/DiamondDetectorClass.h index 9e2f239596ecd..c45b0b251352d 100644 --- a/Analyzer/DiamondTimingAnalyzer/interface/DiamondDetectorClass.h +++ b/Analyzer/DiamondTimingAnalyzer/interface/DiamondDetectorClass.h @@ -51,12 +51,22 @@ class DiamondDetectorClass{ inline int GetMux(const PlaneKey& planeKey) {return Mux_map_[planeKey];} inline int GetMuxValidT(const PlaneKey& planeKey) {return Mux_validT_map_[planeKey];} inline int GetMuxInTrack(const PlaneKey& planeKey) {return Mux_inTrack_map_[planeKey];} + inline std::map GetMuxInTrackMap() {return Mux_inTrack_map_;} inline bool PadActive(const ChannelKey& key) { return (RecHit_map_.find(key) != RecHit_map_.end());} inline double GetTime(const ChannelKey& key) {return RecHit_map_[key].at(0).time();} + + inline std::vector getRecHitVector(const ChannelKey& key) + {return RecHit_map_[key];} + + inline std::map> getRecHitMap() + {return RecHit_map_;} + + inline bool isRecHitEmpty(const ChannelKey& key) + {return RecHit_map_[key].size() == 0;} inline double GetPadPrecision(const ChannelKey& key) {return SPC_map_[key].precision;} diff --git a/Analyzer/DiamondTimingAnalyzer/just_shift_print.sh b/Analyzer/DiamondTimingAnalyzer/just_shift_print.sh new file mode 100644 index 0000000000000..490db54649b14 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/just_shift_print.sh @@ -0,0 +1,29 @@ +#config +runNumber=357440 +maxEvents=90000 +constPREFIX=JUST_SHIFT +experimentName=_diamondDQM_chrys +try=try4 +resultsFolderName=${constPREFIX}_${runNumber}_maxEv${maxEvents}_${experimentName} +#local variables +# workerPrefix=${resultsFolderName}/worker_${constPREFIX}_${runNumber}_maxEv_${maxEvents} +sqlFileName=sqlite_file:/afs/cern.ch/user/m/mobrzut/public/timing_sqlcalib/ppsDiamondTiming_calibration${runNumber}.sqlite +# scritpt +mkdir $resultsFolderName +mkdir $resultsFolderName/$try +echo "######################################## ##########################################" +echo "shift 0:" +echo "ls *.root" # make sure that the directory doesn't contain any root files +shift="cmsRun temp/produceAOD_shift_fromRoot_justShift/reco_cfg_4_diamondDQM_test.py " +# shift="cmsRun python/reco_cfg_AOD_DQM.py " + +# shift+="outputFileName=${workerPrefix}_loop_0.root " +# shift+="calibInput=calib_357440_90k.json " +# shift+="sqlFileName=${sqlFileName} " +# shift+="maxEventsToProcess=${maxEvents}" +echo $shift + +echo "mv *.root ${resultsFolderName}/${try}" + + +echo "--------------------------------------------------------------------------------------------------" diff --git a/Analyzer/DiamondTimingAnalyzer/planes.json b/Analyzer/DiamondTimingAnalyzer/planes.json new file mode 100644 index 0000000000000..34609ed4847ef --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/planes.json @@ -0,0 +1,448 @@ +{ + "Sectors": [ + { + "sector": "0", + "Stations": [ + { + "station": "1", + "Planes": [ + { + "plane": "0", + "Channels": [ + { + "channel": "0", + "planes": "3" + }, + { + "channel": "1", + "planes": "4" + }, + { + "channel": "2", + "planes": "4" + }, + { + "channel": "3", + "planes": "4" + }, + { + "channel": "4", + "planes": "4" + }, + { + "channel": "5", + "planes": "4" + }, + { + "channel": "6", + "planes": "4" + }, + { + "channel": "7", + "planes": "4" + }, + { + "channel": "8", + "planes": "4" + }, + { + "channel": "9", + "planes": "4" + }, + { + "channel": "10", + "planes": "4" + }, + { + "channel": "11", + "planes": "4" + } + ] + }, + { + "plane": "1", + "Channels": [ + { + "channel": "0", + "planes": "3" + }, + { + "channel": "1", + "planes": "4" + }, + { + "channel": "2", + "planes": "4" + }, + { + "channel": "3", + "planes": "4" + }, + { + "channel": "4", + "planes": "4" + }, + { + "channel": "5", + "planes": "4" + }, + { + "channel": "6", + "planes": "4" + }, + { + "channel": "7", + "planes": "4" + }, + { + "channel": "8", + "planes": "4" + }, + { + "channel": "9", + "planes": "4" + }, + { + "channel": "10", + "planes": "4" + }, + { + "channel": "11", + "planes": "4" + } + ] + }, + { + "plane": "2", + "Channels": [ + { + "channel": "0", + "planes": "3" + }, + { + "channel": "1", + "planes": "4" + }, + { + "channel": "2", + "planes": "4" + }, + { + "channel": "3", + "planes": "4" + }, + { + "channel": "4", + "planes": "4" + }, + { + "channel": "5", + "planes": "4" + }, + { + "channel": "6", + "planes": "4" + }, + { + "channel": "7", + "planes": "4" + }, + { + "channel": "8", + "planes": "4" + }, + { + "channel": "9", + "planes": "4" + }, + { + "channel": "10", + "planes": "4" + }, + { + "channel": "11", + "planes": "4" + } + ] + }, + { + "plane": "3", + "Channels": [ + { + "channel": "0", + "planes": "3" + }, + { + "channel": "1", + "planes": "4" + }, + { + "channel": "2", + "planes": "4" + }, + { + "channel": "3", + "planes": "4" + }, + { + "channel": "4", + "planes": "4" + }, + { + "channel": "5", + "planes": "4" + }, + { + "channel": "6", + "planes": "4" + }, + { + "channel": "7", + "planes": "4" + }, + { + "channel": "8", + "planes": "4" + }, + { + "channel": "9", + "planes": "4" + }, + { + "channel": "10", + "planes": "4" + }, + { + "channel": "11", + "planes": "4" + } + ] + } + ] + } + ] + }, + { + "sector": "1", + "Stations": [ + { + "station": "1", + "Planes": [ + { + "plane": "0", + "Channels": [ + { + "channel": "0", + "planes": "3" + }, + { + "channel": "1", + "planes": "4" + }, + { + "channel": "2", + "planes": "4" + }, + { + "channel": "3", + "planes": "4" + }, + { + "channel": "4", + "planes": "4" + }, + { + "channel": "5", + "planes": "4" + }, + { + "channel": "6", + "planes": "4" + }, + { + "channel": "7", + "planes": "4" + }, + { + "channel": "8", + "planes": "4" + }, + { + "channel": "9", + "planes": "4" + }, + { + "channel": "10", + "planes": "4" + }, + { + "channel": "11", + "planes": "4" + } + ] + }, + { + "plane": "1", + "Channels": [ + { + "channel": "0", + "planes": "3" + }, + { + "channel": "1", + "planes": "4" + }, + { + "channel": "2", + "planes": "4" + }, + { + "channel": "3", + "planes": "4" + }, + { + "channel": "4", + "planes": "4" + }, + { + "channel": "5", + "planes": "4" + }, + { + "channel": "6", + "planes": "4" + }, + { + "channel": "7", + "planes": "4" + }, + { + "channel": "8", + "planes": "4" + }, + { + "channel": "9", + "planes": "4" + }, + { + "channel": "10", + "planes": "4" + }, + { + "channel": "11", + "planes": "4" + } + ] + }, + { + "plane": "2", + "Channels": [ + { + "channel": "0", + "planes": "3" + }, + { + "channel": "1", + "planes": "4" + }, + { + "channel": "2", + "planes": "4" + }, + { + "channel": "3", + "planes": "4" + }, + { + "channel": "4", + "planes": "4" + }, + { + "channel": "5", + "planes": "4" + }, + { + "channel": "6", + "planes": "4" + }, + { + "channel": "7", + "planes": "4" + }, + { + "channel": "8", + "planes": "4" + }, + { + "channel": "9", + "planes": "4" + }, + { + "channel": "10", + "planes": "4" + }, + { + "channel": "11", + "planes": "4" + } + ] + }, + { + "plane": "3", + "Channels": [ + { + "channel": "0", + "planes": "3" + }, + { + "channel": "1", + "planes": "4" + }, + { + "channel": "2", + "planes": "4" + }, + { + "channel": "3", + "planes": "4" + }, + { + "channel": "4", + "planes": "4" + }, + { + "channel": "5", + "planes": "4" + }, + { + "channel": "6", + "planes": "4" + }, + { + "channel": "7", + "planes": "4" + }, + { + "channel": "8", + "planes": "4" + }, + { + "channel": "9", + "planes": "4" + }, + { + "channel": "10", + "planes": "4" + }, + { + "channel": "11", + "planes": "4" + } + ] + } + ] + } + ] + } + ] +} diff --git a/Analyzer/DiamondTimingAnalyzer/plugins/DiamondTimingHarvester.cc b/Analyzer/DiamondTimingAnalyzer/plugins/DiamondTimingHarvester.cc index 27fcf92bfb491..03aae2ce84e85 100644 --- a/Analyzer/DiamondTimingAnalyzer/plugins/DiamondTimingHarvester.cc +++ b/Analyzer/DiamondTimingAnalyzer/plugins/DiamondTimingHarvester.cc @@ -94,7 +94,7 @@ class DiamondTimingHarvester : public DQMEDHarvester{ DiamondTimingHarvester::DiamondTimingHarvester(const edm::ParameterSet& iConfig) : geomEsToken_(esConsumes()), - calibEsToken_(esConsumes()), + // calibEsToken_(esConsumes(edm::ESInputTag("PoolDBESSource:PPSTestCalibration"))), output_file(iConfig.getParameter("calib_json_output")), calib_files(iConfig.getParameter>("calibFiles")), loop_index(iConfig.getParameter("loopIndex")), @@ -105,9 +105,13 @@ DiamondTimingHarvester::DiamondTimingHarvester(const edm::ParameterSet& iConfig) edm::LogError("DiamondTimingHarvester")<<"Not enough calibration files"; } + calibEsToken_ = esConsumes( + edm::ESInputTag(iConfig.getParameter("timingCalibrationTag"))); + calibs.push_back(DiamondTimingCalibration()); //empty to be replaced by input calibration to first iteration + for(auto& file : calib_files){ - edm::LogInfo("DiamondTimingHarvester")<<"Opening file "< calibEsTokenHandle_ = iSetup.getHandle(calibEsToken_); + calibs[0] = DiamondTimingCalibration(*calibEsTokenHandle_); + + edm::LogWarning("Calibs") << "calibs[0]" << calibs[0]; const auto& calib = calibs[loop_index]; + edm::LogWarning("Calibs") << "calibs["<< loop_index << "]" << calibs[loop_index]; std::string ch_name, ch_path; for (auto it = geom.beginSensor(); it != geom.endSensor(); ++it) { @@ -163,7 +171,8 @@ void DiamondTimingHarvester::dqmEndRun(DQMStore::IBooker &iBooker, //RESOLUTION auto* l2_res = iGetter.get(ch_path + "/" + "l2_res_" + ch_name); auto* expected_trk_time = iGetter.get(ch_path + "/" + "Expected track time resolution distribution " + ch_name); - if(l2_res->getEntries() > 100){ + edm::LogWarning("l2_res")<<"l2 res number: "<< l2_res->getEntries() << " for path" <getEntries() > 100){ l2_res->getTH1F()->Fit("gaus","+Q","",-10,10); if(l2_res->getTH1F()->GetFunction("gaus") != NULL){ @@ -175,6 +184,7 @@ void DiamondTimingHarvester::dqmEndRun(DQMStore::IBooker &iBooker, double Exp_sigma = expected_trk_time->getTH1F()->GetMean(); if (ResL2_sigma > Exp_sigma) Resolution_L2_map_[histo_key] = pow(pow(ResL2_sigma,2)-pow(Exp_sigma,2), 0.5); + // Resolution_L2_map_[histo_key] = 1.111; else Resolution_L2_map_[histo_key] = 0.050; }else{ diff --git a/Analyzer/DiamondTimingAnalyzer/plugins/DiamondTimingWorker.cc b/Analyzer/DiamondTimingAnalyzer/plugins/DiamondTimingWorker.cc index 7b7595cd6cc05..33621399316e9 100644 --- a/Analyzer/DiamondTimingAnalyzer/plugins/DiamondTimingWorker.cc +++ b/Analyzer/DiamondTimingAnalyzer/plugins/DiamondTimingWorker.cc @@ -117,9 +117,11 @@ DiamondTimingWorker::DiamondTimingWorker(const edm::ParameterSet& iConfig) tokenPixelLocalTrack_( consumes>(iConfig.getParameter("tagPixelLocalTrack"))), geomEsToken_(esConsumes()), - calibEsToken_(esConsumes()), + // calibEsToken_(esConsumes()), validOOT(iConfig.getParameter("tagValidOOT")) { - + //TODO check if this tag is provde or no + calibEsToken_ = esConsumes( + edm::ESInputTag(iConfig.getParameter("timingCalibrationTag"))); Ntracks_cuts_map_[std::make_pair(SECTOR::_45_ID, STATION::_210_M_ID)] = std::make_pair(iConfig.getParameter>("Ntracks_Lcuts")[0], iConfig.getParameter>("Ntracks_Ucuts")[0]); @@ -148,9 +150,9 @@ DiamondTimingWorker::DiamondTimingWorker(const edm::ParameterSet& iConfig) void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { using namespace edm; - + // edm::LogWarning("MyInfoLog") << "Entering analyze method"; //retrieve data - edm::Handle> recHits; + edm::Handle> recHits; // TODO edm::Handle> localTracks; edm::Handle> pixelLocalTracks; edm::ESHandle calib; @@ -159,6 +161,7 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu iEvent.getByToken(tokenLocalTrack_, localTracks); iEvent.getByToken(tokenPixelLocalTrack_, pixelLocalTracks); calib = iSetup.getHandle(calibEsToken_); + // edm::LogWarning("MyInfoLog") << "analyze method read tokens complete"; DiamondDetectorClass DiamondDet(validOOT, *geom, *recHits, *localTracks, DiamondTimingCalibration(*calib)); @@ -174,7 +177,7 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu for (const auto& RP_trks : *pixelLocalTracks) { //array of tracks const CTPPSDetId detId(RP_trks.detId()); - //std::cout << "Tracks in arm " << detId.arm() << ", station " << detId.station() << ", rp " << detId.rp() << std::endl; + // edm::LogWarning("TrackInArm") << "Tracks in arm " << detId.arm() << ", station " << detId.station() << ", rp " << detId.rp(); for (const auto& trk : RP_trks) { if (!trk.isValid()) @@ -182,6 +185,7 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu Pixel_Mux_map_[std::make_pair(detId.arm(), detId.station())]++; } } + // edm::LogWarning("MyInfoLog") << "analyze method: Sector_TBA filled complete"; for (const auto& Ntracks_cuts_iter_ : Ntracks_cuts_map_) { if ((Ntracks_cuts_iter_.second.first < 0) || (Ntracks_cuts_iter_.second.second < 0)) @@ -190,6 +194,8 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu (Pixel_Mux_map_[Ntracks_cuts_iter_.first] > Ntracks_cuts_iter_.second.second)) //condition violated Sector_TBA[Ntracks_cuts_iter_.first.first] = false; } + // edm::LogWarning("MyInfoLog") << "analyze method: Pixel MAP complete"; + if (!(Sector_TBA[0] || Sector_TBA[1])) return; @@ -199,6 +205,8 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu // control over PCL calibration quality // ///////////////////////////////////////////////////////////////// + // edm::LogWarning("MyInfoLog") << "Analyze method: begin of control over PCL calibration quality"; + for (const auto& _recHits : *recHits) { //rechits = array of hits in one channel const CTPPSDiamondDetId detid(_recHits.detId()); const ChannelKey key(detid); @@ -228,15 +236,21 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu // RESOLUTION STUDIES // ///////////////////////////////////////////////////////////////// + // edm::LogWarning("MyInfoLog") << "Analyze method: begin of resolution studies"; //which planes are active std::array active_plane{ {false, false, false, false} }; + // for (auto& item: DiamondDet.GetMuxInTrackMap()){ + // edm::LogWarning("MuxInTrackMap") << "Mux In Track Map item1:" << item.first << " item2: " << item.second; + // } for (const auto& LocalTrack_mapIter : DiamondDet.GetDiamondTrack_map()) { // loop on predigested tracks - int sector = LocalTrack_mapIter.first.z0() > 0.0 ? SECTOR::_45_ID : SECTOR::_56_ID; + // edm::LogWarning("DiamondTrackMapAKALocal") << "DiamondTrackMapSector: z (sector): " << LocalTrack_mapIter.first.z0(); - if (!(Sector_TBA[sector])) - continue; + int sector = LocalTrack_mapIter.first.z0() > 0.0 ? SECTOR::_45_ID : SECTOR::_56_ID; //TODO + + // if (!(Sector_TBA[sector])) + // continue; if (LocalTrack_mapIter.second.size() == 0) continue; @@ -244,16 +258,26 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu //station id int station = LocalTrack_mapIter.second.at(0).first.planeKey.station; auto stationKey = std::pair{sector, station}; - + // edm::LogWarning("SectorStationNumber") << "Sector Station: sector: " << sector << " station: " << station; //which planes are active active_plane[0] = DiamondDet.GetMuxInTrack(PlaneKey(sector, station, 0)) == 1; active_plane[1] = DiamondDet.GetMuxInTrack(PlaneKey(sector, station, 1)) == 1; active_plane[2] = DiamondDet.GetMuxInTrack(PlaneKey(sector, station, 2)) == 1; active_plane[3] = DiamondDet.GetMuxInTrack(PlaneKey(sector, station, 3)) == 1; + // edm::LogWarning("GetMuxInTrackVal") <<"sector:" << sector << "station: " << station << "plane: " << 0 << "Get Mux In Track value:" << DiamondDet.GetMuxInTrack(PlaneKey(sector, station, 0)); + // edm::LogWarning("GetMuxInTrackVal") <<"sector:" << sector << "station: " << station << "plane: " << 1 << "Get Mux In Track value:" << DiamondDet.GetMuxInTrack(PlaneKey(sector, station, 1)); + // edm::LogWarning("GetMuxInTrackVal") <<"sector:" << sector << "station: " << station << "plane: " << 2 << "Get Mux In Track value:" << DiamondDet.GetMuxInTrack(PlaneKey(sector, station, 2)); + // edm::LogWarning("GetMuxInTrackVal") <<"sector:" << sector << "station: " << station << "plane: " << 3 << "Get Mux In Track value:" << DiamondDet.GetMuxInTrack(PlaneKey(sector, station, 3)); + //number of active planes int active_num = std::count_if(active_plane.begin(), active_plane.end(), [](bool it) -> bool{return it;}); + // edm::LogWarning("ActivePlaneNumber") << "Active Plane Number: " << active_num; + + //EDO suggestion + if(active_num < 4) continue; //we don't check active planes here, because each channel might require different number of them + // edm::LogWarning("GetTrackMuxInSector") << "GetTrackMuxInSector: " << DiamondDet.GetTrackMuxInSector(sector); bool mark_tag = DiamondDet.GetTrackMuxInSector(sector) == 1; std::vector hit_selected(PLANES_X_DETECTOR); @@ -266,16 +290,21 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu for (hit_iter = LocalTrack_mapIter.second.begin(); hit_iter < LocalTrack_mapIter.second.end(); hit_iter++) { auto& key = (*hit_iter).first; - if(!active_plane[key.planeKey.plane]) + if(!active_plane[key.planeKey.plane]) { + // edm::LogWarning("HitSelectedFillingNotActive") << "Key "<< key.planeKey.plane; continue; + } double hit_time_SPC = DiamondDet.GetTime(key); - double hit_prec_SPC = DiamondDet.GetPadPrecision(key); + // double hit_prec_SPC = DiamondDet.GetPadPrecision(key); //TODO: Unused variable double hit_weig_SPC = DiamondDet.GetPadWeight(key); - if (mark_tag) + if (mark_tag) { + // edm::LogWarning("HitSelectedIsFilling") << "mark_tag true. " << "Key "<< key << "key.planeKey.plane "<< key.planeKey.plane; hit_selected[key.planeKey.plane] = key; // save for resolution reco - + } else { + // edm::LogWarning("HitSelectedIsNotFilling") << "mark_tag false. " << "Key "<< key; + } Track_time_SPC = (Track_time_SPC * pow(Track_precision_SPC, -2) + hit_time_SPC * hit_weig_SPC) / (pow(Track_precision_SPC, -2) + hit_weig_SPC); Track_precision_SPC = pow((pow(Track_precision_SPC, -2) + hit_weig_SPC), -0.5); @@ -288,12 +317,43 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu histos.trk_time_SPC_vs_LS[stationKey]->Fill(iEvent.luminosityBlock(), Track_time_SPC); if (mark_tag) { + // edm::LogWarning("RecHitMap") << "Analyze method: RecHitMap Size: " << DiamondDet.getRecHitMap().size(); + + // edm::LogWarning("HitSelectedVector") << "Analyze method: hit_selected vector: "; + // for (auto item_hs: hit_selected) { + // // edm::LogWarning("HitSelectedVector") << "hit_selected vector item: " << item_hs; + // } + // MarkLoop for (int pl_mark = 0; pl_mark < PLANES_X_DETECTOR; pl_mark++) { - if(!active_plane[pl_mark]) continue; + if(!active_plane[pl_mark]) { + // if(pl_mark + 1 == PLANES_X_DETECTOR) edm::LogWarning("MarkLoopNoPlaneActive") << "No Plane active"; + continue; + } + // edm::LogWarning("MarkLoopBegin") << "****************** BEGIN OF THE LOOP ********************* "; + // edm::LogWarning("MarkLoopPlMarkInfo") << "pl_mark: " << pl_mark; + double Marked_track_time = 12.5; double Marked_track_precision = 25.0; - double Marked_hit_time = DiamondDet.GetTime(hit_selected[pl_mark]);; + + + // // edm::LogWarning("MyLogInfoGetTimeDebug") << "Analyze method: get item hit_selected for pl_mark: " << pl_mark << " value " << hit_selected[pl_mark]; + + // edm::LogWarning("MyLogInfoGetTimeDebug") << "Analyze method: recHit vector size " << DiamondDet.getRecHitVector(hit_selected[pl_mark]).size(); + // for(const CTPPSDiamondRecHit& item: DiamondDet.getRecHitVector(hit_selected[pl_mark])) { + // // edm::LogWarning("MyLogInfoGetTimeDebug") << "Analyze method: recHit vector element: " << item.tPrecision(); + // } + + if(DiamondDet.isRecHitEmpty(hit_selected[pl_mark])) { + // edm::LogWarning("MarkLoopContinueGtErr") << "REC VECTOR IS EMPTY FOR PL_MARK: " << pl_mark; + // edm::LogWarning("Info") << "-------------- - --------------------------------------------"; + continue; + } + + + double Marked_hit_time = DiamondDet.GetTime(hit_selected[pl_mark]); //TODO: error is thrown here + // edm::LogWarning("MarkLoopGetTimeWorked") << "Get time worked for pl mark: " << pl_mark; + int Marked_hit_channel = hit_selected[pl_mark].channel; ChannelKey key(sector, station, pl_mark, Marked_hit_channel); @@ -304,10 +364,14 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu for (int pl_loop = 0; pl_loop < PLANES_X_DETECTOR; pl_loop++) { if(!active_plane[pl_loop]) continue; if (pl_loop == pl_mark) continue; - + if(DiamondDet.isRecHitEmpty(hit_selected[pl_loop])) { + // // edm::LogWarning("GetTimeWorked") << hit_selected[pl_loop]; + // edm::LogWarning("MarkLoopPlLoopContinueGtErr") << "Get Time is Empty "; + continue; + } double Others_hit_time = DiamondDet.GetTime(hit_selected[pl_loop]); - double Others_hit_prec = DiamondDet.GetPadPrecision(hit_selected[pl_loop]); double Others_hit_weig = DiamondDet.GetPadWeight(hit_selected[pl_loop]); + // edm::LogWarning("MarkLoopPlLoopComplete") << "After the get time protection"; Marked_track_time = (Marked_track_time * pow(Marked_track_precision, -2) + Others_hit_time * Others_hit_weig) / @@ -321,14 +385,18 @@ void DiamondTimingWorker::analyze(const edm::Event& iEvent, const edm::EventSetu histos.l2_res[key]->Fill(Marked_hit_difference); histos.trk_time[key]->Fill(Marked_track_time); histos.expected_trk_time_res[key]->Fill(Marked_track_precision); + // edm::LogWarning("MarkLoopComplete") << "Mark loop complete key: " << key.to_string(); } } } + // edm::LogWarning("AnalyzeComplete") << "Analyze method complete"; + } void DiamondTimingWorker::bookHistograms(DQMStore::IBooker& iBooker, edm::Run const& run, edm::EventSetup const& iSetup) { + // edm::LogWarning("MyInfoLog") << "Entering bookHistograms method"; std::string ch_path; geom = iSetup.getHandle(geomEsToken_); for (auto it = (*geom).beginSensor(); it != (*geom).endSensor(); ++it) { @@ -338,8 +406,11 @@ void DiamondTimingWorker::bookHistograms(DQMStore::IBooker& iBooker, const CTPPSDiamondDetId detid(it->first); ChannelKey key(detid); + // Booking summary histograms for station if (histos.trk_time_SPC.count({detid.arm(), detid.station()}) == 0) { std::string station_path; + // edm::LogWarning("bookHistograms") << "Before stationName method"; + detid.stationName(station_path, CTPPSDiamondDetId::nPath); iBooker.setCurrentFolder(station_path); @@ -365,7 +436,8 @@ void DiamondTimingWorker::bookHistograms(DQMStore::IBooker& iBooker, iBooker.setCurrentFolder(ch_path); std::string name; - + + // Booking histograms for channels name = "Time distribution " + ch_name; histos.t[key] = iBooker.book1D(name.c_str(), (name + ";t (ns);Entries").c_str(), 1200, -60., 60.); diff --git a/Analyzer/DiamondTimingAnalyzer/python/harvester.py b/Analyzer/DiamondTimingAnalyzer/python/harvester.py index dc8a8eb4c8984..e13eb6e8a8040 100644 --- a/Analyzer/DiamondTimingAnalyzer/python/harvester.py +++ b/Analyzer/DiamondTimingAnalyzer/python/harvester.py @@ -1,6 +1,8 @@ import FWCore.ParameterSet.Config as cms from FWCore.ParameterSet.VarParsing import VarParsing from RecoPPS.Local.ctppsDiamondLocalReconstruction_cff import * +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * + process = cms.Process("TIMINGSTUDY") options = VarParsing ('analysis') @@ -10,14 +12,22 @@ # minimum of logs process.load("FWCore.MessageService.MessageLogger_cfi") +# process.MessageLogger.cerr.threshold = "INFO" +# process.MessageLogger.cerr.INFO.limit = -1 process.MessageLogger.cerr.FwkReport.reportEvery = 1000 options.register ('rootFiles', [], - VarParsing.multiplicity.list, + VarParsing.multiplicity.list, #TODO: it was designed to be a list revert change before merging VarParsing.varType.string, "root files produced by DQMWorker") +options.register ('outputDirectoryRoot', + 'OutputHarvester', + VarParsing.multiplicity.singleton, #TODO: it was designed to be a list revert change before merging + VarParsing.varType.string, + "root output dircetory") + # options.register ('calibInput', # '', # VarParsing.multiplicity.singleton, @@ -36,12 +46,6 @@ VarParsing.varType.string, "Input file") -options.register ('geometryFile', - 'Geometry.VeryForwardGeometry.geometryRPFromDD_2018_cfi', - VarParsing.multiplicity.singleton, - VarParsing.varType.string, - "Geometry input file") - options.register ('calibFiles', [], VarParsing.multiplicity.list, @@ -65,6 +69,21 @@ VarParsing.multiplicity.singleton, VarParsing.varType.float, "max rms of t distribution") + +options.register('sqlFileName', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('useDB', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'use data base for calibraiton' +) + options.parseArguments() @@ -82,41 +101,112 @@ from DQMServices.Core.DQMEDHarvester import DQMEDHarvester from Configuration.AlCa.GlobalTag import GlobalTag -process.GlobalTag = GlobalTag(process.GlobalTag, '106X_dataRun2_v26', '') - -if options.calibInput == '': - process.GlobalTag.toGet = cms.VPSet( - cms.PSet(record = cms.string('PPSTimingCalibrationRcd'), - tag = cms.string('PPSDiamondTimingCalibration_v1'), - connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_v9', '') + +### SET TIME SHIFT SOURCE BEGIN +if options.useDB=='True': + use_db=True +elif options.useDB=='False': + use_db=False +elif options.useDB!='': + assert 'UseDB paramter is not valid. It should be True or False (case sensitive)' +else: + use_db=False + + +# if((options.sqlFileName != '') ^ (options.calibInput != '') ^ (options.useDB !='')): + # assert 'Please specify exactly one source of time shift paramiters. One from set {calib.json, SQLLite File or globalDB}' + +use_sqlite_file = options.sqlFileName != '' +if (use_sqlite_file): + print('Using SQL file') + process.load('CondCore.CondDB.CondDB_cfi') + process.CondDB.connect = options.sqlFileName # SQLite input TODO: migrate to using tag + process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), + ) ) +) +elif options.calibInput != '': + print('Using CalibInput file ') + process.ppsTimingCalibrationESSource = cms.ESSource('PPSTimingCalibrationESSource', + calibrationFile = cms.string(options.calibInput), + subDetector = cms.uint32(2), + appendToDataLabel = cms.string('') + ) +else: #default use db + print('Using db') + process.GlobalTag.toGet = cms.VPSet() + process.GlobalTag.toGet.append( + cms.PSet(record = cms.string("PPSTimingCalibrationRcd"), + tag = cms.string("PPSDiamondTimingCalibration_Run3_recovered_v1"), + label = cms.untracked.string('PPSTestCalibration'), + connect = cms.string("frontier://FrontierPrep/CMS_CONDITIONS") + ) ) -else: - process.ppsTimingCalibrationESSource = cms.ESSource('PPSTimingCalibrationESSource', - calibrationFile = cms.string(options.calibInput), - subDetector = cms.uint32(2), - appendToDataLabel = cms.string('') - ) + #TODO: uncomment below when delete sqlite file dependency + # process.GlobalTag.toGet = cms.VPSet( + # cms.PSet(record = cms.string('PPSTimingCalibrationRcd'), + # tag = cms.string('PPSDiamondTimingCalibration_Run3_v1_hlt'), # working tag: PPSDiamondTimingCalibration_Run3_v1_hlt + # #TODO: old tag PPSDiamondTimingCalibration_v1 - to delete + # connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") + # ) + # ) +### SET TIME SHIFT SOURCE END # rechits production process.load("DQM.Integration.config.environment_cfi") process.load("DQMServices.Components.DQMEnvironment_cfi") -process.load(options.geometryFile) - -process.diamondTimingHarvester = DQMEDHarvester("DiamondTimingHarvester", +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file + +# PROCESS HARVESTER: +if(options.calibInput != ''): + process.diamondTimingHarvester = DQMEDHarvester("DiamondTimingHarvester", + # timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + # timingCalibrationTag=cms.string("PPSTimingCalibrationESSource:PPSTiming"), + # timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + timingCalibrationTag=cms.string(":"), + calib_json_output = cms.string(options.calibOutput), + calibFiles = cms.vstring(options.calibFiles), + loopIndex = cms.int32(options.loopIndex), + meanMax = cms.double(options.meanMax), + rmsMax = cms.double(options.rmsMax) + ) +elif (use_sqlite_file): + process.diamondTimingHarvester = DQMEDHarvester("DiamondTimingHarvester", + timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), calib_json_output = cms.string(options.calibOutput), - calibInput = cms.string(options.calibInput), calibFiles = cms.vstring(options.calibFiles), loopIndex = cms.int32(options.loopIndex), meanMax = cms.double(options.meanMax), rmsMax = cms.double(options.rmsMax) ) +else: # defualt use db + process.diamondTimingHarvester = DQMEDHarvester("DiamondTimingHarvester", + timingCalibrationTag=cms.string("GlobalTag:PPSTestCalibration"), + calib_json_output = cms.string(options.calibOutput), + calibFiles = cms.vstring(options.calibFiles), + loopIndex = cms.int32(options.loopIndex), + meanMax = cms.double(options.meanMax), + rmsMax = cms.double(options.rmsMax) + ) +# else: +# assert "need to provide timing calibration tag from json, slq file or db" + +# process.diamondTimingHarvester.timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration") + #CONFIGURE DQM Saver process.dqmEnv.subSystemFolder = "CalibPPS" process.dqmSaver.convention = 'Offline' -process.dqmSaver.workflow = "/Analyzer/DiamondTimingAnalyzer/CMSSW_11_1_8" -#process.dqmSaver.dirName = './OutputFiles/' +process.dqmSaver.workflow = "/AnalyzerWithShift9/DiamondTimingAnalyzer/CMSSW_12_4_6" +process.dqmSaver.dirName = './OutputFiles/' # TODO: it was commented out - revert the change before merge process.path = cms.Path( process.diamondTimingHarvester diff --git a/Analyzer/DiamondTimingAnalyzer/python/reco_cfg_2.py b/Analyzer/DiamondTimingAnalyzer/python/reco_cfg_2.py new file mode 100644 index 0000000000000..8c54592db8386 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/python/reco_cfg_2.py @@ -0,0 +1,155 @@ +#start with the https://github.com/cms-sw/cmssw/blob/master/RecoPPS/Local/test/diamonds_reco_cfg.py +# 1. start with AOD file +# 2. apply SQL lite +# 3. new AOD with shift?? -> check produce DQM files + + +import FWCore.ParameterSet.Config as cms +from FWCore.ParameterSet.VarParsing import VarParsing + +process = cms.Process('PPSTestCalibration') + +options = VarParsing ('analysis') +options.register('sqlFileName', + 'sqlite_file:/afs/cern.ch/user/m/mobrzut/public/timing_sqlcalib/ppsDiamondTiming_calibration357440.sqlite', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('maxEventsToProcess', + 10000, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + 'maxEvents to process' +) + + + +options.parseArguments() + + + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + + +#load GT: +from Configuration.AlCa.GlobalTag import GlobalTag +# 2022 prompt: to be updated +process.GlobalTag = GlobalTag(process.GlobalTag, "124X_dataRun3_v9") + +#load condDB +process.load('CondCore.CondDB.CondDB_cfi') +process.CondDB.connect = options.sqlFileName +process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), # todo added by Chrys + + ) + ) +) + +process.source = cms.Source ("PoolSource", + fileNames = cms.untracked.vstring( +# RUN 440 - "357440": [[1,354]], +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/53746080-d21b-4fdf-9d19-67c6dae347ac.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/b8d3f012-0b59-43b4-adbc-811bcb59c9c4.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/cfa9f82a-5296-49cf-8353-11f8761b675c.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/db3c6c33-9ad0-4d61-9a64-a1aa9578550e.root" +), +) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(options.maxEventsToProcess) +) + +process.MessageLogger.cerr.FwkReport.reportEvery = cms.untracked.int32( 1000 ) + + + +# local RP reconstruction chain with standard settings +process.load("RecoPPS.Configuration.recoCTPPS_cff") + +# rechits production +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * # TODO it looks like it can be deleted +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file + +process.load('RecoPPS.Local.ctppsDiamondRecHits_cfi') + +# local tracks fitter +process.load('RecoPPS.Local.ctppsDiamondLocalTracks_cfi') + + +process.ctppsDiamondLocalTracks.recHitsTag = cms.InputTag("ctppsDiamondRecHits","","Shift") +process.ctppsLocalTrackLiteProducer.tagDiamondTrack = cms.InputTag("ctppsDiamondLocalTracks","","Shift") +process.ctppsProtons.tagLocalTrackLite = cms.InputTag("ctppsLocalTrackLiteProducer","","Shift") +process.ctppsLocalTrackLiteProducer.includeDiamonds = cms.bool(True) +process.ctppsLocalTrackLiteProducer.tagPixelTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer") +process.ctppsLocalTrackLiteProducer.includePixels = cms.bool(True) +process.ctppsDiamondRecHits.timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration") +process.ctppsDiamondRecHits.digiTag= cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond") + + +# process.output = cms.OutputModule("PoolOutputModule", +# fileName = cms.untracked.string("file:AOD.root"), +# outputCommands = cms.untracked.vstring( +# 'drop *', +# 'keep *_ctpps*_*_*', +# ), +# ) + +# DQM DQM DQM DQM +process.load("DQM.Integration.config.environment_cfi") +process.dqmEnv.subSystemFolder = "Analyzer" +process.dqmEnv.eventInfoFolder = "EventInfo" +process.dqmSaver.path = "" +process.dqmSaver.tag = "CTPPS" +# process.dqmEnv.subSystemFolder = "Analyzer" +# process.dqmSaver.workflow = "/Analyzer/DiamondTimingAnalyzer/worker" +process.load("DQMServices.Components.DQMEnvironment_cfi") +# process.dqmEnv.subSystemFolder = "CalibPPS" +process.dqmSaver.workflow = "/Analyzer/DiamondTimingAnalyzer/PPSTestCalibration" + + +# process.load("DQM.Integration.config.environment_cfi") +# process.dqmEnv.eventInfoFolder = "EventInfo" +# process.dqmSaver.path = "" +# process.dqmSaver.tag = "CTPPS" +# # process.load("DQMServices.Core.DQMStore_cfi") +# process.load("DQMServices.Components.DQMEnvironment_cfi") +# process.dqmEnv.subSystemFolder = "CalibPPS" +# process.dqmSaver.convention = 'Offline' +# process.dqmSaver.workflow = "/CalibPPS/TimingCalibration/CMSSW_12_0_0_pre2" +# # process.dqmSaver.workflow ="" + +# # process.dqmSaver.saveByRun = -1 +# process.dqmSaver.saveAtJobEnd = True + + +process.dqmOutput = cms.OutputModule("DQMRootOutputModule", + fileName = cms.untracked.string('AOD_DQM.root') +) + +process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.end_path = cms.EndPath( process.dqmEnv + process.dqmSaver ) + +# execution configuration +process.p = cms.Path( + # process.ctppsDiamondRecHits * + # process.ctppsDiamondLocalTracks + process.ctppsDiamondLocalReconstruction + +) + +# process.outpath = cms.EndPath(process.output) + +process.schedule = cms.Schedule(process.p, process.end_path) diff --git a/Analyzer/DiamondTimingAnalyzer/python/reco_cfg_AOD_DQM.py b/Analyzer/DiamondTimingAnalyzer/python/reco_cfg_AOD_DQM.py new file mode 100644 index 0000000000000..6fb71ab1d89bf --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/python/reco_cfg_AOD_DQM.py @@ -0,0 +1,140 @@ +#start with the https://github.com/cms-sw/cmssw/blob/master/RecoPPS/Local/test/diamonds_reco_cfg.py +# 1. start with AOD file +# 2. apply SQL lite +# 3. new AOD with shift?? -> check produce DQM files + + +from re import T +import FWCore.ParameterSet.Config as cms +from FWCore.ParameterSet.VarParsing import VarParsing + +process = cms.Process('Shift') + +options = VarParsing ('analysis') +options.register('sqlFileName', + 'sqlite_file:/afs/cern.ch/user/m/mobrzut/public/timing_sqlcalib/ppsDiamondTiming_calibration357440.sqlite', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('maxEventsToProcess', + 10000, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + 'maxEvents to process' +) + + + +options.parseArguments() + + + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + + +#load GT: +from Configuration.AlCa.GlobalTag import GlobalTag +# 2022 prompt: to be updated +process.GlobalTag = GlobalTag(process.GlobalTag, "124X_dataRun3_v9") + +#load condDB +process.load('CondCore.CondDB.CondDB_cfi') +process.CondDB.connect = options.sqlFileName +process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), # todo added by Chrys + + ) + ) +) + +process.source = cms.Source ("PoolSource", + fileNames = cms.untracked.vstring( +# RUN 440 - "357440": [[1,354]], +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/53746080-d21b-4fdf-9d19-67c6dae347ac.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/b8d3f012-0b59-43b4-adbc-811bcb59c9c4.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/cfa9f82a-5296-49cf-8353-11f8761b675c.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/db3c6c33-9ad0-4d61-9a64-a1aa9578550e.root" +) +) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(options.maxEventsToProcess) +) + +process.MessageLogger.cerr.FwkReport.reportEvery = cms.untracked.int32( 1000 ) + + + +# local RP reconstruction chain with standard settings +process.load("RecoPPS.Configuration.recoCTPPS_cff") + +# rechits production +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * # TODO it looks like it can be deleted +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file + +process.load('RecoPPS.Local.ctppsDiamondRecHits_cfi') + +# local tracks fitter +process.load('RecoPPS.Local.ctppsDiamondLocalTracks_cfi') + +# set tags: +process.ctppsDiamondRecHits.digiTag= cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond") + + +# DQM BEGIN +process.load("DQM.Integration.config.environment_cfi") +process.dqmEnv.subSystemFolder = "Analyzer" +process.dqmEnv.eventInfoFolder = "EventInfo" +process.dqmSaver.path = "" +process.dqmSaver.tag = "CTPPS" + + +# CTPPS DQM modules +process.load("DQM.CTPPS.ctppsDQM_cff") +process.ctppsDiamondDQMSource.excludeMultipleHits = cms.bool(True) +# process.ctppsDiamondDQMSource.plotOnline = cms.untracked.bool(True) +process.ctppsDiamondDQMSource.plotOffline = cms.untracked.bool(True) + +# DQM END + + +# def set_process_output(): # simple +# process.output = cms.OutputModule("PoolOutputModule", +# fileName = cms.untracked.string("file:AOD.root"), +# outputCommands = cms.untracked.vstring( +# 'drop *', +# 'keep *_ctpps*_*_*', +# ), +# ) + +# set_process_output() + + +# execution configuration +process.path = cms.Path( + process.ctppsDiamondLocalReconstruction +) + +# process.outpath = cms.EndPath(process.output) + +process.end_path = cms.EndPath( + process.dqmEnv + + process.dqmSaver +) + +process.schedule = cms.Schedule( + process.path, + process.end_path +) \ No newline at end of file diff --git a/Analyzer/DiamondTimingAnalyzer/python/worker.py b/Analyzer/DiamondTimingAnalyzer/python/worker.py index 2ba243bac4ca9..c4313e7ff3d15 100644 --- a/Analyzer/DiamondTimingAnalyzer/python/worker.py +++ b/Analyzer/DiamondTimingAnalyzer/python/worker.py @@ -1,17 +1,25 @@ import FWCore.ParameterSet.Config as cms +import copy from FWCore.ParameterSet.VarParsing import VarParsing -from RecoPPS.Local.ctppsDiamondLocalReconstruction_cff import * +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * # TODO it looks like it can be deleted -process = cms.Process("TIMINGSTUDY") + +process = cms.Process('TIMINGSTUDY') # or TIMINGSTUDY?? options = VarParsing ('analysis') -process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) -process.verbosity = cms.untracked.PSet( input = cms.untracked.int32(-1) ) +process.verbosity = cms.untracked.PSet( input = cms.untracked.int32(-1) ) # TODO: confirm if this is needed. -# minimum of logs -process.load("FWCore.MessageService.MessageLogger_cfi") +process.load('FWCore.MessageService.MessageLogger_cfi') +process.MessageLogger.cerr.threshold = '' process.MessageLogger.cerr.FwkReport.reportEvery = 1000 +options.register ('rootInput', + 'file:/eos/project/c/ctpps/subsystems/Automation/hptdc-timing-offline/AOD.root', # test file run 357440 + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "root input file name") + + options.register ('outputFileName', 'run_output.root', VarParsing.multiplicity.singleton, @@ -30,267 +38,169 @@ VarParsing.varType.string, "planes config file") -options.register ('geometryFile', - 'Geometry.VeryForwardGeometry.geometryRPFromDD_2018_cfi', - VarParsing.multiplicity.singleton, - VarParsing.varType.string, - "Geometry input file") - options.register ('validOOT', -1, VarParsing.multiplicity.singleton, VarParsing.varType.int, - "valid OOT slice") - + "valid OOT slice") +options.register('useDB', # default source of time shift tag + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'useDB' +) + +options.register('sqlFileName', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('maxEventsToProcess', + -1, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + 'maxEvents to process' +) + options.parseArguments() - + +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(options.maxEventsToProcess)) + + # import of standard configurations process.load('Configuration.StandardSequences.Services_cff') -process.load('FWCore.MessageService.MessageLogger_cfi') process.load('Configuration.EventContent.EventContent_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file +process.source = cms.Source ("PoolSource", + fileNames = cms.untracked.vstring(options.rootInput) + ) -process.source = cms.Source("PoolSource", - fileNames = cms.untracked.vstring( - *( - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/1ECC0154-9688-6248-ADF5-7B9180CB7CCF.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/21FEFBBE-0E7B-2A4D-A207-917AB49701A2.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/6EE9461B-FC71-7144-94F8-A3AD82581D20.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/C97D30B3-21DB-6447-9596-3220587A02B5.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/D428E596-E313-2848-B326-5C4374865723.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/DBD2A4DF-B43F-FA49-BD25-286E234FCA58.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/DC146602-04E9-A94D-BD8A-8CE20ADA4996.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/E1655977-576F-974F-B197-8898546015F4.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/240000/F57C9DFD-920B-994A-85AD-08983D85A3DA.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/2410000/080968F9-5C0E-BE4D-8D8B-D20AAB71C291.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/2410000/7D2AF654-F36D-894F-9922-EEEC29AEF1BA.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/2410000/FCC39027-5D9F-6942-9D94-9EDB65D41B77.root", - "/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/002EF773-026C-2C49-981E-602DC3F43DF5.root", - "/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/01BDECC6-EDA1-A141-94C7-2BC88B97A586.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/027CA2FB-8559-FF47-9026-E3A716F7569C.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/038AE40E-E498-0E46-AE33-E396FCA00136.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/04E49D12-050E-2243-AEE5-77EA9CEED5F7.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/054E7E4C-A75A-0E45-A4C7-07F328D9C0BB.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/07AC3C61-0EF7-A14F-AB4C-84A61E888B6C.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/08319D13-3375-2B44-BB09-43C91825EC7E.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/0BFE7589-6C55-D649-8DE4-54D18625BB18.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/0D2142AD-9C6D-2C48-B9AE-55185ED382FA.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/0FB29033-CEC1-F541-98AD-33365C270C26.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/12628C6B-81F4-134C-944E-22C0E536F4F4.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/13332FC7-A67A-EF40-9719-4D77B07C4FBC.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1365ED78-1316-4041-AFB6-EB8DCFB4FE4F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/15A7D2D0-0A82-7749-B930-C10D065CE793.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/164B0F40-3659-CE4C-BFA2-6835AC225C3F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1710300F-216D-BC44-8A1F-3B79D53ABE09.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/17C26920-7618-B74A-A261-007A1914376E.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/17F11341-84E8-0F4D-803A-7B0FC40D9623.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1B4E20D4-587D-7942-B5C6-5737E62BDDDC.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1BF800E8-9712-E349-9404-4DC4B35839F8.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1C1D5637-360E-7F4A-AF2B-0C6E6BE03CA6.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1D4E5A98-DD40-C140-A870-8D35611F46F4.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1DBFE360-7E73-BA40-98BE-3851C984C19F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1E9A0DED-6E9B-6F4D-999E-C84AAA0E4B45.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/1EA6651C-DA91-D446-9B21-2349DA0A00BF.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/21AD55BA-C4A5-F84D-8052-56FAB0339BC2.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/220227D8-1966-B24F-85D0-50D92049F881.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/222EA925-28A9-5B4D-BB94-33FE97983456.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/25013A84-C838-7F40-881F-BD3F82C79CF9.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/276328D7-5E7A-EF45-A8C6-3511B7358FE7.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/28A34A0B-2269-DD43-8FDC-3BEEE414D7C0.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/2936BDF5-0538-284E-87BD-9C733117640A.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/2A07C993-ADEA-5842-BD61-F270C46AF7E3.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/2A132A03-80DB-1D46-B875-FB7F8053220F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/2C8C5457-2AF6-D744-BEC0-3840C660BDE1.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/2CA805EF-FFE0-AE40-8A1F-84702A003F05.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/2D0E6263-426C-C84B-A087-2C169CD0738F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/30D8053C-877F-A74C-BA89-65C850639765.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/32C4F351-95D6-BD45-9228-2A5850DCDEEF.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/33B13A47-BA71-9B42-8362-321BA8CBC19D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/36492643-087E-6F47-8879-68A1A2387223.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/36BA6EBA-00FC-C743-AD4F-1FBEEA6F2FB4.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/38364BFE-7F84-CC4C-8545-0656BD19DBB9.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/38E4DDC6-686D-424E-B839-0C999A6ABE1D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/39FAD98A-8337-C044-B76B-68E0A1530BC4.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/3A0865E1-03FA-A441-A6EC-A91D8DDE9BED.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/3E094F5C-223A-4644-B618-350A30153F9E.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/3E98AAB2-FDFA-DD47-929B-F2A66BD66AE6.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/3F7367D9-8D26-D24D-BDCC-BA8F7504BA53.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/406D4CBF-BF41-DF4B-AB75-68D59D52EC32.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/42DBE057-ED41-4742-9AFA-DDEF8B5F5A86.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/43E5D3CA-6A8C-E044-AF25-EECF2755CC0A.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/4501C237-E353-2047-8F0E-EFB03CFE8C6A.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/45E5E0AE-30C1-3143-AE89-6521CC1618B8.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/4664D4C3-7B36-7A43-8475-78ADD908CB10.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/47049D58-A17C-CD45-A986-B8B237D6CA24.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/470D6BF5-7E1A-6541-BD08-132BC82BD978.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/47578029-D405-6B42-8F8D-B709323BAD15.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/47764251-509B-BD40-81BA-8E5BA70158CB.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/4899A728-08E3-5A44-A386-46AA46BD0B21.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/49B8E525-D0F8-3549-A0F6-45A328D7C9B5.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/4AAD90D1-5F97-9E42-8E65-F91EBC637C03.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/4AF3C43A-487E-B646-90D5-641964AF8965.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/4B5AA617-BB2B-104F-861E-D1321ED8F7F5.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/4BC3C2A1-AEF4-D343-AE37-8876C2C2928A.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/51CE0CD1-6597-F548-BD91-DCC1391C2023.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/5456BC8A-5E20-ED4B-B1C7-B97FC897202D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/5752A569-7537-D64C-B3B4-5D0370EE0120.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/59409B26-E339-CF47-B787-25F2BEC344A0.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/5CED1947-044B-6740-868B-65C4FF84B145.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/6533150E-5BA7-6E48-84A9-AC6AF7F8A7C3.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/68BA8E6C-8563-8248-93C3-B820A5ACB6E5.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/69B7D5EB-12C3-5C42-B38E-1722F6E06DB7.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/6D29D075-1873-BE42-A0B6-D8C1D86D1BC3.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/6D4ED335-A5F9-784D-92A4-6A9A315D4BAB.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/71A39B2D-2CA8-C24B-925B-D24B0DB79679.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/723674DE-5DC0-0B42-AFFF-83683A7D7985.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/729BCAE1-8005-5843-9463-9FE821FB8ED7.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/72EED3E8-2935-8846-BC0D-56087E6555C9.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/74D0935F-94EE-594A-9503-AE2B1343A8AB.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/7592CE6B-95EB-424D-ABDE-3B17CA8ED415.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/77027D93-4242-384E-AE90-3FC90BBFCB90.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/77D9A1C6-9C9D-2B4F-A806-244ED956B379.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/7AF0F37B-498A-854E-8006-D55978A3CFEE.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/7BDF6B5E-720F-FF4B-91F6-244ACB92FB6B.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/7C68F877-FC78-7040-ABF5-56D747098B4D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/7CC3687C-4A49-2A43-9639-27CE10A62552.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/7E8B4627-1B0B-844D-A8D4-A754FF005DF4.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/80038494-37AD-8643-89CC-9D9AE345CD1F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/82A27FD0-5985-8842-BE03-37D32D985517.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/849B01BA-7A24-8545-881D-F29C621606AE.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/84DE1CCD-571D-094A-A0FB-ED30CB83F23E.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/86CE0C6C-8EC3-434B-B528-D48B76CC4D4D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/89D1A307-C9E6-144A-956A-7F38B2085C69.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/92071577-519B-CC44-B266-3237A52093A5.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/93D853EC-5D44-C14A-BA6E-A52C1B7ED615.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/95F494ED-2199-524B-9BA0-6C267ABCF81D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/9738533D-1DB4-E140-9AB6-F287B1AA4757.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/97470E76-19E4-7449-AB42-4208BAE1D3E5.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/97996C9D-2645-8441-A55B-97E9BD23056D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/97F04906-C522-044E-A39A-99EB534A6564.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/9C1EF435-0F21-AF4B-94E7-2308C82AF846.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/9C3A1404-06D0-F647-85DB-480B3BEE6997.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/9CF44F16-BB98-2945-A01B-8FCFF93C5DE0.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/9CF45680-C6C3-7245-89B9-C40794149DDA.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/A3901447-064E-6746-B03B-8B8D9562F389.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/A41E98DF-AD86-EA45-AE4B-6EF7C509DB34.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/A819A39C-7016-F74A-94CC-482C4DB57D98.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/AC3E70C9-445C-6945-A6DE-759F429F452B.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/ACED4D7D-C2A9-2240-942D-878ED5622D89.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B129608F-C4D3-7C4E-9A29-E76713770924.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B1CC3074-9EE0-7742-AD70-81A2A0D261A6.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B24E3050-D9AB-2E4D-9CC0-EF17BE64CF03.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B3C75DE7-2DCB-9B46-AF7D-4BAC93DC2F48.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B48619A8-DC75-F649-9475-924E7ED58054.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B4B9F261-1DA2-1241-B3B6-05CE5A1BBE55.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B4C7E07D-FE3D-B44A-9F2C-F03BF5CF7FD4.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B4F1CD28-A6B8-5F48-A0DA-3B09FEE3AFF1.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B51390E7-5CCC-0348-B37F-A4FC3AC98106.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B57C7FBE-E51B-0948-B58E-06AB7B1F496C.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B5EBB61C-C221-B14C-95C6-DEECC85FE1E3.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/B9AE0A53-93D8-E547-9D63-BA02D547E003.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/BD1737FD-214F-B14E-8B71-5B1B5C6AD63F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/C0181147-6841-054B-B5FC-99AF6457F96F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/C19927F6-A6DE-2942-B11A-9DC4D9C4CE09.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/C4B43B24-47F9-CA47-83DE-8C32CA9758F6.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/C537EA44-703B-8B40-B4A0-0C2391614DBD.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/C61B2E9B-FDE1-CD4E-B390-D2EF8CFB1AB0.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/C79AC11A-D1DB-6E47-B49C-367DB3807C34.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/C866A534-8D3F-AB42-AB22-787E6A74FD9D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/CBF9E541-4071-8A40-9DD8-E3F9E56D8B21.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/CC9DC205-0C3A-CA4B-BB00-50CD5C7EC9BA.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/CEF04E1B-C335-0744-851A-D768B9BFEF75.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/D02DF83C-BD9C-5542-8D9F-B8CF2FF627C2.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/D432ACB7-515E-EF41-B3D1-BA3797D64484.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/D635D5F6-798F-C045-A6A7-DA0FDFF72708.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/D6C1D7F2-6930-6244-B66D-A5CAAAC16651.root", - # - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/D6D9BACA-9BEB-014B-9B2F-EACC8695E1FD.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/D7A0F357-9CB3-0142-817F-45C80A9C67FD.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/D7F25FA3-05E1-A240-87BB-44CCE41707C3.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/DA193752-B3D8-FE4E-BD1D-55D26F74F1CC.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/DA302C5C-DF22-074F-9D24-33B745C70675.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/DAE4267D-BE43-A44B-A10B-1F277DEC7015.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/DCA0D214-B345-C34C-9CCB-C5E63BCE4E26.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/DCBBDD3E-922D-BA4C-BFF3-B268DAB2B0AA.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/DD253128-B0B9-864C-8938-E7A11C0BD9D1.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/E0F4A3F2-9828-A14C-90BE-2DAB7ABBAF18.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/E0F5D595-4DA9-C94E-A2AD-8CC4F41112D6.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/E1022087-07CE-864F-B4C6-A796523CEFD3.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/E5506605-BA91-4F41-94C8-95EB18FF60F2.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/E73A1C8E-EB43-CA4F-9A10-8D0DC8F2735F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/E75B9FB0-B81B-B746-8539-7D71ED1618BE.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/E804237E-3D38-4F4A-955A-43BE5C347262.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/EBCA9A50-E8E5-3F41-871B-9AE7DFBE1899.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/EEE10597-1BBC-2449-96AD-ADB7C6E542AE.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/F0109E6E-052B-FC4C-8F46-6B66C0DF71B1.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/F091C6E3-BFDB-1E40-AB74-859735D7D379.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/F18B495D-E863-7040-9576-3B59E497E1A2.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/F2A56CF5-73EA-B843-9562-D51CE269309E.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/F39D20DD-6A74-924E-9931-822D29DA605A.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/F4E7E036-353B-AD4F-BE25-7ECBCF58986F.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/F63B6E04-ED28-BF4D-9832-1774BF8D4C2B.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/F77A1AF4-A437-B746-BBC5-A65D3283746D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/FC639B31-C4EC-4249-8DF3-F24D204C93AD.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/FE16D5D5-06C0-454E-8AC2-FF6CDF84BE2C.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/FE61A0D8-CEDC-2142-81AA-06301F452792.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280000/FF7E23DA-5D9A-3C40-9391-8E8CDC88CCA2.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280001/541255AD-EA7F-1B42-9E03-DA7311B9078D.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280001/A3AEAC55-28C9-1845-BB5D-B4D67070DB59.root", - #"/store/data/Run2018D/ZeroBias/AOD/12Nov2019_UL2018_rsb-v1/280001/DA5E8AD6-43A1-C14C-8AD3-92C04117E3EE.root" - ) -)) - -from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') from Configuration.AlCa.GlobalTag import GlobalTag -process.GlobalTag = GlobalTag(process.GlobalTag, '106X_dataRun2_v26', '') - -if options.calibInput == '': - process.GlobalTag.toGet = cms.VPSet( - cms.PSet(record = cms.string('PPSTimingCalibrationRcd'), - tag = cms.string('PPSDiamondTimingCalibration_v1'), - connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") +# 2022 prompt: to be updated +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_Prompt_frozen_v4', '') + + +#JH - use new tag for timing calibration + +### SET TIME SHIFT SOURCE BEGIN +# if options.useDB=='True': +# use_db=True +# elif options.useDB=='False': +# use_db=False +# elif options.useDB!='': +# assert 'UseDB paramter is not valid. It should be True or False (case sensitive)' +# else: +# use_db=False + + +# if((options.sqlFileName != '') ^ (options.calibInput != '') ^ (options.useDB !='')): + # assert 'Please specify exactly one source of time shift paramiters. One from set {calib.json, SQLLite File or globalDB}' + +use_sqlite_file = options.sqlFileName != '' +if (use_sqlite_file): + print('Using SQL file') + process.load('CondCore.CondDB.CondDB_cfi') + process.CondDB.connect = options.sqlFileName # SQLite input TODO: migrate to using tag + process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), + ) ) - ) -else: +) + +elif options.calibInput != '': + print('Using CalibInput file ') process.ppsTimingCalibrationESSource = cms.ESSource('PPSTimingCalibrationESSource', calibrationFile = cms.string(options.calibInput), subDetector = cms.uint32(2), appendToDataLabel = cms.string('') ) -# rechits production -process.load(options.geometryFile) +else: # default use db + print('Using db') + # TODO: uncomment below when delete sqlite file dependency + process.GlobalTag.toGet = cms.VPSet() + process.GlobalTag.toGet.append( + cms.PSet(record = cms.string("PPSTimingCalibrationRcd"), + tag = cms.string("PPSDiamondTimingCalibration_Run3_recovered_v1"), + label = cms.untracked.string('PPSTestCalibration'), + connect = cms.string("frontier://FrontierPrep/CMS_CONDITIONS") + ) + ) + # process.GlobalTag.toGet = cms.VPSet( + # cms.PSet(record = cms.string('PPSTimingCalibrationRcd'), + # tag = cms.string('PPSDiamondTimingCalibration_Run3_v1_hlt'), # working tag: PPSDiamondTimingCalibration_Run3_v1_hlt + # #TODO: old tag PPSDiamondTimingCalibration_v1 - to delete + # connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") + # ) + # ) +### SET TIME SHIFT SOURCE END + + +# TODO: we miss tjhis from worker.py vvvvv +# rechits production process.load('RecoPPS.Local.ctppsDiamondLocalReconstruction_cff') +# ^^^^^^^^^^^^^^^^^^^^^^^^^ -process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", - tagDigi = cms.InputTag("ctppsDiamondRawToDigi", "TimingDiamond"), - tagRecHit = cms.InputTag("ctppsDiamondRecHits"), - tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracks"), - tagLocalTrack = cms.InputTag("ctppsDiamondLocalTracks"), - tagValidOOT = cms.int32(-1), - planesConfig = cms.string(options.planesConfig), - Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), - Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), -) +tagLocalTrack_ = cms.InputTag("ctppsDiamondLocalTracks","" ,"RECODQM") +tagRecHit_ = cms.InputTag("ctppsDiamondRecHits","" ,"RECODQM") +from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer +if(options.calibInput != ''): + print('Using calib input') + process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", + tagDigi = cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer", "TimingDiamond"), + tagRecHit = tagRecHit_, # changed + tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer", "", "RECO"), + tagLocalTrack = tagLocalTrack_, #changed + timingCalibrationTag=cms.string(":"), + tagValidOOT = cms.int32(-1), #TODO: remove parameter from options or don't hardcode it. + planesConfig = cms.string("planes.json"), + Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), # minimum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), # maximum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + ) +elif (use_sqlite_file): + process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", + tagDigi = cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer", "TimingDiamond"), + tagRecHit =tagRecHit_, + tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer"), + timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + tagLocalTrack = tagLocalTrack_, + tagValidOOT = cms.int32(-1), #TODO: remove parameter from options or don't hardcode it. + planesConfig = cms.string("planes.json"), #TODO: remove parameter from options or don't hardcode it. + Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), # minimum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), # maximum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + ) +else: + process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", + tagDigi = cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer", "TimingDiamond"), + tagRecHit = tagRecHit_, + tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer"), + timingCalibrationTag=cms.string("GlobalTag:PPSTestCalibration"), + tagLocalTrack =tagLocalTrack_, + tagValidOOT = cms.int32(-1), #TODO: remove parameter from options or don't hardcode it. + planesConfig = cms.string("planes.json"), #TODO: remove parameter from options or don't hardcode it. + Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), # minimum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), # maximum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + ) +# else: + # assert "need to provide timing calibration tag from json, slq file or db" +process.ALL = cms.Path(process.diamondTimingWorker) -#process.TFileService = cms.Service("TFileService", -# fileName = cms.string(options.outputFile) -#) -process.DQMStore = cms.Service("DQMStore") process.dqmOutput = cms.OutputModule("DQMRootOutputModule", fileName=cms.untracked.string(options.outputFileName)) - -#print(vars(process)) - -process.path = cms.Path( - process.diamondTimingWorker -) - process.end_path = cms.EndPath(process.dqmOutput) -process.schedule = cms.Schedule( - process.path, - process.end_path -) +process.schedule = cms.Schedule(process.ALL, process.end_path) + +#print(process.dumpPython()) diff --git a/Analyzer/DiamondTimingAnalyzer/rolling_calib_just_print.sh b/Analyzer/DiamondTimingAnalyzer/rolling_calib_just_print.sh new file mode 100644 index 0000000000000..886d08d553dc3 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/rolling_calib_just_print.sh @@ -0,0 +1,76 @@ +#config +runNumber=357440 +maxEvents=450000 +experimentName=WORKER_ON_SHIFTED_FILE_by_chrysFile_9 +resultsFolderName=test_run_${runNumber}_maxEv${maxEvents}_${experimentName} +# sqlFileName=sqlite_file:/afs/cern.ch/user/m/mobrzut/public/timing_sqlcalib/ppsDiamondTiming_calibration${runNumber}.sqlite + +# worker setup +workerFile=temp/ExampleConfig_cfg_1_2_without_shift_multisource.py +shiftExperimentPrefix=JUST_SHIFT_357440_maxEv90000 +rootInput=file:/eos/project/c/ctpps/subsystems/Automation/hptdc-timing-offline/AOD.root +workerPrefix=${resultsFolderName}/worker_timeshift_${runNumber}_maxEv_${maxEvents} + +# harvester setup + +# scritpt +mkdir $resultsFolderName +echo "######################################## ##########################################" +echo "WORKER 0:" +worker0="cmsRun ${workerFile} " +worker0+="outputFileName=${workerPrefix}_loop_0.root " +worker0+="rootInput=${rootInput} " +worker0+="useDB=True " +# worker0+="calibInput=${PWD}/calib_${runNumber}.json " +# worker0+="sqlFileName=${sqlFileName} " +worker0+="maxEventsToProcess=${maxEvents} " +worker0+="2>&1 | tee ${resultsFolderName}/worker_log_0.txt " +echo $worker0 +echo "HARVESTER 0:" +harvester0="cmsRun temp/harvester2_multisource.py " +harvester0+="rootFiles=file:${workerPrefix}_loop_0.root " +harvester0+="calibOutput=${resultsFolderName}/calib_loop_0.json " +harvester0+="useDB=True " +# harvester0+="calibInput=${resultsFolderName}/calib_${runNumber}.json " +# harvester0+="sqlFileName=${sqlFileName} " +harvester0+="outputDirectoryRoot=${resultsFolderName} " +harvester0+="2>&1 | tee ${resultsFolderName}/harvester_log_0.txt " + +echo $harvester0 + + +calibFilesList="${resultsFolderName}/calib_loop_0.json" +for i in 1 2 +do + prev_loop=$(($i-1)) + if [ $prev_loop -gt 0 ] + then + calibFilesList="${calibFilesList},${resultsFolderName}/calib_loop_${prev_loop}.json" + fi + echo "**************************************************************************************" + echo "WORKER $i" + workeri="cmsRun ${workerFile} " + workeri+="rootInput=${rootInput} " + # workeri+="rootInput=file:${workerPrefix}_loop_0.root" # it looks like it should be always the same + workeri+="outputFileName=${workerPrefix}_loop_$i.root " + # workeri+="useDB=True " + workeri+="calibInput=${resultsFolderName}/calib_loop_$prev_loop.json " + # workeri+="sqlFileName=${sqlFileName} " + workeri+="maxEventsToProcess=${maxEvents} " + workeri+="2>&1 | tee ${resultsFolderName}/worker_log_$i.txt " + echo $workeri + + echo "HARVESTER $i" + harvesteri="cmsRun temp/harvester2_multisource.py " + harvesteri+="rootFiles=file:${workerPrefix}_loop_$i.root " + harvesteri+="calibOutput=${resultsFolderName}/calib_loop_$i.json " + harvesteri+="loopIndex=$i " + harvesteri+="calibFiles=$calibFilesList " + # harvesteri+="useDB=True " + harvesteri+="calibInput=${resultsFolderName}/calib_loop_$prev_loop.json " + # harvesteri+="sqlFileName=${sqlFileName} " + harvesteri+="outputDirectoryRoot=${resultsFolderName} " + harvesteri+="2>&1 | tee ${resultsFolderName}/harvester_log_$i.txt " + echo $harvesteri +done +echo "--------------------------------------------------------------------------------------------------" diff --git a/Analyzer/DiamondTimingAnalyzer/src/DiamondDetectorClass.cc b/Analyzer/DiamondTimingAnalyzer/src/DiamondDetectorClass.cc index e6e6e1ce79f5b..28991858f973d 100644 --- a/Analyzer/DiamondTimingAnalyzer/src/DiamondDetectorClass.cc +++ b/Analyzer/DiamondTimingAnalyzer/src/DiamondDetectorClass.cc @@ -45,7 +45,7 @@ void DiamondDetectorClass::ExtractData(){ for (const auto& locTrack : locTracks){ if((valid_OOT_==2) && (locTrack.ootIndex() != valid_OOT_) && (locTrack.ootIndex() != valid_OOT_+1)) continue; if (valid_OOT_!=2 && (locTrack.ootIndex() != valid_OOT_) && valid_OOT_!=-1 ) continue; - + //TODO: confirm if LocalTrackMap is filled corectly LocalTrack_map_.insert(std::make_pair(locTrack, std::vector>())); } } @@ -57,7 +57,9 @@ void DiamondDetectorClass::ExtractData(){ // retrieve and order all events in map. for (const auto& recHit : _recHits){ //rechit - if(((recHit.ootIndex() != (int)(SPC_map_[key].offset/25)) + // if(((recHit.ootIndex() != 0) // TODO: To be used with newest tag + // edm::LogWarning("Offset") <<"Offset:" << SPC_map_[key].offset; + if(((recHit.ootIndex() != (int)(SPC_map_[key].offset/25)) // TODO: To be used with newest tag && valid_OOT_!=-1) || recHit.multipleHits()) continue; diff --git a/Analyzer/DiamondTimingAnalyzer/submitTimingToCRAB.py b/Analyzer/DiamondTimingAnalyzer/submitTimingToCRAB.py new file mode 100644 index 0000000000000..304dc4b252af1 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/submitTimingToCRAB.py @@ -0,0 +1,33 @@ +import CRABClient +from CRABClient.UserUtilities import config +config = config() + +# InputDataset ="/AlCaPPSPrompt/Run2022C-PPSCalMaxTracks-PromptReco-v1/ALCARECO" +InputDataset = "/AlCaPPSPrompt/Run2022C-PPSCalMaxTracks-PromptReco-v1/ALCARECO" # on german DC +requestNumber = 205 + +config.General.transferOutputs = True +config.General.transferLogs = True + +config.General.requestName = f'DiamondTimingRes_mobrzut_{requestNumber}' + + + +config.JobType.pluginName = 'Analysis' +config.JobType.psetName = '/afs/cern.ch/user/m/mobrzut/public/timing_calibration_env/CMSSW_12_4_6/src/Analyzer/DiamondTimingAnalyzer/temp/ExampleConfig_cfg.py' +# config.JobType.pyCfgParams = ["sourceFileList=/afs/cern.ch/user/m/mobrzut/public/Era.dat", "outputFileName=tmp.root"] +config.Data.inputDataset = InputDataset +config.JobType.outputFiles = ["run_output.root"] +config.JobType.priority = 40 + +config.Data.inputDBS = 'global' +config.Data.splitting = 'LumiBased' +config.Data.unitsPerJob = 1000 +config.Data.publication = False +config.Data.outLFNDirBase = '/store/group/dpg_ctpps/comm_ctpps/2018_PixelEfficiency' +config.Data.outputDatasetTag = f'DiamondTimingRes_mobrzut_{requestNumber}' +config.Data.runRange = '357442' +config.Data.lumiMask ='/afs/cern.ch/user/m/mobrzut/public/allrunsSB-PPS-forCalib.json' + + +config.Site.storageSite = 'T2_CH_CERN' diff --git a/Analyzer/DiamondTimingAnalyzer/temp/ExampleConfig_cfg.py b/Analyzer/DiamondTimingAnalyzer/temp/ExampleConfig_cfg.py new file mode 100644 index 0000000000000..5817d2f807832 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/ExampleConfig_cfg.py @@ -0,0 +1,230 @@ +import FWCore.ParameterSet.Config as cms +import copy +from FWCore.ParameterSet.VarParsing import VarParsing +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * # TODO it looks like it can be deleted + + +# TEMP config: +apply_shift = True +saveToDQM = False + + +process = cms.Process('PPSTiming2') # or TIMINGSTUDY?? +options = VarParsing ('analysis') + +process.verbosity = cms.untracked.PSet( input = cms.untracked.int32(-1) ) # TODO: confirm if this is needed. + +process.load('FWCore.MessageService.MessageLogger_cfi') +process.MessageLogger.cerr.threshold = '' +process.MessageLogger.cerr.FwkReport.reportEvery = 1000 + +options.register ('outputFileName', + 'run_output.root', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "output file name") + +options.register ('calibInput', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "Calibration input file for this iteration") + +options.register ('planesConfig', + 'planes.json', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "planes config file") + +options.register ('validOOT', + -1, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + "valid OOT slice") +options.register('useSQLFile', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'useSQLFileAsACalibration' +) + +options.register('sqlFileName', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('maxEventsToProcess', + -1, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + 'maxEvents to process' +) + + + +options.parseArguments() + +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(options.maxEventsToProcess)) + + + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file +# process.load('Geometry.VeryForwardGeometry.geometryRPFromDD_2022_cfi') + +process.source = cms.Source ("PoolSource", + fileNames = cms.untracked.vstring( + # "file:/eos/home-m/mobrzut/357/734/00000/73c5eeec-578d-438f-92f1-3e1fff2ed390.root", + # "file:/eos/home-m/mobrzut/357/734/00000/08e5ee70-ebff-4571-b14c-806961a3d9dd.root", + # "file:/eos/home-m/mobrzut/357/734/00000/d42eaf2c-57bb-48fe-9a22-317053f89115.root" +# "file:/eos/home-m/mobrzut/357/479/00000/68a5a64a-b756-4cf5-9a2a-00181e34f501.root" +# RUN 440 - "357440": [[1,354]], +# "/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/53746080-d21b-4fdf-9d19-67c6dae347ac.root", +# "/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/b8d3f012-0b59-43b4-adbc-811bcb59c9c4.root", +# "/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/cfa9f82a-5296-49cf-8353-11f8761b675c.root", +# "/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/db3c6c33-9ad0-4d61-9a64-a1aa9578550e.root" + + +# RUN 442 - "357442": [[1,1392]], +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/19b41c28-cc6e-4df9-b73a-ae8b187021c7.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/4d2b38b9-f03f-4887-ad72-e53e448cc52d.root" +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/5987c37e-850f-4c00-9e69-d6a3ed8df910.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/9450abb5-9478-4209-b1dd-7ff06beab620.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/a2536da7-b15f-4d3c-be30-9feefb303f41.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/a2f71e31-b36b-4a05-bb14-17e6b404ceec.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/ca8d0e9c-5ac7-4987-ba7b-b771cd933485.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/e6a28ca6-f978-430c-bacf-7b0d59f8c069.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/eac6865b-3265-4d9d-aee9-579dc95e7f63.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/442/00000/ee2f7caa-dcb5-4ab3-b6cf-b302031dd105.root" +) +) + +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +from Configuration.AlCa.GlobalTag import GlobalTag +# 2022 prompt: to be updated +process.GlobalTag = GlobalTag(process.GlobalTag, "124X_dataRun3_v9") + + +#JH - use new tag for timing calibrations +if options.useSQLFile=='True': + use_sqlite_file=True +elif options.useSQLFile=='False': + use_sqlite_file=False +else: + print('Provide true or false for useSQLLiteFile') + exit() + +if (use_sqlite_file): + process.load('CondCore.CondDB.CondDB_cfi') + process.CondDB.connect = options.sqlFileName # SQLite input TODO: migrate to using tag + process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), + ) + ) +) + +if options.calibInput == '': + print('') + #TODO: uncomment below when delete sqlite file dependency + # process.GlobalTag.toGet = cms.VPSet( + # cms.PSet(record = cms.string('PPSTimingCalibrationRcd'), + # tag = cms.string('PPSDiamondTimingCalibration_Run3_v1_hlt'), # working tag: PPSDiamondTimingCalibration_Run3_v1_hlt + # #TODO: old tag PPSDiamondTimingCalibration_v1 - to delete + # connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") + # ) + # ) +else: + process.ppsTimingCalibrationESSource = cms.ESSource('PPSTimingCalibrationESSource', + calibrationFile = cms.string(options.calibInput), + subDetector = cms.uint32(2), + appendToDataLabel = cms.string('') + ) + +# TODO: we miss tjhis from worker.py vvvvv +# rechits production +#process.load('RecoPPS.Local.ctppsDiamondLocalReconstruction_cff') +# ^^^^^^^^^^^^^^^^^^^^^^^^^ + +# JH - rerun reco sequence with new timing conditions +process.load("RecoPPS.Configuration.recoCTPPS_cff") +process.ctppsDiamondLocalTracks.recHitsTag = cms.InputTag("ctppsDiamondRecHits","","PPSTiming2") +process.ctppsLocalTrackLiteProducer.tagDiamondTrack = cms.InputTag("ctppsDiamondLocalTracks","","PPSTiming2") +process.ctppsProtons.tagLocalTrackLite = cms.InputTag("ctppsLocalTrackLiteProducer","","PPSTiming2") +process.ctppsLocalTrackLiteProducer.includeDiamonds = cms.bool(True) +process.ctppsLocalTrackLiteProducer.tagPixelTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer") +process.ctppsLocalTrackLiteProducer.includePixels = cms.bool(True) +process.ctppsDiamondRecHits.timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration") +process.ctppsDiamondRecHits.digiTag= cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond") + +from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer +if(apply_shift): + process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", + tagDigi = cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer", "TimingDiamond"), + tagRecHit = cms.InputTag("ctppsDiamondRecHits","","PPSTiming2"), + tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer"), + timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + tagLocalTrack = cms.InputTag("ctppsDiamondLocalTracks","","PPSTiming2"), + tagValidOOT = cms.int32(-1), #TODO: remove parameter from options or don't hardcode it. + planesConfig = cms.string("planes.json"), #TODO: remove parameter from options or don't hardcode it. + Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), # minimum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), # maximum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + ) +else: + process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", + tagDigi = cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer", "TimingDiamond"), + tagRecHit = cms.InputTag("ctppsDiamondRecHitsAlCaRecoProducer"), + tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer"), + tagLocalTrack = cms.InputTag("ctppsDiamondLocalTracksAlCaRecoProducer"), + timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + tagValidOOT = cms.int32(-1), #TODO: remove parameter from options or don't hardcode it. + planesConfig = cms.string("planes.json"), + Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), # minimum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), # maximum number of tracks in pots [45-210, 45-220, 56-210, 56-220] +) + +if(apply_shift): + process.ALL = cms.Path( + # Re-run the PPS local+proton reconstruction starting from AOD with new timing calibrations + process.ctppsDiamondRecHits * + process.ctppsDiamondLocalTracks * + process.diamondTimingWorker + ) +else: + process.ALL = cms.Path(process.diamondTimingWorker) + +if(saveToDQM): + process.load("DQMServices.Core.DQMStore_cfi") + process.load("DQMServices.Components.DQMEnvironment_cfi") + process.dqmEnv.subSystemFolder = "CalibPPS" + process.dqmSaver.convention = 'Offline' + process.dqmSaver.workflow = "/CalibPPS/TimingCalibration/CMSSW_12_0_0_pre2" + process.dqmSaver.saveByRun = -1 + process.dqmSaver.saveAtJobEnd = True + process.dqmSaver.forceRunNumber = 999999 + + + process.dqmOutput = cms.OutputModule("DQMRootOutputModule", + fileName = cms.untracked.string(options.outputFileName) + ) + + process.load("DQMServices.Components.EDMtoMEConverter_cff") + process.end_path = cms.EndPath(process.dqmSaver) +else: + process.dqmOutput = cms.OutputModule("DQMRootOutputModule", fileName=cms.untracked.string(options.outputFileName)) + process.end_path = cms.EndPath(process.dqmOutput) + + +process.schedule = cms.Schedule(process.ALL, process.end_path) + +#print(process.dumpPython()) diff --git a/Analyzer/DiamondTimingAnalyzer/temp/ExampleConfig_cfg_1_2_without_shift_multisource.py b/Analyzer/DiamondTimingAnalyzer/temp/ExampleConfig_cfg_1_2_without_shift_multisource.py new file mode 100644 index 0000000000000..c972393a36ef5 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/ExampleConfig_cfg_1_2_without_shift_multisource.py @@ -0,0 +1,217 @@ +import FWCore.ParameterSet.Config as cms +import copy +from FWCore.ParameterSet.VarParsing import VarParsing +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * # TODO it looks like it can be deleted + + +# TEMP config: +apply_shift = False +saveToDQM = False + + +process = cms.Process('PPSTiming2') # or TIMINGSTUDY?? +options = VarParsing ('analysis') + +process.verbosity = cms.untracked.PSet( input = cms.untracked.int32(-1) ) # TODO: confirm if this is needed. + +process.load('FWCore.MessageService.MessageLogger_cfi') +process.MessageLogger.cerr.threshold = '' +process.MessageLogger.cerr.FwkReport.reportEvery = 1000 + +options.register ('rootInput', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "root input file name") + + +options.register ('outputFileName', + 'run_output.root', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "output file name") + +options.register ('calibInput', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "Calibration input file for this iteration") + +options.register ('planesConfig', + 'planes.json', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "planes config file") + +options.register ('validOOT', + -1, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + "valid OOT slice") +options.register('useDB', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'useDB' +) + +options.register('sqlFileName', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('maxEventsToProcess', + -1, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + 'maxEvents to process' +) + + + + + + +options.parseArguments() + +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(options.maxEventsToProcess)) + + + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file + +process.source = cms.Source ("PoolSource", + fileNames = cms.untracked.vstring(options.rootInput) + ) + +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +from Configuration.AlCa.GlobalTag import GlobalTag +# 2022 prompt: to be updated +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_Prompt_frozen_v4', '') + + +#JH - use new tag for timing calibration + +### SET TIME SHIFT SOURCE BEGIN +if options.useDB=='True': + use_db=True +elif options.useDB=='False': + use_db=False +elif options.useDB!='': + assert 'UseDB paramter is not valid. It should be True or False (case sensitive)' +else: + use_db=False + + +if((options.sqlFileName != '') ^ (options.calibInput != '') ^ (options.useDB !='')): + assert 'Please specify exactly one source of time shift paramiters. One from set {calib.json, SQLLite File or globalDB}' + +use_sqlite_file = options.sqlFileName != '' +if (use_sqlite_file): + print('Using SQL file') + process.load('CondCore.CondDB.CondDB_cfi') + process.CondDB.connect = options.sqlFileName # SQLite input TODO: migrate to using tag + process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), + ) + ) +) + +if options.calibInput != '': + print('Using CalibInput file ') + process.ppsTimingCalibrationESSource = cms.ESSource('PPSTimingCalibrationESSource', + calibrationFile = cms.string(options.calibInput), + subDetector = cms.uint32(2), + appendToDataLabel = cms.string('') + ) + +if(use_db): + print('Using db') + # TODO: uncomment below when delete sqlite file dependency + process.GlobalTag.toGet = cms.VPSet() + process.GlobalTag.toGet.append( + cms.PSet(record = cms.string("PPSTimingCalibrationRcd"), + tag = cms.string("PPSDiamondTimingCalibration_Run3_recovered_v1"), + label = cms.untracked.string('PPSTestCalibration'), + connect = cms.string("frontier://FrontierPrep/CMS_CONDITIONS") + ) + ) + # process.GlobalTag.toGet = cms.VPSet( + # cms.PSet(record = cms.string('PPSTimingCalibrationRcd'), + # tag = cms.string('PPSDiamondTimingCalibration_Run3_v1_hlt'), # working tag: PPSDiamondTimingCalibration_Run3_v1_hlt + # #TODO: old tag PPSDiamondTimingCalibration_v1 - to delete + # connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") + # ) + # ) +### SET TIME SHIFT SOURCE END + + +# TODO: we miss tjhis from worker.py vvvvv +# rechits production +process.load('RecoPPS.Local.ctppsDiamondLocalReconstruction_cff') +# ^^^^^^^^^^^^^^^^^^^^^^^^^ + +tagLocalTrack_ = cms.InputTag("ctppsDiamondLocalTracks","" ,"RECODQM") +tagRecHit_ = cms.InputTag("ctppsDiamondRecHits","" ,"RECODQM") +from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer +if(options.calibInput != ''): + print('Using calib input') + process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", + tagDigi = cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer", "TimingDiamond"), + tagRecHit = tagRecHit_, # changed + tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer", "", "RECO"), + tagLocalTrack = tagLocalTrack_, #changed + timingCalibrationTag=cms.string(":"), + tagValidOOT = cms.int32(-1), #TODO: remove parameter from options or don't hardcode it. + planesConfig = cms.string("planes.json"), + Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), # minimum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), # maximum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + ) +elif (use_sqlite_file): + process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", + tagDigi = cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer", "TimingDiamond"), + tagRecHit =tagRecHit_, + tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer"), + timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + tagLocalTrack = tagLocalTrack_, + tagValidOOT = cms.int32(-1), #TODO: remove parameter from options or don't hardcode it. + planesConfig = cms.string("planes.json"), #TODO: remove parameter from options or don't hardcode it. + Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), # minimum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), # maximum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + ) +elif(use_db): + process.diamondTimingWorker = DQMEDAnalyzer("DiamondTimingWorker", + tagDigi = cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer", "TimingDiamond"), + tagRecHit = tagRecHit_, + tagPixelLocalTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer"), + timingCalibrationTag=cms.string("GlobalTag:PPSTestCalibration"), + tagLocalTrack =tagLocalTrack_, + tagValidOOT = cms.int32(-1), #TODO: remove parameter from options or don't hardcode it. + planesConfig = cms.string("planes.json"), #TODO: remove parameter from options or don't hardcode it. + Ntracks_Lcuts = cms.vint32([-1,1,-1,1]), # minimum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + Ntracks_Ucuts = cms.vint32([-1,6,-1,6]), # maximum number of tracks in pots [45-210, 45-220, 56-210, 56-220] + ) +else: + assert "need to provide timing calibration tag from json, slq file or db" +process.ALL = cms.Path(process.diamondTimingWorker) + + +process.dqmOutput = cms.OutputModule("DQMRootOutputModule", fileName=cms.untracked.string(options.outputFileName)) +process.end_path = cms.EndPath(process.dqmOutput) + + +process.schedule = cms.Schedule(process.ALL, process.end_path) + +#print(process.dumpPython()) diff --git a/Analyzer/DiamondTimingAnalyzer/temp/harvester2.py b/Analyzer/DiamondTimingAnalyzer/temp/harvester2.py new file mode 100644 index 0000000000000..d129f1f6edba4 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/harvester2.py @@ -0,0 +1,167 @@ +import FWCore.ParameterSet.Config as cms +from FWCore.ParameterSet.VarParsing import VarParsing +from RecoPPS.Local.ctppsDiamondLocalReconstruction_cff import * +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * + + +process = cms.Process("TIMINGSTUDY") +options = VarParsing ('analysis') + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) +process.verbosity = cms.untracked.PSet( input = cms.untracked.int32(-1) ) + +# minimum of logs +process.load("FWCore.MessageService.MessageLogger_cfi") +process.MessageLogger.cerr.FwkReport.reportEvery = 1000 + +options.register ('rootFiles', + '', + VarParsing.multiplicity.singleton, #TODO: it was designed to be a list revert change before merging + VarParsing.varType.string, + "root files produced by DQMWorker") + +options.register ('outputDirectoryRoot', + 'OutputFilesRolling', + VarParsing.multiplicity.singleton, #TODO: it was designed to be a list revert change before merging + VarParsing.varType.string, + "root output dircetory") + +# options.register ('calibInput', +# '', +# VarParsing.multiplicity.singleton, +# VarParsing.varType.string, +# "Input file for calibration from this iteration") + +options.register ('calibOutput', + 'calib.json', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "Output file for calibration from this iteration") + +options.register ('calibInput', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "Input file") + +options.register ('calibFiles', + [], + VarParsing.multiplicity.list, + VarParsing.varType.string, + "Calibration files from previous iterations in ascending order") + +options.register ('loopIndex', + 0, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + "loop iteration") + +options.register ('meanMax', + 1, + VarParsing.multiplicity.singleton, + VarParsing.varType.float, + "max mean of t distribution") + +options.register ('rmsMax', + 1, + VarParsing.multiplicity.singleton, + VarParsing.varType.float, + "max rms of t distribution") + +options.register('sqlFileName', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.parseArguments() + + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +#SOURCE +process.source = cms.Source("DQMRootSource", + fileNames = cms.untracked.vstring(options.rootFiles) +) + +from DQMServices.Core.DQMEDHarvester import DQMEDHarvester +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_v9', '') + +useSQLFile = True +if useSQLFile: + process.load('CondCore.CondDB.CondDB_cfi') + process.CondDB.connect = options.sqlFileName # SQLite input + process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), + ) + ) + ) + + +# if options.calibInput == '': +# process.PoolDBESSource = cms.ESSource('PoolDBESSource', +# process.CondDB, +# DumpStats = cms.untracked.bool(True), +# toGet = cms.VPSet( +# cms.PSet( +# record = cms.string('PPSTimingCalibrationRcd'), +# tag = cms.string('DiamondTimingCalibration'), +# label = cms.untracked.string('PPSTestCalibration') +# ) +# ) +# ) +# else: +if options.calibInput != '': + process.ppsTimingCalibrationESSource = cms.ESSource('PPSTimingCalibrationESSource', + calibrationFile = cms.string(options.calibInput), + subDetector = cms.uint32(2), + appendToDataLabel = cms.string('') + ) + +# rechits production +process.load("DQM.Integration.config.environment_cfi") +process.load("DQMServices.Components.DQMEnvironment_cfi") +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file + +process.diamondTimingHarvester = DQMEDHarvester("DiamondTimingHarvester", +# timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), +# timingCalibrationTag=cms.InputTag("PoolDBESSource:PPSTestCalibration"), + + calib_json_output = cms.string(options.calibOutput), + calibFiles = cms.vstring(options.calibFiles), + loopIndex = cms.int32(options.loopIndex), + meanMax = cms.double(options.meanMax), + rmsMax = cms.double(options.rmsMax) +) + +# process.diamondTimingHarvester.timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration") + + +#CONFIGURE DQM Saver +process.dqmEnv.subSystemFolder = "CalibPPS" +process.dqmSaver.convention = 'Offline' +process.dqmSaver.workflow = f'/AnalyzerWithShiftRolling/DiamondTimingAnalyzer/CMSSW_12_4_6_loop{options.loopIndex}' +process.dqmSaver.dirName = f'./{options.outputDirectoryRoot}/' # TODO: it was commented out - revert the change before merge + +process.path = cms.Path( + process.diamondTimingHarvester +) + +process.end_path = cms.EndPath(process.dqmSaver) + +process.schedule = cms.Schedule( + process.path, + process.end_path +) diff --git a/Analyzer/DiamondTimingAnalyzer/temp/harvester2_multisource.py b/Analyzer/DiamondTimingAnalyzer/temp/harvester2_multisource.py new file mode 100644 index 0000000000000..10bff3adca58f --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/harvester2_multisource.py @@ -0,0 +1,224 @@ +import FWCore.ParameterSet.Config as cms +from FWCore.ParameterSet.VarParsing import VarParsing +from RecoPPS.Local.ctppsDiamondLocalReconstruction_cff import * +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * + + +process = cms.Process("TIMINGSTUDY") +options = VarParsing ('analysis') + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) +process.verbosity = cms.untracked.PSet( input = cms.untracked.int32(-1) ) + +# minimum of logs +process.load("FWCore.MessageService.MessageLogger_cfi") +# process.MessageLogger.cerr.threshold = "INFO" +# process.MessageLogger.cerr.INFO.limit = -1 +process.MessageLogger.cerr.FwkReport.reportEvery = 1000 + +options.register ('rootFiles', + 'file:/afs/cern.ch/user/m/mobrzut/automation/timing_calibration/CMSSW_12_4_6/src/Analyzer/DiamondTimingAnalyzer/run_output.root', + VarParsing.multiplicity.singleton, #TODO: it was designed to be a list revert change before merging + VarParsing.varType.string, + "root files produced by DQMWorker") + +options.register ('outputDirectoryRoot', + 'OutputHarvester', + VarParsing.multiplicity.singleton, #TODO: it was designed to be a list revert change before merging + VarParsing.varType.string, + "root output dircetory") + +# options.register ('calibInput', +# '', +# VarParsing.multiplicity.singleton, +# VarParsing.varType.string, +# "Input file for calibration from this iteration") + +options.register ('calibOutput', + 'calib.json', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "Output file for calibration from this iteration") + +options.register ('calibInput', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + "Input file") + +options.register ('calibFiles', + [], + VarParsing.multiplicity.list, + VarParsing.varType.string, + "Calibration files from previous iterations in ascending order") + +options.register ('loopIndex', + 0, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + "loop iteration") + +options.register ('meanMax', + 1, + VarParsing.multiplicity.singleton, + VarParsing.varType.float, + "max mean of t distribution") + +options.register ('rmsMax', + 1, + VarParsing.multiplicity.singleton, + VarParsing.varType.float, + "max rms of t distribution") + +options.register('sqlFileName', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('useDB', + '', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'use data base for calibraiton' +) + + +options.parseArguments() + + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +#SOURCE +process.source = cms.Source("DQMRootSource", + fileNames = cms.untracked.vstring(options.rootFiles) +) + +from DQMServices.Core.DQMEDHarvester import DQMEDHarvester +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_v9', '') + +### SET TIME SHIFT SOURCE BEGIN +if options.useDB=='True': + use_db=True +elif options.useDB=='False': + use_db=False +elif options.useDB!='': + assert 'UseDB paramter is not valid. It should be True or False (case sensitive)' +else: + use_db=False + + +if((options.sqlFileName != '') ^ (options.calibInput != '') ^ (options.useDB !='')): + assert 'Please specify exactly one source of time shift paramiters. One from set {calib.json, SQLLite File or globalDB}' + +use_sqlite_file = options.sqlFileName != '' +if (use_sqlite_file): + print('Using SQL file') + process.load('CondCore.CondDB.CondDB_cfi') + process.CondDB.connect = options.sqlFileName # SQLite input TODO: migrate to using tag + process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), + ) + ) +) + +if options.calibInput != '': + print('Using CalibInput file ') + process.ppsTimingCalibrationESSource = cms.ESSource('PPSTimingCalibrationESSource', + calibrationFile = cms.string(options.calibInput), + subDetector = cms.uint32(2), + appendToDataLabel = cms.string('') + ) + +if(use_db): + print('Using db') + process.GlobalTag.toGet = cms.VPSet() + process.GlobalTag.toGet.append( + cms.PSet(record = cms.string("PPSTimingCalibrationRcd"), + tag = cms.string("PPSDiamondTimingCalibration_Run3_recovered_v1"), + label = cms.untracked.string('PPSTestCalibration'), + connect = cms.string("frontier://FrontierPrep/CMS_CONDITIONS") + ) + ) + #TODO: uncomment below when delete sqlite file dependency + # process.GlobalTag.toGet = cms.VPSet( + # cms.PSet(record = cms.string('PPSTimingCalibrationRcd'), + # tag = cms.string('PPSDiamondTimingCalibration_Run3_v1_hlt'), # working tag: PPSDiamondTimingCalibration_Run3_v1_hlt + # #TODO: old tag PPSDiamondTimingCalibration_v1 - to delete + # connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") + # ) + # ) +### SET TIME SHIFT SOURCE END + +# rechits production +process.load("DQM.Integration.config.environment_cfi") +process.load("DQMServices.Components.DQMEnvironment_cfi") +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file + +# PROCESS HARVESTER: +if(options.calibInput != ''): + process.diamondTimingHarvester = DQMEDHarvester("DiamondTimingHarvester", + # timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + # timingCalibrationTag=cms.string("PPSTimingCalibrationESSource:PPSTiming"), + # timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + + timingCalibrationTag=cms.string(":"), + calib_json_output = cms.string(options.calibOutput), + calibFiles = cms.vstring(options.calibFiles), + loopIndex = cms.int32(options.loopIndex), + meanMax = cms.double(options.meanMax), + rmsMax = cms.double(options.rmsMax) + ) +elif (use_sqlite_file): + process.diamondTimingHarvester = DQMEDHarvester("DiamondTimingHarvester", +# timingCalibrationTag=cms.string("PPSTimingCalibrationESSource:PPSTiming"), + timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration"), + calib_json_output = cms.string(options.calibOutput), + calibFiles = cms.vstring(options.calibFiles), + loopIndex = cms.int32(options.loopIndex), + meanMax = cms.double(options.meanMax), + rmsMax = cms.double(options.rmsMax) +) +elif(use_db): + process.diamondTimingHarvester = DQMEDHarvester("DiamondTimingHarvester", + timingCalibrationTag=cms.string("GlobalTag:PPSTestCalibration"), + calib_json_output = cms.string(options.calibOutput), + calibFiles = cms.vstring(options.calibFiles), + loopIndex = cms.int32(options.loopIndex), + meanMax = cms.double(options.meanMax), + rmsMax = cms.double(options.rmsMax) + ) +else: + assert "need to provide timing calibration tag from json, slq file or db" + +# process.diamondTimingHarvester.timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration") + + +#CONFIGURE DQM Saver +process.dqmEnv.subSystemFolder = "CalibPPS" +process.dqmSaver.convention = 'Offline' +process.dqmSaver.workflow = f'/AnalyzerWithShiftRolling/DiamondTimingAnalyzer/CMSSW_12_4_6_loop{options.loopIndex}' +process.dqmSaver.dirName = f'./{options.outputDirectoryRoot}/' # TODO: it was commented out - revert the change before merge + +process.path = cms.Path( + process.diamondTimingHarvester +) + +process.end_path = cms.EndPath(process.dqmSaver) + +process.schedule = cms.Schedule( + process.path, + process.end_path +) diff --git a/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_3_based_on_twiki.py b/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_3_based_on_twiki.py new file mode 100644 index 0000000000000..d2a81e5d5dcd0 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_3_based_on_twiki.py @@ -0,0 +1,29 @@ +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_v9', '') + +process.load("CalibPPS.TimingCalibration.ppsTimingCalibrationPCLWorker_cfi") +process.ppsTimingCalibrationPCLWorker.diamondRecHitTags=cms.InputTag("ctppsDiamondRecHits","","PPSTiming2") + +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( + "/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/53746080-d21b-4fdf-9d19-67c6dae347ac.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/b8d3f012-0b59-43b4-adbc-811bcb59c9c4.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/cfa9f82a-5296-49cf-8353-11f8761b675c.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/db3c6c33-9ad0-4d61-9a64-a1aa9578550e.root" + # 'file:LOCAL_FILE_NAME', #local file have to be declared with file prefix + # 'REMOTE_FILE_PATH' #but remote files - for example T2_UK have to be declared without the prefix +)) + +# process.load("EventFilter.CTPPSRawToDigi.ctppsRawToDigi_cff") +# process.load("RecoPPS.Configuration.recoCTPPS_cff") +# + +# process.ctppsDiamondRawToDigi.rawDataTag = cms.InputTag("INSERT_PRODUCT_TAG") + +process.path = cms.Path( + # process.a1* #when running on the streamer files + # process.ctppsRawToDigi * + # process.recoCTPPS * + process.ppsTimingCalibrationPCLWorker +) \ No newline at end of file diff --git a/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_3_based_on_twiki_harvester.py b/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_3_based_on_twiki_harvester.py new file mode 100644 index 0000000000000..11272389d735f --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_3_based_on_twiki_harvester.py @@ -0,0 +1,9 @@ +input_file=['file:LOCAL_FILE_PATH'] #local or remote file path containing worker outputs, for the remote path delete the file prefix, ignored when running with automatic script +run = 357440 #insert run number + +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_v9', '') + +# import FWCore.PythonUtilities.LumiList as LumiList +# process.source.lumisToProcess = LumiList.LumiList(filename = 'INSERT_JSON_MASK').getVLuminosityBlockRange() \ No newline at end of file diff --git a/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_4_diamondDQM_test.py b/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_4_diamondDQM_test.py new file mode 100644 index 0000000000000..b2700bab794a0 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/produceAOD_shift_fromRoot_justShift/reco_cfg_4_diamondDQM_test.py @@ -0,0 +1,145 @@ +import FWCore.ParameterSet.Config as cms +from Configuration.Eras.Era_Run3_cff import Run3 + +process = cms.Process('RECODQM', Run3) + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) +process.verbosity = cms.untracked.PSet( input = cms.untracked.int32(-1) ) + +# minimum of logs +process.MessageLogger = cms.Service("MessageLogger", + cerr = cms.untracked.PSet( + threshold = cms.untracked.string('INFO') + ) +) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +# load DQM framework +process.load("DQM.Integration.config.environment_cfi") +process.dqmEnv.subSystemFolder = "CTPPS" +process.dqmEnv.eventInfoFolder = "EventInfo" +process.dqmSaver.path = "" +process.dqmSaver.tag = "CTPPS" +#process.dqmSaver.runNumber = 999999 + + +# raw data source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring( +#'file:/eos/cms/store/data/Run2022B/AlCaPPS/RAW/v1/000/355/207/00000/c23440f4-49c0-44aa-b8f6-f40598fb4705.root', +#'file:/eos/cms/store/group/dpg_ctpps/comm_ctpps/ALCAPPS-RAW/000/355/988/00000/7728d214-b404-4578-b781-b0c207cfb875.root', +#'/store/data/Run2022D/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v2/000/357/900/00000/0434a2eb-2cea-4d83-8b21-fe91b755e62e.root', +# RUN 440 - "357440": [[1,354]], +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/53746080-d21b-4fdf-9d19-67c6dae347ac.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/b8d3f012-0b59-43b4-adbc-811bcb59c9c4.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/cfa9f82a-5296-49cf-8353-11f8761b675c.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/db3c6c33-9ad0-4d61-9a64-a1aa9578550e.root" ), +) + + + +from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_hlt_relval', '') +process.GlobalTag = GlobalTag(process.GlobalTag, '124X_dataRun3_Prompt_frozen_v4', '') +process.GlobalTag.toGet = cms.VPSet() +process.GlobalTag.toGet.append( + cms.PSet(record = cms.string("PPSTimingCalibrationRcd"), + tag = cms.string("PPSDiamondTimingCalibration_Run3_recovered_v1"), + label = cms.untracked.string('PPSTestCalibration'), + connect = cms.string("frontier://FrontierPrep/CMS_CONDITIONS") + ) +) + + +# raw-to-digi conversion +process.load("EventFilter.CTPPSRawToDigi.ctppsRawToDigi_cff") + +process.ctppsPixelDigis.inputLabel = cms.InputTag("hltPPSCalibrationRaw") +process.ctppsDiamondRawToDigi.rawDataTag = cms.InputTag("hltPPSCalibrationRaw") +process.totemRPRawToDigi.rawDataTag = cms.InputTag("hltPPSCalibrationRaw") +process.totemTimingRawToDigi.rawDataTag = cms.InputTag("hltPPSCalibrationRaw") + + +# local RP reconstruction chain with standard settings +process.load("RecoPPS.Configuration.recoCTPPS_cff") +process.ctppsDiamondRecHits.digiTag=cms.InputTag('ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond') +process.ctppsDiamondRecHits.timingCalibrationTag=cms.string("GlobalTag:PPSTestCalibration") + +#process.load('CondCore.CondDB.CondDB_cfi') +#process.CondDB.connect = 'sqlite_file:ppsDiamondTiming_calibration.sqlite' # SQLite input +#process.PoolDBESSource = cms.ESSource('PoolDBESSource', +# process.CondDB, +# DumpStats = cms.untracked.bool(True), +# toGet = cms.VPSet( +# cms.PSet( +# record = cms.string('PPSTimingCalibrationRcd'), +# tag = cms.string('DiamondTimingCalibration') +# ) +# ) +# ) + +#process.load('Geometry.VeryForwardGeometry.geometryRPFromDD_2021_cfi') +# CTPPS DQM modules +process.load("DQM.CTPPS.ctppsDQM_cff") +process.ctppsDiamondDQMSource.tagDigi=cms.InputTag('ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond') +process.ctppsDiamondDQMSource.tagFEDInfo=cms.InputTag('ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond') +process.ctppsDiamondDQMSource.tagStatus=cms.InputTag('ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond') +process.ctppsDiamondDQMSource.tagPixelLocalTracks=cms.InputTag('ctppsPixelLocalTracksAlCaRecoProducer') +#process.ctppsDiamondDQMSource.excludeMultipleHits = cms.bool(True) +process.ctppsDiamondDQMSource.plotOnline = cms.untracked.bool(True) +process.ctppsDiamondDQMSource.plotOffline = cms.untracked.bool(False) + +process.content = cms.EDAnalyzer("EventContentAnalyzer") + +from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer +process.tdcCalibShiftDQM = DQMEDAnalyzer('TdcCalibShiftDQM') +process.path = cms.Path( + #process.ctppsRawToDigi* + #process.recoCTPPS* + #process.ctppsDQMOnlineSource* + ##process.ctppsDiamondDQMSource* + #process.ctppsDQMOnlineHarvest + #process.tdcCalibShiftDQM + + #process.content* + process.ctppsDiamondRecHits * + process.ctppsDiamondLocalTracks * + #process.ctppsLocalTrackLiteProducer * + #process.ctppsProtons * + process.ctppsDiamondDQMSource* + process.ctppsDQMOnlineHarvest +) + +process.output = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string("file:AOD.root"), + outputCommands = cms.untracked.vstring( + 'drop *', + 'keep *_ctpps*_*_*', + ), +) + + +process.end_path = cms.EndPath( + process.output + + process.dqmEnv + + process.dqmSaver +) + +process.schedule = cms.Schedule( + process.path, + process.end_path +) + +#process.output = cms.OutputModule("PoolOutputModule", +# fileName = cms.untracked.string("AOD.root"), +# outputCommands = cms.untracked.vstring( +# 'drop *', +# 'keep *_ctpps*_*_*', +# ), +#) +#process.outpath = cms.EndPath(process.output) \ No newline at end of file diff --git a/Analyzer/DiamondTimingAnalyzer/temp/reco_cfg.py b/Analyzer/DiamondTimingAnalyzer/temp/reco_cfg.py new file mode 100644 index 0000000000000..4f5726f27d580 --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/reco_cfg.py @@ -0,0 +1,104 @@ +#start with the https://github.com/cms-sw/cmssw/blob/master/RecoPPS/Local/test/diamonds_reco_cfg.py +# 1. start with AOD file +# 2. apply SQL lite +# 3. new AOD with shift?? -> check produce DQM files + + +import FWCore.ParameterSet.Config as cms +from FWCore.ParameterSet.VarParsing import VarParsing + +process = cms.Process('Shift') + +options = VarParsing ('analysis') +options.register('sqlFileName', + 'sqlite_file:/afs/cern.ch/user/m/mobrzut/public/timing_sqlcalib/ppsDiamondTiming_calibration357440.sqlite', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('maxEventsToProcess', + 10000, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + 'maxEvents to process' +) + + + +options.parseArguments() + + + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + + +#load GT: +from Configuration.AlCa.GlobalTag import GlobalTag +# 2022 prompt: to be updated +process.GlobalTag = GlobalTag(process.GlobalTag, "124X_dataRun3_v9") + +#load condDB +process.load('CondCore.CondDB.CondDB_cfi') +process.CondDB.connect = options.sqlFileName +process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), # todo added by Chrys + + ) + ) +) + +process.source = cms.Source ("PoolSource", + fileNames = cms.untracked.vstring( +# RUN 440 - "357440": [[1,354]], +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/53746080-d21b-4fdf-9d19-67c6dae347ac.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/b8d3f012-0b59-43b4-adbc-811bcb59c9c4.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/cfa9f82a-5296-49cf-8353-11f8761b675c.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/db3c6c33-9ad0-4d61-9a64-a1aa9578550e.root" +) +) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(options.maxEventsToProcess) +) + +process.MessageLogger.cerr.FwkReport.reportEvery = cms.untracked.int32( 1000 ) + + + +# local RP reconstruction chain with standard settings +process.load("RecoPPS.Configuration.recoCTPPS_cff") + +# rechits production +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * # TODO it looks like it can be deleted +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file + +process.load('RecoPPS.Local.ctppsDiamondRecHits_cfi') + +# local tracks fitter +process.load('RecoPPS.Local.ctppsDiamondLocalTracks_cfi') + +process.output = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string("file:AOD.root"), + outputCommands = cms.untracked.vstring( + 'drop *', + 'keep *_ctpps*_*_*', + ), +) + +# execution configuration +process.p = cms.Path( + process.ctppsDiamondLocalReconstruction +) + +process.outpath = cms.EndPath(process.output) \ No newline at end of file diff --git a/Analyzer/DiamondTimingAnalyzer/temp/reco_cfg_2.py b/Analyzer/DiamondTimingAnalyzer/temp/reco_cfg_2.py new file mode 100644 index 0000000000000..f87f39a11873c --- /dev/null +++ b/Analyzer/DiamondTimingAnalyzer/temp/reco_cfg_2.py @@ -0,0 +1,141 @@ +#start with the https://github.com/cms-sw/cmssw/blob/master/RecoPPS/Local/test/diamonds_reco_cfg.py +# 1. start with AOD file +# 2. apply SQL lite +# 3. new AOD with shift?? -> check produce DQM files + + +import FWCore.ParameterSet.Config as cms +from FWCore.ParameterSet.VarParsing import VarParsing + +process = cms.Process('Shift') + +options = VarParsing ('analysis') +options.register('sqlFileName', + 'sqlite_file:/afs/cern.ch/user/m/mobrzut/public/timing_sqlcalib/ppsDiamondTiming_calibration357440.sqlite', + VarParsing.multiplicity.singleton, + VarParsing.varType.string, + 'sqlFileNameForCalib' +) + +options.register('maxEventsToProcess', + 10000, + VarParsing.multiplicity.singleton, + VarParsing.varType.int, + 'maxEvents to process' +) + + + +options.parseArguments() + + + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + + +#load GT: +from Configuration.AlCa.GlobalTag import GlobalTag +# 2022 prompt: to be updated +process.GlobalTag = GlobalTag(process.GlobalTag, "124X_dataRun3_v9") + +#load condDB +process.load('CondCore.CondDB.CondDB_cfi') +process.CondDB.connect = options.sqlFileName +process.PoolDBESSource = cms.ESSource('PoolDBESSource', + process.CondDB, + DumpStats = cms.untracked.bool(True), + toGet = cms.VPSet( + cms.PSet( + record = cms.string('PPSTimingCalibrationRcd'), + tag = cms.string('DiamondTimingCalibration'), + label = cms.untracked.string('PPSTestCalibration'), # todo added by Chrys + + ) + ) +) + +process.source = cms.Source ("PoolSource", + fileNames = cms.untracked.vstring( +# RUN 440 - "357440": [[1,354]], +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/53746080-d21b-4fdf-9d19-67c6dae347ac.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/b8d3f012-0b59-43b4-adbc-811bcb59c9c4.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/cfa9f82a-5296-49cf-8353-11f8761b675c.root", +"/store/data/Run2022C/AlCaPPSPrompt/ALCARECO/PPSCalMaxTracks-PromptReco-v1/000/357/440/00000/db3c6c33-9ad0-4d61-9a64-a1aa9578550e.root" +), +) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(options.maxEventsToProcess) +) + +process.MessageLogger.cerr.FwkReport.reportEvery = cms.untracked.int32( 1000 ) + + + +# local RP reconstruction chain with standard settings +process.load("RecoPPS.Configuration.recoCTPPS_cff") + +# rechits production +from Geometry.VeryForwardGeometry.geometryRPFromDB_cfi import * # TODO it looks like it can be deleted +process.load('Geometry.VeryForwardGeometry.geometryRPFromDB_cfi') #TODO: use geometry form DB not from file + +process.load('RecoPPS.Local.ctppsDiamondRecHits_cfi') + +# local tracks fitter +process.load('RecoPPS.Local.ctppsDiamondLocalTracks_cfi') + + +process.ctppsDiamondLocalTracks.recHitsTag = cms.InputTag("ctppsDiamondRecHits","","Shift") +process.ctppsLocalTrackLiteProducer.tagDiamondTrack = cms.InputTag("ctppsDiamondLocalTracks","","Shift") +process.ctppsProtons.tagLocalTrackLite = cms.InputTag("ctppsLocalTrackLiteProducer","","Shift") +process.ctppsLocalTrackLiteProducer.includeDiamonds = cms.bool(True) +process.ctppsLocalTrackLiteProducer.tagPixelTrack = cms.InputTag("ctppsPixelLocalTracksAlCaRecoProducer") +process.ctppsLocalTrackLiteProducer.includePixels = cms.bool(True) +process.ctppsDiamondRecHits.timingCalibrationTag=cms.string("PoolDBESSource:PPSTestCalibration") +process.ctppsDiamondRecHits.digiTag= cms.InputTag("ctppsDiamondRawToDigiAlCaRecoProducer:TimingDiamond") + + +# process.output = cms.OutputModule("PoolOutputModule", +# fileName = cms.untracked.string("file:AOD.root"), +# outputCommands = cms.untracked.vstring( +# 'drop *', +# 'keep *_ctpps*_*_*', +# ), +# ) + +# DQM DQM DQM DQM +process.load("DQM.Integration.config.environment_cfi") +process.dqmEnv.eventInfoFolder = "EventInfo" +process.dqmSaver.path = "" +process.dqmSaver.tag = "CTPPS" +process.load("DQMServices.Core.DQMStore_cfi") +process.load("DQMServices.Components.DQMEnvironment_cfi") +process.dqmEnv.subSystemFolder = "CalibPPS" +process.dqmSaver.convention = 'Offline' +process.dqmSaver.workflow = "/CalibPPS/TimingCalibration/CMSSW_12_0_0_pre2" +# process.dqmSaver.saveByRun = -1 +process.dqmSaver.saveAtJobEnd = True + + +process.dqmOutput = cms.OutputModule("DQMRootOutputModule", + fileName = cms.untracked.string('AOD_DQM.root') +) + +process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.end_path = cms.EndPath( process.dqmEnv + process.dqmSaver ) + +# execution configuration +process.p = cms.Path( + # process.ctppsDiamondRecHits * + # process.ctppsDiamondLocalTracks + process.ctppsDiamondLocalReconstruction + +) + +# process.outpath = cms.EndPath(process.output) + +process.schedule = cms.Schedule(process.p, process.end_path)