MCParticleHarvester Class Reference

Inheritance diagram for MCParticleHarvester:

Public Member Functions
def	__init__ (self)
def	pick (self, mc_particle)
def	generate_cluster_dicts (self, charge_list, path_length_list, normalized_charge_list, name)
def	peel (self, mc_particle)

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 harvester to redo parts of the analysis in the Belle II Paper by Robert 

Definition at line 85 of file harvester.py.

Constructor & Destructor Documentation

__init__()

def __init__

(

self

)

Constructor

Reimplemented from HarvestingModule.

Definition at line 89 of file harvester.py.

    def __init__(self):
        """Constructor"""
        HarvestingModule.__init__(self, foreach="MCParticles", output_file_name="mc_particle.root")
 

Member Function Documentation

generate_cluster_dicts()

def generate_cluster_dicts	(		self,
			charge_list,
			path_length_list,
			normalized_charge_list,
			name
	)

Create a dictionary from the lists of charges, normalized charges, and path lengths of the
   clusters associated with an MCParticle

Definition at line 101 of file harvester.py.

    def generate_cluster_dicts(self, charge_list, path_length_list, normalized_charge_list, name):
        """Create a dictionary from the lists of charges, normalized charges, and path lengths of the
           clusters associated with an MCParticle"""
        result = dict()
 
        truncated, first4, first6 = VXDMomentumEnergyEstimator.generate_truncated(normalized_charge_list)
 
        result.update({f"sum_{name}_charges": sum(charge_list)})
        result.update({f"mean_{name}_charges": np.mean(charge_list)})
        result.update({f"sum_{name}_normalized_charges": sum(normalized_charge_list)})
        result.update({f"mean_{name}_normalized_charges": np.mean(normalized_charge_list)})
 
        result.update({f"sum_{name}_normalized_charges_truncated": sum(truncated)})
        result.update({f"mean_{name}_normalized_charges_truncated": np.mean(truncated)})
        result.update({f"sum_{name}_normalized_charges_first4": sum(first4)})
        result.update({f"mean_{name}_normalized_charges_first4": np.mean(first4)})
        result.update({f"sum_{name}_normalized_charges_first6": sum(first6)})
        result.update({f"mean_{name}_normalized_charges_first6": np.mean(first6)})
 
        return result
 

peel()

def peel	(		self,
			mc_particle
	)

Aggregate the PXD and SVD cluster information for an MCParticle

Reimplemented from HarvestingModule.

Definition at line 122 of file harvester.py.

    def peel(self, mc_particle):
        """Aggregate the PXD and SVD cluster information for an MCParticle"""
        result = dict()
 
        pxd_clusters = mc_particle.getRelationsFrom("PXDClusters")
        svd_clusters = mc_particle.getRelationsFrom("SVDClusters")
 
        pxd_results = VXDMomentumEnergyEstimator.calculate_charges_and_path_lengths_for_one_type(pxd_clusters, mc_particle)
        svd_results = VXDMomentumEnergyEstimator.calculate_charges_and_path_lengths_for_one_type(svd_clusters, mc_particle)
 
        pxd_cluster_dicts = self.generate_cluster_dicts(*pxd_results, name="pxd")
        pxd_charges, pxd_path_length, pxd_normalized_charges = pxd_results
 
        svd_charges, svd_path_length, svd_normalized_charges = svd_results
        svd_cluster_dicts = self.generate_cluster_dicts(*svd_results, name="svd")
 
        combined_cluster_dicts = self.generate_cluster_dicts(pxd_charges + svd_charges,
                                                             pxd_path_length + svd_path_length,
                                                             pxd_normalized_charges + svd_normalized_charges,
                                                             name="combined")
 
        result.update(pxd_cluster_dicts)
        result.update(svd_cluster_dicts)
        result.update(combined_cluster_dicts)
 
        return result
 

pick()

def pick	(		self,
			mc_particle
	)

Select the MCParticle if it is a primary pion and has some PXD and/or SVD clusters

Reimplemented from HarvestingModule.

Definition at line 93 of file harvester.py.

    def pick(self, mc_particle):
        """Select the MCParticle if it is a primary pion and has some PXD and/or SVD clusters"""
        pxd_clusters = mc_particle.getRelationsFrom("PXDClusters")
        svd_clusters = mc_particle.getRelationsFrom("SVDClusters")
        return (mc_particle.hasStatus(Belle2.MCParticle.c_PrimaryParticle) and
                abs(mc_particle.getPDG()) == 211 and
                len(pxd_clusters) + len(svd_clusters) > 0)
 

Member Data Documentation

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

---

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

• tracking/studies/low_momentum_vxd_estimation/harvester.py