VXDHarvester Class Reference

Inheritance diagram for VXDHarvester:

Collaboration diagram for VXDHarvester:

Public Member Functions
def	__init__ (self, clusters, detector, output_file_name, use_mc_info=True)
def	is_valid_cluster (self, cluster)
def	get_tools (self, cluster)
def	peel (self, track_cand)

Public Attributes
	svd_tools
	cached accessor to the SVD-tools singleton
	pxd_tools
	cached accessor to the PXD-tools singleton
	clusters
	cached copy of the name of the cluster StoreArray
	detector
	cached copy of the detector identifier (PXD or SVD)
	use_mc_info
	if true the MC information is used

Static Public Attributes
refiners	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__()

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

Constructor

Reimplemented in PXDHarvester, and SVDHarvester.

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)
 
        
        self.svd_tools = Belle2.VXDMomentumEstimationTools("Belle2::SVDCluster").getInstance()
        
        self.pxd_tools = Belle2.VXDMomentumEstimationTools("Belle2::PXDCluster").getInstance()
 
        
        self.clusters = clusters
        
        self.detector = detector
 
        
        self.use_mc_info = use_mc_info
 

Member Function Documentation

get_tools()

def 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()

def 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()

def 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

cached copy of the name of the cluster StoreArray

Definition at line 168 of file harvester.py.

detector

detector

cached copy of the detector identifier (PXD or SVD)

Definition at line 170 of file harvester.py.

pxd_tools

pxd_tools

cached accessor to the PXD-tools singleton

Definition at line 165 of file harvester.py.

save_tree

refiners 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

cached accessor to the SVD-tools singleton

Definition at line 163 of file harvester.py.

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