ElossHarvestingModule Class Reference

Inheritance diagram for ElossHarvestingModule:

Public Member Functions
def	__init__ (self, output_file_name)
def	initialize (self)
def	prepare (self)
def	pick (self, track)
def	peel (self, track)

Public Attributes
	mc_track_lookup
	by default, there is no method to find matching MC tracks
	track_fitter
	Use the CDCReimannFitter with a constrained origin for track fitting.
	mc_hit_lookup
	Method to find matching MC hits.
	eloss_estimator
	Method to estimate dE/dx in the CDC.
	bfield
	Method to interrogate the magnetic field values.

Static Public Attributes
refiners	save_tree = refiners.save_tree()
	Refiners to be executed at the end of the harvesting / termination of the module Save a tree of all collected variables in a sub folder.
refiners	save_histograms
	Save histograms in a sub folder.
refiners	save_histograms_stackby_charge
	Save the histograms, stacked by charge, in a sub folder.
refiners	save_scatter
	Save the scatterplots in a sub folder.
refiners	save_profiles
	Save the profile histograms to the output ROOT file.
refiners	save_bz_profiles
	Save the magnetic-field profile histogram in a sub folder.
refiners	save_cid_histogram
	Save the eloss-displacement histograms in a sub folder.
refiners	save_cid_profiles
	Save the eloss-displacement profile histograms in a sub folder.
refiners	save_cid_scatters
	Save the eloss-displacement scatterplots in a sub folder.
refiners	save_energy_cid_histogram
	Save the eloss histograms in a sub folder.
refiners	save_energy_cid_profiles
	Save the eloss profile histograms in a sub folder.
refiners	save_energy_cid_scatters
	Save the eloss profile scatterplots in a sub folder.

Detailed Description

Module to collect information about the generated segments and
compose validation plots on terminate.

Definition at line 147 of file record.py.

Constructor & Destructor Documentation

__init__()

def __init__	(		self,
			output_file_name
	)

Constructor

Definition at line 152 of file record.py.

    def __init__(self, output_file_name):
        """Constructor"""
        super().__init__(foreach='CDCTrackVector',
                         output_file_name=output_file_name)
 
        
        self.mc_track_lookup = None
 
        origin_track_fitter = TFCDC.CDCRiemannFitter()
        origin_track_fitter.setOriginConstrained()
        
        self.track_fitter = origin_track_fitter
 

Member Function Documentation

initialize()

def initialize

(

self

)

Receive signal at the start of event processing

Definition at line 165 of file record.py.

    def initialize(self):
        """Receive signal at the start of event processing"""
        super().initialize()
        
        self.mc_track_lookup = TFCDC.CDCMCTrackLookUp.getInstance()
        
        self.mc_hit_lookup = TFCDC.CDCMCHitLookUp.getInstance()
        
        self.eloss_estimator = TFCDC.EnergyLossEstimator.forCDC()
        
        self.bfield = TFCDC.CDCBFieldUtil
 

peel()

def peel	(		self,
			track
	)

Aggregate the track and MC information for dE/dx analysis

Definition at line 198 of file record.py.

    def peel(self, track):
        """Aggregate the track and MC information for dE/dx analysis"""
        mc_track_lookup = self.mc_track_lookup
 
        # rl_drift_circle = 1
        # unit_variance = 0
        # observations2D = TFCDC.CDCObservations2D(rl_drift_circle, unit_variance)
 
        # for recoHit3D in track:
        #    observations2D.append(recoHit3D)
 
        # trajectory2D = track_fitter.fit(observations2D)
        # trajectory2D.setLocalOrigin(TFCDC.Vector2D(0, 0))
 
        mc_particle = mc_track_lookup.getMCParticle(track)
        pdg_code = mc_particle.getPDG()
        t_vertex = mc_particle.getVertex()
        t_mom = mc_particle.getMomentum()
        charge = mc_particle.getCharge()
        mass = mc_particle.getMass()
        mc_energy = mc_particle.getEnergy()
 
        mc_vertex2D = TFCDC.Vector2D(t_vertex.XYvector())
        mc_mom2D = TFCDC.Vector2D(t_mom.XYvector())
        mc_trajectory2D = TFCDC.CDCTrajectory2D(mc_vertex2D, 0, mc_mom2D, charge)
        mc_pt = mc_mom2D.norm()
 
        first_hit = self.mc_track_lookup.getFirstHit(track)
        first_sim_hit = first_hit.getRelated("CDCSimHits")
        if first_sim_hit is None:
            return
        # Make sure we start the track in the first layer to avoid some confusion
        if first_sim_hit.getWireID().getICLayer() != 0:
            return
 
        last_hit = self.mc_track_lookup.getLastHit(track)
        last_sim_hit = last_hit.getRelated("CDCSimHits")
        if last_sim_hit is None:
            return
        # Make sure we start the track in the last layer to avoid some confusion
        # if last_sim_hit.getWireID().getICLayer() != 55: return
        # last_sim_mom3D = TFCDC.Vector3D(last_sim_hit.getMomentum())
 
        first_sim_pos3D = TFCDC.Vector3D(first_sim_hit.getPosTrack())
        first_sim_mom3D = TFCDC.Vector3D(first_sim_hit.getMomentum())
        first_sim_tof = first_sim_hit.getFlightTime()
        first_sim_energy = np.sqrt(first_sim_mom3D.norm() ** 2 + mass ** 2)
        first_sim_pt = first_sim_mom3D.cylindricalR()
        first_sim_pz = first_sim_mom3D.z()
 
        first_sim_mom2D = first_sim_mom3D.xy()
 
        # first_sim_mom2D.normalizeTo(last_sim_mom3D.cylindricalR())
        first_sim_trajectory2D = TFCDC.CDCTrajectory2D(first_sim_pos3D.xy(), first_sim_tof, first_sim_mom2D, charge)
 
        # mc_trajectory3D = mc_track_lookup.getTrajectory3D(track)
        # mc_trajectory2D = mc_trajectory3D.getTrajectory2D()
 
        for reco_hit3D in track:
            sim_hit = self.mc_hit_lookup.getSimHit(reco_hit3D.getWireHit().getHit())
            if sim_hit is None:
                continue
 
            sim_mom3D = TFCDC.Vector3D(sim_hit.getMomentum())
            sim_energy = np.sqrt(sim_mom3D.norm() ** 2 + mass ** 2)
            sim_pt = sim_mom3D.cylindricalR()
            sim_pz = sim_mom3D.z()
 
            mc_eloss_truth = mc_energy - sim_energy
            first_eloss_truth = first_sim_energy - sim_energy
 
            sim_pos3D = TFCDC.Vector3D(sim_hit.getPosTrack())
            sim_pos2D = sim_pos3D.xy()
 
            layer_cid = reco_hit3D.getWire().getICLayer()
            bz = self.bfield.getBFieldZ(sim_pos3D)
            r = sim_pos3D.cylindricalR()
 
            # recoPos3D = reco_hit3D.getRecoPos3D()
            # recoPos3D = TFCDC.Vector3D(sim_hit.getPosTrack())
            # recoPos2D = recoPos3D.xy()
            # refPos2D = reco_hit3D.getRefPos2D()
            # l = reco_hit3D.getSignedRecoDriftLength()
 
            mc_s2D = mc_trajectory2D.calcArcLength2D(sim_pos2D)
            first_s2D = first_sim_trajectory2D.calcArcLength2D(sim_pos2D)
 
            if mc_s2D < 0:
                # mc_s2D += mc_trajectory2D.getArcLength2DPeriod()
                continue
 
            mc_eloss_estimate = self.eloss_estimator.getEnergyLoss(mc_pt, pdg_code, mc_s2D)
            first_eloss_estimate = self.eloss_estimator.getEnergyLoss(first_sim_pt, pdg_code, first_s2D)
            first_ploss_factor = self.eloss_estimator.getMomentumLossFactor(first_sim_pt, pdg_code, first_s2D)
 
            sasha_eloss_estimate = getBetheEnergyLoss(first_sim_pt, pdg_code, first_s2D)
            sasha_ploss_factor = DeltaR(first_s2D, pdg_code, first_sim_pt)
 
            # first_residual2D = first_trajectory2D.getDist2D(refPos2D) - l
            first_residual2D = first_sim_trajectory2D.getDist2D(sim_pos2D)
            first_disp2D = charge * first_residual2D
 
            first_loss_disp2D_estimate = abs(self.eloss_estimator.getLossDist2D(first_sim_pt, pdg_code, first_s2D))
            first_delossed_disp2D = first_disp2D - first_loss_disp2D_estimate
 
            # mc_residual2D = mc_trajectory2D.getDist2D(refPos2D) - l
            mc_residual2D = mc_trajectory2D.getDist2D(sim_pos2D)
            mc_disp2D = charge * mc_residual2D
 
            mc_loss_disp2D_estimate = abs(self.eloss_estimator.getLossDist2D(mc_pt, pdg_code, mc_s2D))
            mc_delossed_disp2D = mc_disp2D - mc_loss_disp2D_estimate
 
            # s2D = trajectory2D.calcArcLength2D(recoPos2D)
            # if s2D < 0: s2D += trajectory2D.getArcLength2DPeriod()
 
            # residual2D = trajectory2D.getDist2D(recoPos2D)
            # disp2D = charge * residual2D
 
            # # Original approach
            # center2D = trajectory2D.getGlobalCircle().center()
            # radius2D = recoPos2D - center2D;
 
            # eLoss = self.eloss_estimator.getEnergyLoss(mc_pt, pdg_code, mc_s2D)
            # dx = self.eloss_estimator.getMomentumLossFactor(mc_pt, pdg_code, mc_s2D)
            # deloss_radius2D = recoPos2D - center2D;
            # deloss_radius2D.scale (1.0 /  dx)
            # loss_disp2D_estimate2 = (deloss_radius2D - radius2D).norm()
 
            # loss_disp2D_estimate3 = radius2D.norm() * (1.0 /dx - 1.0)
            # loss_disp2D_estimate3 = radius2D.norm() * ((1.0 - dx) /dx)
            # loss_disp2D_estimate3 = radius2D.norm() * (eLoss / (mc_pt - eLoss))
 
            if abs(mc_residual2D) > 6:
                continue
 
            if abs(first_residual2D) > 6:
                continue
 
            yield dict(
                layer_cid=layer_cid,
                r=r,
                bz=bz,
                # pt=trajectory2D.getAbsMom2D(),
                pdg_code=abs(pdg_code),
                mass=mass,
                charge=charge,
                mc_pt=mc_pt,
                first_sim_pt=first_sim_pt,
                sim_pt=sim_pt,
 
                diff_pt=first_sim_pt - sim_pt,
                diff_pz=first_sim_pz - sim_pz,
 
                mc_eloss_truth=mc_eloss_truth,
                mc_eloss_estimate=mc_eloss_estimate,
 
                first_eloss_truth=first_eloss_truth,
 
                first_eloss_estimate=first_eloss_estimate,
                sasha_eloss_estimate=sasha_eloss_estimate,
 
                first_ploss_factor=first_ploss_factor,
                sasha_ploss_factor=sasha_ploss_factor,
 
                # l=l,
 
                first_s2D=first_s2D,
                first_residual2D=first_residual2D,
                first_disp2D=first_disp2D,
                first_loss_disp2D_estimate=first_loss_disp2D_estimate,
                first_delossed_disp2D=first_delossed_disp2D,
 
                mc_s2D=mc_s2D,
                mc_residual2D=mc_residual2D,
                mc_disp2D=mc_disp2D,
                mc_loss_disp2D_estimate=mc_loss_disp2D_estimate,
                mc_delossed_disp2D=mc_delossed_disp2D,
 
                # s2D=s2D,
                # disp2D=disp2D,
                # residual2D=residual2D,
 
                # loss_disp2D_estimate2=loss_disp2D_estimate2,
                # loss_disp2D_estimate3=loss_disp2D_estimate3,
            )
 

pick()

def pick	(		self,
			track
	)

Select tracks with at least 4 segments and associated primary MC particle with pt >= 0.25 GeV/c

Definition at line 181 of file record.py.

    def pick(self, track):
        """Select tracks with at least 4 segments and associated primary MC particle with pt >= 0.25 GeV/c"""
        if track.size() < 4:
            return False
 
        mc_track_lookup = self.mc_track_lookup
        mc_particle = mc_track_lookup.getMCParticle(track)
 
        # Check that mc_particle is not a nullptr
        if mc_particle is None:
            return False
 
        if mc_particle.getMomentum().Rho() < 0.250:
            return False
 
        return is_primary(mc_particle)
 

prepare()

def prepare

(

self

)

Initialize the MC-hit lookup method

Definition at line 177 of file record.py.

    def prepare(self):
        """Initialize the MC-hit lookup method"""
        TFCDC.CDCMCHitLookUp.getInstance().fill()
 

Member Data Documentation

bfield

bfield

Method to interrogate the magnetic field values.

Definition at line 175 of file record.py.

eloss_estimator

eloss_estimator

Method to estimate dE/dx in the CDC.

Definition at line 173 of file record.py.

mc_hit_lookup

mc_hit_lookup

Method to find matching MC hits.

Definition at line 171 of file record.py.

mc_track_lookup

mc_track_lookup

by default, there is no method to find matching MC tracks

Method to find matching MC tracks.

Definition at line 158 of file record.py.

save_bz_profiles

refiners save_bz_profiles

static

Initial value:

=  refiners.save_profiles(
        x='r',
        y='bz',
    )

Save the magnetic-field profile histogram in a sub folder.

Definition at line 431 of file record.py.

save_cid_histogram

refiners save_cid_histogram

static

Initial value:

=  refiners.save_histograms(
        select=[
            # 'mc_disp2D',
            # 'mc_delossed_disp2D',
            'first_disp2D',
            'first_delossed_disp2D',
            'bz',
            # 'disp2D',
        ],
        outlier_z_score=5.0,
        groupby=["layer_cid"],
        # stackby="pdg_code",
    )

Save the eloss-displacement histograms in a sub folder.

Definition at line 440 of file record.py.

save_cid_profiles

refiners save_cid_profiles

static

Initial value:

=  refiners.save_profiles(
        x=["mc_pt"],
        y=[
            # 'mc_disp2D',
            # 'mc_delossed_disp2D',
            'first_disp2D',
            'first_delossed_disp2D',
        ],
        outlier_z_score=5.0,
        groupby=["layer_cid"],
        stackby="pdg_code",
    )

Save the eloss-displacement profile histograms in a sub folder.

Definition at line 455 of file record.py.

save_cid_scatters

refiners save_cid_scatters

static

Initial value:

=  refiners.save_scatters(
        x=["mc_pt"],
        y=[
            # 'mc_disp2D',
            # 'mc_delossed_disp2D',
            'first_disp2D',
            'first_delossed_disp2D',
        ],
        outlier_z_score=5.0,
        groupby=["layer_cid"],
        stackby="pdg_code",
    )

Save the eloss-displacement scatterplots in a sub folder.

Definition at line 469 of file record.py.

save_energy_cid_histogram

refiners save_energy_cid_histogram

static

Initial value:

=  refiners.save_histograms(
        select=[
            'pdg_code',
            'first_eloss_estimate',
            'first_eloss_truth',
        ],
        outlier_z_score=5.0,
        groupby=["layer_cid"],
        stackby="pdg_code",
        folder_name='energy/{groupby_addition}',
    )

Save the eloss histograms in a sub folder.

Definition at line 485 of file record.py.

save_energy_cid_profiles

refiners save_energy_cid_profiles

static

Initial value:

=  refiners.save_profiles(
        x=["mc_pt"],
        y=[
            'first_eloss_truth',
            'first_eloss_estimate',
        ],
        outlier_z_score=5.0,
        groupby=["layer_cid"],
        stackby="pdg_code",
        folder_name='energy/{groupby_addition}',
    )

Save the eloss profile histograms in a sub folder.

Definition at line 498 of file record.py.

save_energy_cid_scatters

refiners save_energy_cid_scatters

static

Initial value:

=  refiners.save_scatters(
        x=["mc_pt"],
        y=[
            'first_eloss_truth',
            'first_eloss_estimate',
        ],
        outlier_z_score=5.0,
        groupby=["layer_cid"],
        stackby="pdg_code",
        folder_name='energy/{groupby_addition}',
    )

Save the eloss profile scatterplots in a sub folder.

Definition at line 511 of file record.py.

save_histograms

refiners save_histograms

static

Initial value:

=  refiners.save_histograms(
        outlier_z_score=5.0,
        allow_discrete=True,
    )

Save histograms in a sub folder.

Definition at line 388 of file record.py.

save_histograms_stackby_charge

refiners save_histograms_stackby_charge

static

Initial value:

=  refiners.save_histograms(
        select=[
            # "mc_disp2D",
            "first_disp2D",
            "charge",
        ],
        outlier_z_score=5.0,
        allow_discrete=True,
        fit="gaus",
        fit_z_score=1,
        groupby="charge",
    )

Save the histograms, stacked by charge, in a sub folder.

Definition at line 394 of file record.py.

save_profiles

refiners save_profiles

static

Initial value:

=  refiners.save_profiles(
        x=['mc_s2D'],
        y=[
            # 'mc_disp2D',
            'first_disp2D',
            'disp2D',
        ],
        groupby=[None, "charge"],
    )

Save the profile histograms to the output ROOT file.

Definition at line 420 of file record.py.

save_scatter

refiners save_scatter

static

Initial value:

=  refiners.save_scatters(
        x=['mc_s2D'],
        y=[
            # 'mc_disp2D',
            'disp2D',
        ],
        groupby=[None, "charge"],
        filter=lambda x: x == 211,
        filter_on="pdg_code",
    )

Save the scatterplots in a sub folder.

Definition at line 408 of file record.py.

save_tree

refiners save_tree = refiners.save_tree()

static

Refiners to be executed at the end of the harvesting / termination of the module Save a tree of all collected variables in a sub folder.

Definition at line 386 of file record.py.

track_fitter

track_fitter

Use the CDCReimannFitter with a constrained origin for track fitting.

Definition at line 163 of file record.py.

---

The documentation for this class was generated from the following file:

• tracking/trackFindingCDC/studies/eloss/record.py