10Airflow script for automatic CDC dEdx calibration. It is the electron based
11calibration, where at present only RunGain, injection time, Cosine, WireGain and 1D are implemented.
12The remaining two 2D will be implemented in the near future.
16from ROOT
import gSystem
17from ROOT.Belle2
import CDCDedxRunGainAlgorithm, CDCDedxCosineAlgorithm, CDCDedxWireGainAlgorithm
18from ROOT.Belle2
import CDCDedxCosEdgeAlgorithm, CDCDedxBadWireAlgorithm, CDCDedxInjectTimeAlgorithm
19from ROOT.Belle2
import CDCDedx1DCellAlgorithm, CDCDedxValidationAlgorithm
21from caf.framework
import Calibration
22from caf.strategies
import SequentialRunByRun, SequentialBoundaries
23from prompt
import CalibrationSettings, INPUT_DATA_FILTERS
24import reconstruction
as recon
25from random
import seed
28gSystem.Load(
'libreconstruction.so')
29ROOT.gROOT.SetBatch(
True)
31settings = CalibrationSettings(
33 expert_username=
"renu92garg",
36 input_data_formats=[
"cdst"],
37 input_data_names=[
"bhabha_all_calib"],
39 "payload_boundaries": [],
40 "calib_datamode":
False,
44 "adjustment": 1.00798,
46 "calibration_procedure": {
"rungain0": 0,
"rungain1": 0,
"rungain2": 0}
50 INPUT_DATA_FILTERS[
'Run Type'][
'physics'],
51 INPUT_DATA_FILTERS[
'Data Tag'][
'bhabha_all_calib'],
52 INPUT_DATA_FILTERS[
'Data Quality Tag'][
'Good Or Recoverable'],
53 INPUT_DATA_FILTERS[
'Magnet'][
'On'],
54 INPUT_DATA_FILTERS[
'Beam Energy'][
'4S'],
55 INPUT_DATA_FILTERS[
'Beam Energy'][
'Continuum'],
56 INPUT_DATA_FILTERS[
'Beam Energy'][
'Scan']]},
58 produced_payloads=[
"CDCDedxInjectionTime",
"CDCDedxCosineEdge",
"CDCDedxBadWires",
59 "CDCDedxWireGain",
"CDCDedx1DCell",
"CDCDedxCosineCor",
"CDCDedxRunGain"])
62def get_calibrations(input_data, **kwargs):
63 """ REQUIRED FUNCTION used by b2caf-prompt-run tool
64 This function return a list of Calibration
65 objects we assign to the CAF process
69 file_to_iov_physics = input_data[
"bhabha_all_calib"]
71 expert_config = kwargs.get(
"expert_config")
72 calib_mode = expert_config[
"calib_mode"]
75 fulldataMode = expert_config[
"calib_datamode"]
76 adjustment = expert_config[
"adjustment"]
79 input_files_rungain = list(file_to_iov_physics.keys())
80 input_files_coscorr = list(file_to_iov_physics.keys())
81 input_files_wiregain = list(file_to_iov_physics.keys())
85 maxevt_rg = expert_config[
"maxevt_rg"]
86 maxevt_cc = expert_config[
"maxevt_cc"]
87 maxevt_wg = expert_config[
"maxevt_wg"]
89 from prompt.utils import filter_by_max_events_per_run, filter_by_select_max_events_from_files
92 max_files_for_maxevents = maxevt_rg
93 reduced_file_to_iov_rungain = filter_by_max_events_per_run(file_to_iov_physics, max_files_for_maxevents,
True)
94 input_files_rungain = list(reduced_file_to_iov_rungain.keys())
95 basf2.B2INFO(f
"Total number of files used for rungains = {len(input_files_rungain)}")
98 input_files_coscorr = filter_by_select_max_events_from_files(list(file_to_iov_physics.keys()), maxevt_cc)
99 basf2.B2INFO(f
"Total number of files used for cosine = {len(input_files_coscorr)}")
100 if not input_files_coscorr:
102 f
"Cosine: all requested ({maxevt_cc}) events not found")
105 if maxevt_wg == maxevt_cc:
106 input_files_wiregain = input_files_coscorr
108 input_files_wiregain = filter_by_select_max_events_from_files(list(file_to_iov_physics.keys()), maxevt_wg)
110 basf2.B2INFO(f
"Total number of files used for wiregains = {len(input_files_wiregain)}")
111 if not input_files_wiregain:
113 f
"WireGain: all requested ({maxevt_wg}) events not found")
115 requested_iov = kwargs.get(
"requested_iov",
None)
116 from caf.utils
import ExpRun, IoV
117 output_iov = IoV(requested_iov.exp_low, requested_iov.run_low, -1, -1)
119 payload_boundaries = [ExpRun(output_iov.exp_low, output_iov.run_low)]
120 payload_boundaries.extend([ExpRun(*boundary)
for boundary
in expert_config[
"payload_boundaries"]])
121 basf2.B2INFO(f
"Expert set payload boundaries are: {expert_config['payload_boundaries']}")
123 collector_granularity =
'all'
124 if expert_config[
"payload_boundaries"]
is not None:
125 basf2.B2INFO(
'Found payload_boundaries: set collector granularity to run')
126 collector_granularity =
'run'
128 if calib_mode ==
"full":
129 calibration_procedure = {
143 elif calib_mode ==
"quick":
144 calibration_procedure = {
155 elif calib_mode ==
"manual":
156 calibration_procedure = expert_config[
"calibration_procedure"]
158 basf2.B2FATAL(f
"Calibration mode is not defined {calib_mode}, should be full, quick, or manual")
160 calib_keys = list(calibration_procedure)
161 cals = [
None]*len(calib_keys)
162 basf2.B2INFO(f
"Run calibration mode = {calib_mode}:")
164 for i
in range(len(cals)):
165 max_iter = calibration_procedure[calib_keys[i]]
167 data_files = [input_files_rungain, input_files_coscorr, input_files_wiregain]
168 cal_name =
''.join([i
for i
in calib_keys[i]
if not i.isdigit()])
169 if cal_name ==
"rungain":
170 alg = [rungain_algo(calib_keys[i], adjustment)]
171 elif cal_name ==
"coscorr":
173 elif cal_name ==
"cosedge":
174 alg = [cosedge_algo()]
175 elif cal_name ==
"timegain":
176 alg = [injection_time_algo()]
177 elif cal_name ==
"badwire":
178 alg = [badwire_algo()]
179 elif cal_name ==
"wiregain":
180 alg = [wiregain_algo()]
181 elif cal_name ==
"onedcell":
182 alg = [onedcell_algo()]
183 elif cal_name ==
"validation":
184 alg = [validation_algo()]
186 basf2.B2FATAL(f
"The calibration is not defined, check spelling: calib {i}: {calib_keys[i]}")
188 basf2.B2INFO(f
"calibration for {calib_keys[i]} with number of iteration={max_iter}")
190 cals[i] = CDCDedxCalibration(name=calib_keys[i],
192 input_file_dict=data_files,
193 max_iterations=max_iter,
194 collector_granularity=collector_granularity,
195 dependencies=[cals[i-1]]
if i > 0
else None
197 if payload_boundaries:
198 basf2.B2INFO(
"Found payload_boundaries: calibration strategies set to SequentialBoundaries.")
199 if cal_name ==
"rungain" or cal_name ==
"timegain":
200 cals[i].strategies = SequentialRunByRun
201 for algorithm
in cals[i].algorithms:
202 algorithm.params = {
"iov_coverage": output_iov}
203 if calib_keys[i] ==
"rungain0" or calib_keys[i] ==
"rungain1" or calib_keys[i] ==
"timegain0":
204 cals[i].save_payloads =
False
206 cals[i].strategies = SequentialBoundaries
207 for algorithm
in cals[i].algorithms:
208 algorithm.params = {
"iov_coverage": output_iov,
"payload_boundaries": payload_boundaries}
209 if calib_keys[i] ==
"coscorr0":
210 cals[i].save_payloads =
False
213 for algorithm
in cals[i].algorithms:
214 algorithm.params = {
"apply_iov": output_iov}
220def pre_collector(name='rg'):
222 Define pre collection.
224 name : name of the calibration
225 rungain rungain0 by Default.
227 path : path for pre collection
230 reco_path = basf2.create_path()
231 recon.prepare_cdst_analysis(path=reco_path)
232 if (name ==
"validation"):
233 basf2.B2INFO(
"no trigger skim")
234 elif (name ==
"timegain" or name ==
"onedcell"):
235 trg_bhabhaskim = reco_path.add_module(
"TriggerSkim", triggerLines=[
"software_trigger_cut&skim&accept_radee"])
236 trg_bhabhaskim.if_value(
"==0", basf2.Path(), basf2.AfterConditionPath.END)
237 ps_bhabhaskim = reco_path.add_module(
"Prescale", prescale=0.80)
238 ps_bhabhaskim.if_value(
"==0", basf2.Path(), basf2.AfterConditionPath.END)
240 elif (name ==
"cosedge"):
241 trg_bhabhaskim = reco_path.add_module(
244 "software_trigger_cut&skim&accept_bhabha",
245 "software_trigger_cut&filter&ee_flat_90_180",
246 "software_trigger_cut&filter&ee_flat_0_19"])
247 trg_bhabhaskim.if_value(
"==0", basf2.Path(), basf2.AfterConditionPath.END)
249 trg_bhabhaskim = reco_path.add_module(
"TriggerSkim", triggerLines=[
"software_trigger_cut&skim&accept_bhabha"])
250 trg_bhabhaskim.if_value(
"==0", basf2.Path(), basf2.AfterConditionPath.END)
252 reco_path.add_module(
254 relativeCorrections=
False,
267def collector(granularity='all', name=''):
269 Create a cdcdedx calibration collector
271 name : name of calibration
272 granularity : granularity : all or run
274 collector : collector module
277 from basf2
import register_module
278 if name ==
"validation":
279 col = register_module(
'ElectronValCollector', cleanupCuts=
True)
283 col = register_module(
'CDCDedxElectronCollector', cleanupCuts=
True)
284 if name ==
"timegain":
285 CollParam = {
'isRun':
True,
'isInjTime':
True,
'granularity':
'run'}
287 elif name ==
"coscorr" or name ==
"cosedge":
288 CollParam = {
'isCharge':
True,
'isCosth':
True,
'granularity': granularity}
290 elif name ==
"badwire":
292 CollParam = {
'isWire':
True,
'isDedxhit': isHit,
'isADCcorr':
not isHit,
'granularity': granularity}
294 elif name ==
"wiregain":
295 CollParam = {
'isWire':
True,
'isDedxhit':
True,
'granularity': granularity}
297 elif name ==
"onedcell":
304 'granularity': granularity}
307 CollParam = {
'isRun':
True,
'granularity':
'run'}
315def rungain_algo(name, adjustment):
317 Create a rungain calibration algorithm.
319 algo : rungain algorithm
321 algo = CDCDedxRunGainAlgorithm()
322 algo.setMonitoringPlots(
True)
323 if name ==
"rungain2":
324 algo.setAdjustment(adjustment)
330def injection_time_algo():
332 Create a injection time calibration algorithm.
334 algo : injection time algorithm
336 algo = CDCDedxInjectTimeAlgorithm()
337 algo.setMonitoringPlots(
True)
345 Create a cosine calibration algorithm.
347 algo : cosine algorithm
349 algo = CDCDedxCosineAlgorithm()
350 algo.setMonitoringPlots(
True)
358 Create a cosine edge calibration algorithm.
360 algo : cosine edge algorithm
362 algo = CDCDedxCosEdgeAlgorithm()
363 algo.setMonitoringPlots(
True)
371 Create a badwire calibration algorithm.
373 algo : badwire algorithm
375 algo = CDCDedxBadWireAlgorithm()
377 algo.setHighFracThres(0.2)
378 algo.setMeanThres(0.4)
379 algo.setRMSThres(0.4)
380 algo.setHistPars(150, 0, 5)
381 algo.setMonitoringPlots(
True)
389 Create a wire gain calibration algorithm.
391 algo : wiregain algorithm
393 algo = CDCDedxWireGainAlgorithm()
394 algo.enableExtraPlots(
True)
400 Create oned cell calibration algorithm.
402 algo : oned cell correction algorithm
404 algo = CDCDedx1DCellAlgorithm()
405 algo.enableExtraPlots(
True)
406 algo.setMergePayload(
True)
410def validation_algo():
412 Create validation algorithm
414 algo : validation algorithm
416 algo = CDCDedxValidationAlgorithm()
422 CDCDedxCalibration is a specialized calibration for cdcdedx.
431 collector_granularity='All'):
434 name: name of calibration
435 algorithms: algorithm of calibration
436 input_file_dict: input files list
437 max_iterations: maximum number of iterations
438 dependencies: depends on the previous calibration
439 collector_granularity: granularity : all or run
442 algorithms=algorithms
445 from caf.framework
import Collection
446 cal_name =
''.join([i
for i
in name
if not i.isdigit()])
447 if cal_name ==
"badwire" or cal_name ==
"wiregain":
448 collection =
Collection(collector=
collector(granularity=collector_granularity, name=cal_name),
449 input_files=input_file_dict[2],
450 pre_collector_path=pre_collector(cal_name)
452 elif cal_name ==
"coscorr" or cal_name ==
"cosedge" or cal_name ==
"onedcell":
453 collection =
Collection(collector=
collector(granularity=collector_granularity, name=cal_name),
454 input_files=input_file_dict[1],
455 pre_collector_path=pre_collector(cal_name)
458 collection =
Collection(collector=
collector(granularity=collector_granularity, name=cal_name),
459 input_files=input_file_dict[0],
460 pre_collector_path=pre_collector(cal_name)
462 self.add_collection(name=cal_name, collection=collection)
467 if dependencies
is not None:
468 for dep
in dependencies:
__init__(self, name, algorithms, input_file_dict, max_iterations=5, dependencies=None, collector_granularity='All')
max_iterations
maximum iterations