Belle II Software  release-06-02-00
caf_cdcdedx.py
1 # -*- coding: utf-8 -*-
2 
3 
10 
11 """
12 Airflow script for automatic CDC dEdx calibration. It is currently for the electron based
13 calibration, where at present only RunGain, Cosine and WireGain are implimented. The remaining
14 two 2D and 1D will be implimented in the near future.
15 
16 Second part called "Hadron calibration" are not compitable with CAF/AirFlow
17 and will be done offline for a while.
18 """
19 
20 import ROOT
21 from ROOT import gSystem
22 from ROOT.Belle2 import CDCDedxRunGainAlgorithm, CDCDedxCosineAlgorithm, CDCDedxWireGainAlgorithm
23 from caf.framework import Calibration
24 from caf.strategies import SequentialRunByRun, SequentialBoundaries
25 from prompt import CalibrationSettings, INPUT_DATA_FILTERS
26 import reconstruction as recon
27 from random import seed
28 
29 gSystem.Load('libreconstruction.so')
30 ROOT.gROOT.SetBatch(True)
31 
32 settings = CalibrationSettings(
33  name="CDC dedx",
34  expert_username="jikumar",
35  description=__doc__,
36  input_data_formats=["cdst"],
37  input_data_names=["bhabha_all_calib"],
38  expert_config={
39  "payload_boundaries": [],
40  "calib_datamode": False,
41  "maxevt_rg": 75000,
42  "maxevt_cc": 18e6,
43  "maxevt_wg": 18e6,
44  "adjustment": 1.00798},
45  input_data_filters={
46  "bhabha_all_calib": [
47  INPUT_DATA_FILTERS['Run Type']['physics'],
48  INPUT_DATA_FILTERS['Data Tag']['bhabha_all_calib'],
49  INPUT_DATA_FILTERS['Data Quality Tag']['Good Or Recoverable'],
50  INPUT_DATA_FILTERS['Magnet']['On'],
51  INPUT_DATA_FILTERS['Beam Energy']['4S'],
52  INPUT_DATA_FILTERS['Beam Energy']['Continuum'],
53  INPUT_DATA_FILTERS['Beam Energy']['Scan']]},
54  depends_on=[])
55 
56 
57 def get_calibrations(input_data, **kwargs):
58  """ REQUIRED FUNCTION used by b2caf-prompt-run tool
59  This function return a list of Calibration
60  objects we assign to the CAF process
61  """
62 
63  import basf2
64  file_to_iov_physics = input_data["bhabha_all_calib"]
65 
66  expert_config = kwargs.get("expert_config")
67 
68  # extracting parameters
69  fulldataMode = expert_config["calib_datamode"]
70  adjustment = expert_config["adjustment"]
71 
72  if fulldataMode:
73  input_files_rungain = list(file_to_iov_physics.keys())
74  input_files_coscorr = list(file_to_iov_physics.keys())
75  input_files_wiregain = list(file_to_iov_physics.keys())
76  else:
77  seed(271492)
78 
79  maxevt_rg = expert_config["maxevt_rg"]
80  maxevt_cc = expert_config["maxevt_cc"]
81  maxevt_wg = expert_config["maxevt_wg"]
82 
83  from prompt.utils import filter_by_max_events_per_run, filter_by_select_max_events_from_files
84  # collection for rungains
85  max_files_for_maxevents = maxevt_rg # allevents to accp bhabha event ratio = 0.60
86  reduced_file_to_iov_rungain = filter_by_max_events_per_run(file_to_iov_physics, max_files_for_maxevents, True)
87  input_files_rungain = list(reduced_file_to_iov_rungain.keys())
88  basf2.B2INFO(f"Total number of files used for rungains = {len(input_files_rungain)}")
89 
90  # collection for cosinecorr
91  input_files_coscorr = filter_by_select_max_events_from_files(list(file_to_iov_physics.keys()), maxevt_cc)
92  basf2.B2INFO(f"Total number of files used for cosine = {len(input_files_coscorr)}")
93  if not input_files_coscorr:
94  raise ValueError(
95  f"Cosine: all requested ({maxevt_cc}) events not found")
96 
97  # collection for wiregain
98  if maxevt_wg == maxevt_cc:
99  input_files_wiregain = input_files_coscorr
100  else:
101  input_files_wiregain = filter_by_select_max_events_from_files(list(file_to_iov_physics.keys()), maxevt_wg)
102 
103  basf2.B2INFO(f"Total number of files used for wiregains = {len(input_files_wiregain)}")
104  if not input_files_wiregain:
105  raise ValueError(
106  f"WireGain: all requested ({maxevt_wg}) events not found")
107 
108  requested_iov = kwargs.get("requested_iov", None)
109  from caf.utils import ExpRun, IoV
110  output_iov = IoV(requested_iov.exp_low, requested_iov.run_low, -1, -1)
111 
112  payload_boundaries = [ExpRun(output_iov.exp_low, output_iov.run_low)]
113  payload_boundaries.extend([ExpRun(*boundary) for boundary in expert_config["payload_boundaries"]])
114  basf2.B2INFO(f"Expert set payload boundaries are: {expert_config['payload_boundaries']}")
115 
116  # ----------1a. Run Gain Pre (No Payload saving and take of effect of previous rungains)
117  # Rungain Precollector path
118  Calibrate_RGTrial = basf2.create_path()
119  recon.prepare_cdst_analysis(path=Calibrate_RGTrial)
120  trg_bhabhaskim = Calibrate_RGTrial.add_module("TriggerSkim", triggerLines=["software_trigger_cut&skim&accept_bhabha"])
121  trg_bhabhaskim.if_value("==0", basf2.Path(), basf2.AfterConditionPath.END)
122 
123  Calibrate_RGTrial.add_module(
124  'CDCDedxCorrection',
125  relativeCorrections=False,
126  scaleCor=True,
127  runGain=True,
128  cosineCor=True,
129  wireGain=True,
130  twoDCell=True,
131  oneDCell=True)
132 
133  # Rungain Collector setup
134  Collector_RGTrial = basf2.register_module('CDCDedxElectronCollector')
135  CollParamTrial = {'cleanupCuts': True, 'IsRun': True, 'granularity': 'run', }
136  Collector_RGTrial.param(CollParamTrial)
137 
138  # Rungain Algorithm setup
139  Algorithm_RGTrial = CDCDedxRunGainAlgorithm()
140  Algorithm_RGTrial.setMonitoringPlots(True)
141 
142  # Rungain Calibration setup
143  Calibration_RGTrial = Calibration(
144  name="RunGainCalibrationTrial",
145  algorithms=[Algorithm_RGTrial],
146  collector=Collector_RGTrial,
147  input_files=input_files_rungain)
148  Calibration_RGTrial.strategies = SequentialRunByRun
149  Calibration_RGTrial.pre_collector_path = Calibrate_RGTrial
150  Calibration_RGTrial.algorithms[0].params = {"iov_coverage": output_iov}
151  Calibration_RGTrial.save_payloads = False
152 
153  # ----------1b. Run Gain Pre (No Payload saving)
154  # Rungain Precollector path
155  Calibrate_RGPre = basf2.create_path()
156  recon.prepare_cdst_analysis(path=Calibrate_RGPre)
157  trg_bhabhaskim = Calibrate_RGPre.add_module("TriggerSkim", triggerLines=["software_trigger_cut&skim&accept_bhabha"])
158  trg_bhabhaskim.if_value("==0", basf2.Path(), basf2.AfterConditionPath.END)
159  Calibrate_RGPre.add_module(
160  'CDCDedxCorrection',
161  relativeCorrections=False,
162  scaleCor=True,
163  runGain=True,
164  cosineCor=True,
165  wireGain=True,
166  twoDCell=True,
167  oneDCell=True)
168 
169  # Rungain Collector setup
170  Collector_RGPre = basf2.register_module('CDCDedxElectronCollector')
171  CollParamPre = {'cleanupCuts': True, 'IsRun': True, 'granularity': 'run'}
172  Collector_RGPre.param(CollParamPre)
173 
174  # Rungain Algorithm setup
175  Algorithm_RGPre = CDCDedxRunGainAlgorithm()
176  Algorithm_RGPre.setMonitoringPlots(True)
177 
178  # Rungain Calibration setup
179  Calibration_RGPre = Calibration(
180  name="RunGainCalibrationPre",
181  algorithms=[Algorithm_RGPre],
182  collector=Collector_RGPre,
183  input_files=input_files_rungain)
184  Calibration_RGPre.strategies = SequentialRunByRun
185  Calibration_RGPre.pre_collector_path = Calibrate_RGPre
186  Calibration_RGPre.depends_on(Calibration_RGTrial)
187  Calibration_RGPre.algorithms[0].params = {"iov_coverage": output_iov}
188  Calibration_RGPre.save_payloads = False
189 
190  # ----------2. CosineCorr Gain
191  # Cosine Precollector path
192  Calibrate_CC = basf2.create_path()
193  recon.prepare_cdst_analysis(path=Calibrate_CC)
194  trg_bhabhaskim = Calibrate_CC.add_module("TriggerSkim", triggerLines=["software_trigger_cut&skim&accept_bhabha"])
195  trg_bhabhaskim.if_value("==0", basf2.Path(), basf2.AfterConditionPath.END)
196 
197  Calibrate_CC.add_module(
198  'CDCDedxCorrection',
199  relativeCorrections=False,
200  scaleCor=True,
201  runGain=True,
202  cosineCor=True,
203  wireGain=True,
204  twoDCell=True,
205  oneDCell=True)
206  # Cosine Collector setup
207  Collector_CC = basf2.register_module('CDCDedxElectronCollector')
208  CollParam_CC = {'cleanupCuts': True, 'IsCharge': True, 'IsCosth': True, 'granularity': 'all'}
209  Collector_CC.param(CollParam_CC)
210  if expert_config["payload_boundaries"] is not None:
211  Collector_CC.param("granularity", "run")
212 
213  # Cosine Algorithm setup
214  Algorithm_CC = CDCDedxCosineAlgorithm()
215  Algorithm_CC.setMonitoringPlots(True)
216 
217  # Cosine Calibration setup
218  Calibration_CC = Calibration(
219  name="CosineCorrCalibration",
220  algorithms=[Algorithm_CC],
221  collector=Collector_CC,
222  input_files=input_files_coscorr)
223  Calibration_CC.pre_collector_path = Calibrate_CC
224  Calibration_CC.depends_on(Calibration_RGPre)
225  if expert_config["payload_boundaries"] is not None:
226  Calibration_CC.strategies = SequentialBoundaries
227  basf2.B2INFO(f"Calibration_CC: Found payload_boundaries: calibration strategies set to SequentialBoundaries.")
228  Calibration_CC.algorithms[0].params = {"iov_coverage": output_iov, "payload_boundaries": payload_boundaries}
229  else:
230  Calibration_CC.algorithms[0].params = {"apply_iov": output_iov}
231 
232  # ----------3. WireGain Gain
233  # WireGain Precollector path
234  Calibrate_WG = basf2.create_path()
235  recon.prepare_cdst_analysis(path=Calibrate_WG)
236  trg_bhabhaskim = Calibrate_WG.add_module("TriggerSkim", triggerLines=["software_trigger_cut&skim&accept_bhabha"])
237  trg_bhabhaskim.if_value("==0", basf2.Path(), basf2.AfterConditionPath.END)
238 
239  Calibrate_WG.add_module(
240  'CDCDedxCorrection',
241  relativeCorrections=False,
242  scaleCor=True,
243  runGain=True,
244  cosineCor=True,
245  wireGain=True,
246  twoDCell=True,
247  oneDCell=True)
248 
249  # WireGain Collector setup
250  Collector_WG = basf2.register_module('CDCDedxElectronCollector')
251  CollParam_WG = {'cleanupCuts': True, 'IsWire': True, 'Isdedxhit': True, 'granularity': 'all'}
252  Collector_WG.param(CollParam_WG)
253  if expert_config["payload_boundaries"] is not None:
254  Collector_WG.param("granularity", "run")
255 
256  # WireGain Algorithm setup
257  Algorithm_WG = CDCDedxWireGainAlgorithm()
258  Algorithm_WG.setMonitoringPlots(True)
259 
260  # WireGain Calibration setup
261  Calibration_WG = Calibration(
262  name="WireGainCalibration",
263  algorithms=[Algorithm_WG],
264  collector=Collector_WG,
265  input_files=input_files_wiregain)
266  Calibration_WG.pre_collector_path = Calibrate_WG
267  Calibration_WG.depends_on(Calibration_RGPre)
268  Calibration_WG.depends_on(Calibration_CC)
269  if expert_config["payload_boundaries"] is not None:
270  Calibration_WG.strategies = SequentialBoundaries
271  basf2.B2INFO(f"Calibration_WG: Found payload_boundaries: calibration strategies set to SequentialBoundaries.")
272  Calibration_WG.algorithms[0].params = {"iov_coverage": output_iov, "payload_boundaries": payload_boundaries}
273  else:
274  Calibration_WG.algorithms[0].params = {"apply_iov": output_iov}
275 
276  # ----------4. Final Run Gain to take Wire and Cosine correction in effect
277  # Rungain Precollector path
278  Calibrate_RG = basf2.create_path()
279  recon.prepare_cdst_analysis(path=Calibrate_RG)
280  trg_bhabhaskim = Calibrate_RG.add_module("TriggerSkim", triggerLines=["software_trigger_cut&skim&accept_bhabha"])
281  trg_bhabhaskim.if_value("==0", basf2.Path(), basf2.AfterConditionPath.END)
282 
283  Calibrate_RG.add_module(
284  'CDCDedxCorrection',
285  relativeCorrections=False,
286  scaleCor=True,
287  runGain=True,
288  cosineCor=True,
289  wireGain=True,
290  twoDCell=True,
291  oneDCell=True)
292 
293  # Rungain Collector setup
294  Collector_RG = basf2.register_module('CDCDedxElectronCollector')
295  CollParamFinal = {'cleanupCuts': True, 'IsRun': True, 'granularity': 'run', }
296  Collector_RG.param(CollParamFinal)
297 
298  # Rungain Algorithm setup
299  Algorithm_RG = CDCDedxRunGainAlgorithm()
300  Algorithm_RG.setMonitoringPlots(True)
301  Algorithm_RG.setAdjustment(adjustment)
302 
303  # Rungain Calibration setup
304  Calibration_RG = Calibration(
305  name="RunGainCalibration",
306  algorithms=[Algorithm_RG],
307  collector=Collector_RG,
308  input_files=input_files_rungain)
309  Calibration_RG.strategies = SequentialRunByRun
310  Calibration_RG.depends_on(Calibration_RGPre)
311  Calibration_RG.depends_on(Calibration_CC)
312  Calibration_RG.depends_on(Calibration_WG)
313  Calibration_RG.pre_collector_path = Calibrate_RG
314  Calibration_RG.algorithms[0].params = {"iov_coverage": output_iov}
315 
316  return [Calibration_RGTrial, Calibration_RGPre, Calibration_CC, Calibration_WG, Calibration_RG]