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