Inheritance diagram for VXDHarvester:

Public Member Functions
	__init__ (self, clusters, detector, output_file_name, use_mc_info=True)

	is_valid_cluster (self, cluster)

	get_tools (self, cluster)

	peel (self, track_cand)

Public Attributes
	svd_tools = Belle2.VXDMomentumEstimationTools("Belle2::SVDCluster").getInstance()
	cached accessor to the SVD-tools singleton

	pxd_tools = Belle2.VXDMomentumEstimationTools("Belle2::PXDCluster").getInstance()
	cached accessor to the PXD-tools singleton

	clusters = clusters
	cached copy of the name of the cluster StoreArray

	detector = detector
	cached copy of the detector identifier (PXD or SVD)

	use_mc_info = use_mc_info
	if true the MC information is used

Static Public Attributes
	save_tree = refiners.SaveTreeRefiner()
	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.

Detailed Description

 A base class for the VXD hitwise analysis. Collect dE/dX and the correct p of each hit of the MC particles.

Definition at line 154 of file harvester.py.

Constructor & Destructor Documentation

◆ init()

__init__	(	self,
		clusters,
		detector,
		output_file_name,
		use_mc_info = True )

Constructor

Definition at line 158 of file harvester.py.

    def __init__(self, clusters, detector, output_file_name, use_mc_info=True):
        """Constructor"""
        HarvestingModule.__init__(self, foreach="TrackCands", output_file_name=output_file_name)
 
        ## cached accessor to the SVD-tools singleton
        self.svd_tools = Belle2.VXDMomentumEstimationTools("Belle2::SVDCluster").getInstance()
        ## cached accessor to the PXD-tools singleton
        self.pxd_tools = Belle2.VXDMomentumEstimationTools("Belle2::PXDCluster").getInstance()
 
        ## cached copy of the name of the cluster StoreArray
        self.clusters = clusters
        ## cached copy of the detector identifier (PXD or SVD)
        self.detector = detector
 
        ## if true the MC information is used
        self.use_mc_info = use_mc_info
 

Member Function Documentation

◆ get_tools()

get_tools	(		self,
			cluster )

Get the PXD tools for a PXD cluster or the SVD tools for an SVD cluster

Definition at line 192 of file harvester.py.

    def get_tools(self, cluster):
        """Get the PXD tools for a PXD cluster or the SVD tools for an SVD cluster"""
        return VXDMomentumEnergyEstimator.do_for_each_hit_type(
            cluster,
            lambda cluster: self.svd_tools,
            lambda cluster: self.pxd_tools)
 

◆ is_valid_cluster()

is_valid_cluster	(		self,
			cluster )

Determine if a cluster has an associated SpacePoint and is associated with a primary pion MCParticle

Definition at line 175 of file harvester.py.

    def is_valid_cluster(self, cluster):
        """Determine if a cluster has an associated SpacePoint and is associated with a primary pion MCParticle"""
        mc_particles = cluster.getRelationsTo("MCParticles")
 
        space_point = cluster.getRelated("SpacePoints")
 
        if space_point is None:
            return False
 
        for mc_particle in mc_particles:
            if (mc_particle.hasStatus(Belle2.MCParticle.c_PrimaryParticle) and
                    abs(mc_particle.getPDG()) == 211):
 
                return True
 
        return False
 

◆ peel()

peel	(		self,
			track_cand )

Aggregate the cluster and MCParticle (for primary pion) information associated with the track candidate

Definition at line 199 of file harvester.py.

    def peel(self, track_cand):
        """Aggregate the cluster and MCParticle (for primary pion) information associated with the track candidate"""
        vxd_hit_ids = track_cand.getHitIDs(self.detector)
 
        vxd_hits = Belle2.PyStoreArray(self.clusters)
 
        for vxd_hit_id in vxd_hit_ids:
            cluster = vxd_hits[vxd_hit_id]
 
            if not self.is_valid_cluster(cluster):
                continue
 
            tools = self.get_tools(cluster)
 
            mc_particles = cluster.getRelationsTo("MCParticles")
 
            for mc_particle in mc_particles:
                if (mc_particle.hasStatus(Belle2.MCParticle.c_PrimaryParticle) and abs(mc_particle.getPDG()) == 211):
 
                    if self.use_mc_info:
                        track_momentum = mc_particle.getMomentum()
                        track_position = mc_particle.getProductionVertex()
                        track_charge = mc_particle.getCharge()
                    else:
                        track_momentum = track_cand.getMomSeed()
                        track_position = track_cand.getPosSeed()
                        track_charge = track_cand.getChargeSeed()
 
                    b_field = Belle2.BFieldManager.getField(XYZVector(track_position)).Z() / Belle2.Unit.T
                    track_helix = Belle2.Helix(track_position, track_momentum, int(track_charge), b_field)
 
                    cluster_charge = tools.getCalibratedCharge(cluster)
                    path_length = tools.getPathLength(cluster, track_helix)
                    cluster_thickness = tools.getThicknessOfCluster(cluster)
                    cluster_radius = tools.getRadiusOfCluster(cluster)
                    cluster_width = tools.getWidthOfCluster(cluster)
                    cluster_length = tools.getLengthOfCluster(cluster)
 
                    perp_s_at_cluster_entry = track_helix.getArcLength2DAtCylindricalR(cluster_radius)
                    perp_s_at_cluster_exit = track_helix.getArcLength2DAtCylindricalR(cluster_radius + cluster_thickness)
 
                    mc_momentum = tools.getEntryMomentumOfMCParticle(cluster)
                    mc_position = tools.getEntryPositionOfMCParticle(cluster)
 
                    mc_b_field = Belle2.BFieldManager.getField(mc_position).Z() / Belle2.Unit.T
                    mc_helix = Belle2.Helix(mc_position, mc_momentum, int(track_charge), mc_b_field)
                    mc_path_length = tools.getPathLength(cluster, mc_helix)
 
                    cluster_is_u = VXDMomentumEnergyEstimator.do_for_each_hit_type(
                        cluster,
                        lambda cluster: cluster.isUCluster(),
                        lambda cluster: np.NaN)
 
                    cluster_is_pxd = VXDMomentumEnergyEstimator.do_for_each_hit_type(
                        cluster,
                        lambda cluster: False,
                        lambda cluster: True)
 
                    cluster_layer = tools.getLayerOfCluster(cluster)
                    cluster_segment = tools.getSegmentNumberOfCluster(cluster)
                    cluster_ladder = tools.getLadderOfCluster(cluster)
                    cluster_sensor = tools.getSensorNumberOfCluster(cluster)
 
                    cluster_dict = dict(cluster_charge=cluster_charge,
                                        cluster_thickness=cluster_thickness,
                                        cluster_radius=cluster_radius,
                                        cluster_is_u=cluster_is_u,
                                        cluster_is_pxd=cluster_is_pxd,
                                        cluster_layer=cluster_layer,
                                        cluster_segment=cluster_segment,
                                        cluster_ladder=cluster_ladder,
                                        cluster_width=cluster_width,
                                        cluster_length=cluster_length,
                                        cluster_sensor=cluster_sensor)
 
                    mc_at_hit_dict = dict(mc_helix_perigee_x=mc_helix.getPerigeeX(),
                                          mc_helix_perigee_y=mc_helix.getPerigeeY(),
                                          mc_helix_perigee_z=mc_helix.getPerigeeZ(),
                                          mc_helix_momentum_x=mc_helix.getMomentumX(mc_b_field),
                                          mc_helix_momentum_y=mc_helix.getMomentumY(mc_b_field),
                                          mc_helix_momentum_z=mc_helix.getMomentumZ(mc_b_field),
                                          mc_position=mc_position.Mag(),
                                          mc_position_x=mc_position.X(),
                                          mc_position_y=mc_position.Y(),
                                          mc_position_z=mc_position.Z(),
                                          mc_momentum=mc_momentum.Mag(),
                                          mc_momentum_x=mc_momentum.X(),
                                          mc_momentum_y=mc_momentum.Y(),
                                          mc_momentum_z=mc_momentum.Z())
 
                    dedx_dict = dict(dedx=cluster_charge / path_length,
                                     dedx_with_mc=cluster_charge / mc_path_length,
                                     dedx_with_thickness=cluster_charge / cluster_thickness,
                                     p=mc_momentum.Mag(),
                                     perp_s_at_cluster_entry=perp_s_at_cluster_entry,
                                     perp_s_at_cluster_exit=perp_s_at_cluster_exit,
                                     track_charge=track_charge,
                                     path_length=path_length,
                                     mc_path_length=mc_path_length,
                                     p_origin=mc_particle.getMomentum().R())
 
                    track_dict = dict(track_helix_perigee_x=track_helix.getPerigeeX(),
                                      track_helix_perigee_y=track_helix.getPerigeeY(),
                                      track_helix_perigee_z=track_helix.getPerigeeZ(),
                                      track_helix_momentum_x=track_helix.getMomentumX(b_field),
                                      track_helix_momentum_y=track_helix.getMomentumY(b_field),
                                      track_helix_momentum_z=track_helix.getMomentumZ(b_field))
 
                    result_dict = dict()
                    result_dict.update(cluster_dict)
                    result_dict.update(mc_at_hit_dict)
                    result_dict.update(dedx_dict)
                    result_dict.update(track_dict)
 
            yield result_dict
 

Member Data Documentation

◆ clusters

clusters = clusters

cached copy of the name of the cluster StoreArray

Definition at line 168 of file harvester.py.

◆ detector

detector = detector

cached copy of the detector identifier (PXD or SVD)

Definition at line 170 of file harvester.py.

◆ pxd_tools

pxd_tools = Belle2.VXDMomentumEstimationTools("Belle2::PXDCluster").getInstance()

cached accessor to the PXD-tools singleton

Definition at line 165 of file harvester.py.

◆ save_tree

save_tree = refiners.SaveTreeRefiner()

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 317 of file harvester.py.

◆ svd_tools

svd_tools = Belle2.VXDMomentumEstimationTools("Belle2::SVDCluster").getInstance()

cached accessor to the SVD-tools singleton

Definition at line 163 of file harvester.py.

◆ use_mc_info

use_mc_info = use_mc_info

if true the MC information is used

Definition at line 173 of file harvester.py.

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

tracking/studies/low_momentum_vxd_estimation/harvester.py

Public Member Functions

Public Attributes

Static Public Attributes