analysis modules

Collaboration diagram for analysis modules:

Classes
class	AllParticleCombinerModule
	This module combines all particles of the provided list to one mother particle. More...
class	AnalysisConfigurationModule
	Class to hold general basf2 configuration Used to intiate and configure CreateAnalysis object. More...
class	BestCandidateSelectionModule
	Selects Particles with the highest values of 'variable' in the input list and removes all other particles from the list. More...
class	BelleBremRecoveryModule
	Brem recovery module (used in past belle analyses) This module add four vector of all the brem photon to the four vector associated to the charged particle. More...
class	BremsFinderModule
	Bremsstrahlung finder correction module For each lepton in the input particle list, this module copies it to the output particle list and uses the results of the eclTrackBremFinder module to look for a possible bremsstrahlung photon; if this photon exists, adds its four momentum to the leptons in the output list. More...
class	BtubeCreatorModule
	Create a B particle from a Bbar particle. More...
class	ChargedPidMVAModule
	This module evaluates the response of an MVA trained for binary charged particle identification between two hypotheses, S and B. More...
class	ChargedPidMVAMulticlassModule
	This module evaluates the response of a multi-class MVA trained for global charged particle identification. More...
class	ContinuumSuppressionBuilderModule
	Creates for each Particle in given ParticleList an ContinuumSuppression dataobject and makes BASF2 relation between them. More...
class	CurlTaggerModule
	This module is designed to tag curl tracks. More...
class	DistanceCalculatorModule
	Calculates distance between two vertices, distance of closest approach between a vertex and a track, distance of closest approach between a vertex and Btube. More...
class	DuplicateVertexMarkerModule
	Identify duplicate vertices (distinct particles, but built from the same daughters) and mark the one with best chi2.Only works if the particle has exactly two daughters. More...
class	EventKinematicsModule
	Module to compute global quantities related to the event kinematics, like total missing energy and mass2, visible energy, etc. More...
class	EventShapeCalculatorModule
	Module to compute event shape variables starting from three lists of particle objects (tracks, gammas, Klongs). More...
class	ExtraInfoPrinterModule
	Prints the names of the ExtraInfos for a ParticleList or for the Event. More...
class	ExtraInfoRemoverModule
	This module deletes the extrainfo of each particle in the given ParticleLists. More...
class	FixECLClustersModule
	Sets ConnectedRegionID and ClusterID to ECLClusters on MC samples with old ECLCluster design. More...
class	FlavorTaggerInfoBuilderModule
	Creates for each Particle and RestOfEvent object in the DataStore a FlavorTaggerInfo dataobject and makes BASF2 relation between them. More...
class	FlavorTaggerInfoFillerModule
	Creates a new flavorTaggerInfoMap DataObject for the specific methods. More...
class	InclusiveBtagReconstructionModule
	Inclusively reconstructs anti-B:tag from input ParticleLists for given B:sig. More...
class	Map2Vector
	Helper class to make a vector of all possible combinations of int numbers contained in the input vectors (passed as values in a map). More...
class	InclusiveDstarReconstructionModule
	Inclusive D* reconstruction module. More...
class	KlongDecayReconstructorExpertModule
	reco missing module More...
class	KlongMomentumCalculatorExpertModule
	reco missing module More...
class	DecayTree< T >
	This is a helper class for the MCDecayFinderModule. More...
class	MCDecayFinderModule
	Find decays in MCParticle list matching a given DecayString. More...
class	MCMatcherParticlesModule
	MC matching module: module performs MC matching (sets the relation Particle -> MCParticle) for all particles and its (grand)^N-daughter particles in the user-specified ParticleList. More...
class	OnlyWriteOutParticleListsModule
	Marks all objects in DataStore except those of type ParticleList as WrtieOut=False. More...
class	ParticleCombinerModule
	particle combiner module More...
class	ParticleCombinerFromMCModule
	particle combiner module More...
class	ParticleCopierModule
	Module for creating copies of Particles. More...
class	ParticleListManipulatorModule
	Module for copying Particles (actually their indices) from two or more ParticleLists(s) to another ParticleList. More...
class	ParticleLoaderModule
	Loads MDST dataobjects as Particle objects to the StoreArray<Particle> and collects them in specified ParticleList. More...
class	ParticleMassUpdaterModule
	This module replaces the mass of the particles inside the given particleLists with the invariant mass of the particle corresponding to the given pdgCode. More...
class	ParticleMCDecayStringModule
	Adds the Monte Carlo decay string to a Particle. More...
class	ParticlePrinterModule
	prints particle list to screen More...
class	ParticleSelectorModule
	Loops over all Particles in the ParticleList and removes those Particles from the ParticleList that do not pass given selection criteria. More...
class	ParticleStatsModule
	This module summarises the ParticleLists in the event. More...
class	ParticleVertexFitterModule
	Vertex fitter module. More...
class	ParticleWeightingModule
	Module to apply weights from the database to particles and store added info in ExtraInfo. More...
class	ParticleWeightingLookUpCreatorModule
	Module that creates LookUpTable and upload it to the DB. More...
class	PrintMCParticlesModule
	The PrintMCParticles module. More...
class	PseudoVertexFitterModule
	Pseudo Vertex fitter module. More...
class	RemoveParticlesNotInListsModule
	Removes all Particles that are not in a given list of ParticleLists (or daughters of those). More...
class	RestOfEventBuilderModule
	Creates for each Particle in given ParticleList an RestOfEvent (ROE) dataobject and makes BASF2 relation between them. More...
class	RestOfEventInterpreterModule
	Creates a mask (vector of boolean values) for tracks and clusters in RestOfEvent regarding their usage. More...
class	RestOfEventPrinterModule
	prints ROE information and masks to screen More...
class	RestOfEventUpdaterModule
	Updates an existing mask (map of boolean values) for tracks or eclClusters in RestOfEvent with an available property (e.g. More...
class	SelectDaughtersModule
	Redefine (select) the daughters of a particle. More...
class	SignalSideParticleFilterModule
	The module returns true if the current RestOfEvent object is related to any of the Particles in the input ParticleLists. More...
class	SignalSideParticleListCreatorModule
	The module creates a ParticleList and fills it with one of the daughter Particles. More...
class	SignalSideVariablesToDaughterExtraInfoModule
	The module writes properties (values of specified variables) of the particle related to the current ROE as an ExtraInfo to the single particle in the input ParticleList. More...
class	SignalSideVariablesToExtraInfoModule
	The module writes property of single particle found in the input ParticleList as an ExtraInfo to the Particle related to the current ROE. More...
class	SkimFilterModule
	This module filters events based on presence of candidates in a list of ParticleLists. More...
class	TagUniqueSignalModule
	Loops through the particle list finds a unique signal candidate for each event. More...
class	TagVertexModule
	Tag side Vertex Fitter module for modular analysis. More...
struct	ParticleAndWeight
	this struct is used to store and sort the tag tracks More...
class	TauDecayMarkerModule
	Module to identify generated tau pair decays, using MCParticle information. More...
class	TrackingEfficiencyModule
	This set of module is designed for tracking systematics studies. More...
class	TrackingMomentumModule
	Tracking momentum systematics. More...
class	TreeFitterModule
	Module to fit an entire decay tree. More...
class	V0DaughterMassUpdaterModule
	This module replaces the mass of two daughters of the selected V0 particles inside the given particleLists with masses of given pdgCode. More...
class	VariablesToEventBasedTreeModule
	Module to calculate variables specified by the user for a given ParticleList and save them into a TTree. More...
class	VariablesToEventExtraInfoModule
	For each particle in the input list the selected variables are saved in an event-extra-info field with the given name, Can be used to save MC truth information, for example, in a ntuple of reconstructed particles. More...
class	VariablesToExtraInfoModule
	For each particle in the input list the selected variables are saved in an extra-info field with the given name, Can be used when wanting to save variables before modifying them, e.g. More...
class	VariablesToHistogramModule
	Module to calculate variables specified by the user for a given ParticleList and save them into an Histogram. More...
class	VariablesToNtupleModule
	Module to calculate variables specified by the user for a given ParticleList and save them into a ROOT TTree. More...
class	VariableToReturnValueModule
	Module to calculate variable specified by the user and set return value accordingly. More...

Typedefs
typedef std::tuple< double, double >	BinLimitsTuple
	Currently, std::pair can not be retrieved from python list We will get ParticleWeightingLookUpTable entries with tuples and transform tuples to pairs here. More...
typedef std::map< std::string, BinLimitsTuple >	NDBinTuple
	the NDimensional tuple of bin limits
typedef std::tuple< WeightInfo, NDBinTuple >	noIdEntry
	the ID
typedef std::tuple< noIdEntry, double >	specificIDEntry
	the specific ID
typedef std::vector< noIdEntry >	listOfNoIdEntries
	List of entries for table to be created from without specified ID.
typedef std::vector< specificIDEntry >	listOfSpecificIDEntries
	List of entries for table to be created from with specified ID.

Functions
bool	isFSP (int pdg)
	defines what is a final state particle for this purpose.
static const TVector3	vecNaN (realNaN, realNaN, realNaN)
	vector with NaN entries
static const TMatrixDSym	matNaN (3,(double[]) { realNaN, realNaN, realNaN, realNaN, realNaN, realNaN, realNaN, realNaN, realNaN })
	3x3 matrix with NaN entries
static TLorentzVector	flipVector (TLorentzVector vIn)
static double	getProperLifeTime (const MCParticle *mc)
	proper life time, i.e. More...
	BelleBremRecoveryModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
	BremsFinderModule ()
	Constructor, for setting module description and parameters.
virtual void	initialize () override
	Use this to initialize resources or memory your module needs. More...
virtual void	event () override
	Called once for each event. More...
	KlongDecayReconstructorExpertModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
	KlongMomentumCalculatorExpertModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
	DecayTree ()
	Default constructor.
	DecayTree (T *obj)
	Constructor with decaying object (e.g. More...
	~DecayTree ()
	Destructor.
std::vector< DecayTree< T > * >	getDaughters ()
	Return list of decay daughters.
T *	getObj ()
	Return the decaying object itself, e.g. More...
void	setObj (T *obj)
	Set the decaying object, e.g. More...
void	clear ()
	Frees memory occupied by m_myObject and the daughter objects.
void	append (DecayTree< T > *t)
	Add a daughter, which is a DecayTree itself.
	MCMatcherParticlesModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
void	setLooseMCMatch (const Particle *particle)
	Finds common mother of the majority of daughters. More...
	ParticleCombinerModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
	ParticleCombinerFromMCModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
void	registerParticleRecursively (const DecayDescriptor &decaydescriptor)
	Register particles which have (sub-)decay recursively. More...
void	combineRecursively (const DecayDescriptor &decaydescriptor)
	Combine particles which have (sub-)decay recursively. More...
	ParticleCopierModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
	ParticleListManipulatorModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
void	fillUniqueIdentifier (const Particle *p, std::vector< int > &idSequence)
	Fills unique identifier for the input particle. More...
bool	isUnique (const std::vector< int > &idSequence)
	Compares input idSequence to all sequences already included in the list. More...
	ParticleLoaderModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
virtual void	terminate () override
	Terminate the Module. More...
void	roeToParticles ()
	Loads ROE object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList.
void	addROEToParticleList (RestOfEvent *roe, int pdgCode=0, bool isSelfConjugatedParticle=true)
	Helper method to load ROE object as Particle.
void	v0sToParticles ()
	Loads V0 object as Particle of specified type to StoreArray<Particle> and adds it to the ParticleList.
void	tracksToParticles ()
	Loads Track object as Particle to StoreArray<Particle> and adds it to the ParticleList.
void	eclClustersToParticles ()
	Loads ECLCluster object as Particle to StoreArray<Particle> and adds it to the ParticleList.
void	klmClustersToParticles ()
	Loads KLMCluster object as Particle to StoreArray<Particle> and adds it to the ParticleList.
void	mcParticlesToParticles ()
	Loads specified MCParticles as Particle to StoreArray<Particle>
bool	isValidPDGCode (const int pdgCode)
	returns true if the PDG code determined from the decayString is valid
void	appendDaughtersRecursive (Particle *mother)
	recursively append bottom of a particle's decay chain (daughters of mother, granddaughters of daughter and so on).
	ParticleMCDecayStringModule ()
	Constructor.
virtual void	initialize () override
	Initialize the module.
virtual void	event () override
	Called for each event.
virtual void	terminate () override
	Terminate modules.
const MCParticle *	getInitialParticle (const MCParticle *mcP)
	search from mcP upwards for a particle that matches specified mother PDG codes.
std::string	getDecayString (const Particle &p)
	get the decay string for p.
std::string	getDecayStringFromParticle (const Particle *p)
	get decay string of particle
std::string	getMCDecayStringFromParticle (const Particle *p)
	get mc decay string from particle
std::string	getMCDecayStringFromMCParticle (const MCParticle *mcPMatched)
	get mc decay string from mc particle
std::string	buildMCDecayString (const MCParticle *mcPMother, const MCParticle *mcPMatched)
	return decay string for mcPMother, highlight mcPMatched.
void	convertToConciseString (std::string &string)
	Convert the extended string to a more concise format.
	ParticlePrinterModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
void	printVariables (const Particle *particle) const
	Prints out the values of variables specified by the user via the Variables module parameter.
	ParticleSelectorModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
	ParticleVertexFitterModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	beginRun () override
	Called when entering a new run. More...
virtual void	event () override
	Event processor.
bool	doVertexFit (Particle *p)
	Main steering routine. More...
bool	fillFitParticles (const Particle *mother, std::vector< const Particle * > &fitChildren, std::vector< const Particle * > &pi0Children)
	Fills valid particle's children (with valid error matrix) in the vector of Particles that will enter the fit. More...
bool	redoPi0MassFit (Particle *pi0Temp, const Particle *pi0Orig, const analysis::VertexFitKFit &kv)
	Performs mass refit of pi0 assuming that pi0 originates from the point given by VertexFit.
bool	doKVertexFit (Particle *p, bool ipProfileConstraint, bool ipTubeConstraint)
	Unconstrained vertex fit using KFit. More...
bool	doKMassVertexFit (Particle *p)
	Mass-constrained vertex fit using KFit. More...
bool	doKMassPointingVertexFit (Particle *p)
	Mass-constrained vertex fit with additional pointing constraint using KFit. More...
bool	doKMassFit (Particle *p)
	Mass fit using KFit. More...
bool	doKFourCFit (Particle *p)
	FourC fit using KFit. More...
bool	makeKVertexMother (analysis::VertexFitKFit &kv, Particle *p)
	Update mother particle after unconstrained vertex fit using KFit. More...
bool	makeKMassVertexMother (analysis::MassVertexFitKFit &kv, Particle *p)
	Update mother particle after mass-constrained vertex fit using KFit. More...
bool	makeKMassPointingVertexMother (analysis::MassPointingVertexFitKFit &kv, Particle *p)
	Update mother particle after mass-constrained vertex fit with additional pointing constraint using KFit. More...
bool	makeKMassMother (analysis::MassFitKFit &kv, Particle *p)
	Update mother particle after mass fit using KFit. More...
bool	makeKFourCMother (analysis::FourCFitKFit &kv, Particle *p)
	Update mother particle after FourC fit using KFit. More...
void	updateMapOfTrackAndDaughter (unsigned &l, std::vector< std::vector< unsigned >> &pars, std::vector< unsigned > &pard, std::vector< Particle * > &allparticles, const Particle *daughter)
	update the map of daughter and tracks, find out which tracks belong to each daughter. More...
bool	doRaveFit (Particle *mother)
	Fit using Rave. More...
bool	allSelectedDaughters (const Particle *mother, const std::vector< const Particle * > &tracksVertex)
	check if all the Daughters (o grand-daughters) are selected for the vertex fit
bool	addChildofParticletoKFit (analysis::FourCFitKFit &kv, const Particle *particle)
	Adds given particle's child to the FourCFitKFit. More...
void	addIPProfileToKFit (analysis::VertexFitKFit &kv)
	Adds IPProfile constraint to the vertex fit using KFit.
void	addIPTubeToKFit (analysis::VertexFitKFit &kv)
	Adds IPTube constraint to the vertex fit using KFit.
void	findConstraintBoost (double cut)
	calculate iptube constraint (quasi cylinder along boost direction) for RAVE fit
void	smearBeamSpot (double width)
	smear beam spot covariance
	ParticleWeightingModule ()
	Constructor.
WeightInfo	getInfo (const Particle *p)
	Get LookUp information for the particle. More...
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processing by the module. More...
	ParticleWeightingLookUpCreatorModule ()
	Constructor.
NDBin	NDBinTupleToNDBin (const NDBinTuple &bin_tuple)
	Currently, std::pair can not be retrieved from python list We will get ParticleWeightingLookUpTable entries with tuples and transform tuples to pairs here. More...
virtual void	initialize () override
	Initialize the Module. More...
virtual void	terminate () override
	Clean up anything created in initialize().
	PseudoVertexFitterModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
bool	add_matrix (Particle *p)
	Main steering routine. More...
	RestOfEventInterpreterModule ()
	Constructor: Sets the description, the properties and the parameters of the module.
virtual void	initialize () override
	Overriden initialize method.
virtual void	event () override
	Overriden event method.
	RestOfEventPrinterModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	event () override
	Event processor.
void	printMaskParticles (const std::vector< const Particle * > &maskParticles) const
	Prints out values of the specific ROE mask.
	RestOfEventUpdaterModule ()
	Constructor: Sets the description, the properties and the parameters of the module.
virtual void	initialize () override
	Overriden initialize method.
virtual void	event () override
	Overriden event method.
void	updateMasksWithV0 (const StoreObjPtr< RestOfEvent > &roe, std::vector< const Particle * > &particlesToUpdate)
	Update ROE masks with provided composite particle collection. More...
void	updateMasksWithParticles (const StoreObjPtr< RestOfEvent > &roe, std::vector< const Particle * > &particlesToUpdate, Particle::EParticleSourceObject listType)
	Update ROE masks by excluding or keeping particles. More...
	TagVertexModule ()
	Constructor.
virtual void	initialize () override
	Initialize the Module. More...
virtual void	beginRun () override
	Called when entering a new run. More...
virtual void	event () override
	Event processor.
bool	doVertexFit (const Particle *Breco)
	central method for the tag side vertex fit
std::pair< TVector3, TMatrixDSym >	findConstraint (const Particle *Breco, double cut) const
	calculate the constraint for the vertex fit on the tag side using Breco information
std::pair< TVector3, TMatrixDSym >	findConstraintBTube (const Particle *Breco, double cut)
	calculate constraint for the vertex fit on the tag side using the B tube (cylinder along the expected BTag line of flights
std::pair< TVector3, TMatrixDSym >	findConstraintBoost (double cut, double shiftAlongBoost=-2000.) const
	calculate the standard constraint for the vertex fit on the tag side
void	BtagMCVertex (const Particle *Breco)
	get the vertex of the MC B particle associated to Btag. More...
static bool	compBrecoBgen (const Particle *Breco, const MCParticle *Bgen)
	compare Breco with the two MC B particles
std::vector< const Particle * >	getTagTracks_standardAlgorithm (const Particle *Breco, int nPXDHits) const
	performs the fit using the standard algorithm - using all tracks in RoE The user can specify a request on the PXD hits left by the tracks
std::vector< ParticleAndWeight >	getParticlesWithoutKS (const std::vector< const Particle * > &tagParticles, double massWindowWidth=0.01) const
	Get a list of pions from a list of pions removing the Kshorts Warning: this assumes all the particles are pions, which is fine are all the particles are reconstructed as pions in the TagV module.
bool	makeGeneralFit ()
	TO DO: tag side vertex fit in the case of semileptonic tag side decay. More...
void	fillParticles (std::vector< ParticleAndWeight > &particleAndWeights)
	Fill sorted list of particles into external variable.
void	fillTagVinfo (const TVector3 &tagVpos, const TMatrixDSym &tagVposErr)
	Fill tagV vertex info.
bool	makeGeneralFitRave ()
	make the vertex fit on the tag side: RAVE AVF tracks coming from Ks removed all other tracks used
bool	makeGeneralFitKFit ()
	make the vertex fit on the tag side: KFit tracks coming from Ks removed all other tracks used
void	deltaT (const Particle *Breco)
	calculate DeltaT and MC-DeltaT (rec - tag) in ps from Breco and Btag vertices DT = Dl / gamma beta c , l = boost direction
Particle *	doVertexFitForBTube (const Particle *mother, std::string fitType) const
	it returns an intersection between B rec and beam spot (= origin of BTube)
TrackFitResult	getTrackWithTrueCoordinates (ParticleAndWeight const &paw) const
	If the fit has to be done with the truth info, Rave is fed with a track where the momentum is replaced by the true momentum and the position replaced by the point on the true particle trajectory closest to the measured track position The function below takes care of that.
static TVector3	getTruePoca (ParticleAndWeight const &paw)
	This finds the point on the true particle trajectory closest to the measured track position.
TrackFitResult	getTrackWithRollBackCoordinates (ParticleAndWeight const &paw)
	If the fit has to be done with the rolled back tracks, Rave or KFit is fed with a track where the position of track is shifted by the vector difference of mother B and production point of track from truth info The function below takes care of that.
TVector3	getRollBackPoca (ParticleAndWeight const &paw)
	This shifts the position of tracks by the vector difference of mother B and production point of track from truth info.
void	resetReturnParams ()
	Reset all parameters that are computed in each event and then used to compute tuple variables.
static std::string	printVector (const TVector3 &vec)
	Print a TVector3 (useful for debugging)
static std::string	printMatrix (const TMatrixD &mat)
	Print a TMatrix (useful for debugging)
static std::string	printMatrix (const TMatrixDSym &mat)
	Print a TMatrixFSym (useful for debugging)

Variables
static const double	realNaN = std::numeric_limits<double>::quiet_NaN()
	shortcut for NaN of double type

Detailed Description

Typedef Documentation

BinLimitsTuple

typedef std::tuple<double, double> BinLimitsTuple

Currently, std::pair can not be retrieved from python list We will get ParticleWeightingLookUpTable entries with tuples and transform tuples to pairs here.

the tuple of bin limits

Definition at line 37 of file ParticleWeightingLookUpCreatorModule.h.

Function Documentation

add_matrix()

bool add_matrix ( Particle *  p )

private

Main steering routine.

Parameters

p	pointer to particle

Returns

true for successfully adding the covariance matrix

Definition at line 74 of file PseudoVertexFitterModule.cc.

  {
    // steering starts here
    if (mother->getNDaughters() < 2) return false;
 
    bool ok = false;
 
    const std::vector<Particle*> daughters = mother->getDaughters();
    std::vector<TMatrixFSym> daughter_matrices;
    daughter_matrices.reserve(daughters.size());
    for (auto daughter : daughters) {
      daughter_matrices.push_back(daughter->getMomentumVertexErrorMatrix());
    }
 
    TMatrixFSym mother_errMatrix(7);
    for (int i = 0; i < 7; i++) {
      for (int j = 0; j < 7; j++) {
        for (unsigned int k = 0; k < daughters.size(); k++) {
          mother_errMatrix[i][j] += daughter_matrices[k][i][j];
        }
      }
    }
 
    mother->setMomentumVertexErrorMatrix(mother_errMatrix);
    if (mother->getMomentumVertexErrorMatrix() == mother_errMatrix) {
      ok = true;
    }
    if (!ok) return false;
    return true;
  }

addChildofParticletoKFit()

bool addChildofParticletoKFit ( analysis::FourCFitKFit &  kv, const Particle *  particle  )

private

Adds given particle's child to the FourCFitKFit.

Parameters

kv	reference to KFit FourCFit object
particle	pointer to particle

Definition at line 1032 of file ParticleVertexFitterModule.cc.

  {
    for (unsigned ichild = 0; ichild < particle->getNDaughters(); ichild++) {
      const Particle* child = particle->getDaughter(ichild);
      if (child->getNDaughters() > 0) addChildofParticletoKFit(kf, child);
      else {
        if (child->getPValue() < 0) return false; // error matrix not valid
 
        kf.addParticle(child);
      }
    }
    return true;
  }

beginRun() [1/2]

void beginRun ( )

overridevirtual

Called when entering a new run.

Set run dependent things like run header parameters, alignment, etc.

Reimplemented from Module.

Definition at line 105 of file ParticleVertexFitterModule.cc.

beginRun() [2/2]

void beginRun ( )

overridevirtual

Called when entering a new run.

Set run dependent things

Reimplemented from Module.

Definition at line 158 of file TagVertexModule.cc.

  {
    //TODO: set magnetic field for each run
    //m_Bfield = BFieldMap::Instance().getBField(m_BeamSpotCenter).Z();
  }

BtagMCVertex()

void BtagMCVertex ( const Particle *  Breco )

private

get the vertex of the MC B particle associated to Btag.

It works anly with signal MC

Definition at line 543 of file TagVertexModule.cc.

combineRecursively()

void combineRecursively

(

const DecayDescriptor &

decaydescriptor

)

Combine particles which have (sub-)decay recursively.

The function is called in event().

Definition at line 175 of file ParticleCombinerFromMCModule.cc.

  {
    // Mother particle
    const DecayDescriptorParticle* mother = decaydescriptor.getMother();
    int pdgCode = mother->getPDGCode();
    std::string listName = mother->getFullName();
    std::string antiListName = ParticleListName::antiParticleListName(listName);
    bool isSelfConjugatedParticle = (listName == antiListName);
 
    StoreArray<Particle> particles;
 
    StoreObjPtr<ParticleList> outputList(listName);
    outputList.create();
    outputList->initialize(pdgCode, listName);
 
    if (!isSelfConjugatedParticle && m_chargeConjugation) {
      StoreObjPtr<ParticleList> outputAntiList(antiListName);
      outputAntiList.create();
      outputAntiList->initialize(-1 * pdgCode, antiListName);
 
      outputList->bindAntiParticleList(*(outputAntiList));
    }
 
    unsigned int numberOfLists = decaydescriptor.getNDaughters();
 
    for (unsigned int i = 0; i < numberOfLists; ++i) {
      const DecayDescriptor* dDaughter = decaydescriptor.getDaughter(i);
 
      if (dDaughter->getNDaughters() == 0) {
        // if daughter does not have daughters, check if it is not reconstructed particle.
        const DecayDescriptorParticle* daughter = decaydescriptor.getDaughter(i)->getMother();
        StoreObjPtr<ParticleList> plist(daughter->getFullName());
        // if daughter is not created, returns error
        if (!plist.isValid())
          B2ERROR(daughter->getFullName() << " is not created");
        // if daughter contains reconstructed particles, returns error.
        unsigned nPart = plist->getListSize();
        for (unsigned iPart = 0; iPart < nPart; iPart++) {
          const Particle* part = plist->getParticle(iPart);
          Particle::EParticleSourceObject particleType = part->getParticleSource();
          if (particleType == Particle::c_Track or
              particleType == Particle::c_ECLCluster or
              particleType == Particle::c_KLMCluster)
            B2ERROR(daughter->getFullName() << " contains a reconstructed particle! It is not accepted in ParticleCombinerFromMCModule!");
        }
        // if not, do nothing.
      } else {
        // if daughter has daughter, call the function recursively
        combineRecursively(*dDaughter);
      }
    }
 
    // initialize the generator
    m_generator = std::make_unique<ParticleGenerator>(decaydescriptor, "");
    m_generator->init();
 
    while (m_generator->loadNext(m_chargeConjugation)) {
      Particle&& particle = m_generator->getCurrentParticle();
 
      Particle* newParticle = particles.appendNew(particle);
      // append to the created particle the user specified decay mode ID
      newParticle->addExtraInfo("decayModeID", m_decayModeID);
 
      int iparticle = particles.getEntries() - 1;
      outputList->addParticle(iparticle, particle.getPDGCode(), particle.getFlavorType());
    }
 
    // select only signal particles
    std::unique_ptr<Variable::Cut> cutIsSignal = Variable::Cut::compile("isSignal");
 
    std::vector<unsigned int> toRemove;
    unsigned int n = outputList->getListSize();
    for (unsigned i = 0; i < n; i++) {
      const Particle* part = outputList->getParticle(i);
 
      MCMatching::setMCTruth(part);
      MCMatching::getMCErrors(part);
 
      if (!cutIsSignal->check(part)) toRemove.push_back(part->getArrayIndex());
    }
    outputList->removeParticles(toRemove);
 
  }

DecayTree()

DecayTree ( T *  obj )

explicit

Constructor with decaying object (e.g.

MCParticle) provided.

Definition at line 59 of file DecayTree.h.

doKFourCFit()

bool doKFourCFit ( Particle *  p )

private

FourC fit using KFit.

Parameters

p	pointer to particle

Returns

true for successful fit

Definition at line 611 of file ParticleVertexFitterModule.cc.

doKMassFit()

bool doKMassFit ( Particle *  p )

private

Mass fit using KFit.

Parameters

p	pointer to particle

Returns

true for successful fit

Definition at line 584 of file ParticleVertexFitterModule.cc.

doKMassPointingVertexFit()

bool doKMassPointingVertexFit ( Particle *  p )

private

Mass-constrained vertex fit with additional pointing constraint using KFit.

Parameters

p	pointer to particle

Returns

true for successful fit

Definition at line 539 of file ParticleVertexFitterModule.cc.

doKMassVertexFit()

bool doKMassVertexFit ( Particle *  p )

private

Mass-constrained vertex fit using KFit.

Parameters

p	pointer to particle

Returns

true for successful fit

Definition at line 460 of file ParticleVertexFitterModule.cc.

doKVertexFit()

bool doKVertexFit ( Particle *  p, bool  ipProfileConstraint, bool  ipTubeConstraint  )

private

Unconstrained vertex fit using KFit.

Parameters

p	pointer to particle

Returns

true for successful fit

Definition at line 384 of file ParticleVertexFitterModule.cc.

doRaveFit()

bool doRaveFit ( Particle *  mother )

private

Fit using Rave.

Parameters

mother

pointer to particle

Returns

true for successful fit and update of mother

Definition at line 853 of file ParticleVertexFitterModule.cc.

doVertexFit()

bool doVertexFit ( Particle *  p )

private

Main steering routine.

Parameters

p	pointer to particle

Returns

true for successful fit and prob(chi^2,ndf) > m_confidenceLevel

Definition at line 193 of file ParticleVertexFitterModule.cc.

event() [1/2]

void event ( )

overridevirtual

Called once for each event.

This is most likely where your module will actually do anything.

Reimplemented from Module.

Definition at line 166 of file BremsFinderModule.cc.

  {
    StoreArray<Particle> particles;
    StoreArray<MCParticle> mcParticles;
 
    RelationArray particlesToMCParticles(particles, mcParticles);
 
    // new output particle list
    m_outputList.create();
    m_outputList->initialize(m_pdgCode, m_outputListName);
 
    m_outputAntiList.create();
    m_outputAntiList->initialize(-1 * m_pdgCode, m_outputAntiListName);
    m_outputAntiList->bindAntiParticleList(*(m_outputList));
 
    // Number of photons (calculate it here only once)
    const unsigned int nGamma = m_gammaList->getListSize();
 
    // Number of leptons (calculate it here only once)
    const unsigned int nLep = m_inputList->getListSize();
 
    const std::string relationName = "Bremsstrahlung";
 
    //In the case of only one track per photon
    if (m_usePhotonOnlyOnce) {
      for (unsigned n = 0; n < nGamma; n++) {
        Particle* gamma = m_gammaList->getParticle(n);
        //Skip this if it the best match has already been asigned (pathological case: happens only if you use the same gamma list
        //to correct more than once. Performance studies, in which the same list is used with different options, are an example
        if (gamma->hasExtraInfo("bestMatchIndex")) continue;
 
        auto cluster = gamma->getECLCluster();
        //Get the tracks related to each photon...
        RelationVector<Track> relatedTracks = cluster->getRelationsTo<Track>("", relationName);
        double bestWeight = m_maximumAcceptance;
        unsigned bestMatchIndex = 0;
        unsigned trkIndex = 0;
        //Loop over the related tracks...
        for (auto trk = relatedTracks.begin(); trk != relatedTracks.end(); trk++, trkIndex++) {
          //... and over the input particles' tracks...
          for (unsigned i = 0; i < nLep; i++) {
            const Particle* lepton = m_inputList->getParticle(i);
            auto leptonTrack = lepton->getTrack();
            //... check that the particle track corresponds to the related track....
            if (leptonTrack->getArrayIndex() == trk->getArrayIndex()) {
              double weight = relatedTracks.weight(trkIndex);
              if (weight < bestWeight) {
                bestWeight = weight;
                //... and only select the best match among the tracks in the input list
                bestMatchIndex = trk->getArrayIndex();
              }
              break; //If the particle corresponding to the related track is found, break the loop over the particles and go for the next related track
            }
          }
        }
        //... finally, add the best match index as an extra info for the photon
        gamma->addExtraInfo("bestMatchIndex", bestMatchIndex);
      }
    }
 
    // loop over charged particles, correct them and add them to the output list
 
    for (unsigned i = 0; i < nLep; i++) {
      const Particle* lepton = m_inputList->getParticle(i);
 
      //Get the track of this lepton...
      auto track = lepton->getTrack();
 
      //... and get the bremsstrahlung clusters related to this track
      RelationVector<ECLCluster> bremClusters = track->getRelationsFrom<ECLCluster>("", relationName);
 
      std::vector<std::pair <double, Particle*> > selectedGammas;
 
      unsigned j = 0;
      for (auto bremCluster = bremClusters.begin(); bremCluster != bremClusters.end(); bremCluster++, j++) {
        double weight = bremClusters.weight(j);
 
        if (weight > m_maximumAcceptance) continue;
 
        for (unsigned k = 0; k < nGamma; k++) {
 
          Particle* gamma = m_gammaList->getParticle(k);
          auto cluster = gamma->getECLCluster();
 
          if (bremCluster->getClusterId() == cluster->getClusterId()) {
            if (m_usePhotonOnlyOnce) { //If only one track per photon should be used...
              if (track->getArrayIndex() == static_cast<int>
                  (gamma->getExtraInfo("bestMatchIndex")))      //... check if this track is the best match ...
                selectedGammas.push_back(std::make_pair(weight, gamma)); //... and if it is, add it to the selected gammas
            } else {
              selectedGammas.push_back(std::make_pair(weight, gamma));
            }
          }
 
        } // Closes for loop on gammas
 
      } // Closes for loop on brem clusters
 
      //The 4-momentum of the new lepton in the output particle list
      TLorentzVector new4Vec = lepton->get4Vector();
 
      //Sort weight-particle pairs by weight. Smaller weights go first
      std::sort(selectedGammas.begin(), selectedGammas.end());
 
      //Add to this 4-momentum those of the selected photon(s)
      for (auto const& bremsPair : selectedGammas) {
        Particle* g = bremsPair.second;
        new4Vec += g->get4Vector();
        if (! m_addMultiplePhotons) break; //stop after adding the first photon
      }
 
      //Create the new particle with the 4-momentum calculated before
      Particle correctedLepton(new4Vec, lepton->getPDGCode(), Particle::EFlavorType::c_Flavored, Particle::c_Track,
                               track->getArrayIndex());
 
      //And add the original lepton as its daughter
      correctedLepton.appendDaughter(lepton, false);
 
      const TMatrixFSym& lepErrorMatrix = lepton->getMomentumVertexErrorMatrix();
      TMatrixFSym corLepMatrix(lepErrorMatrix);
 
      double bremsGammaEnergySum = 0.0;
      //Now, if there are any, add the brems photons as daughters as well. As before, we distinguish between the multiple and only one brems photon cases
      int photonIndex = 0;
      for (auto const& bremsPair : selectedGammas) {
        //Add the weights as extra info of the mother
        Particle* bremsGamma = bremsPair.second;
        std::string extraInfoName = "bremsWeightWithPhoton" + std::to_string(photonIndex);
        correctedLepton.addExtraInfo(extraInfoName, bremsPair.first);
        photonIndex++;
        bremsGammaEnergySum += Variable::eclClusterE(bremsGamma);
 
        const TMatrixFSym& gammaErrorMatrix = bremsGamma->getMomentumVertexErrorMatrix();
        for (int irow = 0; irow <= 3; irow++) {
          for (int icol = irow; icol <= 3; icol++) corLepMatrix(irow, icol) += gammaErrorMatrix(irow, icol);
        }
        correctedLepton.appendDaughter(bremsGamma, false);
        B2DEBUG(10, "[BremsFinderModule] Found a bremsstrahlung gamma and added its 4-vector to the charged particle");
        if (! m_addMultiplePhotons) break; //stop after adding the first photon
      }
 
      correctedLepton.setMomentumVertexErrorMatrix(corLepMatrix);
 
      // add the info from original lepton to the new lepton
      correctedLepton.setVertex(lepton->getVertex());
      correctedLepton.setPValue(lepton->getPValue());
      correctedLepton.addExtraInfo("bremsCorrected", float(selectedGammas.size() > 0));
      correctedLepton.addExtraInfo("bremsCorrectedPhotonEnergy", bremsGammaEnergySum);
 
      // add the mc relation
      Particle* newLepton = particles.appendNew(correctedLepton);
      const MCParticle* mcLepton = lepton->getRelated<MCParticle>();
      const PIDLikelihood* pid = lepton->getPIDLikelihood();
 
      if (pid) newLepton->addRelationTo(pid);
 
      if (mcLepton != nullptr) newLepton->addRelationTo(mcLepton);
 
      m_outputList->addParticle(newLepton);
 
    } //Closes for loop on leptons
 
  } //Close event()

event() [2/2]

void event ( )

overridevirtual

Event processing by the module.

This method is called once for each event.

Reimplemented from Module.

Definition at line 77 of file ParticleWeightingModule.cc.

  {
    if (!m_inputList) {
      B2WARNING("Input list " << m_inputList.getName() << " was not created?");
      return;
    }
    StoreArray<Particle> particles;
    const unsigned int numParticles = m_inputList->getListSize();
    for (unsigned int i = 0; i < numParticles; i++) {
      const Particle* ppointer = m_inputList->getParticle(i);
      double index = ppointer->getArrayIndex();
      Particle* p = particles[index];
      WeightInfo info = getInfo(p);
      for (const auto& entry : info) {
        p->addExtraInfo(m_tableName + "_" + entry.first, entry.second);
      }
    }
  }

fillFitParticles()

bool fillFitParticles ( const Particle *  mother, std::vector< const Particle * > &  fitChildren, std::vector< const Particle * > &  pi0Children  )

private

Fills valid particle's children (with valid error matrix) in the vector of Particles that will enter the fit.

Pi0 particles are treated separately so they are filled to another vector.

Definition at line 285 of file ParticleVertexFitterModule.cc.

fillUniqueIdentifier()

void fillUniqueIdentifier ( const Particle *  p, std::vector< int > &  idSequence  )

private

Fills unique identifier for the input particle.

The unique identifier is a sequence of pairs (PDG code of the particle, number of daughters if composite or mdstArrayIndex if final state particle) for all particles in the decay chain.

Example: B+ -> (anti-D0 -> K+ pi-) pi+ idSequence: (521, 2, -421, 2, 321, K+ mdstArrayIndex, -211, pi- mdstArrayIndex, 211, pi+ mdstArrayIndex)

Definition at line 203 of file ParticleListManipulatorModule.cc.

  {
    idSequence.push_back(p->getPDGCode());
 
    if (p->getNDaughters() == 0) {
      idSequence.push_back(p->getMdstArrayIndex());
    } else {
      idSequence.push_back(p->getNDaughters());
      auto daughters = p->getDaughters();
      // sorting the daughters by their pdgCode to identify decay chains only differing by the order of their daughters
      sort(daughters.begin(), daughters.end(), [](const auto a, const auto b) {
        return a->getPDGCode() > b->getPDGCode();
      });
      // this is not FSP (go one level down)
      for (const auto& daughter : daughters)
        fillUniqueIdentifier(daughter, idSequence);
    }
  }

getInfo()

WeightInfo getInfo

(

const Particle *

p

)

Get LookUp information for the particle.

Parameters

p

particle

Returns

LookUp information (map: key - LookUp parameter; value - value of the parameter )

Definition at line 52 of file ParticleWeightingModule.cc.

getObj()

T * getObj

Return the decaying object itself, e.g.

an MCParticle.

Definition at line 78 of file DecayTree.h.

getProperLifeTime()

static double Belle2::getProperLifeTime ( const MCParticle *  mc )

static

proper life time, i.e.

in the rest system (in ps)

Definition at line 537 of file TagVertexModule.cc.

initialize() [1/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 45 of file PseudoVertexFitterModule.cc.

initialize() [2/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 59 of file RestOfEventPrinterModule.cc.

  {
    StoreArray<RestOfEvent>().isRequired();
  }

initialize() [3/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 57 of file ParticlePrinterModule.cc.

  {
    if (!m_listName.empty()) {
      StoreObjPtr<ParticleList> plist(m_listName);
      plist.isRequired();
 
      // obtain the input and output particle lists from the decay string
      bool valid = m_decaydescriptor.init(m_listName);
      if (!valid)
        B2ERROR("ParticlePrinterModule::initialize Invalid input DecayString: " << m_listName);
 
      int nProducts = m_decaydescriptor.getNDaughters();
      if (nProducts > 0)
        B2ERROR("ParticlePrinterModule::initialize Invalid input DecayString " << m_listName
                << ". DecayString should not contain any daughters, only the mother particle.");
    }
  }

initialize() [4/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 70 of file KlongDecayReconstructorExpertModule.cc.

  {
    // clear everything, initialize private members
    m_listName = "";
    m_generator = nullptr;
 
    // obtain the input and output particle lists from the decay string
    bool valid = m_decaydescriptor.init(m_decayString);
    if (!valid)
      B2ERROR("Invalid input DecayString: " << m_decayString);
 
    // Mother particle
    const DecayDescriptorParticle* mother = m_decaydescriptor.getMother();
 
    m_pdgCode = mother->getPDGCode();
    m_listName = mother->getFullName();
 
    m_antiListName = ParticleListName::antiParticleListName(m_listName);
    m_isSelfConjugatedParticle = (m_listName == m_antiListName);
 
    std::string newDecayString;
    std::string kListName;
    newDecayString = m_listName + " -> ";
 
    bool k_check = false;
 
    // Daughters
    int nProducts = m_decaydescriptor.getNDaughters();
    for (int i = 0; i < nProducts; ++i) {
      const DecayDescriptorParticle* daughter = m_decaydescriptor.getDaughter(i)->getMother();
      if (daughter->getPDGCode() != Const::Klong.getPDGCode()) {
        StoreObjPtr<ParticleList>().isRequired(daughter->getFullName());
        newDecayString = newDecayString + daughter->getFullName() + " ";
      } else {
        StoreObjPtr<ParticleList>().isRequired(daughter->getFullName() + m_recoList);
        kListName = daughter->getFullName() + m_recoList;
        k_check = true;
      }
    }
 
    if (!k_check)
      B2FATAL("This module is meant to reconstruct decays with a K_L0 in the final state. There is no K_L0 in this decay!");
    newDecayString = newDecayString + kListName;
 
    m_generator = std::make_unique<ParticleGenerator>(newDecayString, m_cutParameter);
 
    StoreObjPtr<ParticleList> particleList(m_listName);
    DataStore::EStoreFlags flags = m_writeOut ? DataStore::c_WriteOut : DataStore::c_DontWriteOut;
    particleList.registerInDataStore(flags);
    if (!m_isSelfConjugatedParticle) {
      StoreObjPtr<ParticleList> antiParticleList(m_antiListName);
      antiParticleList.registerInDataStore(flags);
    }
 
    m_cut = Variable::Cut::compile(m_cutParameter);
 
  }

initialize() [5/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 70 of file KlongMomentumCalculatorExpertModule.cc.

  {
    // clear everything, initialize private members
    m_pdgCode = 0;
    m_listName = "";
    m_isSelfConjugatedParticle = false;
    m_generator = nullptr;
 
    // obtain the input and output particle lists from the decay string
    bool valid = m_decaydescriptor.init(m_decayString);
    if (!valid)
      B2ERROR("Invalid input DecayString: " << m_decayString);
 
    // Mother particle
    const DecayDescriptorParticle* mother = m_decaydescriptor.getMother();
 
    m_pdgCode = mother->getPDGCode();
    m_listName = mother->getFullName();
 
    m_antiListName = ParticleListName::antiParticleListName(m_listName);
    m_isSelfConjugatedParticle = (m_listName == m_antiListName);
 
    m_klistName = m_recoList;
 
    // Daughters
    bool k_check = false;
    int nProducts = m_decaydescriptor.getNDaughters();
    for (int i = 0; i < nProducts; ++i) {
      const DecayDescriptorParticle* daughter =
        m_decaydescriptor.getDaughter(i)->getMother();
      StoreObjPtr<ParticleList>().isRequired(daughter->getFullName());
      if (daughter->getPDGCode() == Const::Klong.getPDGCode()) {
        m_klistName = daughter->getFullName() + m_klistName;
        k_check = true;
      }
    }
 
    if (!k_check)
      B2FATAL("This module is meant to reconstruct decays with a K_L0 in the final state. There is no K_L0 in this decay!");
 
    m_generator = std::make_unique<ParticleGenerator>(m_decayString, m_cutParameter);
 
    StoreObjPtr<ParticleList> KparticleList(m_klistName);
    DataStore::EStoreFlags flags = m_writeOut ? DataStore::c_WriteOut : DataStore::c_DontWriteOut;
    KparticleList.registerInDataStore(flags);
 
    m_cut = Variable::Cut::compile(m_cutParameter);
 
  }

initialize() [6/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 92 of file ParticleCombinerModule.cc.

  {
    // clear everything
    m_pdgCode = 0;
    m_listName = "";
 
    // obtain the input and output particle lists from the decay string
    bool valid = m_decaydescriptor.init(m_decayString);
    if (!valid)
      B2ERROR("Invalid input DecayString: " << m_decayString);
 
    // Mother particle
    const DecayDescriptorParticle* mother = m_decaydescriptor.getMother();
 
    m_pdgCode = mother->getPDGCode();
    m_listName = mother->getFullName();
 
    m_antiListName = ParticleListName::antiParticleListName(m_listName);
    m_isSelfConjugatedParticle = (m_listName == m_antiListName);
 
    // Daughters
    int nProducts = m_decaydescriptor.getNDaughters();
    int daughtersNetCharge = 0;
    for (int i = 0; i < nProducts; ++i) {
      const DecayDescriptorParticle* daughter =
        m_decaydescriptor.getDaughter(i)->getMother();
      StoreObjPtr<ParticleList>().isRequired(daughter->getFullName());
      int daughterPDGCode = daughter->getPDGCode();
      if (m_recoilParticleType == 2 && i == 0) {
        daughtersNetCharge -= EvtPDLUtil::charge(daughterPDGCode);
      } else {
        daughtersNetCharge += EvtPDLUtil::charge(daughterPDGCode);
      }
    }
 
    if (daughtersNetCharge != EvtPDLUtil::charge(m_pdgCode)) {
      if (!m_allowChargeViolation) {
        B2FATAL("Your decay string " << m_decayString << " violates electric charge conservation!\n"
                "If you want to allow this you can set the argument 'allowChargeViolation' to True. Something like:\n"
                "modularAnalysis.reconstructDecay(" << m_decayString << ", your_cuts, allowChargeViolation=True, path=mypath)");
      }
      B2WARNING("Your decay string " << m_decayString << " violates electric charge conservation!\n"
                "Processing is continued assuming that you allowed this deliberately, e.g. for systematic studies etc.");
    }
 
    m_generator = std::make_unique<ParticleGenerator>(m_decayString, m_cutParameter);
 
    StoreObjPtr<ParticleList> particleList(m_listName);
    DataStore::EStoreFlags flags = m_writeOut ? DataStore::c_WriteOut : DataStore::c_DontWriteOut;
    particleList.registerInDataStore(flags);
    if (!m_isSelfConjugatedParticle && m_chargeConjugation) {
      StoreObjPtr<ParticleList> antiParticleList(m_antiListName);
      antiParticleList.registerInDataStore(flags);
    }
 
    if (m_recoilParticleType != 0 && m_recoilParticleType != 1 && m_recoilParticleType != 2)
      B2FATAL("Invalid recoil particle type = " << m_recoilParticleType <<
              "! Valid values are 0 (not a recoil), 1 (recoiling against e+e- and daughters), 2 (daughter of a recoil)");
  }

initialize() [7/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 75 of file ParticleCombinerFromMCModule.cc.

initialize() [8/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 56 of file ParticleSelectorModule.cc.

  {
    // obtain the input and output particle lists from the decay string
    bool valid = m_decaydescriptor.init(m_decayString);
    if (!valid)
      B2ERROR("ParticleSelectorModule::initialize Invalid input DecayString: " << m_decayString);
 
    int nProducts = m_decaydescriptor.getNDaughters();
    if (nProducts > 0)
      B2ERROR("ParticleSelectorModule::initialize Invalid input DecayString " << m_decayString
              << ". DecayString should not contain any daughters, only the mother particle.");
 
    // Mother particle
    const DecayDescriptorParticle* mother = m_decaydescriptor.getMother();
 
    m_listName = mother->getFullName();
 
    StoreObjPtr<ParticleList> particleList(m_listName);
    particleList.isRequired(m_listName);
 
    m_cut = Variable::Cut::compile(m_cutParameter);
 
    B2INFO("ParticleSelector: " << m_listName);
    B2INFO("   -> With cuts  : " << m_cutParameter);
  }

initialize() [9/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 79 of file BelleBremRecoveryModule.cc.

  {
    // check the validity of output ParticleList name
    bool valid = m_decaydescriptor.init(m_outputListName);
    if (!valid)
      B2ERROR("[BelleBremRecoveryModule] Invalid output ParticleList name: " << m_outputListName);
 
    // output particle
    const DecayDescriptorParticle* mother = m_decaydescriptor.getMother();
    m_pdgCode  = mother->getPDGCode();
    m_outputAntiListName = ParticleListName::antiParticleListName(m_outputListName);
 
    // get existing particle lists
    if (m_inputListName == m_outputListName) {
      B2ERROR("[BelleBremRecoveryModule] Input and output particle list names are the same: " << m_inputListName);
    } else if (!m_decaydescriptor.init(m_inputListName)) {
      B2ERROR("[BelleBremRecoveryModule] Invalid input particle list name: " << m_inputListName);
    } else {
      m_inputparticleList.isRequired(m_inputListName);
    }
 
    if (!m_decaydescriptorGamma.init(m_gammaListName)) {
      B2ERROR("[BelleBremRecoveryModule] Invalid gamma particle list name: " << m_gammaListName);
    } else {
      m_gammaList.isRequired(m_gammaListName);
    }
 
    // make output list
    DataStore::EStoreFlags flags = m_writeOut ? DataStore::c_WriteOut : DataStore::c_DontWriteOut;
    m_outputparticleList.registerInDataStore(m_outputListName, flags);
    m_outputAntiparticleList.registerInDataStore(m_outputAntiListName, flags);
 
    StoreArray<Particle> particles;
    StoreArray<PIDLikelihood> pidlikelihoods;
    particles.registerRelationTo(pidlikelihoods);
  }

initialize() [10/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 61 of file ParticleCopierModule.cc.

  {
    // Input lists
    for (const std::string& listName : m_inputListNames) {
      StoreObjPtr<ParticleList>().isRequired(listName);
    }
  }

initialize() [11/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 78 of file ParticleListManipulatorModule.cc.

initialize() [12/18]

void initialize ( )

overridevirtual

Use this to initialize resources or memory your module needs.

Also register any outputs of your module (StoreArrays, RelationArrays, StoreObjPtrs) here, see the respective class documentation for details.

Reimplemented from Module.

Definition at line 120 of file BremsFinderModule.cc.

initialize() [13/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 69 of file ParticleWeightingModule.cc.

initialize() [14/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 82 of file ParticleVertexFitterModule.cc.

initialize() [15/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 128 of file TagVertexModule.cc.

initialize() [16/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 70 of file ParticleWeightingLookUpCreatorModule.cc.

  {
    ParticleWeightingLookUpTable table = ParticleWeightingLookUpTable();
 
    if (!m_outOfRangeWeight.empty()) {
      table.defineOutOfRangeWeight(m_outOfRangeWeight);
    }
 
    if (!m_tableIDNotSpec.empty() and m_tableIDSpec.empty()) {
      for (auto entry : m_tableIDNotSpec) {
        WeightInfo info = std::get<0>(entry);
        NDBin bin = NDBinTupleToNDBin(std::get<1>(entry));
        table.addEntry(info, bin);
      }
    } else if (!m_tableIDSpec.empty() and m_tableIDNotSpec.empty()) {
      for (auto entry : m_tableIDSpec) {
        noIdEntry noid = std::get<0>(entry);
        double bin_id = std::get<1>(entry);
        WeightInfo info = std::get<0>(noid);
        NDBin bin = NDBinTupleToNDBin(std::get<1>(noid));
        table.addEntry(info, bin, bin_id);
      }
    } else {
      B2ERROR("Please define one table: with OR without specific bin IDs");
    }
 
    if (!m_outOfRangeWeight.empty()) {
      table.defineOutOfRangeWeight(m_outOfRangeWeight);
    }
    B2INFO("Printing LookUp table");
    table.printParticleWeightingLookUpTable();
 
    Belle2::DBImportObjPtr<Belle2::ParticleWeightingLookUpTable> importer{m_tableName};
    importer.construct(table);
    importer.import(Belle2::IntervalOfValidity(m_experimentLow, m_runLow, m_experimentHigh, m_runHigh));
 
  }

initialize() [17/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 70 of file MCMatcherParticlesModule.cc.

  {
    // check that there are MCParticles: shout if not
    if (!m_mcparticles.isValid()) {
      B2WARNING("No MCParticles array found!"
                << " This is obvously fine if you're analysing real data,"
                << " but you have added the MCMatcher module to your path,"
                << " did you mean to do this?");
      return;
    }
 
    // if we have MCParticles then continue with the initialisation
    m_particles.isRequired();
    m_particles.registerRelationTo(m_mcparticles);
    m_plist.isRequired(m_listName);
 
    bool legacyAlgorithm = AnalysisConfiguration::instance()->useLegacyMCMatching();
    B2INFO("MCMatcher module will search for Particle -> MCParticle associations for the ParticleList " << m_listName << ".");
    if (legacyAlgorithm)
      B2INFO(" - The MCMatcher will use legacy algorithm suitable for analysis of Belle MC or Belle II MC5.");
    else
      B2INFO("  - The MCMatcher will use default algorithm suitable for analysis of Belle II MC (for MC5 use legacy algorithm).");
  }

initialize() [18/18]

void initialize ( )

overridevirtual

Initialize the Module.

This method is called at the beginning of data processing.

Reimplemented from Module.

Definition at line 109 of file ParticleLoaderModule.cc.

  {
    B2INFO("ParticleLoader's Summary of Actions:");
 
    StoreArray<Particle> particles;
    StoreArray<MCParticle> mcparticles;
    StoreArray<PIDLikelihood> pidlikelihoods;
    StoreArray<TrackFitResult> trackfitresults;
    StoreObjPtr<ParticleExtraInfoMap> extraInfoMap;
    StoreObjPtr<EventExtraInfo> eventExtraInfo;
 
    particles.registerInDataStore();
    extraInfoMap.registerInDataStore();
    eventExtraInfo.registerInDataStore();
    //register relations if these things exists
    if (mcparticles.isOptional()) {
      particles.registerRelationTo(mcparticles);
    }
    if (pidlikelihoods.isOptional()) {
      particles.registerRelationTo(pidlikelihoods);
    }
    if (trackfitresults.isOptional()) {
      particles.registerRelationTo(trackfitresults);
    }
 
    if (m_useMCParticles) {
      mcparticles.isRequired();
    }
 
    if (m_decayStringsWithCuts.empty()) {
      B2WARNING("Obsolete usage of the ParticleLoader module (load all MDST objects as all possible Particle object types). Specify the particle type via decayStringsWithCuts module parameter instead.");
    } else {
      for (auto decayStringCutTuple : m_decayStringsWithCuts) {
 
        // parsing of the input tuple (DecayString, Cut)
        string decayString = get<0>(decayStringCutTuple);
        std::string cutParameter = get<1>(decayStringCutTuple);
 
        // obtain the output particle lists from the decay string
        bool valid = m_decaydescriptor.init(decayString);
        if (!valid)
          B2ERROR("ParticleLoaderModule::initialize Invalid input DecayString: " << decayString);
 
        // Mother particle
        const DecayDescriptorParticle* mother = m_decaydescriptor.getMother();
 
        int pdgCode  = mother->getPDGCode();
        string listName = mother->getFullName();
 
        // special case. if the list is called "all" it may not have a
        // corresponding cut string this can introduce very dangerous bugs
        string listLabel = mother->getLabel();
        if (listLabel == "all")
          if (cutParameter != "")
            B2FATAL("You have tried to create a list " << listName << " with cuts! This is *very* error prone, so it is now forbidden.");
 
        if (not isValidPDGCode(pdgCode) and (m_useMCParticles == false and m_useROEs == false))
          B2ERROR("Invalid particle type requested to be loaded. Set a valid decayString module parameter.");
 
        // if we're not loading MCParticles and we are loading K0S, Lambdas, or photons --> ee then this decaystring is a V0
        bool mdstSourceIsV0 = false;
        if (!m_useMCParticles &&
            (abs(pdgCode) == abs(Const::Kshort.getPDGCode()) || abs(pdgCode) == abs(Const::Lambda.getPDGCode())
             || (abs(pdgCode) == abs(Const::photon.getPDGCode()) && m_addDaughters == true)))
          mdstSourceIsV0 = true;
 
        int nProducts = m_decaydescriptor.getNDaughters();
        if (mdstSourceIsV0 == false) {
          if (nProducts > 0) {
            if (!m_useROEs) {
              B2ERROR("ParticleLoaderModule::initialize Invalid input DecayString " << decayString
                      << ". DecayString should not contain any daughters, only the mother particle.");
            } else {
              B2INFO("ParticleLoaderModule: Replacing the source particle list name by " <<
                     m_decaydescriptor.getDaughter(0)->getMother()->getFullName()
                     << " all other daughters will be ignored.");
              m_sourceParticleListName = m_decaydescriptor.getDaughter(0)->getMother()->getFullName();
            }
          }
        } else {
          if (nProducts != 2)
            B2ERROR("ParticleLoaderModule::initialize Invalid input DecayString " << decayString
                    << ". MDST source of the particle list is V0, DecayString should contain exactly two daughters, as well as the mother particle.");
          else {
            if (m_decaydescriptor.getDaughter(0)->getMother()->getPDGCode() * m_decaydescriptor.getDaughter(1)->getMother()->getPDGCode() > 0)
              B2ERROR("MDST source of the particle list is V0, the two daughters should have opposite charge");
          }
        }
 
        string antiListName = ParticleListName::antiParticleListName(listName);
        bool isSelfConjugatedParticle = (listName == antiListName);
 
        StoreObjPtr<ParticleList> particleList(listName);
        if (!particleList.isOptional()) {
          //if it doesn't exist:
 
          DataStore::EStoreFlags flags = m_writeOut ? DataStore::c_WriteOut : DataStore::c_DontWriteOut;
          particleList.registerInDataStore(flags);
          if (!isSelfConjugatedParticle) {
            StoreObjPtr<ParticleList> antiParticleList(antiListName);
            antiParticleList.registerInDataStore(flags);
          }
        } else {
          // TODO: test that this actually works
          B2WARNING("The ParticleList with name " << listName << " already exists in the DataStore. Nothing to do.");
          continue;
        }
 
        std::shared_ptr<Variable::Cut> cut = std::shared_ptr<Variable::Cut>(Variable::Cut::compile(cutParameter));
 
        // add PList to corresponding collection of Lists
        B2INFO(" o) creating (anti-)ParticleList with name: " << listName << " (" << antiListName << ")");
        if (m_useROEs) {
          B2INFO("   -> MDST source: RestOfEvents");
          m_ROE2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
        } else if (m_useMCParticles) {
          B2INFO("   -> MDST source: MCParticles");
          m_MCParticles2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
        } else {
          bool chargedFSP = Const::chargedStableSet.contains(Const::ParticleType(abs(pdgCode)));
          if (chargedFSP) {
            B2INFO("   -> MDST source: Tracks");
            m_Tracks2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
          }
 
          if (abs(pdgCode) == abs(Const::photon.getPDGCode())) {
            if (m_addDaughters == false) {
              B2INFO("   -> MDST source: ECLClusters");
              m_ECLClusters2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
            } else {
              B2INFO("   -> MDST source: V0");
              m_V02Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
            }
          }
 
          if (abs(pdgCode) == abs(Const::Kshort.getPDGCode())) {
            B2INFO("   -> MDST source: V0");
            m_V02Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
          }
 
          if (abs(pdgCode) == abs(Const::Klong.getPDGCode()) || abs(pdgCode) == abs(Const::neutron.getPDGCode())) {
            B2INFO("   -> MDST source: exclusively KLMClusters or exclusively ECLClusters (matching between those not used)");
            m_KLMClusters2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
            m_ECLClusters2Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
          }
 
          if (abs(pdgCode) == abs(Const::Lambda.getPDGCode())) {
            B2INFO("   -> MDST source: V0");
            m_V02Plists.emplace_back(pdgCode, listName, antiListName, isSelfConjugatedParticle, cut);
          }
        }
        B2INFO("   -> With cuts  : " << cutParameter);
      }
    }
 
 
    m_chargeZeroTrackCounts = std::vector<int>(m_Tracks2Plists.size(), 0);
    m_sameChargeDaughtersV0Counts = std::vector<int>(m_V02Plists.size(), 0);
  }

isUnique()

bool isUnique ( const std::vector< int > &  idSequence )

private

Compares input idSequence to all sequences already included in the list.

If sequence is not found in the list a sequence is found to be unique.

Definition at line 222 of file ParticleListManipulatorModule.cc.

makeGeneralFit()

bool makeGeneralFit ( )

private

TO DO: tag side vertex fit in the case of semileptonic tag side decay.

make the vertex fit on the tag side with chosen fit algorithm

Definition at line 683 of file TagVertexModule.cc.

makeKFourCMother()

bool makeKFourCMother ( analysis::FourCFitKFit &  kv, Particle *  p  )

private

Update mother particle after FourC fit using KFit.

Parameters

kv	reference to KFit MassFit object
p	pointer to particle

Returns

true for successful construction of mother

Definition at line 769 of file ParticleVertexFitterModule.cc.

makeKMassMother()

bool makeKMassMother ( analysis::MassFitKFit &  kv, Particle *  p  )

private

Update mother particle after mass fit using KFit.

Parameters

kv	reference to KFit MassFit object
p	pointer to particle

Returns

true for successful construction of mother

Definition at line 737 of file ParticleVertexFitterModule.cc.

makeKMassPointingVertexMother()

bool makeKMassPointingVertexMother ( analysis::MassPointingVertexFitKFit &  kv, Particle *  p  )

private

Update mother particle after mass-constrained vertex fit with additional pointing constraint using KFit.

Parameters

kv	reference to KFit MassPointingVertexFit object
p	pointer to particle

Returns

true for successful construction of mother

Definition at line 704 of file ParticleVertexFitterModule.cc.

makeKMassVertexMother()

bool makeKMassVertexMother ( analysis::MassVertexFitKFit &  kv, Particle *  p  )

private

Update mother particle after mass-constrained vertex fit using KFit.

Parameters

kv	reference to KFit MassVertexFit object
p	pointer to particle

Returns

true for successful construction of mother

Definition at line 674 of file ParticleVertexFitterModule.cc.

makeKVertexMother()

bool makeKVertexMother ( analysis::VertexFitKFit &  kv, Particle *  p  )

private

Update mother particle after unconstrained vertex fit using KFit.

Parameters

kv	reference to KFit VertexFit object
p	pointer to particle

Returns

true for successful construction of mother

Definition at line 644 of file ParticleVertexFitterModule.cc.

NDBinTupleToNDBin()

NDBin NDBinTupleToNDBin ( const NDBinTuple &  bin_tuple )

private

Currently, std::pair can not be retrieved from python list We will get ParticleWeightingLookUpTable entries with tuples and transform tuples to pairs here.

Some massaging of python input is needed.

Definition at line 57 of file ParticleWeightingLookUpCreatorModule.cc.

registerParticleRecursively()

void registerParticleRecursively

(

const DecayDescriptor &

decaydescriptor

)

Register particles which have (sub-)decay recursively.

The function is called in initialize().

Definition at line 134 of file ParticleCombinerFromMCModule.cc.

setLooseMCMatch()

void setLooseMCMatch ( const Particle *  particle )

private

Finds common mother of the majority of daughters.

The results are stored to extraInfo.

Definition at line 116 of file MCMatcherParticlesModule.cc.

setObj()

void setObj

(

T *

obj

)

Set the decaying object, e.g.

an MCParticle.

Definition at line 84 of file DecayTree.h.

terminate()

void terminate ( )

overridevirtual

Terminate the Module.

This method is called at the end of data processing.

Reimplemented from Module.

Definition at line 289 of file ParticleLoaderModule.cc.

updateMapOfTrackAndDaughter()

void updateMapOfTrackAndDaughter ( unsigned &  l, std::vector< std::vector< unsigned >> &  pars, std::vector< unsigned > &  pard, std::vector< Particle * > &  allparticles, const Particle *  daughter  )

private

update the map of daughter and tracks, find out which tracks belong to each daughter.

Parameters

l	represent the tracks ID
pars	map of all parameters
pard	vector of parameters
allparticles	vector of all particles
daughter	pointer to particle

Definition at line 830 of file ParticleVertexFitterModule.cc.

updateMasksWithParticles()

void updateMasksWithParticles ( const StoreObjPtr< RestOfEvent > &  roe, std::vector< const Particle * > &  particlesToUpdate, Particle::EParticleSourceObject  listType  )

private

Update ROE masks by excluding or keeping particles.

Parameters

Pointer	to RestOfEvent object for update
Reference	to particle collection
ParticleType	of the collection

Definition at line 133 of file RestOfEventUpdaterModule.cc.

  {
    for (auto& maskToUpdate : m_maskNamesForUpdating) {
      if (maskToUpdate == "") {
        B2FATAL("Cannot update ROE mask with no name!");
      }
      if (!roe->hasMask(maskToUpdate)) {
        // Change name to get all ROE particles in case of new mask
        roe->initializeMask(maskToUpdate, "ROEUpdaterModule");
      }
      roe->excludeParticlesFromMask(maskToUpdate, particlesToUpdate, listType, m_discard);
 
    }
  }

updateMasksWithV0()

void updateMasksWithV0 ( const StoreObjPtr< RestOfEvent > &  roe, std::vector< const Particle * > &  particlesToUpdate  )

private

Update ROE masks with provided composite particle collection.

Parameters

Pointer	to RestOfEvent object for update
Reference	to composite particle collection

Definition at line 113 of file RestOfEventUpdaterModule.cc.