caf_pxd_landau.py

 
 
# This steering file computes PXD calibrations for hot pixels, dead pixels, hit occupancy and
# energy loss (gain). The script uses the CAF framework. This script uses by default the
# SequentialRunByRun strategy and is designed to try to compute new calibration constants
# regularly to follow temporal changes of the PXD.
#
# The script allows you to create a list of runs that will be ignored in the calibration.
# Use this list for known bad runs.
#
# Before calibration, you have to put a file to IoV mapping called 'file_iov_map.pkl' in your
# working directory. The mapping file should map file locations to IoV ranges and allows to
# logically address data by experiment and run numbers.  You can create such a map file by using
# the tool b2caf-filemap. See also the option --help.
#
# b2caf-filemap -m raw  -p "/hsm/belle2/bdata/Data/Raw/e0003/r*/**/*.root"
#
# The next step is to prepare mc runs containing PXDSimHits. That setup for the simulation
# should mimik the situation of beam data as closely as possible.
#
# basf2 submit_create_mcruns.py -- --backend='local' --outputdir='pxd_mc_phase2' --runLow=4000 --runHigh=6522 --expNo=3
#
# The scripts submits the creation of mc runs to a CAF.backend (here local) for all for given run range. Runs in the
# specified runs but not found in 'file_iov_map.pkl' will be skipped. The simulated runs will be collected in the folder
# outputdir. It is best to create another mapping file for the mc data.
#
# b2caf-filemap -m metadata  -p --output-file "dummy_mc_file_iov_map.pkl" "pxd_mc_phase2/*.root"
#
# Finally, a CAF script for the calibration needs to be started:
#
# basf2 caf_pxd_landau.py -- --runLow=5613 --runHigh=5613 --expNo=3
#
# The results will be collected in a folder 'pxd_calibration_results_range_XY'. In order to complete the
# process, the check and uploads the outputdbs to a global tag (GT).
#
# b2conditionsdb upload Calibration_Offline_Development ./database.txt
#
# The option --help provides extensive help for the b2conditionsdb tool.
 
 
import argparse
from caf.strategies import SequentialRunByRun
from caf.utils import ExpRun, IoV
from caf.backends import LSF
from caf.framework import Calibration, CAF
import ROOT  # noqa (makes ROOT.Belle2 accessible)
from ROOT.Belle2 import PXDHotPixelMaskCalibrationAlgorithm
from ROOT.Belle2 import PXDChargeCalibrationAlgorithm
from ROOT.Belle2 import PXDGainCalibrationAlgorithm
import pickle
import basf2 as b2
b2.set_log_level(b2.LogLevel.INFO)
 
ROOT.gROOT.SetBatch(True)
 
 
parser = argparse.ArgumentParser(
    description="Compute gain correction maps for PXD from beam data")
parser.add_argument(
    '--runLow',
    default=0,
    type=int,
    help='Compute mask for specific IoV')
parser.add_argument('--runHigh', default=-1, type=int,
                    help='Compute mask for specific IoV')
parser.add_argument(
    '--expNo',
    default=3,
    type=int,
    help='Compute mask for specific IoV')
parser.add_argument('--maxSubRuns', default=20, type=int,
                    help='Maximum number of subruns to use')
args = parser.parse_args()
 
 
# input files
pxd_ignore_run_list = [ExpRun(3, 484), ExpRun(3, 485), ExpRun(3, 486), ExpRun(3, 524)]
 
# Set the IoV range for this calibration
iov_to_calibrate = IoV(
    exp_low=args.expNo,
    run_low=args.runLow,
    exp_high=args.expNo,
    run_high=args.runHigh)
 
 
# Access files_to_iovs for beam runs
with open("file_iov_map.pkl", 'br') as map_file:
    files_to_iovs = pickle.load(map_file)
 
# Get list of input files (beam data)
input_files = []
 
input_file_iov_set = set(files_to_iovs.values())
for file_iov in input_file_iov_set:
    if iov_to_calibrate.contains(file_iov):
        subruns = [k for k, v in files_to_iovs.items() if v == file_iov]
        input_files.extend(subruns[:args.maxSubRuns])
 
print(f'Number selected input files:  {len(input_files)}')
 
 
# Access files_to_iovs for MC runs
with open("mc_file_iov_map.pkl", 'br') as map_file:
    mc_files_to_iovs = pickle.load(map_file)
 
mc_input_files = list(mc_files_to_iovs.keys())
 
 
print(f'Number selected mc input files:  {len(mc_input_files)}')
 
 
# HOTPIXEl CALIBRATION
 
# Create and configure the collector and its pre collector path
hotpixel_collector = b2.register_module("PXDRawHotPixelMaskCollector")
hotpixel_collector.param("granularity", "run")
 
# The pre collector path must contain geometry and unpacker
pre_hotpixel_collector_path = b2.create_path()
pre_hotpixel_collector_path.add_module(
    "Gearbox", fileName='geometry/Beast2_phase2.xml')
pre_hotpixel_collector_path.add_module("Geometry", useDB=False)
pre_hotpixel_collector_path.add_module('PXDUnpacker')
pre_hotpixel_collector_path.add_module('PXDPostErrorChecker')
pre_hotpixel_collector_path.add_module('Progress')
# Create and configure the calibration algorithm
hotpixel_algo = PXDHotPixelMaskCalibrationAlgorithm()
 
# We can play around with hotpixelkiller parameters
# Continue masking even when few/no events were collected
hotpixel_algo.forceContinueMasking = False
# Minimum number of collected events for masking
hotpixel_algo.minEvents = 10000
# Only consider dead pixel masking when median number of hits per pixel is
# higher
hotpixel_algo.minHits = 15
# Occupancy threshold is median occupancy x multiplier
hotpixel_algo.pixelMultiplier = 7
# Set True to allow masking of hot drain lines
hotpixel_algo.maskDrains = True
# Occupancy threshold is median occupancy x multiplier
hotpixel_algo.drainMultiplier = 7
# Set True to allow masking of hot rows
hotpixel_algo.maskRows = True
# Occupancy threshold is median occupancy x multiplier
hotpixel_algo.rowMultiplier = 7
 
# We want to use a specific collector collecting from raw hits
hotpixel_algo.setPrefix("PXDRawHotPixelMaskCollector")
 
# Create a hotpixel calibration
hotpixel_cal = Calibration(
    name="PXDHotPixelMaskCalibrationAlgorithm",
    collector=hotpixel_collector,
    algorithms=hotpixel_algo,
    input_files=input_files)
hotpixel_cal.pre_collector_path = pre_hotpixel_collector_path
 
# Apply the map to this calibration, now the CAF doesn't have to do it
hotpixel_cal.files_to_iovs = files_to_iovs
 
# Here we set the AlgorithmStrategy
hotpixel_cal.strategies = SequentialRunByRun
hotpixel_cal.max_files_per_collector_job = 1
hotpixel_cal.use_central_database("Calibration_Offline_Development")
 
hotpixel_cal.ignored_runs = pxd_ignore_run_list
hotpixel_cal.algorithms[0].params["iov_coverage"] = iov_to_calibrate
 
 
# Landau Fit on DATA
 
 
# Create and configure the collector on beam data and its pre collector path
charge_collector = b2.register_module("PXDClusterChargeCollector")
charge_collector.param("granularity", "run")
charge_collector.param("minClusterCharge", 8)
charge_collector.param("minClusterSize", 2)
charge_collector.param("maxClusterSize", 6)
charge_collector.param("nBinsU", 4)
charge_collector.param("nBinsV", 6)
 
 
# The pre collector path on data
pre_charge_collector_path = b2.create_path()
pre_charge_collector_path.add_module(
    "Gearbox", fileName='geometry/Beast2_phase2.xml')
pre_charge_collector_path.add_module("Geometry", useDB=False)
pre_charge_collector_path.add_module("ActivatePXDPixelMasker")
pre_charge_collector_path.add_module("PXDUnpacker")
pre_charge_collector_path.add_module('PXDPostErrorChecker')
pre_charge_collector_path.add_module("PXDRawHitSorter")
pre_charge_collector_path.add_module("PXDClusterizer")
 
 
landau_algo = PXDChargeCalibrationAlgorithm()
 
# We can play around with algo parameters
# Minimum number of collected clusters for estimating gains
landau_algo.minClusters = 5000
# Artificial noise sigma for smearing cluster charge
landau_algo.noiseSigma = 0.6
# Force continue algorithm instead of c_notEnoughData
landau_algo.forceContinue = False
landau_algo.strategy = 1      # 0: medians, 1: landau fit
# We want to use a specific collector
landau_algo.setPrefix("PXDClusterChargeCollector")
 
# create calibration
charge_cal = Calibration(
    name="PXDChargeCalibrationAlgorithm",
    collector=charge_collector,
    algorithms=landau_algo,
    input_files=input_files)
 
charge_cal.pre_collector_path = pre_charge_collector_path
 
# Apply the map to this calibration, now the CAF doesn't have to do it
charge_cal.files_to_iovs = files_to_iovs
 
# Here we set the AlgorithmStrategy
charge_cal.strategies = SequentialRunByRun
charge_cal.max_files_per_collector_job = 1
 
charge_cal.algorithms[0].params["iov_coverage"] = iov_to_calibrate
charge_cal.ignored_runs = pxd_ignore_run_list
 
charge_cal.use_central_database("Calibration_Offline_Development")
 
 
# gain calibration on mc
 
gain_collector = b2.register_module("PXDClusterChargeCollector")
gain_collector.param("granularity", "run")
gain_collector.param("minClusterCharge", 8)
gain_collector.param("minClusterSize", 2)
gain_collector.param("maxClusterSize", 6)
gain_collector.param("nBinsU", 4)
gain_collector.param("nBinsV", 6)
 
# The pre collector path on mc files
pre_gain_collector_path = b2.create_path()
pre_gain_collector_path.add_module(
    "Gearbox", fileName='geometry/Beast2_phase2.xml')
pre_gain_collector_path.add_module("Geometry", useDB=False)
pre_gain_collector_path.add_module("PXDDigitizer")
pre_gain_collector_path.add_module("PXDClusterizer")
 
 
# Create and configure the calibration algorithm
gain_algo = PXDGainCalibrationAlgorithm()
 
# We can play around with algo parameters
# Minimum number of collected clusters for estimating gains
gain_algo.minClusters = 3000
# Artificial noise sigma for smearing cluster charge
gain_algo.noiseSigma = 0.6
# Force continue algorithm instead of c_notEnoughData
gain_algo.forceContinue = False
gain_algo.strategy = 1     # 0: median, 1: landau fit
# We want to use a specific collector
gain_algo.setPrefix("PXDClusterChargeCollector")
 
# Create a charge calibration
gain_cal = Calibration(
    name="PXDGainCalibrationAlgorithm",
    collector=gain_collector,
    algorithms=gain_algo,
    input_files=mc_input_files)
 
gain_cal.pre_collector_path = pre_gain_collector_path
 
# Apply the map to this calibration, now the CAF doesn't have to do it
gain_cal.files_to_iovs = mc_files_to_iovs
 
# Here we set the AlgorithmStrategy
gain_cal.strategies = SequentialRunByRun
gain_cal.max_files_per_collector_job = 1
 
gain_cal.algorithms[0].params["iov_coverage"] = iov_to_calibrate
gain_cal.ignored_runs = pxd_ignore_run_list
 
gain_cal.use_central_database("Calibration_Offline_Development")
 
 
# CAF
 
# Define dependencies. In this case: hotpixel_cal -> charge_cal -> gain_cal
charge_cal.depends_on(hotpixel_cal)
gain_cal.depends_on(charge_cal)
 
# create a CAF instance and add the calibration
cal_fw = CAF()
cal_fw.add_calibration(hotpixel_cal)
cal_fw.add_calibration(charge_cal)
cal_fw.add_calibration(gain_cal)
# cal_fw.backend = backends.Local(max_processes=20)
cal_fw.backend = LSF()
cal_fw.output_dir = f'pxd_calibration_results_range_{args.runLow}_{args.runHigh}_{args.expNo}'
cal_fw.run(iov=iov_to_calibrate)