42 set_log_level(LogLevel.INFO)
48 ROOT.gROOT.SetBatch(
True)
50 from ROOT.Belle2
import PXDGainCalibrationAlgorithm
51 from ROOT.Belle2
import PXDChargeCalibrationAlgorithm
52 from ROOT.Belle2
import PXDHotPixelMaskCalibrationAlgorithm
53 from caf.framework
import Calibration, CAF
54 from caf
import backends
55 from caf.backends
import LSF
56 from caf.utils
import ExpRun, IoV
57 from caf.utils
import get_iov_from_file
58 from caf.utils
import find_absolute_file_paths
59 from caf.strategies
import SequentialRunByRun, SingleIOV, SimpleRunByRun
62 parser = argparse.ArgumentParser(description=
"Compute gain correction maps for PXD from beam data")
63 parser.add_argument(
'--runLow', default=0, type=int, help=
'Compute mask for specific IoV')
64 parser.add_argument(
'--runHigh', default=-1, type=int, help=
'Compute mask for specific IoV')
65 parser.add_argument(
'--expNo', default=3, type=int, help=
'Compute mask for specific IoV')
66 parser.add_argument(
'--maxSubRuns', default=20, type=int, help=
'Maximum number of subruns to use')
67 args = parser.parse_args()
71 pxd_ignore_run_list = [ExpRun(3, 484), ExpRun(3, 485), ExpRun(3, 486), ExpRun(3, 524)]
74 iov_to_calibrate = IoV(exp_low=args.expNo, run_low=args.runLow, exp_high=args.expNo, run_high=args.runHigh)
78 with open(
"file_iov_map.pkl",
'br')
as map_file:
79 files_to_iovs = pickle.load(map_file)
84 input_file_iov_set = set(files_to_iovs.values())
85 for file_iov
in input_file_iov_set:
86 if iov_to_calibrate.contains(file_iov):
87 subruns = [k
for k, v
in files_to_iovs.items()
if v == file_iov]
88 input_files.extend(subruns[:args.maxSubRuns])
90 print(
'Number selected input files: {}'.format(len(input_files)))
94 with open(
"mc_file_iov_map.pkl",
'br')
as map_file:
95 mc_files_to_iovs = pickle.load(map_file)
97 mc_input_files = list(mc_files_to_iovs.keys())
100 print(
'Number selected mc input files: {}'.format(len(mc_input_files)))
106 hotpixel_collector = register_module(
"PXDRawHotPixelMaskCollector")
107 hotpixel_collector.param(
"granularity",
"run")
110 pre_hotpixel_collector_path = create_path()
111 pre_hotpixel_collector_path.add_module(
"Gearbox", fileName=
'geometry/Beast2_phase2.xml')
112 pre_hotpixel_collector_path.add_module(
"Geometry", useDB=
False)
113 pre_hotpixel_collector_path.add_module(
'PXDUnpacker')
114 pre_hotpixel_collector_path.add_module(
'PXDPostErrorChecker')
115 pre_hotpixel_collector_path.add_module(
'Progress')
117 hotpixel_algo = PXDHotPixelMaskCalibrationAlgorithm()
120 hotpixel_algo.forceContinueMasking =
False
121 hotpixel_algo.minEvents = 10000
122 hotpixel_algo.minHits = 15
123 hotpixel_algo.pixelMultiplier = 7
124 hotpixel_algo.maskDrains =
True
125 hotpixel_algo.drainMultiplier = 7
126 hotpixel_algo.maskRows =
True
127 hotpixel_algo.rowMultiplier = 7
130 hotpixel_algo.setPrefix(
"PXDRawHotPixelMaskCollector")
134 name=
"PXDHotPixelMaskCalibrationAlgorithm",
135 collector=hotpixel_collector,
136 algorithms=hotpixel_algo,
137 input_files=input_files)
138 hotpixel_cal.pre_collector_path = pre_hotpixel_collector_path
141 hotpixel_cal.files_to_iovs = files_to_iovs
144 hotpixel_cal.strategies = SequentialRunByRun
145 hotpixel_cal.max_files_per_collector_job = 1
146 hotpixel_cal.use_central_database(
"Calibration_Offline_Development")
148 hotpixel_cal.ignored_runs = pxd_ignore_run_list
149 hotpixel_cal.algorithms[0].params[
"iov_coverage"] = iov_to_calibrate
156 charge_collector = register_module(
"PXDClusterChargeCollector")
157 charge_collector.param(
"granularity",
"run")
158 charge_collector.param(
"minClusterCharge", 8)
159 charge_collector.param(
"minClusterSize", 2)
160 charge_collector.param(
"maxClusterSize", 6)
161 charge_collector.param(
"nBinsU", 4)
162 charge_collector.param(
"nBinsV", 6)
166 pre_charge_collector_path = create_path()
167 pre_charge_collector_path.add_module(
"Gearbox", fileName=
'geometry/Beast2_phase2.xml')
168 pre_charge_collector_path.add_module(
"Geometry", useDB=
False)
169 pre_charge_collector_path.add_module(
"ActivatePXDPixelMasker")
170 pre_charge_collector_path.add_module(
"PXDUnpacker")
171 pre_charge_collector_path.add_module(
'PXDPostErrorChecker')
172 pre_charge_collector_path.add_module(
"PXDRawHitSorter")
173 pre_charge_collector_path.add_module(
"PXDClusterizer")
176 landau_algo = PXDChargeCalibrationAlgorithm()
179 landau_algo.minClusters = 5000
180 landau_algo.noiseSigma = 0.6
181 landau_algo.forceContinue =
False
182 landau_algo.strategy = 1
184 landau_algo.setPrefix(
"PXDClusterChargeCollector")
188 name=
"PXDChargeCalibrationAlgorithm",
189 collector=charge_collector,
190 algorithms=landau_algo,
191 input_files=input_files)
193 charge_cal.pre_collector_path = pre_charge_collector_path
196 charge_cal.files_to_iovs = files_to_iovs
199 charge_cal.strategies = SequentialRunByRun
200 charge_cal.max_files_per_collector_job = 1
202 charge_cal.algorithms[0].params[
"iov_coverage"] = iov_to_calibrate
203 charge_cal.ignored_runs = pxd_ignore_run_list
205 charge_cal.use_central_database(
"Calibration_Offline_Development")
210 gain_collector = register_module(
"PXDClusterChargeCollector")
211 gain_collector.param(
"granularity",
"run")
212 gain_collector.param(
"minClusterCharge", 8)
213 gain_collector.param(
"minClusterSize", 2)
214 gain_collector.param(
"maxClusterSize", 6)
215 gain_collector.param(
"nBinsU", 4)
216 gain_collector.param(
"nBinsV", 6)
219 pre_gain_collector_path = create_path()
220 pre_gain_collector_path.add_module(
"Gearbox", fileName=
'geometry/Beast2_phase2.xml')
221 pre_gain_collector_path.add_module(
"Geometry", useDB=
False)
222 pre_gain_collector_path.add_module(
"PXDDigitizer")
223 pre_gain_collector_path.add_module(
"PXDClusterizer")
227 gain_algo = PXDGainCalibrationAlgorithm()
230 gain_algo.minClusters = 3000
231 gain_algo.noiseSigma = 0.6
232 gain_algo.forceContinue =
False
233 gain_algo.strategy = 1
235 gain_algo.setPrefix(
"PXDClusterChargeCollector")
239 name=
"PXDGainCalibrationAlgorithm",
240 collector=gain_collector,
241 algorithms=gain_algo,
242 input_files=mc_input_files)
244 gain_cal.pre_collector_path = pre_gain_collector_path
247 gain_cal.files_to_iovs = mc_files_to_iovs
250 gain_cal.strategies = SequentialRunByRun
251 gain_cal.max_files_per_collector_job = 1
253 gain_cal.algorithms[0].params[
"iov_coverage"] = iov_to_calibrate
254 gain_cal.ignored_runs = pxd_ignore_run_list
256 gain_cal.use_central_database(
"Calibration_Offline_Development")
262 charge_cal.depends_on(hotpixel_cal)
263 gain_cal.depends_on(charge_cal)
267 cal_fw.add_calibration(hotpixel_cal)
268 cal_fw.add_calibration(charge_cal)
269 cal_fw.add_calibration(gain_cal)
271 cal_fw.backend = LSF()
272 cal_fw.output_dir =
'pxd_calibration_results_range_{}_{}_{}'.format(args.runLow, args.runHigh, args.expNo)
273 cal_fw.run(iov=iov_to_calibrate)