cosmicsCAF.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
 
 
 
 
import basf2 as b2
import os
import ROOT
from ROOT.Belle2 import CDCDedxMomentumAlgorithm, CDCDedxCosineAlgorithm
from ROOT.Belle2 import CDCDedxWireGainAlgorithm, CDCDedxRunGainAlgorithm
from ROOT.Belle2 import CDCDedx2DCorrectionAlgorithm, CDCDedx1DCleanupAlgorithm
from caf.framework import Calibration, CAF
 
ROOT.gROOT.SetBatch(True)
 
# Specify the input file(s)
input_files = [os.path.abspath(
    '/group/belle2/users/jbennett/GCR2/release-01-02-01/DB00000359/r00282/dst.cosmic.0002.0282.f00000.root')]
 
# Modify the collector to apply other calibration constants
momentum_col = b2.register_module('CDCDedxElectronCollector')
momentum_col_params = {'cleanupCuts': False,
                       'scaleCor': False,
                       'momentumCor': False,
                       'momentumCorFromDB': False,
                       'cosineCor': False,
                       }
momentum_col.param(momentum_col_params)
 
mod_col = b2.register_module('CDCDedxElectronCollector')
mod_col_params = {'cleanupCuts': True,
                  'scaleCor': False,
                  'momentumCor': False,
                  'momentumCorFromDB': False,
                  'cosineCor': False,
                  }
mod_col.param(mod_col_params)
 
# Define the calibration algorithms
momentum_alg = CDCDedxMomentumAlgorithm()
cosine_alg = CDCDedxCosineAlgorithm()
run_gain_alg = CDCDedxRunGainAlgorithm()
wire_gain_alg = CDCDedxWireGainAlgorithm()
twod_alg = CDCDedx2DCorrectionAlgorithm()
oned_alg = CDCDedx1DCleanupAlgorithm()
 
# Create Calibration objects from Collector, Algorithm(s), and input files
momentum_cal = Calibration(
    name='MomentumCalibration',
    collector=momentum_col,
    algorithms=[momentum_alg],
    input_files=input_files)
 
cosine_cal = Calibration(
    name='CosineCalibration',
    collector=mod_col,
    algorithms=[cosine_alg],
    input_files=input_files)
 
wire_gain_cal = Calibration(
    name='WireGainCalibration',
    collector=mod_col,
    algorithms=[wire_gain_alg],
    input_files=input_files)
 
run_gain_cal = Calibration(
    name='RunGainCalibration',
    collector=mod_col,
    algorithms=[run_gain_alg],
    input_files=input_files)
 
other_cal = Calibration(
    name='OtherDedxCalibrations',
    collector=mod_col,
    algorithms=[twod_alg, oned_alg],
    input_files=input_files)
 
# Use the constants in the local databases
momdb = 'calibration_results/MomentumCalibration/outputdb'
cosdb = 'calibration_results/CosineCalibration/outputdb'
wgdb = 'calibration_results/WireGainCalibration/outputdb'
rgdb = 'calibration_results/RunGainCalibration/outputdb'
localdb = '/home/belle2/jbennett/CRDATA/release-00-09-01/DB00000266/r03118/calib/localdb/database.txt'
 
momentum_cal.use_local_database(localdb)
 
cosine_cal.use_local_database(localdb)
cosine_cal.use_local_database(momdb)
 
wire_gain_cal.use_local_database(localdb)
wire_gain_cal.use_local_database(momdb)
wire_gain_cal.use_local_database(cosdb)
 
run_gain_cal.use_local_database(localdb)
run_gain_cal.use_local_database(momdb)
run_gain_cal.use_local_database(cosdb)
run_gain_cal.use_local_database(wgdb)
 
other_cal.use_local_database(localdb)
other_cal.use_local_database(momdb)
other_cal.use_local_database(cosdb)
other_cal.use_local_database(wgdb)
other_cal.use_local_database(rgdb)
 
# Add a pre-collector path to apply old calibration constants
correct_for_mom = b2.create_path()
correct_for_mom.add_module('CDCDedxCorrection', scaleCor=False, momentumCor=False,
                           momentumCorFromDB=False, cosineCor=True,
                           runGain=True, wireGain=True)
momentum_cal.pre_collector_path = correct_for_mom
 
correct_for_cos = b2.create_path()
correct_for_cos.add_module('CDCDedxCorrection', scaleCor=False, momentumCor=True,
                           momentumCorFromDB=True, cosineCor=False,
                           runGain=True, wireGain=True)
cosine_cal.pre_collector_path = correct_for_cos
cosine_cal.depends_on(momentum_cal)
 
correct_for_wire_gain = b2.create_path()
correct_for_wire_gain.add_module('CDCDedxCorrection', scaleCor=False, momentumCor=True,
                                 momentumCorFromDB=True, cosineCor=True,
                                 runGain=True, wireGain=False)
wire_gain_cal.pre_collector_path = correct_for_wire_gain
wire_gain_cal.depends_on(momentum_cal)
wire_gain_cal.depends_on(cosine_cal)
 
correct_for_run_gain = b2.create_path()
correct_for_run_gain.add_module('CDCDedxCorrection', scaleCor=False, momentumCor=True,
                                momentumCorFromDB=True, cosineCor=True,
                                runGain=False, wireGain=True)
run_gain_cal.pre_collector_path = correct_for_run_gain
run_gain_cal.depends_on(momentum_cal)
run_gain_cal.depends_on(cosine_cal)
run_gain_cal.depends_on(wire_gain_cal)
 
correct_for_others = b2.create_path()
correct_for_others.add_module('CDCDedxCorrection', scaleCor=False, momentumCor=True,
                              momentumCorFromDB=True, cosineCor=True,
                              runGain=True, wireGain=True)
other_cal.pre_collector_path = correct_for_others
other_cal.depends_on(momentum_cal)
other_cal.depends_on(cosine_cal)
other_cal.depends_on(wire_gain_cal)
other_cal.depends_on(run_gain_cal)
 
 
# Create a CAF instance and add calibrations
caf_fw = CAF()
caf_fw.add_calibration(momentum_cal)
caf_fw.add_calibration(cosine_cal)
caf_fw.add_calibration(wire_gain_cal)
caf_fw.add_calibration(run_gain_cal)
caf_fw.add_calibration(other_cal)
 
# Run the calibration
caf_fw.run()  # Creates local database files when finished (no auto upload)