74 set_log_level(LogLevel.INFO)
81 from ROOT.Belle2
import PXDDataMCGainCalibrationAlgorithm
82 from caf.framework
import Calibration, CAF
83 from caf
import backends
84 from caf.backends
import LSF
85 from caf.utils
import ExpRun, IoV
86 from caf.utils
import get_iov_from_file
87 from caf.utils
import find_absolute_file_paths
88 from caf.utils
import LocalDatabase
89 from caf.utils
import CentralDatabase
90 from caf.strategies
import SequentialRunByRun, SingleIOV, SimpleRunByRun
91 from rawdata
import add_unpackers
92 from tracking
import add_tracking_reconstruction
95 parser = argparse.ArgumentParser(description=
"Compute gain correction maps for PXD from beam data")
96 parser.add_argument(
'--runLow', default=0, type=int, help=
'Compute mask for specific IoV')
97 parser.add_argument(
'--runHigh', default=-1, type=int, help=
'Compute mask for specific IoV')
98 parser.add_argument(
'--expNo', default=3, type=int, help=
'Compute mask for specific IoV')
99 parser.add_argument(
'--maxSubRuns', default=-1, type=int, help=
'Maximum number of subruns to use')
100 parser.add_argument(
'--localDB', default=
"", type=str, help=
'path to local DB database.txt')
101 parser.add_argument(
'--ignoreRuns', default=
"DefaultFromKEKCC", type=str,
102 help=
'Full paths to list of runs to ignore, separate multiple by a comma , ')
103 parser.add_argument(
'--mcOnly', dest=
'mcOnly', action=
"store_true",
104 help=
'Run charge calibration for MC only, otherwise specify --dataOnly \
105 or run the full gain calibration on data using MC charge from DB')
106 parser.add_argument(
'--dataOnly', dest=
'dataOnly', action=
"store_true",
107 help=
'Run charge calibration for Data only, otherwise specify --mcOnly \
108 or run the full gain calibration on data using MC charge from DB')
109 parser.add_argument(
'--useTrackClusters', default=0, type=int,
110 help=
'Flag to use track matched clusters (=1) and apply theta angle projection to cluster charge (=2)')
112 args = parser.parse_args()
114 ROOT.gROOT.SetBatch(
True)
121 iov_to_calibrate = IoV(exp_low=args.expNo, run_low=args.runLow, exp_high=args.expNo, run_high=args.runHigh)
124 pxd_ignore_run_list = []
128 with open(
"mc_file_iov_map.pkl",
'br')
as map_file:
129 files_to_iovs = pickle.load(map_file)
130 input_files = list(files_to_iovs.keys())
131 print(
'Number selected mc input files: {}'.format(len(input_files)))
136 pxd_ignore_run_list = [ExpRun(3, 484), ExpRun(3, 485), ExpRun(3, 486), ExpRun(3, 524),
143 ignoreRuns = args.ignoreRuns
144 if "DefaultFromKEKCC" in ignoreRuns:
145 dirkekcc =
"/hsm/belle2/bdata/Data/Raw/e000{}/".format(args.expNo)
146 ignoreRuns = dirkekcc +
"RunListBeam," + dirkekcc +
"RunListCosmic"
148 for flist
in ignoreRuns.split(
","):
149 fignore = open(flist,
'r')
150 line = fignore.readline()
152 run = line[0:line.find(
',')]
153 pxd_ignore_run_list.append(ExpRun(args.expNo, int(run)))
154 line = fignore.readline()
157 print(
'List of ignored runs')
158 print(pxd_ignore_run_list)
161 with open(
"file_iov_map.pkl",
'br')
as map_file:
162 files_to_iovs = pickle.load(map_file)
164 input_file_iov_set = set(files_to_iovs.values())
165 for file_iov
in input_file_iov_set:
166 if iov_to_calibrate.contains(file_iov):
167 subruns = [k
for k, v
in files_to_iovs.items()
if v == file_iov]
168 input_files.extend(subruns[:args.maxSubRuns])
170 print(
'Number selected data input files: {}'.format(len(input_files)))
179 charge_collector = register_module(
"PXDClusterChargeCollector")
180 charge_collector.param(
"granularity",
"run")
181 charge_collector.param(
"minClusterCharge", 8)
182 charge_collector.param(
"minClusterSize", 2)
183 charge_collector.param(
"maxClusterSize", 6)
184 charge_collector.param(
"nBinsU", 4)
185 charge_collector.param(
"nBinsV", 6)
187 if not args.mcOnly
and not args.dataOnly:
188 charge_collector.param(
"chargePayloadName",
"PXDMCClusterChargeMapPar")
189 charge_collector.param(
"fillChargeHistogram",
True)
190 charge_collector.param(
"matchTrack", args.useTrackClusters)
194 pre_charge_collector_path = create_path()
195 pre_charge_collector_path.add_module(
"Gearbox")
196 pre_charge_collector_path.add_module(
"Geometry")
198 pre_charge_collector_path.add_module(
"PXDDigitizer")
199 if args.useTrackClusters:
200 add_tracking_reconstruction(pre_charge_collector_path)
202 pre_charge_collector_path.add_module(
"PXDClusterizer")
204 if args.useTrackClusters:
205 add_unpackers(pre_charge_collector_path, [
'PXD',
'SVD',
'CDC'])
206 add_tracking_reconstruction(pre_charge_collector_path)
208 add_unpackers(pre_charge_collector_path, [
'PXD'])
209 pre_charge_collector_path.add_module(
"PXDClusterizer")
211 for module
in pre_charge_collector_path.modules():
212 if module.name() ==
'Geeometry':
213 module.param(
'excludedComponents', [
'ECL',
'KLM',
'TOP'])
214 if module.name() ==
'PXDUnpacker':
215 module.param(
'SuppressErrorMask', 0xffffffff)
216 if module.name() ==
'PXDPostErrorChecker':
217 module.param(
'CriticalErrorMask', 0)
223 datamc_algo = PXDDataMCGainCalibrationAlgorithm()
226 datamc_algo.minClusters = 5000
227 datamc_algo.noiseSigma = 0.0
228 datamc_algo.forceContinue =
False
229 datamc_algo.strategy = 0
230 if args.mcOnly
or args.dataOnly:
231 datamc_algo.doCalibration =
False
233 datamc_algo.chargePayloadName =
"PXDMCClusterChargeMapPar"
235 datamc_algo.chargePayloadName =
"PXDClusterChargeMapPar"
237 datamc_algo.doCalibration =
True
238 datamc_algo.useChargeHistogram =
True
240 datamc_algo.setPrefix(
"PXDClusterChargeCollector")
244 name=
"PXDDataMCGainCalibrationAlgorithm",
245 collector=charge_collector,
246 algorithms=datamc_algo,
247 input_files=input_files,
248 pre_collector_path=pre_charge_collector_path,
249 database_chain=[CentralDatabase(
"data_reprocessing_prompt"), CentralDatabase(
"pxd_calibration"), LocalDatabase(args.localDB)]
253 charge_cal.files_to_iovs = files_to_iovs
256 charge_cal.strategies = SequentialRunByRun
257 charge_cal.max_files_per_collector_job = 1
259 charge_cal.algorithms[0].params[
"iov_coverage"] = iov_to_calibrate
260 charge_cal.ignored_runs = pxd_ignore_run_list
268 cal_fw.add_calibration(charge_cal)
269 cal_fw.backend = LSF()
271 cal_fw.output_dir =
'pxd_calibration_results_e{}_range_{}_{}'.format(args.expNo, args.runLow, args.runHigh)
272 cal_fw.run(iov=iov_to_calibrate)