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