6.3.1. VariableManager¶
The VariableManager handles all variables in basf2
analysis.
It is implemented as a singleton
C++ class with a python interface.
The C++ documentation is here.
Tip
For (unfortunate) historical reasons, the python accessor to the VariableManager
singleton is called variables
and is in the python variables
module.
This leads to strange-looking python import
commands.
For example:
from variables import variables
To avoid confusion, example/tutorial scripts often use a namespace alias vm
.
You might want to use this in your scripts.
from variables import variables as vm # shorthand for VariableManager
- class VariableManager¶
Singleton class to hold all variables and aliases in the current scope.
- addAlias(alias, expression)¶
Create a new alias.
Variable names are deliberately verbose and explicit (to avoid ambiguity). However, it is often not desirable to deal with long unwieldy variable names particularly in the context of Variable Manager Output.
Example:
Aliases to a verbose variable may be set with:
>>> from variables import variables as vm >>> vm.addAlias("shortname", "aReallyLongAndSpecificVariableName(1, 2, 3)")
See also
variables.utils.create_aliases
andvariables.utils.create_aliases_for_selected
might be helpful if you find yourself setting many aliases in your analysis script.Warning
The VariableManager instance is configured independently of the
basf2.Path
. In case of adding the same alias twice, the configuration just before callingbasf2.process
is what wins.
- getAliasNames()¶
Get a list of all alias names (in reverse order added)
Tip
This returns a
ROOT.vector
which you will probably need to convert into a pythonlist(str)
.>>> my_aliases = list(vm.getAliasNames())
- Returns
ROOT.vector
list of alias names
- addCollection(collection, variables)¶
Create a new variable collection.
Tip
This method takes a
ROOT.vector<string>
as input. It’s probably easier to usevariables.utils.add_collection
which wraps this function for you.- Parameters
collection (str) – The new collection to create.
variables – A
ROOT.std.vector(string)
instance of variables to add as the variable collection.
- Returns
True if the collection was successfully added
- getCollection(collection)¶
Get a list of all variables in the
collection
.- Parameters
collection (str) – The name of the existing variable collection
- Returns
ROOT.vector
list of variable names
- printAliases()¶
Prints all aliases currently registered. Useful to call just before calling
basf2.process
on an analysisbasf2.Path
when debugging.
6.3.2. Variables by group¶
Here is a categorised list of variables known to basf2
.
You can also look at the alphabetical index: basf2 Variable Index.
Kinematics¶
- ArmenterosDaughter1Qt¶
Transverse momentum of the first daughter with respect to the V0 mother. The mother is required to have exactly two daughters
- ArmenterosDaughter2Qt¶
Transverse momentum of the second daughter with respect to the V0 mother. The mother is required to have exactly two daughters
- ArmenterosLongitudinalMomentumAsymmetry¶
Longitudinal momentum asymmetry of V0’s daughters. The mother (V0) is required to have exactly two daughters
- E¶
energy
- ECLClusterE_uncertainty¶
energy uncertainty as given by the underlying ECL cluster.
- E_uncertainty¶
energy uncertainty (sqrt(sigma2))
- ErrM¶
uncertainty of invariant mass
- ImpactXY¶
The impact parameter of the given particle in the xy plane
- InvM¶
invariant mass (determined from particle’s daughter 4-momentum vectors). If this particle has no daughters, defaults to
M
.
- InvMLambda¶
Invariant mass (determined from particle’s daughter 4-momentum vectors), assuming the first daughter is a pion and the second daughter is a proton. If the particle has not 2 daughters, it returns just the mass value.
- M¶
The particle’s mass.
Note that this is context-dependent variable and can take different values depending on the situation. This should be the “best” value possible with the information provided.
If this particle is track- or cluster- based, then this is the value of the mass hypothesis.
If this particle is an MC particle then this is the mass of that particle.
If this particle is composite, then initially this takes the value of the invariant mass of the daughters.
If this particle is composite and a mass or vertex fit has been performed then this may be updated by the fit.
You will see a difference between this mass and the
InvM
.
- M2¶
The particle’s mass squared.
- Mbc¶
beam constrained mass
- PDG¶
PDG code
- Q¶
released energy in decay
- SigM¶
signed deviation of particle’s invariant mass from its nominal mass in units of the uncertainty on the invariant mass (dM/ErrM)
- b2bClusterPhi¶
Azimuthal angle in the lab system that is back-to-back to the particle’s associated ECLCluster in the CMS. Returns NAN if no cluster is found. Useful for low multiplicity studies.
- b2bClusterTheta¶
Polar angle in the lab system that is back-to-back to the particle’s associated ECLCluster in the CMS. Returns NAN if no cluster is found. Useful for low multiplicity studies.
- b2bPhi¶
Azimuthal angle in the lab system that is back-to-back to the particle in the CMS. Useful for low multiplicity studies.
- b2bTheta¶
Polar angle in the lab system that is back-to-back to the particle in the CMS. Useful for low multiplicity studies.
- cosAngleBetweenMomentumAndVertexVector¶
cosine of the angle between momentum and vertex vector (vector connecting ip and fitted vertex) of this particle
- cosAngleBetweenMomentumAndVertexVectorInXYPlane¶
cosine of the angle between momentum and vertex vector (vector connecting ip and fitted vertex) of this particle in xy-plane
- cosTheta¶
momentum cosine of polar angle
- cosThetaBetweenParticleAndNominalB¶
cosine of the angle in CMS between momentum the particle and a nominal B particle. It is somewhere between -1 and 1 if only a massless particle like a neutrino is missing in the reconstruction.
- cosThetaErr¶
error of momentum cosine of polar angle
- cosToThrustOfEvent¶
Returns the cosine of the angle between the particle and the thrust axis of the event, as calculate by the EventShapeCalculator module. buildEventShape() must be run before calling this variable
- dM¶
mass minus nominal mass
- dQ¶
released energy in decay minus nominal one
- deltaE¶
energy difference
- eRecoil¶
energy recoiling against given Particle
- m2Recoil¶
invariant mass squared of the system recoiling against given Particle
- m2RecoilSignalSide¶
Squared recoil mass of the signal side which is calculated in the CMS frame under the assumption that the signal and tag side are produced back to back and the tag side energy equals the beam energy. The variable must be applied to the Upsilon and the tag side must be the first, the signal side the second daughter
- mRecoil¶
Invariant mass of the system recoiling against given Particle
- momDevChi2¶
momentum deviation chi^2 value calculated aschi^2 = sum_i (p_i - mc(p_i))^2/sigma(p_i)^2, where sum runs over i = px, py, pz andmc(p_i) is the mc truth value and sigma(p_i) is the estimated error of i-th component of momentum vector
- momVertCovM(i, j)¶
returns the (i,j)-th element of the MomentumVertex Covariance Matrix (7x7). Order of elements in the covariance matrix is: px, py, pz, E, x, y, z.
- p¶
momentum magnitude
- pErr¶
error of momentum magnitude
- pRecoil¶
magnitude of 3 - momentum recoiling against given Particle
- pRecoilPhi¶
Azimuthal angle of a particle’s missing momentum
- pRecoilTheta¶
Polar angle of a particle’s missing momentum
- phi¶
momentum azimuthal angle in radians
- phiErr¶
error of momentum azimuthal angle in radians
- pt¶
transverse momentum
- ptErr¶
error of transverse momentum
- px¶
momentum component x
- pxErr¶
error of momentum component x
- pxRecoil¶
component x of 3-momentum recoiling against given Particle
- py¶
momentum component y
- pyErr¶
error of momentum component y
- pyRecoil¶
component y of 3-momentum recoiling against given Particle
- pz¶
momentum component z
- pzErr¶
error of momentum component z
- pzRecoil¶
component z of 3-momentum recoiling against given Particle
- theta¶
polar angle in radians
- thetaErr¶
error of polar angle in radians
- xp¶
scaled momentum: the momentum of the particle in the CMS as a fraction of its maximum available momentum in the collision
Helicity¶
- acoplanarityAngle¶
Acoplanarity angle (see
Particle::getAcoplanarity
) assuming a two body decay of the particle and its daughters. See PDG Polarization Review for the definition of the acoplanarity angle.
- cosAcoplanarityAngle(i, j)¶
Cosine of the acoplanarity angle (\(\Phi\) in the PDG Polarization Review). Given a two-body decay, the acoplanarity angle is defined as the angle between the two decay planes in the reference frame of the mother.
We calculate the acoplanarity angle as the angle between the two normal vectors of the decay planes. Each normal vector is the cross product of the momentum of one daughter (in the frame of the mother) and the momentum of one of the granddaughters (in the reference frame of the daughter).
This variable needs two integer arguments: the first one,
i
is the index of the first granddaughter, and the second one,j
the index of the second granddaughter.For example, in the decay \(B^0 \to \left(J/\psi \to \mu^+ \mu^-\right) \left(K^{*0} \to K^+ \pi^-\right)\), if the provided particle is \(B^0\) and the selected indices are (0, 0), the variable will return the acoplanarity using the \(\mu^+\) and the \(K^+\) granddaughters.
- cosHelicityAngle(i, j)¶
Cosine of the helicity angle between the momentum of the provided particle and the momentum of the selected granddaughter in the reference frame of the selected daughter (\(\theta_1\) and \(\theta_2\) in the PDG 2018, p. 722).
This variable needs two integer arguments: the first one,
i
, is the index of the daughter and the second one,j
is the index of the granddaughter.For example, in the decay \(B^0 \to \left(J/\psi \to \mu^+ \mu^-\right) \left(K^{*0} \to K^+ \pi^-\right)\), if the provided particle is \(B^0\) and the selected indices are (0, 0), the variable will return the angle between the momentum of the \(B^0\) and the momentum of the \(\mu^+\), both momenta in the rest frame of the \(J/\psi\).
This variable is needed for angular analyses of \(B\)-meson decays into two vector particles.
- cosHelicityAngleBeamMomentum(i)¶
Cosine of the helicity angle of the \(i\)-th daughter of the particle provided, assuming that the mother of the provided particle corresponds to the centre-of-mass system, whose parameters are automatically loaded by the function, given the accelerator’s conditions.
- cosHelicityAngleDaughter(i [, j])¶
Cosine of the helicity angle of the i-th daughter (see
Particle::getCosHelicityDaughter
). The optional second argument is the index of the granddaughter that defines the angle, default is 0.For example, in the decay: \(B^0 \to \left(J/\psi \to \mu^+ \mu^-\right) \left(K^{*0} \to K^+ \pi^-\right)\), if the provided particle is \(B^0\) and the selected index is 0, the variable will return the helicity angle of the \(\mu^+\). If the selected index is 1 the variable will return the helicity angle of the \(K^+\) (defined via the rest frame of the \(K^{*0}\)). In rare cases if one wanted the helicity angle of the second granddaughter, indices 1,1 would return the helicity angle of the \(\pi^-\)).
See PDG Polarization Review for the definition of the helicity angle.
- cosHelicityAngleMomentum¶
If the given particle has two daughters: cosine of the angle between the line defined by the momentum difference of the two daughters in the frame of the given particle (mother) and the momentum of the given particle in the lab frame.
If the given particle has three daughters: cosine of the angle between the normal vector of the plane defined by the momenta of the three daughters in the frame of the given particle (mother) and the momentum of the given particle in the lab frame.
Otherwise, it returns 0.
- cosHelicityAngleMomentumPi0Dalitz¶
To be used for the decay \(\pi^0 \to e^+ e^- \gamma\): cosine of the angle between the momentum of the gamma in the frame of the given particle (mother) and the momentum of the given particle in the lab frame.
Otherwise, it returns 0.
- cosHelicityAnglePrimary¶
Cosine of the helicity angle (see``Particle::getCosHelicity``) assuming the center of mass system as mother rest frame. See PDG Polarization Review for the definition of the helicity angle.
Tracking¶
Here is a list of track variables:
- chi2¶
Chi2 of the track fit. Computed based on pValue and ndf. Note that for pValue exactly equal to 0 it returns infinity(). For mdst versions < 5.1, returns quiet_NaN().
- d0¶
Signed distance to the POCA in the r-phi plane
- d0Err¶
Error of signed distance to the POCA in the r-phi plane
- d0Pull¶
(mc-meas)/err_meas for d0
- firstCDCLayer¶
First activated CDC layer associated to the track
- firstPXDLayer¶
First activated PXD layer associated to the track
- firstSVDLayer¶
First activated SVD layer associated to the track
- hasExtraCDCHitsInLayer(i)¶
[Eventbased] Returns 1 if a non-assigned hit exists in the specified CDC layer
- hasExtraCDCHitsInSuperLayer(i)¶
[Eventbased] Returns 1 if a non-assigned hit exists in the specified CDC SuperLayer
- helixExtPhi¶
Returns phi of extrapolated helix parameters (parameters (in cm): radius, z fwd, z bwd)
- helixExtTheta¶
Returns theta of extrapolated helix parameters (parameters (in cm): radius, z fwd, z bwd)
- lastCDCLayer¶
Last CDC layer associated to the track
- nCDCHits¶
Number of CDC hits associated to the track
- nExtraCDCHits¶
[Eventbased] The number of CDC hits in the event not assigned to any track
- nExtraCDCHitsPostCleaning¶
[Eventbased] The number of CDC hits in the event not assigned to any track nor very likely beam background (i.e. hits that survive a cleanup selection)
- nExtraCDCSegments¶
[Eventbased] The number of CDC segments not assigned to any track
- nPXDHits¶
Number of PXD hits associated to the track
- nSVDHits¶
Number of SVD hits associated to the track
- nVXDHits¶
Number of PXD and SVD hits associated to the track
- ndf¶
Number of degrees of freedom of the track fit. Note that it is not NHIT-5 due to outlier hit rejection. For mdst versions < 5.1, returns quiet_NaN().
- omega¶
Curvature of the track
- omegaErr¶
Error of curvature of the track
- omegaPull¶
(mc-meas)/err_meas for omega
- pValue¶
chi2 probability of the track fit
- phi0¶
Angle of the transverse momentum in the r-phi plane
- phi0Err¶
Error of angle of the transverse momentum in the r-phi plane
- phi0Pull¶
(mc-meas)/err_meas for phi0
- tanLambda¶
Slope of the track in the r-z plane
- tanLambdaErr¶
Error of slope of the track in the r-z plane
- tanLambdaPull¶
(mc-meas)/err_meas for tanLambda
- trackFindingFailureFlag¶
[Eventbased] A flag set by the tracking if there is reason to assume there was a track in the event missed by the tracking, or the track finding was (partly) aborted for this event.
- trackFitHypothesisPDG¶
PDG code of the track hypothesis actually used for the fit
- trackNECLClusters¶
Number ecl clusters matched to the track. This is always 0 or 1 with newer versions of ECL reconstruction.
- z0¶
z coordinate of the POCA
- z0Err¶
Error of z coordinate of the POCA
- z0Pull¶
(mc-meas)/err_meas for z0
V0 Tracking¶
Here is a list of track variables for V0 daughters:
- V0Deltad0¶
Return the difference between d0 impact parameters of V0’s daughters with the V0 vertex point as a pivot for the track.
- V0Deltaz0¶
Return the difference between z0 impact parameters of V0’s daughters with the V0 vertex point as a pivot for the track.
- V0d0(id)¶
Return the d0 impact parameter of a V0’s daughter with daughterID index with the V0 vertex point as a pivot for the track.
- V0z0(id)¶
Return the z0 impact parameter of a V0’s daughter with daughterID index with the V0 vertex point as a pivot for the track.
- convertedPhotonDelR(i, j)¶
Discriminating variable Delta-R calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonDelTanLambda(i, j)¶
Discriminating variable Delta-TanLambda calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonDelZ(i, j)¶
Discriminating variable Delta-Z calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonInvariantMass(i, j)¶
Invariant mass of the i-j daughter system as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonPx(i, j)¶
Estimate of x-component of photon momentum calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonPy(i, j)¶
Estimate of y-component of photon momentum calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonPz(i, j)¶
Estimate of z-component of photon momentum calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonRho(i, j)¶
Estimate of vertex Rho calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonX(i, j)¶
Estimate of vertex X coordinate calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonY(i, j)¶
Estimate of vertex Y coordinate calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- convertedPhotonZ(i, j)¶
Estimate of vertex Z coordinate calculated for daughters (i,j) as defined in https://indico.belle2.org/event/3644/contributions/18622/attachments/9401/14443/Photon_vertexin_B2GM.pdf, assuming it’s a converted photon
- v0DaughterCov(i, j)¶
j-th element of the 15 covariance matrix elements (at IP perigee) of the i-th daughter track. (0,0), (0,1) … (1,1), (1,2) … (2,2) …
- v0DaughterD0(i)¶
d0 of the i-th daughter track fit
- v0DaughterD0Error(i)¶
d0 error of the i-th daughter track fit
- v0DaughterD0PullWithOriginAsPivot(i)¶
d0 pull of the i-th daughter track with the origin as the track pivot
- v0DaughterD0PullWithTrueVertexAsPivot(i)¶
d0 pull of the i-th daughter track with the true V0 vertex as the track pivot
- v0DaughterFirstCDCLayer(i)¶
First activated CDC layer associated to the i-th daughter track
- v0DaughterFirstPXDLayer(i)¶
First activated PXD layer associated to the i-th daughter track
- v0DaughterFirstSVDLayer(i)¶
First activated SVD layer associated to the i-th daughter track
- v0DaughterLastCDCLayer(i)¶
Last CDC layer associated to the i-th daughter track
- v0DaughterNCDCHits(i)¶
Number of CDC hits associated to the i-th daughter track
- v0DaughterNPXDHits(i)¶
Number of PXD hits associated to the i-th daughter track
- v0DaughterNSVDHits(i)¶
Number of SVD hits associated to the i-th daughter track
- v0DaughterNVXDHits(i)¶
Number of PXD+SVD hits associated to the i-th daughter track
- v0DaughterOmega(i)¶
omega of the i-th daughter track fit
- v0DaughterOmegaError(i)¶
omega error of the i-th daughter track fit
- v0DaughterOmegaPullWithOriginAsPivot(i)¶
omega pull of the i-th daughter track with the origin as the track pivot
- v0DaughterOmegaPullWithTrueVertexAsPivot(i)¶
omega pull of the i-th daughter track with the true V0 vertex as the track pivot
- v0DaughterPValue(i)¶
chi2 probalility of the i-th daughter track fit
- v0DaughterPhi0(i)¶
phi0 of the i-th daughter track fit
- v0DaughterPhi0Error(i)¶
phi0 error of the i-th daughter track fit
- v0DaughterPhi0PullWithOriginAsPivot(i)¶
phi0 pull of the i-th daughter track with the origin as the track pivot
- v0DaughterPhi0PullWithTrueVertexAsPivot(i)¶
phi0 pull of the i-th daughter track with the true V0 vertex as the track pivot
- v0DaughterTanLambda(i)¶
tan(lambda) of the i-th daughter track fit
- v0DaughterTanLambdaError(i)¶
tan(lambda) error of the i-th daughter track fit
- v0DaughterTanLambdaPullWithOriginAsPivot(i)¶
tan(lambda) pull of the i-th daughter track with the origin as the track pivot
- v0DaughterTanLambdaPullWithTrueVertexAsPivot(i)¶
tan(lambda) pull of the i-th daughter track with the true V0 vertex as the track pivot
- v0DaughterTau(i, j)¶
j-th track parameter (at IP perigee) of the i-th daughter track. j: 0:d0, 1:phi0, 2:omega, 3:z0, 4:tanLambda
- v0DaughterZ0(i)¶
z0 of the i-th daughter track fit
- v0DaughterZ0Error(i)¶
z0 error of the i-th daughter track fit
- v0DaughterZ0PullWithOriginAsPivot(i)¶
z0 pull of the i-th daughter track with the origin as the track pivot
- v0DaughterZ0PullWithTrueVertexAsPivot(i)¶
z0 pull of the i-th daughter track with the true V0 vertex as the track pivot
flag for V0 daughters sharing the first(innermost) VXD hit. 0x1(0x2) bit represents V/z(U/r-phi)-hit share.
flag for V0 daughters sharing the first(innermost) VXD U-side hit.
flag for V0 daughters sharing the first(innermost) VXD V-side hit.
PID¶
Here is a list of particle identification variables:
Warning
The definitions of the default PID variables have changed between release-01 and release-02.
Prior to release-02-00-00 (i.e. in release-01-XX-YY) each ID was calculated against the pion likelihood alone, or the kaon in the case of the pion itself. Namely the pair probability (also known as the binary probability) was returned:
for all particles: \(\text{<Part>ID}=\mathcal{L}_{\text{<Part>}}/\mathcal{L}_\pi\), where \(\text{<Part>}\in[e,\mu,K,p,d]\).
for pions: \(\text{PionID}=\mathcal{L}_\pi/\mathcal{L}_K\).
In other words, pionID was sensitive only to the pion-kaon mis-id, and not to the pion-proton or pion-muon mis-identification.
- binaryPID(pdgCode1, pdgCode2)¶
Returns the binary probability for the first provided mass hypothesis with respect to the second mass hypothesis using all detector components
- binaryPID_noSVD(pdgCode1, pdgCode2)¶
Returns the binary probability for the first provided mass hypothesis with respect to the second mass hypothesis using all detector components, excluding the SVD.
- deuteronID¶
deuteron identification probability defined as \(\mathcal{L}_d/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors
- deuteronID_noSVD¶
(SPECIAL (TEMP) variable) deuteron identification probability defined as \(\mathcal{L}_d/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors excluding the SVD
- electronID¶
electron identification probability defined as \(\mathcal{L}_e/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors
- electronID_noSVD¶
(SPECIAL (TEMP) variable) electron identification probability defined as \(\mathcal{L}_e/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors excluding the SVD
- electronID_noTOP¶
(SPECIAL (TEMP) variable) electron identification probability defined as \(\mathcal{L}_e/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors excluding the TOP
- kaonID¶
kaon identification probability defined as \(\mathcal{L}_K/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors
- kaonID_noSVD¶
(SPECIAL (TEMP) variable) kaon identification probability defined as \(\mathcal{L}_K/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors excluding the SVD
- muonID¶
muon identification probability defined as \(\mathcal{L}_\mu/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors
- muonID_noSVD¶
(SPECIAL (TEMP) variable) muon identification probability defined as \(\mathcal{L}_\mu/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors excluding the SVD
- nbarID¶
Returns MVA classifier for antineutron PID.
1 signal(antineutron) like
0 background like
-1 invalid using this PID due to some ECL variables used unavailable
This PID is only for antineutron. Neutron is also considered as background. The variables used are
clusterPulseShapeDiscriminationMVA
,clusterE
,clusterLAT
,clusterE1E9
,clusterE9E21
,clusterAbsZernikeMoment40
,clusterAbsZernikeMoment51
,clusterZernikeMVA
.
- particleID¶
the particle identification probability under the particle’s own hypothesis, using info from all available detectors
- pionID¶
pion identification probability defined as \(\mathcal{L}_\pi/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors
- pionID_noSVD¶
(SPECIAL (TEMP) variable) pion identification probability defined as \(\mathcal{L}_\pi/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors excluding the SVD
- protonID¶
proton identification probability defined as \(\mathcal{L}_p/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors
- protonID_noSVD¶
(SPECIAL (TEMP) variable) proton identification probability defined as \(\mathcal{L}_p/(\mathcal{L}_e+\mathcal{L}_\mu+\mathcal{L}_\pi+\mathcal{L}_K+\mathcal{L}_p+\mathcal{L}_d)\), using info from all available detectors excluding the SVD
Basic particle information¶
- charge¶
Returns electric charge of particle in units of \(e\).
- chiProb¶
A context-dependent \(\chi^2\) probability for ‘the fit’ related to this particle.
If this particle is track-based, then this is the pvalue of the track fit (identical to
pValue
).If this particle is cluster-based then this variable is currently unused.
If this particle is composite and a vertex fit has been performed, then this is the \(\chi^2\) probability of the vertex fit result.
Tip
If multiple vertex fits are performed then the last one sets the
chiProb
overwriting all previous.See also
pValue
for tracks
- flavor¶
Returns 1.0 if particle is flavored type, 0.0 if it is unflavored.
- isFromECL¶
Returns 1.0 if this particle was created from an ECLCluster, 0 otherwise.
- isFromKLM¶
Returns 1.0 if this particle was created from a KLMCluster, 0 otherwise.
- isFromTrack¶
Returns 1.0 if this particle was created from a track, 0 otherwise.
- isFromV0¶
Returns 1.0 if this particle was created from a V0, 0 otherwise.
- isUnspecified¶
Returns 1 if the particle is marked as an unspecified object (like B0 -> @Xsd e+ e-), 0 otherwise
- mdstIndex¶
Store array index (0 - based) of the MDST object from which the Particle was created. It’s 0 for composite particles.
Tip
It is not a unique identifier of particle. For example, a pion and a gamma can have the same
mdstIndex
: pions are created from tracks whereas gammas are created from ECL clusters; tracks and ECL clusters are stored in different arrays. A photon may be created from ECL cluster with index 0 and a pion may be created from track with index 0 will both havemdstIndex
equal to 0, but they will be different particles.Tip
Tip
If you are looking for unique identifier of the particle, please use
uniqueParticleIdentifier
.
- nDaughters¶
Returns number of daughter particles
- particleSource¶
Returns mdst source used to create the particle. The meaning of the values are
0: undefined
1: created from track
2: created from ECL cluster
3: created from KLM cluster
4: created from V0
5: MC particle
6: composite particle
- uniqueParticleIdentifier¶
Returns unique identifier of final state particle. Particles created from the same object (e.g. from the same track) have different
uniqueParticleIdentifier
value.
PID for expert¶
These expert-level variables are metavariable that allow the used to access the LogLikelihood values, the binary likelihood ratios and the global likelihood ratios for any arbitrary detector combination of mass hypothesis. The accepted detector codes are SVD, TOP, CDC, ARICH, ECL, KLM and ALL.
If a likelihood is not available from the selected detector list, NaN is returned.
Warning
These variables are not to be used in physics analyses, but only by experts doing performance studies.
- pidChargedBDTScore(pdgCodeHyp, detector)¶
returns the charged Pid BDT score for a certain mass hypothesis with respect to all other charged stable particle hypotheses. The second argument specifies which BDT training to use: based on ‘ALL’ PID detectors (NB: ‘SVD’ is currently excluded), or ‘ECL’ only. The choice depends on the ChargedPidMVAMulticlassModule’s configuration.
- pidDeltaLogLikelihoodValueExpert(pdgCode1, pdgCode2, detectorList)¶
returns LogL(hyp1) - LogL(hyp2) (aka DLL) for two mass hypotheses and a set of detectors.
- pidIsMostLikely¶
Returns 1 if the PID likelihood for the particle given its PID is the largest one
- pidLogLikelihoodValueExpert(pdgCode, detectorList)¶
returns the log likelihood value of for a specific mass hypothesis and set of detectors.
- pidMissingProbabilityExpert(detectorList)¶
returns 1 if the PID probabiliy is missing for the provided detector list, otherwise 0.
- pidMostLikelyPDG¶
Returns PDG code of the largest PID likelihood, or NaN if PID information is not available.
- pidPairChargedBDTScore(pdgCodeHyp, pdgCodeTest, detector)¶
returns the charged Pid BDT score for a certain mass hypothesis with respect to an alternative hypothesis. The second argument specifies which BDT training to use: based on ‘ALL’ PID detectors (NB: ‘SVD’ is currently excluded), or ‘ECL’ only. The choice depends on the ChargedPidMVAModule’s configuration.
- pidPairProbabilityExpert(pdgCodeHyp, pdgCodeTest, detectorList)¶
Pair (or binary) probability for the pdgCodeHyp mass hypothesis respect to the pdgCodeTest one, using an arbitrary set of detectors. \(\mathcal{L}_{hyp}/(\mathcal{L}_{test}+\mathcal{L}_{hyp}\)
- pidProbabilityExpert(pdgCodeHyp, detectorList)¶
probability for the pdgCodeHyp mass hypothesis respect to all the other ones, using an arbitrary set of detectors \(\mathcal{L}_{hyp}/(\Sigma_{\text{all~hyp}}\mathcal{L}_{i}\).
ECL Cluster¶
Here is a list of variables related to ECL cluster. All ECLCluster-based variables return NaN if no ECLCluster is found.
Note
All floating type variables in the mdst dataobject ECLCluster use ROOT Double32_t types with specific range declaration to save disk storage. This has two important consequences for a user:
All ECL cluster variables have a limited precision. This precision is always better than the intrinsic ECL data acquisition precision. However, if these variables are histogrammed, binning effects are likely.
All ECL cluster variables are clipped at the lower and upper boundaries: Values below (above) these boundaries will be set to the lower (upper) bound.
Lower and upper limits, and precision of these variables are mentioned inside the note box below them. One should note this in the context of binning effects.
- beamBackgroundProbabilityMVA¶
Returns MVA classifier that uses shower shape variables to distinguish true clusters from beam background clusters.
1 for true photon clusters
0 for beam background clusters
The variables used in the training (in decreasing order of significance): clusterTiming, clusterE, clusterTheta, clusterZernikeMVA, clusterE1E9, clusterLat, clusterSecondMoment and clusterPhi.
- clusterAbsZernikeMoment40¶
Returns absolute value of Zernike moment 40 (\(|Z_{40}|\)). (shower shape variable).
Note
- clusterAbsZernikeMoment51¶
Returns absolute value of Zernike moment 51 (\(|Z_{51}|\)). (shower shape variable).
Note
- clusterCellID¶
Returns cellId of the crystal with highest energy in the ECLCluster.
- clusterClusterID¶
Returns ECL cluster ID of this ECL cluster within the connected region (CR) to which it belongs to.
- clusterConnectedRegionID¶
Returns ECL cluster’s connected region ID.
- clusterDeltaLTemp¶
- Returns DeltaL for the shower shape.A cluster comprises the energy depositions of several crystals. All these crystals have slightly different orientations in space. A shower direction can be constructed by calculating the weighted average of these orientations using the corresponding energy depositions as weights. The intersection (more precisely the point of closest approach) of the vector with this direction originating from the cluster center and an extrapolated track can be used as reference for the calculation of the shower depth. It is defined as the distance between this intersection and the cluster center.
Warning
This distance is calculated on the reconstructed level and is temporarily included to the ECL cluster MDST data format for studying purposes. If it is found that it is not crucial for physics analysis then this variable will be removed in future releases. Therefore, keep in mind that this variable might be removed in the future!
Note
- clusterE¶
Returns ECL cluster’s energy corrected for leakage and background.
The raw photon energy is given by the weighted sum of all ECL crystal energies within the ECL cluster. The weights per crystals are \(\leq 1\) after cluster energy splitting in the case of overlapping clusters. The number of crystals that are included in the sum depends on a initial energy estimation and local beam background levels at the highest energy crystal position. It is optimized to minimize the core width (resolution) of true photons. Photon energy distributions always show a low energy tail due to unavoidable longitudinal and transverse leakage that can be further modified by the clustering algorithm and beam backgrounds.The peak position of the photon energy distributions are corrected to match the true photon energy in MC:
Leakage correction: Using large MC samples of mono-energetic single photons, a correction factor \(f\) as function of reconstructed detector position, reconstructed photon energy and beam backgrounds is determined via \(f = \frac{\text{peak_reconstructed}}{\text{energy_true}}\).
Cluster energy calibration (data only): To reach the target precision of \(< 1.8\%\) energy resolution for high energetic photons, the remaining difference between MC and data must be calibrated using kinematically fit muon pairs. This calibration is only applied to data and not to MC and will take time to develop.
Energy Bias Correction module, sub-percent correction, is NOT applied on clusterE, but on photon energy and momentum. Only applied to data.
It is important to note that after perfect leakage correction and cluster energy calibration, the \(\pi^{0}\) mass peak will be shifted slightly to smaller values than the PDG average due to the low energy tails of photons. The \(\pi^{0}\) mass peak must not be corrected to the PDG value by adjusting the reconstructed photon energies. Selection criteria based on the mass for \(\pi^{0}\) candidates must be based on the biased value. Most analysis will used mass constrained \(\pi^{0}\) s anyhow.
Warning
We only store clusters with \(E > 20\,\) MeV.
Note
Please read this first.Lower limit: \(-5\) (\(e^{-5} = 0.00674\,\) GeV)Upper limit: \(3.0\) (\(e^3 = 20.08553\,\) GeV)Precision: \(18\) bitThis value can be changed to a different reference frame withuseCMSFrame
.
- clusterE1E9¶
Returns ratio of energies of the central crystal, E1, and 3x3 crystals, E9, around the central crystal. Since \(E1 \leq E9\), this ratio is \(\leq 1\) and tends towards larger values for photons and smaller values for hadrons.
Note
- clusterE9E21¶
Returns ratio of energies in inner 3x3 crystals, E9, and 5x5 crystals around the central crystal without corners. Since \(E9 \leq E21\), this ratio is \(\leq 1\) and tends towards larger values for photons and smaller values for hadrons.
Note
- clusterE9E25¶
Deprecated - kept for backwards compatibility - returns clusterE9E21.
- clusterEoP¶
Returns ratio of uncorrelated energy E over momentum p, a convenience alias for (clusterE / p).
- clusterErrorE¶
Returns ECL cluster’s uncertainty on energy (from background level and energy dependent tabulation).
- clusterErrorPhi¶
Returns ECL cluster’s uncertainty on \(\phi\) (from background level and energy dependent tabulation).
- clusterErrorTheta¶
Returns ECL cluster’s uncertainty on \(\theta\) (from background level and energy dependent tabulation).
- clusterErrorTiming¶
Returns ECL cluster’s timing uncertainty that contains \(99\%\) of true photons (dt99).
The photon timing uncertainty is currently determined using MC. The resulting parametrization depends on the true energy deposition in the highest energetic crystal and the local beam background level in that crystal. The resulting timing distribution is non-Gaussian and for each photon the value dt99 is stored, where \(|\text{timing}| / \text{dt99} < 1\) is designed to give a \(99\%\) timing efficiency for true photons from the IP. The resulting efficiency is approximately flat in energy and independent of beam background levels.
Very large values of dt99 are an indication of failed waveform fits in the ECL. We remove such clusters in most physics photon lists.
Note
Warning
In real data there will be a sizeable number of high energetic Bhabha events (from previous or later bunch collisions) that can easily be rejected by timing cuts. However, these events create large ECL clusters that can overlap with other ECL clusters and it is not clear that a simple rejection is the correction strategy.
- clusterHasFailedErrorTiming¶
Status bit for if the ECL cluster’s timing uncertainty calculation failed. Photon timing is given by the fitted time of the recorded waveform of the highest energetic crystal in a cluster; however, that fit can fail and so this variable tells the user if that has happened.
- clusterHasFailedTiming¶
Status bit for if the ECL cluster’s timing fit failed. Photon timing is given by the fitted time of the recorded waveform of the highest energetic crystal in a cluster; however, that fit can fail and so this variable tells the user if that has happened.
- clusterHasNPhotons¶
Returns 1.0 if cluster has the ‘N photons’ hypothesis (historically called ‘N1’), 0.0 if not, and NaN if no cluster is associated to the particle.
- clusterHasNeutralHadron¶
Returns 1.0 if the cluster has the ‘neutral hadrons’ hypothesis (historically called ‘N2’), 0.0 if not, and NaN if no cluster is associated to the particle.
- clusterHasPulseShapeDiscrimination¶
Status bit to indicate if cluster has digits with waveforms that passed energy and \(\chi^2\) thresholds for computing PSD variables.
- clusterHighestE¶
Returns energy of the highest energetic crystal in the ECL cluster after reweighting.
Warning
This variable must be used carefully since it can bias shower selection towards photons that hit crystals in the center and hence have a large energy deposition in the highest energy crystal.
Note
Please read this first.Lower limit: \(-5\) (\(e^{-5} = 0.00674\,\) GeV)Upper limit: \(3.0\) (\(e^3 = 20.08553\,\) GeV)Precision: \(18\) bit
- clusterKlId¶
Returns MVA classifier that uses ECL clusters variables to discriminate Klong clusters from em background.
1 for Kl
0 for background
- clusterLAT¶
Returns lateral energy distribution (shower variable). It is defined as following:
\[S = \frac{\sum_{i=2}^{n} w_{i} E_{i} r^2_{i}}{(w_{0} E_{0} + w_{1} E_{1}) r^2_{0} + \sum_{i=2}^{n} w_{i} E_{i} r^2_{i}}\]where \(E_{i} = (E_{0}, E_{1}, ...)\) are the single crystal energies sorted by energy (\(E_{0}\) is the highest energy and \(E_{1}\) the second highest), \(w_{i}\) is the crystal weight, \(r_{i}\) is the distance of the \(i\)-th digit to the shower center projected to a plane perpendicular to the shower axis, and \(r_{0} \approx 5\,cm\) is the distance between two crystals.
clusterLAT peaks around 0.3 for radially symmetrical electromagnetic showers and is larger for hadronic events, and electrons with a close-by radiative or Bremsstrahlung photon.
Note
- clusterMdstIndex¶
StoreArray index(0 - based) of the MDST ECLCluster (useful for track-based particles matched to a cluster).
- clusterNHits¶
Returns sum of weights \(w_{i}\) (\(w_{i} \leq 1\)) of all crystals in an ECL cluster. For non-overlapping clusters this is equal to the number of crystals in the cluster. In case of energy splitting among nearby clusters, this can be a non-integer value.
Note
Please read this first.Lower limit: \(0.0\)Upper limit: \(200.0\)Precision: \(10\) bitIf fractional weights are not of interest, this value should be cast to the nearest integer.
- clusterNumberOfHadronDigits¶
Returns ECL cluster’s number of hadron digits in cluster (pulse shape discrimination variable). Weighted sum of digits in cluster with significant scintillation emission (\(> 3\,\) MeV) in the hadronic scintillation component. Computed only using cluster digits with energy \(> 50\,\) MeV and good offline waveform fit \(\chi^2\).
Note
- clusterPhi¶
Returns ECL cluster’s azimuthal angle \(\phi\) (this is not generally equal to a photon azimuthal angle).
The direction of a cluster is given by the connecting line of \(\,(0,0,0)\,\) and cluster centroid position in the ECL.The cluster centroid position is calculated using up to 21 crystals (5x5 excluding corners) after cluster energy splitting in the case of overlapping clusters.The centroid position is the logarithmically weighted average of all crystals evaluated at the crystal centers. Cluster centroids are generally biased towards the centers of the highest energetic crystal. This effect is larger for low energetic photons.Beam backgrounds slightly decrease the position resolution, mainly for low energetic photons.Note
Radius of a cluster is almost constant in the barrel and should not be used directly in any selection.
Unlike for charged tracks, the uncertainty (covariance) of the photon directions is not determined based on individual cluster properties but taken from on MC-based parametrizations of the resolution as function of true photon energy, true photon direction and beam background level.
Warning
Users must use the actual particle direction (done automatically in the modularAnalysis using the average IP position (can be changed if needed)) and not the ECL Cluster direction (position in the ECL measured from \((0,0,0)\)) for particle kinematics.
Note
- clusterPhiID¶
Returns phiId of the crystal with highest energy in the ECLCluster.
- clusterPulseShapeDiscriminationMVA¶
Returns MVA classifier that uses pulse shape discrimination to identify electromagnetic vs hadronic showers.
1 for electromagnetic showers
0 for hadronic showers
- clusterR¶
Returns ECL cluster’s centroid distance from \((0,0,0)\).
- clusterReg¶
Returns an integer code for the ECL region of a cluster.
1: forward, 2: barrel, 3: backward,
11: between FWD and barrel, 13: between BWD and barrel,
0: otherwise
- clusterSecondMoment¶
Returns second moment \(S\). It is defined as:
\[S = \frac{\sum_{i=0}^{n} w_{i} E_{i} r^2_{i}}{\sum_{i=0}^{n} w_{i} E_{i}}\]where \(E_{i} = (E_0, E_1, ...)\) are the single crystal energies sorted by energy, \(w_{i}\) is the crystal weight, and \(r_{i}\) is the distance of the \(i\)-th digit to the shower center projected to a plane perpendicular to the shower axis.
Note
- clusterTheta¶
Returns ECL cluster’s polar angle \(\theta\) (this is not generally equal to a photon polar angle).
The direction of a cluster is given by the connecting line of \(\,(0,0,0)\,\) and cluster centroid position in the ECL.The cluster centroid position is calculated using up to 21 crystals (5x5 excluding corners) after cluster energy splitting in the case of overlapping clusters.The centroid position is the logarithmically weighted average of all crystals evaluated at the crystal centers. Cluster centroids are generally biased towards the centers of the highest energetic crystal. This effect is larger for low energetic photons.Beam backgrounds slightly decrease the position resolution, mainly for low energetic photons.Note
Radius of a cluster is almost constant in the barrel and should not be used directly in any selection.
Unlike for charged tracks, the uncertainty (covariance) of the photon directions is not determined based on individual cluster properties but taken from on MC-based parametrizations of the resolution as function of true photon energy, true photon direction and beam background level.
Warning
Users must use the actual particle direction (done automatically in the modularAnalysis using the average IP position (can be changed if needed)) and not the ECL Cluster direction (position in the ECL measured from \((0,0,0)\)) for particle kinematics.
Note
- clusterThetaID¶
Returns thetaId of the crystal with highest energy in the ECLCluster.
- clusterTiming¶
Returns the time of the ECL cluster. It is calculated as the Photon timing minus the Event t0. Photon timing is given by the fitted time of the recorded waveform of the highest energy crystal in the cluster. After all calibrations and corrections (including Time-Of-Flight), photons from the interaction point (IP) should have a Photon timing that corresponds to the Event t0, \(t_{0}\). The Event t0 is the time of the event and may be measured by a different sub-detector (see Event t0 documentation). For an ECL cluster produced at the interaction point in time with the event, the cluster time should be consistent with zero within the uncertainties. Special values are returned if the fit for the Photon timing fails (see documentation for
clusterHasFailedTiming
). (For MC, the calibrations and corrections are not fully simulated).Note
- clusterTrackMatch¶
Returns 1.0 if at least one reconstructed charged track is matched to the ECL cluster.
Every reconstructed charged track is extrapolated into the ECL. Every ECL crystal that is crossed by the track extrapolation is marked. Each ECL cluster that contains any marked crystal is matched to the track. Multiple tracks can be matched to one cluster and multiple clusters can be matched to one track. It is conceptually correct to have two tracks matched to the same cluster.
- clusterUncorrE¶
[Expert] [Calibration] Returns ECL cluster’s uncorrected energy. That is, before leakage corrections. This variable should only be used for study of the ECL. Please see
clusterE
.
- clusterZernikeMVA¶
Returns output of a MVA using eleven Zernike moments of the cluster. Zernike moments are calculated per shower in a plane perpendicular to the shower direction via
\[|Z_{nm}| = \frac{n+1}{\pi} \frac{1}{\sum_{i} w_{i} E_{i}} \left|\sum_{i} R_{nm}(\rho_{i}) e^{-im\alpha_{i}} w_{i} E_{i} \right|\]where n, m are the integers, \(i\) runs over the crystals in the shower, \(E_{i}\) is the energy of the i-th crystal in the shower, \(R_{nm}\) is a polynomial of degree \(n\), \(\rho_{i}\) is the radial distance of the \(i\)-th crystal in the perpendicular plane, and \(\alpha_{i}\) is the polar angle of the \(i\)-th crystal in the perpendicular plane. As a crystal can be related to more than one shower, \(w_{i}\) is the fraction of the energy of the \(i\)-th crystal associated with the shower.
More details about the implementation can be found in BELLE2-NOTE-TE-2017-001 .
More details about Zernike polynomials can be found in Wikipedia .
For cluster with hypothesisId==N1: raw MVA output.For cluster with hypothesisId==N2: 1 - prod{clusterZernikeMVA}, where the product is on all N1 showers belonging to the same connected region (shower shape variable).Note
- eclClusterOnlyInvariantMass¶
[Expert] The invariant mass calculated from all ECLCluster daughters (i.e. photons) and cluster-matched tracks using the cluster 4-momenta.
Used for ECL-based dark sector physics and debugging track-cluster matching.
- eclExtPhi¶
Returns extrapolated \(\phi\).
- eclExtPhiId¶
Returns extrapolated \(\phi\) ID.
- eclExtTheta¶
Returns extrapolated \(\theta\).
- maxWeightedDistanceFromAverageECLTime¶
Returns maximum weighted distance between time of the cluster of a photon and the ECL average time, amongst the clusters (neutrals) and matched clusters (charged) of daughters (of all generations) of the provided particle.
- minC2TDist¶
Returns distance between ECL cluster and nearest track hitting the ECL.
A cluster comprises the energy depositions of several crystals. All these crystals have slightly different orientations in space. A shower direction can be constructed by calculating the weighted average of these orientations using the corresponding energy depositions as weights. The intersection (more precisely the point of closest approach) of the vector with this direction originating from the cluster center and an extrapolated track can be used as reference for the calculation of the track depth. It is defined as the distance between this intersection and the track hit position on the front face of the ECL.
Note
This distance is calculated on the reconstructed level.
Note
- minC2TDistID¶
Nearest track array index
- minC2TDistVar(variable, particleList=pi-:all)¶
Returns variable value for the nearest track to the given ECL cluster. First argument is a variable name, e.g. nCDCHits. The second argument is the particle list name which will be used to pick up the nearest track, default is pi-:all.
- nECLClusterTrackMatches¶
Returns number of charged tracks matched to this cluster.
Note
Sometimes (perfectly correctly) two tracks are extrapolated into the same cluster.
For charged particles, this should return at least 1 (but sometimes 2 or more).
For neutrals, this should always return 0.
Returns NaN if there is no cluster.
- nECLOutOfTimeCrystals¶
[Eventbased] Returns the number of crystals (ECLCalDigits) that are out of time.
- nECLOutOfTimeCrystalsBWDEndcap¶
[Eventbased] Returns the number of crystals (ECLCalDigits) that are out of time in the backward endcap.
- nECLOutOfTimeCrystalsBarrel¶
[Eventbased] Returns the number of crystals (ECLCalDigits) that are out of time in the barrel.
- nECLOutOfTimeCrystalsFWDEndcap¶
[Eventbased] Returns the number of crystals (ECLCalDigits) that are out of time in the forward endcap.
- nRejectedECLShowers¶
[Eventbased] Returns the number of showers in the ECL that do not become clusters.
- nRejectedECLShowersBWDEndcap¶
[Eventbased] Returns the number of showers in the ECL that do not become clusters, from the backward endcap.
- nRejectedECLShowersBarrel¶
[Eventbased] Returns the number of showers in the ECL that do not become clusters, from the barrel.
- nRejectedECLShowersFWDEndcap¶
[Eventbased] Returns the number of showers in the ECL that do not become clusters, from the forward endcap.
- photonHasOverlap(cutString, photonlistname, tracklistname)¶
Returns true if the connected ECL region of the particle’s cluster is shared by another particle’s cluster. Neutral and charged cluster are considered. A cut string can be provided to ignore cluster that do not satisfy the given criteria. By default, the ParticleList
gamma:all
is used for the check of neutral ECL cluster, and the ParticleListe-:all
for the check of charged ECL cluster. However, one can customize the name of the ParticleLists via additional arguments. If no argument or only a cut string is provided andgamma:all
ore-:all
does not exist or if the variable is requested for a particle that is not a photon, NaN is returned.
- weightedAverageECLTime¶
Returns ECL weighted average time of all clusters (neutrals) and matched clusters (charged) of daughters (of any generation) of the provided particle.
There are also some special variables related to the MC matching of ECL clusters (specifically).
- clusterBestMCMatchWeight¶
returns the weight of the ECLCluster -> MCParticle relation for the relation with the largest weight.
- clusterBestMCPDG¶
returns the PDG code of the MCParticle for the ECLCluster -> MCParticle relation with the largest weight.
- clusterMCMatchWeight¶
Returns the weight of the ECLCluster -> MCParticle relation for the MCParticle matched to the particle. Returns NaN if: no cluster is related to the particle, the particle is not MC matched, or if there are no mcmatches for the cluster. Returns -1 if the cluster was matched to particles, but not the match of the particle provided.
Acceptance¶
Here is a list of variables for acceptance cuts:
- inARICHAcceptance¶
Returns 1.0 if particle is within ARICH geometrical and kinematical acceptance, 0.0 otherwise. This variable is an alias for
thetaInARICHAcceptance
.
- inCDCAcceptance¶
Returns 1.0 if particle is within CDC geometrical and kinematical acceptance, 0.0 otherwise. This variable is an alias for
thetaInCDCAcceptance
.
- inECLAcceptance¶
Returns 1.0 if particle is within ECL geometrical and kinematical acceptance, 0.0 otherwise.”); This variable is a combination of
thetaInEECLAcceptance
,thetaInBECLAcceptance
andptInBECLAcceptance
.
- inKLMAcceptance¶
Returns 1.0 if particle is within KLM geometrical and kinematical acceptance, 0.0 otherwise. This variable is a combination of
thetaInEKLMAcceptance
,thetaInBKLMAcceptance
andptInBKLMAcceptance
.
- inTOPAcceptance¶
Returns 1.0 if particle is within TOP geometrical and kinematical acceptance, 0.0 otherwise. This variable is a combination of
thetaInTOPAcceptance
andptInTOPAcceptance
.
- ptInBECLAcceptance¶
Returns 1.0 if particle transverse momentum \(p_t\) is within Barrel ECL acceptance, \(p_t > 0.28\) GeV, 0.0 otherwise.
- ptInBKLMAcceptance¶
Returns 1.0 if particle transverse momentum \(p_t\) is within Barrel KLM acceptance, \(p_t > 0.6\) GeV, 0.0 otherwise.
- ptInTOPAcceptance¶
Returns 1.0 if particle transverse momentum \(p_t\) is within TOP acceptance, \(p_t > 0.27\) GeV, 0.0 otherwise.
- thetaInARICHAcceptance¶
Returns 1.0 if particle is within ARICH angular acceptance, 0.0 otherwise. This variable checks if the particle polar angle \(\theta\) is within the range \(14^\circ < \theta < 30^\circ\). The polar angle is computed using only the initial particle momentum.
- thetaInBECLAcceptance¶
Returns 1.0 if particle is within Barrel ECL angular acceptance, 0.0 otherwise. This variable checks if the particle polar angle \(\theta\) is within the range \(32.2^\circ < \theta < 128.7^\circ\). The polar angle is computed using only the initial particle momentum.
- thetaInBKLMAcceptance¶
Returns 1.0 if particle is within Barrel KLM angular acceptance, 0.0 otherwise. This variable checks if the particle polar angle \(\theta\) is within the range \(37^\circ < \theta < 130^\circ\). The polar angle is computed using only the initial particle momentum.
- thetaInCDCAcceptance¶
Returns 1.0 if particle is within CDC angular acceptance, 0.0 otherwise. This variable checks if the particle polar angle \(\theta\) is within the range \(17^\circ < \theta < 150^\circ\). The polar angle is computed using only the initial particle momentum.
- thetaInECLAcceptance¶
Checks if particle is within ECL angular acceptance. This variable checks if the particle polar angle \(\theta\) is within certain ranges. Return values and the corresponding \(\theta\) ranges are the following:
0: Outside of ECL acceptance, \(\theta < 12.4^\circ\) or \(\theta < 155.1^\circ\).
1: Forward ECL, \(12.4^\circ < \theta < 31.4^\circ\);
2: Barrel ECL, \(32.2^\circ < \theta < 128.7^\circ\);
3: Backward ECL, \(130.7^\circ < \theta < 155.1^\circ\).
The polar angle is computed using only the initial particle momentum.
- thetaInEECLAcceptance¶
Returns 1.0 if particle is within Endcap ECL angular acceptance, 0.0 otherwise. This variable checks if the particle polar angle \(\theta\) is within the range \(12.4^\circ < \theta < 31.4^\circ\) or \(130.7^\circ < \theta < 155.1^\circ\). The polar angle is computed using only the initial particle momentum.
- thetaInEKLMAcceptance¶
Returns 1.0 if particle is within Endcap KLM angular acceptance, 0.0 otherwise. This variable checks if the particle polar angle \(\theta\) is within the range \(18^\circ < \theta < 47^\circ\) or \(122^\circ < \theta < 155^\circ\). The polar angle is computed using only the initial particle momentum.
- thetaInKLMAcceptance¶
Checks if particle is within KLM angular acceptance. This variable checks if the particle polar angle \(\theta\) is within certain ranges. Return values and the corresponding \(\theta\) ranges are the following:
0: Outside of KLM acceptance, \(\theta < 18^\circ\) or \(\theta < 155^\circ\).
1: Forward endcap, \(18^\circ < \theta < 37^\circ\);
2: Forward overlap, \(37^\circ < \theta < 47^\circ\);
3: Barrel, \(47^\circ < \theta < 122^\circ\);
4: Backward overlap, \(122^\circ < \theta < 130^\circ\);
5: Backward endcap, \(130^\circ < \theta < 155^\circ\).
The polar angle is computed using only the initial particle momentum.
- thetaInKLMOverlapAcceptance¶
Returns 1.0 if particle is within the angular region where KLM barrel and endcaps overlap, 0.0 otherwise. This variable checks if the particle polar angle \(\theta\) is within the range \(37^\circ < \theta < 47^\circ\) or \(122^\circ < \theta < 130^\circ\). The polar angle is computed using only the initial particle momentum.
- thetaInTOPAcceptance¶
Returns 1.0 if particle is within TOP angular acceptance, 0.0 otherwise. This variable checks if the particle polar angle \(\theta\) is within the range \(31^\circ < \theta < 128^\circ\). The polar angle is computed using only the initial particle momentum.
Trigger¶
Here is a list of trigger variables:
- L1FTDL(name)¶
[Eventbased] Returns the FTDL (Final Trigger Decision Logic, before prescale) status of the trigger bit with the given name.
- L1FTDLBit(i)¶
[Eventbased] Returns the FTDL (Final Trigger Decision Logic, before prescale) status of i-th trigger bit.
- L1Input(name)¶
[Eventbased] Returns the input bit status of the trigger bit with the given name.
- L1InputBit(i)¶
[Eventbased] Returns the input bit status of the i-th input trigger bit.
- L1PSNM(name)¶
[Eventbased] Returns the PSNM (Prescale And Mask, after prescale) status of the trigger bit with the given name.
- L1PSNMBit(i)¶
[Eventbased] Returns the PSNM (Prescale And Mask, after prescale) status of i-th trigger bit.
- L1PSNMBitPrescale(i)¶
[Eventbased] Returns the PSNM (prescale and mask) prescale of i-th trigger bit.
- L1Prescale(name)¶
[Eventbased] Returns the PSNM (prescale and mask) prescale of the trigger bit with the given name.
- L1TimeQuality¶
[Eventbased] Returns ETimingQuality time quality.
- L1TimeType¶
[Eventbased] Returns ETimingType time type.
- L1Trigger¶
[Eventbased] Returns 1 if at least one PSNM L1 trigger bit is true.
- isPoissonTriggerInInjectionVeto¶
[Eventbased] Returns 1 if the poisson random trigger is within the injection veto window.
- HighLevelTrigger¶
[Eventbased] 1.0 if event passes the HLT trigger, 0.0 if not
- SoftwareTriggerPrescaling(triggerIdentifier)¶
[Eventbased] return the prescaling for the specific software trigger identifier. Please note, this prescaling is taken from the currently setup database. It only corresponds to the correct HLT prescale if you are using the online database!If the trigger identifier is not found, returns NaN.
- SoftwareTriggerResult(triggerIdentifier)¶
[Eventbased] [Expert] returns the SoftwareTriggerCutResult, defined as reject (-1), accept (1), or noResult (0). If the trigger identifier is not found, returns NaN.
For example:
SoftwareTriggerResult(filter 1_Estargt1_GeV_cluster_no_other_cluster_Estargt0.3_GeV)
which is equivalent to
SoftwareTriggerResult(software_trigger_cut&filter&1_Estargt1_GeV_cluster_no_other_cluster_Estargt0.3_GeV)
Warning
the meanings of these change depending if using trigger or the skim stage, hence expert.
See also
b2hlt_triggers
for possible triggerIdentifiers.
- SoftwareTriggerResultNonPrescaled(triggerIdentifier)¶
[Eventbased] [Expert] returns the SoftwareTriggerCutResult, if this trigger would not be prescaled.Please note, this is not the final HLT decision! It is defined as reject (-1), accept (1), or noResult (0). Note that the meanings of these change depending if using trigger or the skim stage, hence expert.If the trigger identifier is not found, returns NaN.
Event¶
Here is a list of event variables:
- Ecms¶
[Eventbased] Returns center-of-mass energy.
- EventType¶
[Eventbased] EventType (0 MC, 1 Data)
Warning
Deprecated since version light-minos-2012.
Use
isMC
instead of this variable but keep in mind that the meaning of the outcome is reversed.
- IPCov(i, j)¶
[Eventbased] Returns (i,j)-th element of the covariance matrix of the measured interaction point.
- IPX¶
[Eventbased] Returns x coordinate of the measured interaction point.
Note
For old data and uncalibrated MC files this will return 0.0.
Note
You might hear tracking and calibration people refer to this as the
BeamSpot
.
- IPY¶
[Eventbased] Returns y coordinate of the measured interaction point.
- IPZ¶
[Eventbased] Returns z coordinate of the measured interaction point.
- beamE¶
[Eventbased] Returns total beam energy in the laboratory frame.
- beamPx¶
[Eventbased] Returns x component of total beam momentum in the laboratory frame.
- beamPy¶
[Eventbased] Returns y component of total beam momentum in the laboratory frame.
- beamPz¶
[Eventbased] Returns z component of total beam momentum in the laboratory frame.
- belleECLEnergy¶
[Eventbased][Legacy] Returns total energy in ECL in the event as used in Belle 1 analyses.
Warning
For Belle II use cases use either
totalEnergyOfParticlesInList(gamma:all)
, or (probably better) fill a photon list with some minimal cleanup cuts and use that insteafrom variables import variables as vm fillParticleList("gamma:cleaned", "E > 0.05 and isFromECL==1", path=path) fillParticleList("e+:cleaned", "clusterE > 0.05", path=path) vm.addAlias("myNeutralECLEnergy", "totalEnergyOfParticlesInList(gamma:cleaned)") vm.addAlias("myChargedECLEnergy", "totalEnergyOfParticlesInList(e+:cleaned)") vm.addAlias("myECLEnergy", "formula(myNeutralECLEnergy+myChargedECLEnergy)")
- date¶
[Eventbased] Returns the date when the event was recorded, a number of the form YYYYMMDD (in UTC).
See also
year
,eventTimeSeconds
,eventTimeSecondsFractionRemainder
, provided for convenience.
- eventTimeSeconds¶
[Eventbased] Time of the event in seconds (truncated down) since 1970/1/1 (Unix epoch).
- eventTimeSecondsFractionRemainder¶
[Eventbased] Remainder of the event time in fractions of a second.
Tip
Use eventTimeSeconds + eventTimeSecondsFractionRemainder to get the total event time in seconds.
- evtNum¶
[Eventbased] Returns the event number.
- expNum¶
[Eventbased] Returns the experiment number.
- genIPX¶
[Eventbased] Returns x coordinate of the interaction point used for the underlying MC generation. Returns NaN for data.
Note
This is normally smeared from 0.0
- genIPY¶
[Eventbased] Returns y coordinate of the interaction point used for the underlying MC generation. Returns NaN for data.
- genIPZ¶
[Eventbased] Returns z coordinate of the interaction point used for the underlying MC generation. Returns NaN for data.
- hasRecentInjection¶
[Eventbased] Returns 1 if an injection happened recently, 0 otherwise.
- injectionInHER¶
[Eventbased] Returns 1 if injection was in HER, 0 otherwise.
- isChargedBEvent¶
[Eventbased] Returns 1.0 if event contains a charged B-meson on generator level.
- isContinuumEvent¶
[Eventbased] Returns 1.0 if event doesn’t contain a \(\Upsilon(4S)\) particle on generator level, 0.0 otherwise.
- isMC¶
[Eventbased] Returns 1 if current basf2 process is running over simulated (Monte-Carlo) dataset and 0 in case of real experimental data.
- isNotContinuumEvent¶
[Eventbased] Returns 1.0 if event does contain an \(\Upsilon(4S)\) particle on generator level and therefore is not a continuum event, 0.0 otherwise.
- isUnmixedBEvent¶
[Eventbased] Returns 1.0 if the event contains opposite flavor neutral B-mesons on generator level, 0.0 in case of same flavor B-mesons and NaN if the event has no generated neutral B.
- nChargeZeroTrackFits¶
[Eventbased] Returns number of track fits with zero charge.
Note
Sometimes, track fits can have zero charge, if background or non IP originating tracks, for example, are fit from the IP. These tracks are excluded from particle lists, but a large amount of charge zero fits may indicate problems with whole event constraints or abnominally high beam backgrounds and/or noisy events.
- nKLMClusters¶
[Eventbased] Returns number of KLM clusters in the event.
- nMCParticles¶
[Eventbased] Returns number of MCParticles in the event.
- nTracks¶
[Eventbased] Returns the total number of tracks (unfiltered) in the event.
Warning
This variable is exceedingly background-dependent and should not really be used in any selections (other than perhaps for monitoring purposes).
See also
nCleanedTracks
for a more useful variable for use in selections.
- productionIdentifier¶
[Eventbased] Production identifier. Uniquely identifies an MC sample by the (grid-jargon) production ID. This is useful when analysing large MC samples split between more than one production or combining different MC samples (e.g. combining all continuum samples). In such cases the event numbers are sequential only within a production, so experiment/run/event will restart with every new sample analysed.
Tip
Experiment/run/event/production is unique for all MC samples. Experiment/run/event is unique for data.
- revolutionCounter2¶
[Eventbased] The lowest bit of revolution counter, i.e. return 0 or 1
Note
related to PXD data acquisition; PXD needs ~2 revolutions to read out one frame
- runNum¶
[Eventbased] Returns the run number.
- timeSinceLastInjectionClockTicks¶
[Eventbased] Time since the last injected bunch passed by the detector in micro seconds.
- timeSinceLastInjectionMicroSeconds¶
[Eventbased] Time since the last injected bunch passed by the detector in micro seconds.
- timeSinceLastInjectionSignalClockTicks¶
[Eventbased] Time since the last injection pre-kick signal in clock ticks (127MHz=RF/4 clock)
Warning
this returns the time without the delay until the injected bunch reaches the detector (which differs for HER/LER)
- timeSinceLastInjectionSignalMicroSeconds¶
[Eventbased] Time since the last injection pre-kick signal in micro seconds
Warning
this returns the time without the delay until the injected bunch reaches the detector (which differs for HER/LER)
- timeSincePrevTriggerClockTicks¶
[Eventbased] Time since the previous trigger in clock ticks (127MHz=RF/4 clock).
- timeSincePrevTriggerMicroSeconds¶
[Eventbased] Time since the previous trigger in micro seconds.
- triggeredBunchNumber¶
[Eventbased] Number of triggered bunch ranging from 0-1279.
Note
There are a maximum of 5120 buckets, which could each carry one bunch of e+/e-, but we only have 1280 clock ticks (=5120/4) to identify the bunches
- triggeredBunchNumberTTD¶
[Eventbased] Number of triggered bunch ranging from 0-1279.
Warning
This is the bunch number as provided by the TTD, which does not necessarily correspond to the ‘global’ SKB bunch number.
Note
There are a maximum of 5120 buckets, which could each carry one bunch of e+/e-, but we only have 1280 clock ticks (=5120/4) to identify the bunches.
- year¶
[Eventbased] Returns the year when the event was recorded (in UTC).
Tip
For more precise event time, see
eventTimeSeconds
andeventTimeSecondsFractionRemainder
.
Parameter Functions¶
Here is a list of variables that require a parameter:
- NumberOfMCParticlesInEvent(pdgcode)¶
Returns number of MC Particles (including anti-particles) with the given pdgcode in the event.
Used in the FEI to determine to calculate reconstruction efficiencies.
The variable is event-based and does not need a valid particle pointer as input.
- azimuthalAngleInDecayPlane(i, j)¶
Azimuthal angle of i-th daughter in decay plane towards projection of particle momentum into decay plane.
First we define the following symbols:
P: four-momentum vector of decaying particle in whose decay plane the azimuthal angle is measured
M: “mother” of p, however not necessarily the direct mother but any higher state, here the CMS itself is chosen
D1: daughter for which the azimuthal angle is supposed to be calculated
D2: another daughter needed to span the decay plane
L: normal to the decay plane (four-component vector)
L can be defined via the following relation:
\[L^{\sigma} = \delta^{\sigma\nu} \epsilon_{\mu\nu\alpha\beta} P^{\mu}D1^{\alpha}D2^{\beta}\]The azimuthal angle is given by
\[\phi \equiv \cos^{-1} \left(\frac{-\vec{M_{\parallel}} \cdot \vec{D1}}{|\vec{M_{\parallel}}| \cdot |\vec{D1}|}\right)\]For a frame independent formulation the three component vectors need to be written via invariant four-momentum vectors.
\[\begin{split}-\vec{M_{\parallel}} \cdot \vec{D1} &= \biggl[M - \frac{(M \cdot L)L}{L^2}\biggr] \cdot D1 - \frac{(M \cdot P)(D1 \cdot P)}{m^2_P}\\ |\vec{M_{\parallel}}| &= |\vec{M}| \sqrt{1 - \cos^2 \psi}\\ |\vec{M}| &= \sqrt{\frac{(M \cdot P)^2}{m^2_P} - m^2_M}\\ \cos \psi &= \frac{\vec{M} \cdot \vec{L}}{|\vec{M}| \cdot |\vec{L}|} = \frac{-M \cdot L}{|\vec{M}| \cdot \sqrt{-L^2}}\\ |\vec{D1}| &= \sqrt{\frac{(D1 \cdot P)^2}{m^2_P} - m^2_{D1}}\end{split}\]
- constant(float i)¶
Returns i.
Useful for debugging purposes and in conjunction with the formula meta-variable.
- daughterInvariantMass(i, j, ...)¶
Returns invariant mass of the given daughter particles. E.g.:
daughterInvariantMass(0, 1) returns the invariant mass of the first and second daughter.
daughterInvariantMass(0, 1, 2) returns the invariant mass of the first, second and third daughter.
Useful to identify intermediate resonances in a decay, which weren’t reconstructed explicitly.
Returns NaN if particle is nullptr or if the given daughter-index is out of bound (>= amount of daughters).
- daughterMCInvariantMass(i, j, ...)¶
Returns true invariant mass of the given daughter particles, same behaviour as daughterInvariantMass variable.
- decayAngle(i)¶
Angle in the mother’s rest frame between the reverted CMS momentum vector and the direction of the i-th daughter
- hasAncestor(PDG, abs)¶
Returns a positive integer if an ancestor with the given PDG code is found, 0 otherwise.
The integer is the level where the ancestor was found, 1: first mother, 2: grandmother, etc.
Second argument is optional, 1 means that the sign of the PDG code is taken into account, default is 0.
If there is no MC relations found, -1 is returned. In case of nullptr particle, NaN is returned.
- isAncestorOf(i, j, ...)¶
Returns a positive integer if daughter at position particle->daughter(i)->daughter(j)… is an ancestor of the related MC particle, 0 otherwise.
Positive integer represents the number of steps needed to get from final MC daughter to ancestor. If any particle or MCparticle is a nullptr, NaN is returned. If MC relations of any particle doesn’t exist, -1.0 is returned.
- massDifference(i)¶
Difference in invariant masses of this particle and its i-th daughter
- massDifferenceError(i)¶
Estimated uncertainty on difference in invariant masses of this particle and its i-th daughter
- massDifferenceSignificance(i)¶
Signed significance of the deviation from the nominal mass difference of this particle and its i-th daughter [(massDiff - NOMINAL_MASS_DIFF)/ErrMassDiff]
- pointingAngle(i)¶
Angle between i-th daughter’s momentum vector and vector connecting production and decay vertex of i-th daughter. This makes only sense if the i-th daughter has itself daughter particles and therefore a properly defined vertex.
- randomChoice(i, j, ...)¶
Returns random element of given numbers.
Useful for testing purposes.
Meta Functions¶
Here is a list of variables that returns extra info of a given particle:
- abs(variable)¶
Returns absolute value of the given variable. E.g. abs(mcPDG) returns the absolute value of the mcPDG, which is often useful for cuts.
- acos(variable)¶
Returns arccosine value of the given variable.
- angleToClosestInList(particleListName)¶
Returns the angle between this particle and the closest particle (smallest opening angle) in the list provided.
- angleToMostB2BInList(particleListName)¶
Returns the angle between this particle and the most back-to-back particle (closest opening angle to 180) in the list provided.
- asin(variable)¶
Returns arcsine of the given variable.
- atan(variable)¶
Returns arctangent value of the given variable.
- averageValueInList(particleListName, variable)¶
Returns the arithmetic mean of the given variable of the particles in the given particle list.
- closestInList(particleListName, variable)¶
Returns
variable
for the closest particle (smallest opening angle) in the list provided.
- conditionalVariableSelector(cut, variableIfTrue, variableIfFalse)¶
Returns one of the two supplied variables, depending on whether the particle passes the supplied cut. The first variable is returned if the particle passes the cut, and the second variable is returned otherwise.
- cos(variable)¶
Returns cosine value of the given variable.
- countDaughters(cut)¶
Returns number of direct daughters which satisfy the cut. Used by the skimming package (for what exactly?) Returns NaN if particle is a nullptr.
- countInList(particleList, cut='')¶
[Eventbased] Returns number of particle which pass given in cut in the specified particle list. Useful for creating statistics about the number of particles in a list. E.g.
countInList(e+, isSignal == 1)
returns the number of correctly reconstructed electrons in the event. The variable is event-based and does not need a valid particle pointer as input.
- daughter(i, variable)¶
Returns value of variable for the i-th daughter. E.g.
daughter(0, p)
returns the total momentum of the first daughter.daughter(0, daughter(1, p)
returns the total momentum of the second daughter of the first daughter.
Returns NaN if particle is nullptr or if the given daughter-index is out of bound (>= amount of daughters).
- daughterAngle(daughterIndex_1, daughterIndex_2[, daughterIndex_3])¶
Returns the angle in between any pair of particles belonging to the same decay tree.
The particles are identified via generalized daughter indexes, which are simply colon-separated lists of daughter indexes, ordered starting from the root particle. For example,
0:1:3
identifies the fourth daughter (3) of the second daughter (1) of the first daughter (0) of the mother particle.1
simply identifies the second daughter of the root particle.Both two and three generalized indexes can be given to
daughterAngle
. If two indices are given, the variable returns the angle between the momenta of the two given particles. If three indices are given, the variable returns the angle between the momentum of the third particle and a vector which is the sum of the first two daughter momenta.Tip
daughterAngle(0, 3)
will return the angle between the first and fourth daughter.daughterAngle(0, 1, 3)
will return the angle between the fourth daughter and the sum of the first and second daughter.daughterAngle(0:0, 3:0)
will return the angle between the first daughter of the first daughter, and the first daughter of the fourth daughter.
- daughterClusterAngleInBetween(i, j)¶
Returns function which returns the angle between clusters associated to the two daughters.If two indices given: returns the angle between the momenta of the clusters associated to the two given daughters.If three indices given: returns the angle between the momentum of the third particle’s cluster and a vector which is the sum of the first two daughter’s cluster momenta.Returns nan if any of the daughters specified don’t have an associated cluster.The arguments in the argument vector must be integers corresponding to the ith and jth (and kth) daughters.
- daughterCombination(variable, daughterIndex_1, daughterIndex_2 ... daughterIndex_n)¶
Returns a
variable
function only of the 4-momentum calculated on an arbitrary set of (grand)daughters.Warning
variable
can only be a function of the daughters’ 4-momenta.Daughters from different generations of the decay tree can be combined using generalized daughter indexes, which are simply colon-separated the list of daughter indexes, starting from the root particle: for example,
0:1:3
identifies the fourth daughter (3) of the second daughter (1) of the first daughter (0) of the mother particle.Tip
daughterCombination(M, 0, 3, 4)
will return the invariant mass of the system made of the first, fourth and fifth daughter of particle.daughterCombination(M, 0:0, 3:0)
will return the invariant mass of the system made of the first daughter of the first daughter and the first daughter of the fourth daughter.
- daughterDiffOf(i, j, variable)¶
Returns the difference of a variable between the two given daughters. E.g.
useRestFrame(daughterDiffOf(0, 1, p))
returns the momentum difference between first and second daughter in the rest frame of the given particle. (That means that it returns \(p_j - p_i\)) Nota Bene: for the particular case ‘variable=phi’ you should use thedaughterDiffOfPhi
function.
- daughterDiffOfClusterPhi(i, j)¶
Returns the difference in \(\phi\) between the ECLClusters of two given daughters. The difference is signed and takes account of the ordering of the given daughters. The function returns \(\phi_j - \phi_i\). The function returns NaN if at least one of the daughters is not matched to or not based on an ECLCluster.
- daughterDiffOfClusterPhiCMS(i, j)¶
Returns the difference in \(\phi\) between the ECLClusters of two given daughters in the CMS frame. The difference is signed and takes account of the ordering of the given daughters. The function returns \(\phi_j - \phi_i\). The function returns NaN if at least one of the daughters is not matched to or not based on an ECLCluster.
- daughterDiffOfPhi(i, j)¶
Returns the difference in \(\phi\) between the two given daughters. The difference is signed and takes account of the ordering of the given daughters. The function returns \(\phi_j - \phi_i\).
- daughterDiffOfPhiCMS(i, j)¶
Returns the difference in \(\phi\) between the two given daughters in the CMS frame. The difference is signed and takes account of the ordering of the given daughters. The function returns \(\phi_j - \phi_i\).
- daughterHighest(variable)¶
Returns the highest value of the given variable among all daughters. E.g.
useCMSFrame(daughterHighest(p))
returns the highest momentum in CMS frame.
- daughterInvM(i, j)¶
Returns the invariant Mass adding the Lorentz vectors of the given daughters. E.g.
daughterInvM(0, 1, 2)
returns the invariant Mass \(m = \sqrt{(p_0 + p_1 + p_2)^2}\) of first, second and third daughter.
- daughterLowest(variable)¶
Returns the lowest value of the given variable among all daughters. E.g.
useCMSFrame(daughterLowest(p))
returns the lowest momentum in CMS frame.
- daughterMotherDiffOf(i, variable)¶
Returns the difference of a variable between the given daughter and the mother particle itself. E.g.
useRestFrame(daughterMotherDiffOf(0, p))
returns the momentum difference between the given particle and its first daughter in the rest frame of the mother.
- daughterMotherNormDiffOf(i, variable)¶
Returns the normalized difference of a variable between the given daughter and the mother particle itself. E.g.
daughterMotherNormDiffOf(1, p)
returns the normalized momentum difference between the given particle and its second daughter in the lab frame.
- daughterNormDiffOf(i, j, variable)¶
Returns the normalized difference of a variable between the two given daughters. E.g.
daughterNormDiffOf(0, 1, p)
returns the normalized momentum difference between first and second daughter in the lab frame.
- daughterProductOf(variable)¶
Returns product of a variable over all daughters. E.g.
daughterProductOf(extraInfo(SignalProbability))
returns the product of the SignalProbabilitys of all daughters.
- daughterSumOf(variable)¶
Returns sum of a variable over all daughters. E.g.
daughterSumOf(nDaughters)
returns the number of grand-daughters.
- eclClusterSpecialTrackMatched(cut)¶
Returns if at least one Track that satisfies the given condition is related to the ECLCluster of the Particle.
- eventCached(variable)¶
[Eventbased] Returns value of event-based variable and caches this value in the EventExtraInfo. The result of second call to this variable in the same event will be provided from the cache. It is recommended to use this variable in order to declare custom aliases as event-based. This is necessary if using the eventwise mode of variablesToNtuple).
- eventExtraInfo(name)¶
[Eventbased] Returns extra info stored under the given name in the event extra info. The extraInfo has to be set first by another module like MVAExpert in event mode. If nothing is set under this name, NaN is returned.
- exp(variable)¶
Returns exponential evaluated for the given variable.
- extraInfo(name)¶
Returns extra info stored under the given name. The extraInfo has to be set by a module first. E.g.
extraInfo(SignalProbability)
returns the SignalProbability calculated by theMVAExpert
module. If nothing is set under the given name or if the particle is a nullptr, NaN is returned. In the latter case please useeventExtraInfo
if you want to access an EventExtraInfo variable.
- formula(v1 + v2 * [v3 - v4] / v5^v6)¶
Returns the result of the given formula, where v1 to vN are variables or floating point numbers. Currently the only supported operations are addition (
+
), subtraction (-
), multiplication (*
), division (/
) and power (^
or**
). Parenthesis can be in the form of square brackets[v1 * v2]
or normal brackets(v1 * v2)
. It will work also with variables taking arguments. Operator precedence is taken into account. For example(daughter(0, E) + daughter(1, E))**2 - p**2 + 0.138
Changed in version release-03-00-00: now both,
[]
and()
can be used for grouping operations,**
can be used for exponent and float literals are possible directly in the formula.
- genParticle(index, variable)¶
[Eventbased] Returns the
variable
for the ith generator particle. The arguments of the function must be theindex
of the particle in the MCParticle Array, andvariable
, the name of the function or variable for that generator particle. Ifindex
goes beyond the length of the MCParticles array, NaN will be returned.E.g.
genParticle(0, p)
returns the total momentum of the first MCParticle, which is the Upsilon(4S) in a generic decay.genParticle(0, mcDaughter(1, p)
returns the total momentum of the second daughter of the first MC Particle, which is the momentum of the second B meson in a generic decay.
- genUpsilon4S(variable)¶
[Eventbased] Returns the
variable
evaluated for the generator-level \(\Upsilon(4S)\). If no generator level \(\Upsilon(4S)\) exists for the event, NaN will be returned.E.g.
genUpsilon4S(p)
returns the total momentum of the \(\Upsilon(4S)\) in a generic decay.genUpsilon4S(mcDaughter(1, p)
returns the total momentum of the second daughter of the generator-level \(\Upsilon(4S)\) (i.e. the momentum of the second B meson in a generic decay.
- getVariableByRank(particleList, rankedVariableName, variableName, rank)¶
Returns the value of
variableName
for the candidate in theparticleList
with the requestedrank
.Note
The
BestCandidateSelection
module available viarankByHighest
/rankByLowest
has to be used before.Warning
The first candidate matching the given rank is used. Thus, it is not recommended to use this variable in conjunction with
allowMultiRank
in theBestCandidateSelection
module.The suffix
_rank
is automatically added to the argumentrankedVariableName
, which either has to be the name of the variable used to order the candidates or the selected outputVariable name without the ending_rank
. This means that your selected name for the rank variable has to end with_rank
.An example of this variable’s usage is given in the tutorial B2A602-BestCandidateSelection
- grandDaughterDecayAngle(i, j)¶
Returns the decay angle of the granddaughter in the daughter particle’s rest frame. It is calculated with respect to the reverted momentum vector of the particle. Two arguments representing the daughter and granddaughter indices have to be provided as arguments.
- grandDaughterDiffOf(i, j, variable)¶
Returns the difference of a variable between the first daughters of the two given daughters. E.g.
useRestFrame(grandDaughterDiffOf(0, 1, p))
returns the momentum difference between the first daughters of the first and second daughter in the rest frame of the given particle. (That means that it returns \(p_j - p_i\)) Nota Bene: for the particular case ‘variable=phi’ you should use thegrandDaughterDiffOfPhi
function.
- grandDaughterDiffOfClusterPhi(i, j)¶
Returns the difference in \(\phi\) between the ECLClusters of the daughters of the two given daughters. The difference is signed and takes account of the ordering of the given daughters. The function returns \(\phi_j - \phi_i\). The function returns NaN if at least one of the daughters is not matched to or not based on an ECLCluster.
- grandDaughterDiffOfPhi(i, j)¶
Returns the difference in \(\phi\) between the first daughters of the two given daughters. The difference is signed and takes account of the ordering of the given daughters. The function returns \(\phi_j - \phi_i\).
- ifNANgiveX(variable, x)¶
Returns x (has to be a number) if variable value is nan (determined via std::isnan(double)). Useful for technical purposes while training MVAs.
- invMassInLists(pList1, pList2, ...)¶
Returns the invariant mass of the combination of particles in the given particle lists.
- isDaughterOfList(particleListNames)¶
Returns 1 if the given particle is a daughter of at least one of the particles in the given particle Lists.
- isDescendantOfList(particleListName[, anotherParticleListName][, generationFlag = -1])¶
Returns 1 if the given particle appears in the decay chain of the particles in the given ParticleLists.
Passing an integer as the last argument, allows to check if the particle belongs to the specific generation:
isDescendantOfList(<particle_list>,1)
returns 1 if particle is a daughter of the list,isDescendantOfList(<particle_list>,2)
returns 1 if particle is a granddaughter of the list,isDescendantOfList(<particle_list>,3)
returns 1 if particle is a great-granddaughter of the list, etc.Default value is
-1
that is inclusive for all generations.
- isGrandDaughterOfList(particleListNames)¶
Returns 1 if the given particle is a grand daughter of at least one of the particles in the given particle Lists.
- isInList(particleListName)¶
Returns 1.0 if the particle is in the list provided, 0.0 if not. Note that this only checks the particle given. For daughters of composite particles, please see
isDaughterOfList
.
- isInfinity(variable)¶
Returns true if variable value evaluates to infinity (determined via std::isinf(double)). Useful for debugging.
- isMCDescendantOfList(particleListName[, anotherParticleListName][, generationFlag = -1])¶
Returns 1 if the given particle is linked to the same MC particle as any reconstructed daughter of the decay lists.
Passing an integer as the last argument, allows to check if the particle belongs to the specific generation:
isMCDescendantOfList(<particle_list>,1)
returns 1 if particle is matched to the same particle as any daughter of the list,isMCDescendantOfList(<particle_list>,2)
returns 1 if particle is matched to the same particle as any granddaughter of the list,isMCDescendantOfList(<particle_list>,3)
returns 1 if particle is matched to the same particle as any great-granddaughter of the list, etc.Default value is
-1
that is inclusive for all generations.
It makes only sense for lists created with
fillParticleListFromMC
function withaddDaughters=True
argument.
- isNAN(variable)¶
Returns true if variable value evaluates to nan (determined via std::isnan(double)). Useful for debugging.
- log(variable)¶
Returns natural logarithm evaluated for the given variable.
- log10(variable)¶
Returns base-10 logarithm evaluated for the given variable.
- matchedMC(variable)¶
Returns variable output for the matched MCParticle by constructing a temporary Particle from it. This may not work too well if your variable requires accessing daughters of the particle. E.g.
matchedMC(p)
returns the total momentum of the related MCParticle. Returns NaN if no matched MCParticle exists.
- matchedMCHasPDG(PDGCode)¶
Returns if the absolute value of aPDGCode of a MCParticle related to a Particle matches a given PDGCode.Returns 0/0.5/1 if PDGCode does not match/is not available/ matches
- max(var1, var2)¶
Returns max value of two variables.
- maxOpeningAngleInList(particleListName)¶
Returns maximum opening angle in the given particle List.
- maxPtInList(particleListName)¶
Returns maximum transverse momentum Pt in the given particle List.
- mcDaughter(i, variable)¶
Returns the value of the requested variable for the i-th Monte Carlo daughter of the particle.
Returns NaN if the particle is nullptr, if the particle is not matched to an MC particle, or if the i-th MC daughter does not exist.
E.g.
mcDaughter(0, PDG)
will return the PDG code of the first MC daughter of the matched MC particle of the reconstructed particle the function is applied to.The meta variable can also be nested:
mcDaughter(0, mcDaughter(1, PDG))
.
- mcDaughterAngle(daughterIndex_1, daughterIndex_2, [daughterIndex_3])¶
MC matched version of the
daughterAngle
function.
- mcDaughterDiffOf(i, j, variable)¶
MC matched version of the
daughterDiffOf
function.
- mcDaughterDiffOfPhi(i, j)¶
MC matched version of the
daughterDiffOfPhi
function.
- mcDaughterDiffOfPhiCMS(i, j)¶
MC matched version of the
daughterDiffOfPhiCMS
function.
- mcMother(variable)¶
Returns the value of the requested variable for the Monte Carlo mother of the particle.
Returns NaN if the particle is nullptr, if the particle is not matched to an MC particle, or if the MC mother does not exist.
E.g.
mcMother(PDG)
will return the PDG code of the MC mother of the matched MC particle of the reconstructed particle the function is applied to.The meta variable can also be nested:
mcMother(mcMother(PDG))
.
- mcParticleIsInMCList(particleListName)¶
Returns 1.0 if the particle’s matched MC particle is also matched to a particle in
particleListName
(or if either of the lists were filled from generator levelmodularAnalysis.fillParticleListFromMC
.)See also
isMCDescendantOfList
to check daughters.
- medianValueInList(particleListName, variable)¶
Returns the median value of the given variable of the particles in the given particle list.
- min(var1, var2)¶
Returns min value of two variables.
- modulo(variable, n)¶
Returns rest of division of variable by n.
- mostB2BInList(particleListName, variable)¶
Returns
variable
for the most back-to-back particle (closest opening angle to 180) in the list provided.
- nCleanedECLClusters(cut)¶
[Eventbased] Returns the number of clean Clusters in the event Clean clusters are defined by the clusters which pass the given cut assuming a photon hypothesis.
- nCleanedTracks(cut)¶
[Eventbased] Returns the number of clean Tracks in the event Clean tracks are defined by the tracks which pass the given cut assuming a pion hypothesis.
- nParticlesInList(particleListName)¶
[Eventbased] Returns number of particles in the given particle List.
- numberOfNonOverlappingParticles(pList1, pList2, ...)¶
Returns the number of non-overlapping particles in the given particle listsUseful to check if there is additional physics going on in the detector if one reconstructed the Y4S
- pValueCombination(p1, p2, ...)¶
Returns the combined p-value of the provided p-values according to the formula given in Nucl. Instr. and Meth. A 411 (1998) 449 . If any of the p-values is invalid, i.e. smaller than zero, -1 is returned.
- particleCached(variable)¶
Returns value of given variable and caches this value in the ParticleExtraInfo of the provided particle. The result of second call to this variable on the same particle will be provided from the cache.
- passesCut(cut)¶
Returns 1 if particle passes the cut otherwise 0. Useful if you want to write out if a particle would have passed a cut or not. Returns NaN if particle is a nullptr.
- passesEventCut(cut)¶
[Eventbased] Returns 1 if event passes the cut otherwise 0. Useful if you want to select events passing a cut without looping into particles, such as for skimming.
- sin(variable)¶
Returns sine value of the given variable.
- sourceObjectIsInList(particleListName)¶
Returns 1.0 if the underlying mdst object (e.g. track, or cluster) was used to create a particle in
particleListName
, 0.0 if not.Note
This only makes sense for particles that are not composite. Returns -1 for composite particles.
- tan(variable)¶
Returns tangent value of the given variable.
- totalECLEnergyOfParticlesInList(particleListName)¶
Returns the total ECL energy of particles in the given particle List.
- totalEnergyOfParticlesInList(particleListName)¶
Returns the total energy of particles in the given particle List.
- totalPxOfParticlesInList(particleListName)¶
Returns the total momentum Px of particles in the given particle List.
- totalPyOfParticlesInList(particleListName)¶
Returns the total momentum Py of particles in the given particle List.
- totalPzOfParticlesInList(particleListName)¶
Returns the total momentum Pz of particles in the given particle List.
- unmask(variable, flag1, flag2, ...)¶
unmask(variable, flag1, flag2, …) or unmask(variable, mask) sets certain bits in the variable to zero. For example, if you want to set the second, fourth and fifth bits to zero, you could call
unmask(variable, 2, 8, 16)
orunmask(variable, 26)
.
- useAlternativeDaughterHypothesis(variable, daughterIndex_1:newMassHyp_1, ..., daughterIndex_n:newMassHyp_n)¶
Returns a
variable
calculated using new mass hypotheses for (some of) the particle’s daughers.Warning
variable
can only be a function of the particle 4-momentum, which is re-calculated as the sum of the daughters’ 4-momenta. This means that if you made a kinematic fit without updating the daughters’ momenta, the result of this variable will not reflect the effect of the kinematic fit. Also, the track fit is not performed again: the variable only re-calculates the 4-vectors using different mass assumptions. The alternative mass assumpion is used only internally by the variable, and is not stored in the datastore (i.e the daughters are not permanently changed).Warning
Generalized daughter indexes are not supported (yet!): this variable can be used only on first-generation daughters.
Tip
useAlternativeDaughterHypothesis(M, 0:K+, 2:pi-)
will return the invariant mass of the particle assuming that the first daughter is a kaon and the third is a pion, instead of whatever was used in reconstructing the decay.useAlternativeDaughterHypothesis(mRecoil, 1:p+)
will return the recoil mass of the particle assuming that the second daughter is a proton instead of whatever was used in reconstructing the decay.
- useCMSFrame(variable)¶
Returns the value of the variable using the CMS frame as current reference frame. E.g.
useCMSFrame(E)
returns the energy of a particle in the CMS frame.
- useLabFrame(variable)¶
Returns the value of
variable
in the lab frame.Tip
The lab frame is the default reference frame, usually you don’t need to use this meta-variable. E.g.
useLabFrame(E)
returns the energy of a particle in the Lab frame, same as justE
.Specifying the lab frame is useful in some corner-cases. For example:
useRestFrame(daughter(0, formula(E - useLabFrame(E))))
which is the difference of the first daughter’s energy in the rest frame of the mother (current particle) with the same daughter’s lab-frame energy.
- useParticleRestFrame(variable, particleList)¶
Returns the value of the variable in the rest frame of the first Particle contained in the given ParticleList. It is strongly recommended to pass a ParticleList that contains at most only one Particle in each event. When more than one Particle is present in the ParticleList, only the first Particle in the list is used for computing the rest frame and a warning is thrown. If the given ParticleList is empty in an event, it returns NaN.
- useRecoilParticleRestFrame(variable, particleList)¶
Returns the value of the variable in the rest frame of recoil system against the first Particle contained in the given ParticleList. It is strongly recommended to pass a ParticleList that contains at most only one Particle in each event. When more than one Particle is present in the ParticleList, only the first Particle in the list is used for computing the rest frame and a warning is thrown. If the given ParticleList is empty in an event, it returns NaN.
- useRestFrame(variable)¶
Returns the value of the variable using the rest frame of the given particle as current reference frame. E.g.
useRestFrame(daughter(0, p))
returns the total momentum of the first daughter in its mother’s rest-frame
- useTagSideRecoilRestFrame(variable, daughterIndexTagB)¶
Returns the value of the variable in the rest frame of the recoiling particle to the tag side B meson. The variable should only be applied to an Upsilon(4S) list. E.g.
useTagSideRecoilRestFrame(daughter(1, daughter(1, p)), 0)
applied on a Upsilon(4S) list (Upsilon(4S)->B+:tag B-:sig
) returns the momentum of the second daughter of the signal B meson in the signal B meson rest frame.
- varFor(pdgCode, variable)¶
Returns the value of the variable for the given particle if its abs(pdgCode) agrees with the given one. E.g.
varFor(11, p)
returns the momentum if the particle is an electron or a positron.
- varForFirstMCAncestorOfType(type, variable)¶
Returns requested variable of the first ancestor of the given type. Ancestor type can be set up by PDG code or by particle name (check evt.pdl for valid particle names)
- varForMCGen(variable)¶
Returns the value of the variable for the given particle if the MC particle related to it is primary, not virtual, and not initial. If no MC particle is related to the given particle, or the MC particle is not primary, virtual, or initial, NaN will be returned. E.g.
varForMCGen(PDG)
returns the PDG code of the MC particle related to the given particle if it is primary, not virtual, and not initial.
- veto(particleList, cut, pdgCode = 11)¶
Combines current particle with particles from the given particle list and returns 1 if the combination passes the provided cut. For instance one can apply this function on a signal Photon and provide a list of all photons in the rest of event and a cut around the neutral Pion mass (e.g.
0.130 < M < 0.140
). If a combination of the signal Photon with a ROE photon fits this criteria, hence looks like a neutral pion, the veto-Metavariable will return 1
MC matching and MC truth¶
Here is a list of MC truth-related variables. For some variables, you will need to run truth matching in order to get sensible results.
from modularAnalysis import matchMCTruth
matchMCTruth("B0:myCandidates") # for example
Variables will also work on generator-level particles:
from modularAnalysis import fillParticleListFromMC
fillParticleListFromMC("B0:generator", "") # the generator-level B particles
- Eher¶
[Eventbased] The nominal HER energy used by the generator.
Warning
This variable does not make sense for data.
- Eler¶
[Eventbased] The nominal LER energy used by the generator.
Warning
This variable does not make sense for data.
- XAngle¶
[Eventbased] The nominal beam crossing angle in the x-z plane from generator level beam kinematics.
Warning
This variable does not make sense for data.
- YAngle¶
[Eventbased] The nominal beam crossing angle in the y-z plane from generator level beam kinematics.
Warning
This variable does not make sense for data.
- genMotherID¶
Check the array index of a particles generated mother
- genMotherID(i)
Check the array index of a particle n-th MC mother particle by providing an argument. 0 is first mother, 1 is grandmother etc.
- genMotherP¶
Generated momentum of a particles MC mother particle
- genMotherPDG¶
Check the PDG code of a particles MC mother particle
- genMotherPDG(i)
Check the PDG code of a particles n-th MC mother particle by providing an argument. 0 is first mother, 1 is grandmother etc.
- genNMissingDaughter(PDG)¶
Returns the number of missing daughters having assigned PDG codes. NaN if no MCParticle is associated to the particle.
- genNStepsToDaughter(i)¶
Returns number of steps to i-th daughter from the particle at generator level. NaN if no MCParticle is associated to the particle or i-th daughter. NaN if i-th daughter does not exist.
- genParticleID¶
Check the array index of a particle’s related MCParticle
- generatorEventWeight¶
[Eventbased] Returns the event weight produced by the event generator
- isBBCrossfeed¶
Returns 1 for crossfeed in reconstruction of given B meson, 0 for no crossfeed and NaN for no true B meson or failed truthmatching.
- isCloneTrack¶
Return 1 if the charged final state particle comes from a cloned track, 0 if not a clone. Returns NAN if neutral, composite, or MCParticle not found (like for data or if not MCMatched)
- isMisidentified¶
return 1 if the particle is misidentified: at least one of the final state particles has the wrong PDG code assignment (including wrong charge), 0 if PDG code is fine, and NaN if no related MCParticle could be found.
- isOrHasCloneTrack¶
Return 1 if the particle is a clone track or has a clone track as a daughter, 0 otherwise.
- isPrimarySignal¶
1.0 if Particle is correctly reconstructed (SIGNAL) and primary, 0.0 if not, and NaN if no related MCParticle could be found
- isSignal¶
1.0 if Particle is correctly reconstructed (SIGNAL), 0.0 if not, and NaN if no related MCParticle could be found. It behaves according to DecayStringGrammar.
- isSignalAcceptBremsPhotons¶
1.0 if Particle is correctly reconstructed (SIGNAL), 0.0 if not, and NaN if no related MCParticle could be found. Particles with gamma daughters attached through the bremsstrahlung recovery modules are allowed.
- isSignalAcceptMissing¶
same as isSignal, but also accept missing particle
- isSignalAcceptMissingGamma¶
same as isSignal, but also accept missing gamma, such as B -> K* gamma, pi0 -> gamma gamma
- isSignalAcceptMissingMassive¶
same as isSignal, but also accept missing massive particle
- isSignalAcceptMissingNeutrino¶
same as isSignal, but also accept missing neutrino
- isSignalAcceptWrongFSPs¶
1.0 if Particle is almost correctly reconstructed (SIGNAL), 0.0 if not, and NaN if no related MCParticle could be found. Misidentification of charged FSP is allowed.
- isWrongCharge¶
return 1 if the charge of the particle is wrongly assigned, 0 if it’s the correct charge, and NaN if no related MCParticle could be found.
- mcCosThetaBetweenParticleAndNominalB¶
Cosine of the angle in CMS between momentum the particle and a nominal B particle. In this calculation, the momenta of all descendant neutrinos are subtracted from the B momentum.
- mcDecayTime¶
The decay time of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcE¶
The energy of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcErrors¶
The bit pattern indicating the quality of MC match (see MCMatching::MCErrorFlags)
- mcFSR¶
Returns 1 if Particle is related to FSR MCParticle, 0 if Particle is related to non - FSR MCParticle ,NaN if Particle is not related to MCParticle.
- mcISR¶
Returns 1 if Particle is related to ISR MCParticle, 0 if Particle is related to non - ISR MCParticle, NaN if Particle is not related to MCParticle.
- mcInitial¶
Returns 1 if Particle is related to initial MCParticle, 0 if Particle is related to non - initial MCParticle, NaN if Particle is not related to MCParticle.
- mcLifeTime¶
The life time of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcMatchWeight¶
The weight of the Particle -> MCParticle relation (only for the first Relation = largest weight).
- mcP¶
The total momentum of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcPDG¶
The PDG code of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcPT¶
The pt of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcPX¶
The px of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcPY¶
The py of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcPZ¶
The pz of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcParticleStatus¶
Returns status bits of related MCParticle or NaN if MCParticle relation is not set.
- mcPhi¶
The phi of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcPhotos¶
Returns 1 if Particle is related to Photos MCParticle, 0 if Particle is related to non - Photos MCParticle, NaN if Particle is not related to MCParticle.
- mcPrimary¶
Returns 1 if Particle is related to primary MCParticle, 0 if Particle is related to non - primary MCParticle, NaN if Particle is not related to MCParticle.
- mcRecoilMass¶
The mass recoiling against the particles attached as particle’s daughters calculated using MC truth values.
- mcSecPhysProc¶
Returns the secondary physics process flag.
- mcTheta¶
The theta of matched MCParticle, NaN if no match. Requires running matchMCTruth() on the reconstructed particles, or a particle list filled with generator particles (MCParticle objects).
- mcVirtual¶
Returns 1 if Particle is related to virtual MCParticle, 0 if Particle is related to non - virtual MCParticle, NaN if Particle is not related to MCParticle.
- nMCMatches¶
The number of relations of this Particle to MCParticle.
- isReconstructible¶
checks charged particles were seen in the SVD and neutrals in the ECL, returns 1.0 if so, 0.0 if not, NaN for composite particles or if no related MCParticle could be found. Useful for generator studies, not for reconstructed particles.
- seenInARICH¶
returns 1.0 if the MC particle was seen in the ARICH, 0.0 if not, NaN for composite particles or if no related MCParticle could be found. Useful for generator studies, not for reconstructed particles.
- seenInCDC¶
returns 1.0 if the MC particle was seen in the CDC, 0.0 if not, NaN for composite particles or if no related MCParticle could be found. Useful for generator studies, not for reconstructed particles.
- seenInECL¶
returns 1.0 if the MC particle was seen in the ECL, 0.0 if not, NaN for composite particles or if no related MCParticle could be found. Useful for generator studies, not for reconstructed particles.
- seenInKLM¶
returns 1.0 if the MC particle was seen in the KLM, 0.0 if not, NaN for composite particles or if no related MCParticle could be found. Useful for generator studies, not for reconstructed particles.
- seenInPXD¶
returns 1.0 if the MC particle was seen in the PXD, 0.0 if not, NaN for composite particles or if no related MCParticle could be found. Useful for generator studies, not for reconstructed particles.
- seenInSVD¶
returns 1.0 if the MC particle was seen in the SVD, 0.0 if not, NaN for composite particles or if no related MCParticle could be found. Useful for generator studies, not for reconstructed particles.
- seenInTOP¶
returns 1.0 if the MC particle was seen in the TOP, 0.0 if not, NaN for composite particles or if no related MCParticle could be found. Useful for generator studies, not for reconstructed particles.
- B0Mode
[Eventbased] It will return the decays mode of B0 particles
- Bbar0Mode
[Eventbased] It will return the decays mode of anti-B0 particles
- BminusMode
[Eventbased] It will return the decays mode of B- particles
- BplusMode
[Eventbased] It will return the decays mode of B+ particles
- Bs0Mode
[Eventbased] It will return the decays mode of B_s0 particles
- Bsbar0Mode
[Eventbased] It will return the decays mode of anti-B_s0 particles
- D0Mode
[Eventbased] It will return the decays mode of D0 particles
- Dbar0Mode
[Eventbased] It will return the decays mode of anti-D0 particles
- DminusMode
[Eventbased] It will return the decays mode of D- particles
- DplusMode
[Eventbased] It will return the decays mode of D+ particles
- DsminusMode
[Eventbased] It will return the decays mode of D_s- particles
- DsplusMode
[Eventbased] It will return the decays mode of D_s+ particles
- DstminusMode
[Eventbased] It will return the decays mode of D*- particles
- DstplusMode
[Eventbased] It will return the decays mode of D*+ particles
- TauminusMode
[Eventbased] It will return the decays mode of tau- particles
- TauplusMode
[Eventbased] It will return the decays mode of tau+ particles
- tauMinusMCMode
[Eventbased] Decay ID for the negative tau lepton in a tau pair generated event.
- tauMinusMCProng
[Eventbased] Prong for the negative tau lepton in a tau pair generated event.
- tauPlusMCMode
[Eventbased] Decay ID for the positive tau lepton in a tau pair generated event.
- tauPlusMCProng
[Eventbased] Prong for the positive tau lepton in a tau pair generated event.
Daughter info¶
Here is a list of variables getting info from particle’s daughters:
- hasCharmedDaughter(i)¶
Returns information regarding the charm quark presence in the decay.
- hasCharmoniumDaughter¶
Returns information regarding the charmonium state presence in the decay.
- hasRealPhotonDaughter¶
Returns information regarding photon daughter origin for a particle.
KLM Cluster and \(K_{L}^0\) Identification¶
Here is a list of KLM Cluster and \(K_{L}^0\) identification variables:
Warning
Please note that these variables refer to KLMClusters, which are designed to reconstruct \(K_{L}^0\) and other neutral particles with the KLM subdetector. These variables must not be used to do particle identification of charged tracks (for example, they must not be used to identify muons), otherwise there is a serious risk to spoil a physics analysis.
For particle identification of charged tracks, please use the canonical PID variables.
- klmClusterBelleECLFlag¶
Returns the Belle-style ECL flag.
- klmClusterBelleTrackFlag¶
Returns the Belle-style Track flag.
- klmClusterEnergy¶
Returns the energy of the associated KLMCluster.
Warning
This variable returns an approximation of the energy: it uses
klmClusterMomentum
as momentum and the hypothesis that the KLMCluster is originated by a \(K_{L}^0\) (\(E_{\text{KLM}} = \sqrt{M_{K^0_L}^2 + p_{\text{KLM}}^2}\), where \(E_{\text{KLM}}\) is this variable, \(M_{K^0_L}\) is the \(K^0_L\) mass and \(p_{\text{KLM}}\) isklmClusterMomentum
). It should be used with caution, and may not be physically meaningful, especially for \(n\) candidates.
- klmClusterInnermostLayer¶
Returns the number of the innermost KLM layer with a 2-dimensional hit of the associated KLMCluster.
- klmClusterIsBKLM¶
Returns 1 if the associated KLMCluster is in barrel KLM.
- klmClusterIsBackwardEKLM¶
Returns 1 if the associated KLMCluster is in backward endcap KLM.
- klmClusterIsEKLM¶
Returns 1 if the associated KLMCluster is in endcap KLM.
- klmClusterIsForwardEKLM¶
Returns 1 if the associated KLMCluster is in forward endcap KLM.
- klmClusterKlId¶
Returns the KlId classifier output associated to the KLMCluster.
- klmClusterLayers¶
Returns the number of KLM layers with 2-dimensional hits of the associated KLMCluster.
- klmClusterMomentum¶
Returns the momentum magnitude of the associated KLMCluster.
Warning
This variable returns an approximation of the momentum, since it is proportional to
klmClusterLayers
(\(p_{\text{KLM}} = 0.215 \cdot N_{\text{layers}}\), where \(p_{\text{KLM}}\) is this variable and \(N_{\text{layers}}\) isklmClusterLayers
). It should be used with caution, and may not be physically meaningful.
- klmClusterPhi¶
Returns the azimuthal (\(\phi\)) angle of the associated KLMCluster.
- klmClusterPositionX¶
Returns the \(x\) position of the associated KLMCluster.
- klmClusterPositionY¶
Returns the \(y\) position of the associated KLMCluster.
- klmClusterPositionZ¶
Returns the \(z\) position of the associated KLMCluster.
- klmClusterTheta¶
Returns the polar (\(\theta\)) angle of the associated KLMCluster.
- klmClusterTiming¶
Returns the timing informationf of the associated KLMCluster.
Warning
Currently the KLM has no time calibration. This leads to a huge discrepancy for the variable
klmClusterTiming
if one compares collisions and simulated data. Moreover, the distribution of the variable on collisions data has a very complicated structure, due to the different timing shifts of different KLM components. It is recommended to not use it in any case until the KLM is calibrated, even for simulated data.
- klmClusterTrackDistance¶
Returns the distance between the Track and the KLMCluster associated to this Particle. This variable returns NaN if there is no Track-to-KLMCluster relationship.
Note
When used over samples (data or MC) produced with release-06 or newer releases, the variable returns values in cm; otherwise, over samples produced with release-05 or older releases, the variable returns values in mm.
- maximumKLMAngleCMS¶
Returns the maximum angle in the CMS frame between the Particle and all KLMClusters in the event.
- nKLMClusterECLClusterMatches¶
Returns the number of ECLClusters matched to the KLMCluster associated to this Particle.
- nKLMClusterTrackMatches¶
Returns the number of Tracks matched to the KLMCluster associated to this Particle. This variable can return a number greater than 0 for \(K_{L}^0\) or \(n\) candidates originating from KLMClusters and returns NaN for Particles with no KLMClusters associated.
- nMatchedKLMClusters¶
Returns the number of KLMClusters matched to the particle. It only works for Particles created either from Tracks or from ECLCluster, while it returns NaN for \(K_{L}^0\) or \(n\) candidates originating from KLMClusters.
Time Dependent CPV Analysis Variables¶
To use most of the variables in this section on need to run vertex.TagV
method:
- DeltaBoost¶
\(\Delta z\) in the boost direction
- DeltaBoostErr¶
Uncertanty of \(\Delta z\) in the boost direction
- DeltaT¶
Proper decay time difference \(\Delta t\) between signal B-meson \((B_{rec})\) and tag B-meson \((B_{tag})\) in ps.
- DeltaTBelle¶
[Legacy] \(\Delta t\) in ps, as it was used in Belle
- DeltaTErr¶
Proper decay time difference \(\Delta t\) uncertainty in ps
- DeltaTRes¶
\(\Delta t\) residual in ps, to be used for resolution function studies
- DeltaZ¶
Difference of decay vertex longitudinal components between signal B-meson \((B_{rec})\) and tag B-meson \((B_{tag})\): \(\Delta z = z(B_{rec}) - z(B_{tag})\)
- DeltaZErr¶
Uncertainty of the difference \(z(B_{rec}) - z(B_{tag})\)
- LBoost¶
Returns the vertex component in the boost direction
- LBoostErr¶
Returns the error of the vertex in the boost direction
- OBoost¶
Returns the vertex component in the direction orthogonal to the boost
- OBoostErr¶
Returns the error of the vertex in the direction orthogonal to the boost
- TagTrackAverage(var)¶
return the average over the tag tracks of the variable
var
.var
must be one of the TagTrackXXX variables, for example:TagTrackAverage(TagTrackDistanceToConstraint)
. The tracks that are assigned a zero weight are ignored.
- TagTrackAverageSquares(var)¶
return the average over the tag tracks of the square of the variable
var
.var
must be one of the TagTrackXXX variables, for example:TagTrackAverageSquares(TagTrackDistanceToConstraint)
. The tracks that are assigned a zero weight are ignored.
- TagTrackD0(i)¶
return the d0 parameter of the ith track used in the tag vtx fit
- TagTrackDistanceToConstraint(i)¶
returns the measured distance between the ith tag track and the centre of the constraint.
- TagTrackDistanceToConstraintErr(i)¶
returns the estimated error on the distance between the ith tag track and the centre of the constraint.
- TagTrackDistanceToConstraintSignificance(i)¶
returns the significance of the distance between the centre of the constraint and the tag track indexed by track index (computed as distance / uncertainty)
- TagTrackDistanceToTagV(i)¶
returns the measured distance between the ith tag track and the tag vtx.
- TagTrackDistanceToTagVErr(i)¶
returns the estimated error on the distance between the ith tag track and the tag vtx. Warning: only the uncertainties on the track position parameters are taken into account.
- TagTrackDistanceToTagVSignificance(i)¶
returns the significance of the distance between the tag vtx and the tag track indexed by trackIndex (computed as distance / uncertainty)
- TagTrackMax(var)¶
return the maximum value of the variable
var
evaluated for each tag track.var
must be one of the TagTrackXXX variables, for example:TagTrackMax(TagTrackDistanceToConstraint)
. The tracks that are assigned a zero weight are ignored.
- TagTrackMin(var)¶
return the minimum value of the variable
var
evaluated for each tag track.var
must be one of the TagTrackXXX variables, for example:TagTrackMin(TagTrackDistanceToConstraint)
. The tracks that are assigned a zero weight are ignored.
- TagTrackMomentum(i)¶
return the magnitude of the momentum of the ith track used in the tag vtx fit.
- TagTrackMomentumX(i)¶
return the X component of the momentum of the ith track used in the tag vtx fit.
- TagTrackMomentumY(i)¶
return the Y component of the momentum of the ith track used in the tag vtx fit.
- TagTrackMomentumZ(i)¶
return the Z component of the momentum of the ith track used in the tag vtx fit.
- TagTrackRaveWeight(i)¶
returns the weight assigned by Rave to track i
- TagTrackTrueDistanceToTagV(i)¶
return the true distance between the true B Tag decay vertex and the p’cle corresponding to the ith tag vtx track.
- TagTrackTrueMomentumX(i)¶
return the X component of the true momentum of the MC particle corresponding to the ith tag vtx track.
- TagTrackTrueMomentumY(i)¶
return the Y component of the true momentum of the MC particle corresponding to the ith tag vtx track.
- TagTrackTrueMomentumZ(i)¶
return the Z component of the true momentum of the MC particle corresponding to the ith tag vtx track.
- TagTrackTrueOriginX(i)¶
return the X component of the true origin of the MC particle corresponding to the ith tag vtx track.
- TagTrackTrueOriginY(i)¶
return the Y component of the true origin of the MC particle corresponding to the ith tag vtx track.
- TagTrackTrueOriginZ(i)¶
return the Z component of the true origin of the MC particle corresponding to the ith tag vtx track.
- TagTrackTrueVecToTagVX(i)¶
return the X coordinate of the vector between the mc particle corresponding to the ith tag vtx track and the true tag B decay vertex.
- TagTrackTrueVecToTagVY(i)¶
return the Y coordinate of the vector between the mc particle corresponding to the ith tag vtx track and the true tag B decay vertex.
- TagTrackTrueVecToTagVZ(i)¶
return the Z coordinate of the vector between the mc particle corresponding to the ith tag vtx track and the true tag B decay vertex.
- TagTrackWeightedAverage(var)¶
return the average over the tag tracks of the variable
var
, weighted by weights of the tag vertex fitter.var
must be one of the TagTrackXXX variables, for example:TagTrackWeightedAverage(TagTrackDistanceToConstraint)
.
- TagTrackWeightedAverageSquares(var)¶
return the average over the tag tracks of the variable
var
, weighted by weights of the tag vertex fitter.var
must be one of the TagTrackXXX variables, for example:TagTrackWeightedAverageSquares(TagTrackDistanceToConstraint)
.
- TagTrackZ0(i)¶
return the z0 parameter of the ith track used in the tag vtx fit
- TagVChi2¶
chi2 value of the tag vertex fit
- TagVChi2IP¶
IP component of chi2 value of the tag vertex fit
- TagVDistanceToConstraint¶
returns the measured distance between the tag vtx and the centre of the constraint.
- TagVDistanceToConstraintErr¶
returns the estimated error on the distance between the tag vtx and the centre of the constraint.
- TagVDistanceToConstraintSignificance¶
returns the significance of the distance between the tag vtx and the centre of the constraint (computed as distance / uncertainty)
- TagVFitTruthStatus¶
Returns the status of the fit performed with the truth info. Possible values are: 0: fit performed with measured parameters, 1: fit performed with true parameters, 2: unable to recover truth parameters
- TagVLBoost¶
Returns the TagV component in the boost direction
- TagVLBoostErr¶
Returns the error of TagV in the boost direction
- TagVNDF¶
Number of degrees of freedom in the tag vertex fit
- TagVNFitTracks¶
returns the number of tracks used by rave to fit the vertex (not counting the ones coming from Kshorts)
- TagVNTracks¶
Number of tracks in the tag vertex
- TagVOBoost¶
Returns the TagV component in the direction orthogonal to the boost
- TagVOBoostErr¶
Returns the error of TagV in the direction orthogonal to the boost
- TagVRollBackStatus¶
Returns the status of the fit performed with rolled back tracks. Possible values are: 0: fit performed with measured parameters, 1: fit performed with rolled back tracks, 2: unable to recover truth parameters
- TagVType¶
Type of algo for the tag vertex. -1: failed (1,2: single track, deprecated), 3: standard, 4: standard_PXD, 5: no constraint
- TagVpVal¶
Tag vertex p-Value
- TagVx¶
Tag vertex X component
- TagVxErr¶
Tag vertex X component uncertainty
- TagVy¶
Tag vertex Y component
- TagVyErr¶
Tag vertex Y component uncertainty
- TagVz¶
Tag vertex Z component
- TagVzErr¶
Tag vertex Z component uncertainty
- internalTagVMCFlavor¶
[Expert] [Debugging] This variable is only for internal checks of the TagV module by developers. It returns the internal mc flavor information of the tag-side B provided by the TagV module.
- mcDeltaBoost¶
True difference of decay vertex boost-direction components between signal B-meson \((B_{rec})\) and tag B-meson \((B_{tag})\): \(\Delta l = l(B_{rec}) - l(B_{tag})\)
- mcDeltaT¶
Generated proper decay time difference (in z-difference approximation) \(\Delta t\) in ps: \((l(B_{\rm rec}) - l(B_{\rm tag}))/\beta_{\Upsilon(4S)}\gamma_{\Upsilon(4S)}\)
- mcDeltaTau¶
Generated proper decay time difference \(\Delta t\) in ps: \(\tau(B_{\rm rec})-\tau(B_{\rm tag})\)
- mcLBoost¶
Returns the MC vertex component in the boost direction
- mcOBoost¶
Returns the MC vertex component in the direction orthogonal to the boost
- mcTagVLBoost¶
Returns the MC TagV component in the boost direction
- mcTagVOBoost¶
Returns the MC TagV component in the direction orthogonal to the boost
- mcTagVx¶
Generated Tag vertex X component
- mcTagVy¶
Generated Tag vertex Y component
- mcTagVz¶
Generated Tag vertex Z component
Flavor Tagger¶
Analysis variables¶
- isRelatedRestOfEventB0Flavor¶
Returns -1 (1) if the RestOfEvent related to the given particle is related to a
anti-B0
(B0
). TheMCError
bit of Breco has to be 0, 1, 2, 16 or 1024. The output of the variable is 0 otherwise. If one particle in the RestOfEvent is found to belong to the reconstructedB0
, the output is -2(2) for aanti-B0
(B0
) on the reconstructed side.
- qOutput(combinerMethod)¶
Returns the flavor tag \(q\) output of the flavorTagger for the given combinerMethod. The available methods are ‘FBDT’ and ‘FANN’ (category-based combiners), and ‘DNN’ (DNN tagger output).
Warning
You have to run the Flavor Tagger for this variable to be meaningful.
See also
- qrOutput(combinerMethod)¶
Returns the output of the flavorTagger, flavor tag \(q\) times the dilution factor \(r\), for the given combiner method. The available methods are ‘FBDT’ and ‘FANN’ (category-based combiners), and ‘DNN’ (DNN tagger output).
Warning
You have to run the Flavor Tagger for this variable to be meaningful.
See also
- rBinBelle(combinerMethod)¶
Returns the corresponding \(r\) (dilution) bin according to the Belle binning for the given
combinerMethod
. The available methods are ‘FBDT’ and ‘FANN’ (category-based combiners), and ‘DNN’ (DNN tagger output). The return values and the corresponding dilution ranges are the following:0: \(0.000 < r < 0.100\);
1: \(0.100 < r < 0.250\);
2: \(0.250 < r < 0.500\);
3: \(0.500 < r < 0.625\);
4: \(0.625 < r < 0.750\);
5: \(0.750 < r < 0.875\);
6: \(0.875 < r < 1.000\).
Warning
You have to run the Flavor Tagger for this variable to be meaningful.
See also
Training and expert variables¶
- BtagToWBosonVariables(requestedVariable)¶
[Eventbased][Expert] Returns values of FlavorTagging-specific kinematical variables assuming a semileptonic decay with the given particle as target. The input values of
requestedVariable
can be the following: recoilMass, pMissCMS, cosThetaMissCMS and EW90.
- FSCVariables(requestedVariable)¶
[Eventbased][Expert] Returns values of FlavorTagging-specific kinematical variables for
FastSlowCorrelated
category. The input values ofrequestedVariable
can be the following: pFastCMS, cosSlowFast, SlowFastHaveOpositeCharges, or cosTPTOFast.
- HighestProbInCat(particleListName, extraInfoName)¶
[Expert] Returns the highest target track probability value for the given category, for allowed input values for
extraInfoName
seehasHighestProbInCat
.
- KaonPionVariables(requestedVariable)¶
[Expert] Returns values of FlavorTagging-specific kinematical variables for
KaonPion
category. The input values ofrequestedVariable
can be the following: cosKaonPion, HaveOpositeCharges.
- NumberOfKShortsInRoe¶
[Expert] Returns the number of
K_S0
in the rest of event. The particle listK_S0:inRoe
has to be filled beforehand.
- QpOf(particleListName, outputExtraInfo, rankingExtraInfo)¶
[Eventbased][Expert] Returns the \(q*p\) value for a given particle list provided as the 1st argument, where math:
p
is the probability of a category stored as extraInfo, provided as the 2nd argument, allowed values are same as inhasHighestProbInCat
. The particle is selected after ranking according to a flavor tagging extraInfo, provided as the 3rd argument, allowed values are same as inhasHighestProbInCat
.
- ancestorHasWhichFlavor¶
[Expert] Checks the decay chain of the given particle upwards up to the
Upsilon(4S)
resonance and outputs 0 (1) if an ancestor is found to be aanti-B0
(B0
), if not -2.
- chargeTimesKaonLiklihood¶
[Expert] Returns
q*(highest PID_Likelihood for Kaons)
, 0. otherwise.
- cosTPTO¶
[Expert] Returns cosine of angle between thrust axis of given particle and thrust axis of ROE.
- hasHighestProbInCat(particleListName, extraInfoName)¶
[Expert] Returns 1.0 if the given Particle is classified as target track, i.e. if it has the highest target track probability in particleListName. The probability is accessed via
extraInfoName
, which can have the following input values:isRightTrack(Electron),
isRightTrack(IntermediateElectron),
isRightTrack(Muon),
isRightTrack(IntermediateMuon),
isRightTrack(KinLepton),
isRightTrack(IntermediateKinLepton),
isRightTrack(Kaon),
isRightTrack(SlowPion),
isRightTrack(FastHadron),
isRightTrack(MaximumPstar),
isRightTrack(Lambda),
isRightCategory(Electron),
isRightCategory(IntermediateElectron),
isRightCategory(Muon),
isRightCategory(IntermediateMuon),
isRightCategory(KinLepton),
isRightCategory(IntermediateKinLepton),
isRightCategory(Kaon),
isRightCategory(SlowPion),
isRightCategory(FastHadron),
isRightCategory(MaximumPstar),
isRightCategory(Lambda),
isRightCategory(KaonPion),
isRightCategory(FSC).
- hasRestOfEventTracks¶
[Expert] Returns the amount of tracks in the RestOfEvent related to the given Particle. -2 if the RestOfEvent is empty.
- hasTrueTarget(categoryName)¶
[Expert] Returns 1 if the given category has a target, 0 otherwise.
- hasTrueTargets(categoryName)¶
[Expert] Returns 1 if target particles (checking only the decay chain) of the category with the given name is found in the MC particles. The allowed categories are the official Flavor Tagger Category Names.
- isInElectronOrMuonCat¶
[Expert] Returns 1.0 if the particle has been selected as target in the Muon or Electron Category, 0.0 otherwise.
- isLambda¶
[Expert] Returns 1.0 if particle is truth-matched to
Lambda0
, 0.0 otherwise.
- isMajorityInRestOfEventFromB0¶
[Eventbased][Expert] Checks if the majority of the tracks in the current RestOfEvent are from a
B0
.
- isMajorityInRestOfEventFromB0bar¶
[Eventbased][Expert] Check if the majority of the tracks in the current RestOfEvent are from a
anti-B0
.
- isRelatedRestOfEventMajorityB0Flavor¶
[Expert] Returns 0 (1) if the majority of tracks and clusters of the RestOfEvent related to the given Particle are related to a
anti-B0
(B0
).
- isRestOfEventMajorityB0Flavor¶
[Expert] Returns 0 (1) if the majority of tracks and clusters of the current RestOfEvent are related to a
anti-B0
(B0
).
- isRightCategory(particleName)¶
[Expert] Returns 1.0 if the class track by
particleName
category has the same flavor as the MC target track, 0.0 otherwise. Allowed input values forparticleName
argument in this variable are the following:Electron,
IntermediateElectron,
Muon,
IntermediateMuon,
KinLepton,
IntermediateKinLepton
Kaon,
SlowPion,
FastHadron,
KaonPion,
MaximumPstar,
FSC,
Lambda,
mcAssociated.
- isRightTrack(particleName)¶
[Expert] Returns 1.0 if the given particle was really from a B-meson depending on category provided in
particleName
argument, 0.0 otherwise. Allowed input values forparticleName
argument in this variable are the following:Electron,
IntermediateElectron,
Muon,
IntermediateMuon,
KinLepton,
IntermediateKinLepton,
Kaon,
SlowPion,
FastHadron,
Lambda,
mcAssociated.
- isTrueCategory(categoryName)¶
[Expert] Returns 1 if the given category tags the B0 MC flavor correctly, 0 otherwise.
- isTrueFTCategory(categoryName)¶
[Expert] Returns 1 if the target particle (checking the decay chain) of the category with the given name is found in the MC particles, and if it provides the right flavor. The allowed categories are the official Flavor Tagger Category Names.
- lambdaFlavor¶
[Expert] Returns 1.0 if particle is
Lambda0
, -1.0 in case ofanti-Lambda0
, 0.0 otherwise.
- lambdaZError¶
[Expert] Returns the variance of the z-component of the decay vertex.
- mcFlavorOfOtherB¶
[Expert] Returns the MC flavor (+1 or -1) of the accompanying tag-side B meson if the given particle is a correctly truth-matched B candidate, 0 otherwise. In other words, this variable checks the generated flavor of the other generated
Upsilon(4S)
daughter.”);
- momentumOfSecondDaughter¶
[Expert] Returns the momentum of second daughter if exists, 0. otherwise.
- momentumOfSecondDaughterCMS¶
[Expert] Returns the momentum of the second daughter in the centre-of-mass system, 0. if this daughter doesn’t exist.
- pMissTag¶
[Expert] Calculates the missing momentum for a given particle on the tag side.
- ptTracksRoe¶
[Expert] Returns the transverse momentum of all charged tracks of the ROE related to the given particle, 0.0 if particle has no related ROE.
- qpCategory(categoryName)¶
[Expert] Returns the output \(q\) (charge of target track) times \(p\) (probability that this is the right category) of the category with the given name. The allowed categories are the official Flavor Tagger Category Names.
- qrCombined¶
[Eventbased][Expert] Returns -1 (1) if current RestOfEvent is related to a
anti-B0
(B0
). TheMCError
bit of Breco has to be 0, 1, 2, 16 or 1024. The output of the variable is 0 otherwise. If one particle in the RestOfEvent is found to belong to the reconstructedB0
, the output is -2(2) for aanti-B0
(B0
) on the reconstructed side.”);
- variableOfTarget(particleListName, inputVariable, rankingExtraInfo)¶
[Eventbased][Expert] Returns the value of an input variable provided as the 2nd argument for a particle selected from the given list provided as the 1st argument. The particles are ranked according to a flavor tagging extraInfo, provided as the 2nd argument, allowed values are same as in
hasHighestProbInCat
.
- weightedQpOf(particleListName, outputExtraInfo, rankingExtraInfo)¶
[Eventbased][Expert] Returns the weighted \(q*p\) value for a given particle list, provided as the 1st argument, where math:
p
is the probability of a category stored as extraInfo, provided in the 2nd argument, allowed values are same as inhasHighestProbInCat
. The particles in the list are ranked according to a flavor tagging extraInfo, provided as the 3rd argument, allowed values are same as inhasHighestProbInCat
. The values for the three top particles is combined into an effective (weighted) output.
Rest of Event¶
- bssMassDifference(maskName)¶
Bs* - Bs mass difference
- currentROEIsInList(particleList)¶
[Eventbased] Returns 1 the associated particle of the current ROE is contained in the given list or its charge-conjugated.Useful to restrict the for_each loop over ROEs to ROEs of a certain ParticleList.
- etaProb(mode)¶
Returns eta probability, where mode is used to specify the selection criteria for soft photon. The following strings are available.
standard
: loose energy cut and no clusterNHits cut are applied to soft photontight
: tight energy cut and no clusterNHits cut are applied to soft photoncluster
: loose energy cut and clusterNHits cut are applied to soft photonboth
: tight energy cut and clusterNHits cut are applied to soft photon
You can find more details in
writePi0EtaVeto
function in modularAnalysis.py.
- hasAncestorFromSignalSide¶
Returns 1 if a particle has ancestor from signal side, 0 otherwise. Requires generator information and truth-matching. One can use this variable only in a
for_each
loop over the RestOfEvent StoreArray.
- isCloneOfSignalSide¶
Returns 1 if a particle is a clone of signal side final state particles, 0 otherwise. Requires generator information and truth-matching. One can use this variable only in a
for_each
loop over the RestOfEvent StoreArray.
- isInRestOfEvent¶
Returns 1 if a track, ecl or klmCluster associated to particle is in the current RestOfEvent object, 0 otherwise.One can use this variable only in a for_each loop over the RestOfEvent StoreArray.
- nROE_Charged(maskName, PDGcode = 0)¶
Returns number of all charged particles in the related RestOfEvent object. First optional argument is ROE mask name. Second argument is a PDG code to count only one charged particle species, independently of charge. For example:
nROE_Charged(cleanMask, 321)
will output number of kaons in Rest Of Event withcleanMask
. PDG code 0 is used to count all charged particles
- nROE_Composites(maskName)¶
Returns number of composite particles or V0s in the related RestOfEvent object that pass the selection criteria.
- nROE_ECLClusters(maskName)¶
Returns number of ECL clusters in the related RestOfEvent object that pass the selection criteria.
- nROE_KLMClusters¶
Returns number of all remaining KLM clusters in the related RestOfEvent object.
- nROE_NeutralECLClusters(maskName)¶
Returns number of neutral ECL clusters in the related RestOfEvent object that pass the selection criteria.
- nROE_NeutralHadrons(maskName)¶
Returns number of all neutral hadrons in the related RestOfEvent object, accepts 1 optional argument of ROE mask name.
- nROE_ParticlesInList(pListName)¶
Returns the number of particles in ROE from the given particle list. Use of variable aliases is advised.
- nROE_Photons(maskName)¶
Returns number of all photons in the related RestOfEvent object, accepts 1 optional argument of ROE mask name.
- nROE_RemainingTracks¶
Returns number of tracks in ROE - number of tracks of given particleOne can use this variable only in a for_each loop over the RestOfEvent StoreArray.
- nROE_RemainingTracks(maskName)
Returns number of remaining tracks between the ROE (specified via a mask) and the given particle. For the given particle only tracks are counted which are in the RoE.One can use this variable only in a for_each loop over the RestOfEvent StoreArray.Is required for the specific FEI.
- nROE_Tracks(maskName)¶
Returns number of tracks in the related RestOfEvent object that pass the selection criteria.
- particleRelatedToCurrentROE(var)¶
[Eventbased] Returns variable applied to the particle which is related to the current RestOfEvent objectOne can use this variable only in a for_each loop over the RestOfEvent StoreArray.
- passesROEMask(maskName)¶
Returns boolean value if a particle passes a certain mask or not. Only to be used in for_each path, otherwise returns quiet NaN.
- pi0Prob(mode)¶
Returns pi0 probability, where mode is used to specify the selection criteria for soft photon. The following strings are available.
standard
: loose energy cut and no clusterNHits cut are applied to soft photontight
: tight energy cut and no clusterNHits cut are applied to soft photoncluster
: loose energy cut and clusterNHits cut are applied to soft photonboth
: tight energy cut and clusterNHits cut are applied to soft photon
You can find more details in
writePi0EtaVeto
function in modularAnalysis.py.
- printROE¶
For debugging, prints indices of all particles in the ROE and all masks. Returns 0.
- roeCharge(maskName)¶
Returns total charge of the related RestOfEvent object.
- roeDeltae(maskName)¶
Returns energy difference of the related RestOfEvent object with respect to \(E_\mathrm{cms}/2\).
- roeE(maskName)¶
Returns energy of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roeEextra(maskName)¶
Returns extra energy from ECLClusters in the calorimeter that is not associated to the given Particle
- roeM(maskName)¶
Returns invariant mass of unused tracks and clusters in ROE
- roeMC_E¶
Returns true energy of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roeMC_M¶
Returns true invariant mass of unused tracks and clusters in ROE
- roeMC_MissFlags(maskName)¶
Returns flags corresponding to missing particles on ROE side.
- roeMC_P¶
Returns true momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roeMC_PTheta¶
Returns polar angle of true momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roeMC_Pt¶
Returns transverse component of true momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roeMC_Px¶
Returns x component of true momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roeMC_Py¶
Returns y component of true momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roeMC_Pz¶
Returns z component of true momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roeMbc(maskName)¶
Returns beam constrained mass of the related RestOfEvent object with respect to \(E_\mathrm{cms}/2\).
- roeNeextra(maskName)¶
Returns extra energy from neutral ECLClusters in the calorimeter that is not associated to the given Particle, can be used with
use***Frame()
function.
- roeP(maskName)¶
Returns momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roePTheta(maskName)¶
Returns theta angle of momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roePt(maskName)¶
Returns transverse component of momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roePx(maskName)¶
Returns x component of momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roePy(maskName)¶
Returns y component of momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- roePz(maskName)¶
Returns z component of momentum of unused tracks and clusters in ROE, can be used with
use***Frame()
function.
- useROERecoilFrame(variable)¶
Returns the value of the variable using the rest frame of the ROE recoil as current reference frame. Can be used inside for_each loop or outside of it if the particle has associated Rest of Event. E.g.
useROERecoilFrame(E)
returns the energy of a particle in the ROE recoil frame.
- weCosThetaEll(maskName)¶
Returns the angle between \(M\) and lepton in \(W\) rest frame in the decays of the type: \(M \to h_1 ... h_n \ell\), where W 4-momentum is given as
\[p_W = p_\ell + p_\nu.\]The neutrino momentum is calculated from ROE taking into account the specified mask, and setting
\[E_{\nu} = |p_{miss}|.\]
- weDeltae(maskName, opt)¶
Returns the energy difference of the B meson, corrected with the missing neutrino momentum (reconstructed side + neutrino) with respect to \(E_\mathrm{cms}/2\).
- weMbc(maskName, opt)¶
Returns beam constrained mass of B meson, corrected with the missing neutrino momentum (reconstructed side + neutrino) with respect to \(E_\mathrm{cms}/2\).
- weMissE(maskName, opt)¶
Returns the energy of the missing momentum, possible options
opt
are the following:0
: CMS, use energy and momentum of charged particles and photons1
: CMS, same as0
, fix \(E_\mathrm{miss} = p_\mathrm{miss}\)2
: CMS, same as0
, fix \(E_\mathrm{roe} = E_\mathrm{cms}/2\)3
: CMS, use only energy and momentum of signal side4
: CMS, same as3
, update with direction of ROE momentum5
: LAB, use energy and momentum of charged particles and photons from whole event6
: LAB, same as5
, fix \(E_\mathrm{miss} = p_\mathrm{miss}\)7
: CMS, correct pmiss 3-momentum vector with factor alpha so that \(d_E = 0\) (used for \(M_\mathrm{bc}\) calculation).
- weMissM2(maskName, opt)¶
Returns the invariant mass squared of the missing momentum (see
weMissE
possible options)
- weMissM2OverMissE(maskName)¶
Returns missing mass squared over missing energy
- weMissP(maskName, opt)¶
Returns the magnitude of the missing momentum (see possible
weMissE
options)
- weMissPTheta(maskName, opt)¶
Returns the polar angle of the missing momentum (see possible
weMissE
options)
- weMissPx(maskName, opt)¶
Returns the x component of the missing momentum (see
weMissE
possible options)
- weMissPy(maskName, opt)¶
Returns the y component of the missing momentum (see
weMissE
possible options)
- weMissPz(maskName, opt)¶
Returns the z component of the missing momentum (see
weMissE
possible options)
- weQ2lnu(maskName, option)¶
Returns the momentum transfer squared, \(q^2\), calculated in CMS as \(q^2 = (p_l + p_\nu)^2\), where \(B \to H_1\dots H_n \ell \nu_\ell\). Lepton is assumed to be the last reconstructed daughter. This calculation uses constraints from dE = 0 and Mbc = Mb to correct the neutrino direction. By default, option is set to
7
(seeweMissE
). Unless you know what you are doing, keep this default value.
- weQ2lnuSimple(maskName, option)¶
Returns the momentum transfer squared, \(q^2\), calculated in CMS as \(q^2 = (p_l + p_\nu)^2\), where \(B \to H_1\dots H_n \ell \nu_\ell\). Lepton is assumed to be the last reconstructed daughter. By default, option is set to
1
(seeweMissE
). Unless you know what you are doing, keep this default value.
- weXiZ(maskName)¶
Returns Xi_z in event (for Bhabha suppression and two-photon scattering)
Continuum Suppression¶
For a detailed description of the continuum suppression, see Continuum suppression.
All variables in this group require the ContinuumSuppressionBuilder
module to be added to the path,
and a rest of event for the candidate particles. This can be done with both the
modularAnalysis.buildRestOfEvent
, and the modularAnalysis.buildContinuumSuppression
convenience functions.
- CleoConeCS(integer, string)¶
Returns i-th cleo cones from the continuum suppression. The allowed inputs for
integer
argument are integers from 1 to 9. If only theinteger
argument is specified, the CleoCones are calculated from all final state particles. Thestring
argument is optional and the only allowed input value is ‘ROE’, which sets the CleoCones to be calculated only from ROE particles.Warning
You have to run the Continuum Suppression builder module for this variable to be meaningful.
See also
- KSFWVariables(variable, string)¶
Returns variable et, mm2, or one of the 16 KSFW moments. If only the
variable
argument is specified, the KSFW moment calculated from the B primary daughters is returned. If string is set toFS1
, the KSFW moment calculated from the B final state daughters is returned. Allowed input values forvariable
argument are the following:mm2, et
hso00, hso01, hso02, hso03, hso04
hso10, hso12, hso14
hso20, hso22, hso24
hoo0, hoo1, hoo2, hoo3, hoo4.
Warning
You have to run the Continuum Suppression builder module for this variable to be meaningful.
See also
- R2¶
Returns reduced Fox-Wolfram R2, defined as ratio of the i-th to the 0-th order Fox Wolfram moments.
Warning
You have to run the Continuum Suppression builder module for this variable to be meaningful.
See also
- R2EventLevel¶
[Eventbased] Event-Level Reduced Fox-Wolfram moment R2.
Note
Deprecated since version release-05-00-00.
The same value can be calculated with the Event Shape module, see
foxWolframR
.
- cosTBTO¶
Returns cosine of angle between thrust axis of the signal B and thrust axis of ROE.
Warning
You have to run the Continuum Suppression builder module for this variable to be meaningful.
See also
- cosTBz¶
Returns cosine of angle between thrust axis of the signal B and z-axis.
Warning
You have to run the Continuum Suppression builder module for this variable to be meaningful.
See also
- thrustBm¶
Returns magnitude of the signal B thrust axis.
Warning
You have to run the Continuum Suppression builder module for this variable to be meaningful.
See also
- thrustOm¶
Returns magnitude of the ROE thrust axis.
Warning
You have to run the Continuum Suppression builder module for this variable to be meaningful.
See also
- transformedNetworkOutput(name, low, high)¶
Transforms the network output \(C \to C'\) via: \(C'=\operatorname{log}((C-\mathrm{low})/(\mathrm{high}-C))\). The arguments of the metavariable are the following:
name
is theextraInfo
name, where the network output \(C\) has been stored. If particle is not specified, eventextraInfo
is used instead;low
,high
are floating point numbers.
Returns NaN, if the
extraInfo
has not been found.
- useBThrustFrame(variable, mode)¶
Returns the variable with respect to rotated coordinates, in which z lies on the specified thrust axis. If mode is set to
Signal
it will use the thrust axis of the reconstructed B candidate, if mode is set to ROE it will use the ROE thrust axis. If mode is set toAuto
the function use the thrust axis based on Rest Of Event (ROE) particles. LikeisInRestOfEvent
, one has to use this metavariable in ROE loop.Warning
You have to run the Continuum Suppression builder module for this variable to be meaningful.
See also
Event Shape¶
These variables are available after adding the event shape builder modules.
This can be done with the function modularAnalysis.buildEventShape
.
For a detailed description of the event shape variables, see EventShape
- aplanarity¶
[Eventbased] Event aplanarity, defined as the 3/2 of the third sphericity eigenvalue.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- backwardHemisphereEnergy¶
[Eventbased] Total energy of the particles flying in the direction opposite to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- backwardHemisphereMass¶
[Eventbased] Invariant mass of the particles flying in the direction opposite to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- backwardHemisphereMomentum¶
[Eventbased] Total momentum of the particles flying in the direction opposite to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- backwardHemisphereX¶
[Eventbased] X component of the total momentum of the particles flying in the direction opposite to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- backwardHemisphereY¶
[Eventbased] Y component of the total momentum of the particles flying in the direction opposite to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- backwardHemisphereZ¶
[Eventbased] Z component of the total momentum of the particles flying in the direction opposite to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoCone(i, axisName)¶
[Eventbased] Returns i-th order Cleo cone, calculated with respect to the axis
axisName
. The orderi
can go from 0 up to 8th, theaxisName
can be either ‘thrust’ or ‘collision’.Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust0¶
[Eventbased] 0th Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust1¶
[Eventbased] 1st Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust2¶
[Eventbased] 2nd Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust3¶
[Eventbased] 3rd Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust4¶
[Eventbased] 4th Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust5¶
[Eventbased] 5th Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust6¶
[Eventbased] 6th Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust7¶
[Eventbased] 7th Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- cleoConeThrust8¶
[Eventbased] 8th Cleo cone calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- forwardHemisphereEnergy¶
[Eventbased] Total energy of the particles flying in the same direction as the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- forwardHemisphereMass¶
[Eventbased] Invariant mass of the particles flying in the same direction as the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- forwardHemisphereMomentum¶
[Eventbased] Total momentum of the particles flying in the same direction as the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- forwardHemisphereX¶
[Eventbased] X component of the total momentum of the particles flying in the same direction as the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- forwardHemisphereY¶
[Eventbased] Y component of the total momentum of the particles flying in the same direction as the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- forwardHemisphereZ¶
[Eventbased] Z component of the total momentum of the particles flying in the same direction of the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- foxWolframH(i)¶
[Eventbased] Returns i-th order Fox Wolfram moment. The order
i
can go from 0 up to 8th.”Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- foxWolframR(i)¶
[Eventbased] Ratio of the i-th to the 0-th order Fox Wolfram moments. The order
i
can go from 0 up to 8th.Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- foxWolframR1¶
[Eventbased] Ratio of the 1-st to the 0-th order Fox Wolfram moments. This is just an alias of foxWolframR(1) defined for the user’s convenience.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- foxWolframR2¶
[Eventbased] Ratio of the 2-nd to the 0-th order Fox Wolfram moments. This is just an alias of foxWolframR(2) defined for the user’s convenience.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- foxWolframR3¶
[Eventbased] Ratio of the 3-rd to the 0-th order Fox Wolfram moments. This is just an alias of foxWolframR(3) defined for the user’s convenience.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- foxWolframR4¶
[Eventbased] Ratio of the 4-th to the 0-th order Fox Wolfram moments. This is just an alias of foxWolframR(4) defined for the user’s convenience.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- harmonicMoment(i, axisName)¶
[Eventbased] Returns i-th order harmonic moment, calculated with respect to the axis
axisName
. The orderi
can go from 0 up to 8th, theaxisName
can be either ‘thrust’ or ‘collision’.Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- harmonicMomentThrust0¶
[Eventbased] Harmonic moment of the 0th order calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- harmonicMomentThrust1¶
[Eventbased] Harmonic moment of the 1st order calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- harmonicMomentThrust2¶
[Eventbased] Harmonic moment of the 2nd order calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- harmonicMomentThrust3¶
[Eventbased] Harmonic moment of the 3rd order calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- harmonicMomentThrust4¶
[Eventbased] Harmonic moment of the 4th order calculated with respect to the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- sphericity¶
[Eventbased] Event sphericity, defined as the linear combination of the sphericity eigenvalues \(\\lambda_i\): \(S = (3/2)(\\lambda_2+\\lambda_3)\).
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- thrust¶
[Eventbased] Event thrust.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- thrustAxisCosTheta¶
[Eventbased] Cosine of the polar angle component of the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- thrustAxisX¶
[Eventbased] X component of the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- thrustAxisY¶
[Eventbased] Y component of the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- thrustAxisZ¶
[Eventbased] Z component of the thrust axis.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
- useThrustFrame(variable)¶
Evaluates a variable value in the thrust reference frame.
Warning
You have to run the Event Shape builder module for this variable to be meaningful.
See also
Event Kinematics¶
These variables are available after adding the event kinematics module.
This can be done with the function modularAnalysis.buildEventKinematics
.
The variable collection event_kinematics
allows to add all of them comfortably to your ntuple.
- genMissingEnergyOfEventCMS¶
[Eventbased] The missing energy in center-of-mass frame from generator.
- genMissingMass2OfEvent¶
[Eventbased] The missing mass squared from generator
- genMissingMomentumOfEventCMS¶
[Eventbased] The magnitude of the missing momentum in center-of-mass frame from generator
- genTotalPhotonsEnergyOfEvent¶
[Eventbased] The energy in laboratory frame of all the photons. from generator.
- genVisibleEnergyOfEventCMS¶
[Eventbased] The visible energy in center-of-mass frame from generator.
- missingEnergyOfEventCMS¶
[Eventbased] The missing energy in center-of-mass frame.
- missingMass2OfEvent¶
[Eventbased] The missing mass squared.
- missingMomentumOfEvent¶
[Eventbased] The magnitude of the missing momentum in laboratory frame.
Warning
You have to run the Event Kinematics builder module for this variable to be meaningful.
See also
- missingMomentumOfEventCMS¶
[Eventbased] The magnitude of the missing momentum in center-of-mass frame.
- missingMomentumOfEventCMS_Px¶
[Eventbased] The x component of the missing momentum in center-of-mass frame.
- missingMomentumOfEventCMS_Py¶
[Eventbased] The y component of the missing momentum in center-of-mass frame.
- missingMomentumOfEventCMS_Pz¶
[Eventbased] The z component of the missing momentum in center-of-mass frame.
- missingMomentumOfEventCMS_theta¶
[Eventbased] The theta angle of the missing momentum in center-of-mass frame.
- missingMomentumOfEvent_Px¶
[Eventbased] The x component of the missing momentum in laboratory frame.
- missingMomentumOfEvent_Py¶
[Eventbased] The y component of the missing momentum in laboratory frame.
- missingMomentumOfEvent_Pz¶
[Eventbased] The z component of the missing momentum in laboratory frame.
- missingMomentumOfEvent_theta¶
[Eventbased] The theta angle of the missing momentum of the event in laboratory frame.
- totalPhotonsEnergyOfEvent¶
[Eventbased] The energy in laboratory frame of all the photons.
- visibleEnergyOfEventCMS¶
[Eventbased] The visible energy in center-of-mass frame.
Flight Information¶
Here is a list of flight time and distance variables of a (grand)daughter particle w.r.t. its (grand)mother decay vertex:
- flightDistance¶
Returns the flight distance of particle. If a treeFit has been performed the flight distance calculated by TreeFitter is returned. Otherwise if a beam constrained rave fit has been performed the production vertex set by rave and the decay vertex are used to calculate the flight distance. If neither fit has been performed the i.p. is taken to be the production vertex.
- flightDistanceErr¶
Returns the flight distance error of particle. If a treeFit has been performed the flight distance error calculated by TreeFitter is returned. Otherwise if a beam constrained rave fit has been performed the production vertex set by rave and the decay vertex are used to calculate the flight distance error. If neither fit has been performed the i.p. is taken to be the production vertex.
- flightDistanceOfDaughter(daughterN, gdaughterN = -1)¶
Returns the flight distance between mother and daughter particle with daughterN index. If a treeFit has been performed the value calculated by treeFitter is returned. Otherwise the value is calculated using the decay vertices of the mother and daughter particle. If a second index granddaughterM is given the value is calculated between the mother and the Mth grandaughter (Mth daughter of Nth daughter).
- flightDistanceOfDaughterErr(daughterN, gdaughterN = -1)¶
Returns the flight distance error between mother and daughter particle with daughterN index. If a treeFit has been performed the value calculated by treeFitter is returned. Otherwise the value is calculated using the decay vertices of the mother and daughter particle. If a second index granddaughterM is given the value is calculated between the mother and the Mth grandaughter (Mth daughter of Nth daughter).
- flightTime¶
Returns the flight time of particle. If a treeFit has been performed the flight time calculated by TreeFitter is returned. Otherwise if a beam constrained rave fit has been performed the production vertex set by rave and the decay vertex are used to calculate the flight time. If neither fit has been performed the i.p. is taken to be the production vertex.
- flightTimeErr¶
Returns the flight time error of particle. If a treeFit has been performed the flight time error calculated by TreeFitter is returned. Otherwise if a beam constrained rave fit has been performed the production vertex set by rave and the decay vertex are used to calculate the flight time error. If neither fit has been performed the i.p. is taken to be the production vertex.
- flightTimeOfDaughter(daughterN, gdaughterN = -1)¶
Returns the flight time between mother and daughter particle with daughterN index. If a treeFit has been performed the value calculated by treeFitter is returned. Otherwise the value is calculated using the decay vertices of the mother and daughter particle. If a second index granddaughterM is given the value is calculated between the mother and the Mth grandaughter (Mth daughter of Nth daughter).
- flightTimeOfDaughterErr(daughterN, gdaughterN = -1)¶
Returns the flight time error between mother and daughter particle with daughterN index. If a treeFit has been performed the value calculated by treeFitter is returned. Otherwise the value is calculated using the decay vertices of the mother and daughter particle. If a second index granddaughterM is given the value is calculated between the mother and the Mth grandaughter (Mth daughter of Nth daughter).
- mcFlightDistance¶
Returns the MC flight distance of the particle
- mcFlightDistanceOfDaughter(daughterN, gdaughterN = -1)¶
Returns the MC flight distance between mother and daughter particle using generated info
- mcFlightTime¶
Returns the MC flight time of the particle
- mcFlightTimeOfDaughter(daughterN, gdaughterN = -1)¶
Returns the MC flight time between mother and daughter particle using generated info
- vertexDistance¶
Returns the distance between the production and decay vertex of a particle. Returns NaN if particle has no production or decay vertex.
- vertexDistanceErr¶
Returns the uncertainty on the distance between the production and decay vertex of a particle. Returns NaN if particle has no production or decay vertex.
- vertexDistanceOfDaughter(daughterN, option = '')¶
If any second argument is provided it returns the distance between the decay vertices of the particle and of its daughter with index daughterN. Otherwise, it is assumed that the particle has a production vertex (typically the IP) which is used to calculate the distance to the daughter’s decay vertex. Returns NaN in case anything goes wrong.
- vertexDistanceOfDaughterErr(daughterN, option = '')¶
If any second argument is provided it returns the uncertainty on the distance between the decay vertices of the particle and of its daughter with index daughterN. Otherwise, it is assumed that the particle has a production vertex (typically the IP) with a corresponding covariance matrix to calculate the uncertainty on the distance to the daughter’s decay vertex. Returns NaN in case anything goes wrong.
- vertexDistanceOfDaughterSignificance(daughterN, option = '')¶
If any second argument is provided it returns the distance between the decay vertices of the particle and of its daughter with index daughterN in units of the uncertainty on this value. Otherwise, it is assumed that the particle has a production vertex (typically the IP) with a corresponding covariance matrix and the significance of the separation to this vertex is calculated.
- vertexDistanceSignificance¶
Returns the distance between the production and decay vertex of a particle in units of the uncertainty on this value, i.e. the significance of the vertex separation.
Vertex Information¶
Here is a list of production and decay vertex variables:
- dcosTheta¶
vertex or POCA polar angle in respect to IP
- distance¶
3D distance between the IP and the particle decay vertex, if available.
In case the particle has been created from a track, the distance is defined between the POCA and IP. If the particle is built from an ECL cluster, the decay vertex is set to the nominal IP. If the particle is created from a KLM cluster, the distance is calculated between the IP and the cluster itself.
- dphi¶
vertex azimuthal angle of the vertex or POCA in degrees in respect to IP
- dr¶
transverse distance in respect to IP for a vertex; track d0 relative to IP for a track.
- dx¶
vertex or POCA in case of tracks x in respect to IP
- dy¶
vertex or POCA in case of tracks y in respect to IP
- dz¶
vertex or POCA in case of tracks z in respect to IP
- mcDecayVertexFromIPDistance¶
Returns the distance of the decay vertex of the matched generated particle from the IP. Returns nan if the particle has no matched generated particle.
- mcDecayVertexFromIPRho¶
Returns the transverse position of the decay vertex of the matched generated particle wrt the IP. Returns nan if the particle has no matched generated particle.
- mcDecayVertexFromIPX¶
Returns the x position of the decay vertex of the matched generated particle wrt the IP. Returns nan if the particle has no matched generated particle.
- mcDecayVertexFromIPY¶
Returns the y position of the decay vertex of the matched generated particle wrt the IP. Returns nan if the particle has no matched generated particle.
- mcDecayVertexFromIPZ¶
Returns the z position of the decay vertex of the matched generated particle wrt the IP. Returns nan if the particle has no matched generated particle.
- mcDecayVertexRho¶
Returns the transverse position of the decay vertex of the matched generated particle. Returns nan if the particle has no matched generated particle.
- mcDecayVertexX¶
Returns the x position of the decay vertex of the matched generated particle. Returns nan if the particle has no matched generated particle.
- mcDecayVertexY¶
Returns the y position of the decay vertex of the matched generated particle. Returns nan if the particle has no matched generated particle.
- mcDecayVertexZ¶
Returns the z position of the decay vertex of the matched generated particle. Returns nan if the particle has no matched generated particle.
- mcProductionVertexFromIPX¶
Returns the x position of the production vertex of the matched generated particle wrt the IP. Returns nan if the particle has no matched generated particle.
- mcProductionVertexFromIPY¶
Returns the y position of the production vertex of the matched generated particle wrt the IP. Returns nan if the particle has no matched generated particle.
- mcProductionVertexFromIPZ¶
Returns the z position of the production vertex of the matched generated particle wrt the IP. Returns nan if the particle has no matched generated particle.
- mcProductionVertexX¶
Returns the x position of production vertex of matched generated particle. Returns nan if the particle has no matched generated particle.
- mcProductionVertexY¶
Returns the y position of production vertex of matched generated particle. Returns nan if the particle has no matched generated particle.
- mcProductionVertexZ¶
Returns the z position of production vertex of matched generated particle. Returns nan if the particle has no matched generated particle.
- prodVertexCov(i, j)¶
Returns the ij covariance matrix component of particle production vertex, arguments i,j should be 0, 1 or 2. Returns NaN if particle has no production covariance matrix.
- prodVertexX¶
Returns the x position of particle production vertex. Returns NaN if particle has no production vertex.
- prodVertexXErr¶
Returns the x position uncertainty of particle production vertex. Returns NaN if particle has no production vertex.
- prodVertexY¶
Returns the y position of particle production vertex.
- prodVertexYErr¶
Returns the y position uncertainty of particle production vertex.
- prodVertexZ¶
Returns the z position of particle production vertex.
- prodVertexZErr¶
Returns the z position uncertainty of particle production vertex.
- significanceOfDistance¶
significance of distance from vertex or POCA to interaction point(-1 in case of numerical problems)
- x¶
x coordinate of vertex in case of composite particle, or point of closest approach (POCA) in case of a track
- x_uncertainty¶
uncertainty on x (measured with respect to the origin)
- y¶
y coordinate of vertex in case of composite particle, or point of closest approach (POCA) in case of a track
- y_uncertainty¶
uncertainty on y (measured with respect to the origin)
- z¶
z coordinate of vertex in case of composite particle, or point of closest approach (POCA) in case of a track
- z_uncertainty¶
uncertainty on z (measured with respect to the origin)
Orca Kinematic Fitter¶
Warning
In order to populate these variables, you need to run the Orca kinematic fitter. I.e.
import kinfit
kinfit.fitKinematic4C(your_candidates, path=mypath) # or similar
- OrcaKinFitChi2¶
The \(\chi^2\) returned by the Orca kinematic fitter. Returns NaN if Orca was not run.
Warning
this is the raw \(\chi^2\), not over ndf.
- OrcaKinFitErrorCode¶
The error code returned by the Orca kinematic fitter. Returns NaN if Orca was not run.
- OrcaKinFitProb¶
The p-value returned by the Orca kinematic fitter. Returns NaN if Orca was not run.
- OrcaKinFitUnmeasuredE¶
The energy of the “unmeasured photon” returned by Orca kinematic fitter for specific 1C fits with the
addUnmeasuredPhoton
parameter set. I.e. for fits with sufficient constraints remaining to constrain a missing 3-vector. Returns NaN if Orca was not run or if theaddUnmeasuredPhoton
parameter was not set.
- OrcaKinFitUnmeasuredErrorE¶
The uncertainty on
OrcaKinFitUnmeasuredE
.
- OrcaKinFitUnmeasuredErrorPhi¶
The uncertainty on
OrcaKinFitUnmeasuredPhi
.
- OrcaKinFitUnmeasuredErrorTheta¶
The uncertainty on
OrcaKinFitUnmeasuredTheta
.
- OrcaKinFitUnmeasuredPhi¶
The azimuthal angle of the “unmeasured photon” returned by Orca kinematic fitter for specific 1C fits with the
addUnmeasuredPhoton
parameter set. I.e. for fits with sufficient constraints remaining to constrain a missing 3-vector. Returns NaN if Orca was not run or if theaddUnmeasuredPhoton
parameter was not set.
- OrcaKinFitUnmeasuredTheta¶
The polar angle of the “unmeasured photon” returned by Orca kinematic fitter for specific 1C fits with the
addUnmeasuredPhoton
parameter set. I.e. for fits with sufficient constraints remaining to constrain a missing 3-vector. Returns NaN if Orca was not run or if theaddUnmeasuredPhoton
parameter was not set.
For fully-inclusive particles¶
Here is a list of useful variables to work with fully-inclusive particles, which are produced via Rest Of Event, AllParticleCombiner
or other inclusive reconstruction modules:
- daughterAverageOf(variable)¶
Returns the mean value of a variable over all daughters.
- nCompositeDaughters¶
Returns the number of final state composite daughters.
- nDaughterCharged(pdg)¶
Returns the number of charged daughters with the provided PDG code or the number of all charged daughters if no argument has been provided.
- nDaughterNeutralHadrons¶
Returns the number of K_L0 or neutrons among the final state daughters.
- nDaughterPhotons¶
Returns the number of final state daughter photons.
Specific kinematic variables¶
This variables group is reserved for the variables for analyses of specific decays like, \(B \to h l \nu\), \(B \to h l^\pm l^\mp\), etc.
- recMissM2¶
Returns the invariant mass squared of the missing momentum calculated assumings thereco B is at rest and calculating the neutrino (missing) momentum from \(p_\nu = p_B - p_\mathrm{had} - p_\mathrm{lep}\)
- recQ2Bh¶
Returns the momentum transfer squared, \(q^2\), calculated in CMS as \(q^2 = (p_B - p_h)^2\), where p_h is the CMS momentum of all hadrons in the decay \(B \to H_1\dots H_n \ell \nu_\ell\). This calculation uses a weighted average of the B meson around the reco B cone. Based on diamond frame calculation of \(q^2\) following the idea presented in https://www.osti.gov/biblio/1442697 It will switch to use of
recQ2BhSimple
if absolute ofcosThetaBetweenParticleAndNominalB
> 1.
- recQ2BhSimple¶
Returns the momentum transfer squared, \(q^2\), calculated in CMS as \(q^2 = (p_B - p_h)^2\), where p_h is the CMS momentum of all hadrons in the decay \(B \to H_1 ... H_n \ell \nu_\ell\). The B meson momentum in CMS is assumed to be 0.
Belle and b2bii
variables¶
Several legacy Belle variables are provided.
Note
These are intended for studies with b2bii
and for comparison between Belle and Belle II.
- BelleFirstCDCHitX¶
[Legacy] Returns x component of starting point of the track near the 1st SVD or CDC hit for SVD1 data (exp. 7 - 27) or the 1st CDC hit for SVD2 data (from exp. 31). (Belle only, originally stored in mdst_trk_fit.)
- BelleFirstCDCHitY¶
[Legacy] Returns y component of starting point of the track near the 1st SVD or CDC hit for SVD1 data (exp. 7 - 27) or the 1st CDC hit for SVD2 data (from exp. 31). (Belle only, originally stored in mdst_trk_fit.)
- BelleFirstCDCHitZ¶
[Legacy] Returns z component of starting point of the track near the 1st SVD or CDC hit for SVD1 data (exp. 7 - 27) or the 1st CDC hit for SVD2 data (from exp. 31). (Belle only, originally stored in mdst_trk_fit.)
- BelleLastCDCHitX¶
[Legacy] Returns x component of end point of the track near the last CDC hit. (Belle only, originally stored in mdst_trk_fit.)
- BelleLastCDCHitY¶
[Legacy] Returns y component of end point of the track near the last CDC hit. (Belle only, originally stored in mdst_trk_fit.)
- BelleLastCDCHitZ¶
[Legacy] Returns z component of end point of the track near the last CDC hit. (Belle only, originally stored in mdst_trk_fit.)
- BellePi0SigM¶
[Legacy] Returns the significance of the pi0 mass used in the FEI for B2BII. The significance is calculated as the difference between the reconstructed and the nominal mass divided by the mass uncertainty. Since the pi0’s covariance matrix for B2BII is empty, the latter is calculated using the photon daughters’ covariance matrices.
- clusterBelleQuality¶
[Legacy] Returns ECL cluster’s quality indicating a good cluster in GSIM (stored in deltaL of ECL cluster object). Belle analysis typically used clusters with quality == 0 in their \(E_{\text{extra ECL}}\) (Belle only).
- goodBelleGamma¶
[Legacy] Returns 1.0 if photon candidate passes simple region dependent energy selection for Belle data and MC (50/100/150 MeV).
- goodBelleKshort¶
[Legacy] GoodKs Returns 1.0 if a \(K_{S}^0\to\pi\pi\) candidate passes the Belle algorithm: a momentum-binned selection including requirements on impact parameter of, and angle between the daughter pions as well as separation from the vertex and flight distance in the transverse plane.
- goodBelleLambda¶
[Legacy] Returns 2.0, 1.0, 0.0 as an indication of goodness of \(\Lambda^0\) candidates, based on:
The distance of the two daughter tracks at their interception at z axis,
the minimum distance of the daughter tracks and the IP in xy plane,
the difference of the azimuthal angle of the vertex vector and the momentum vector,
and the flight distance of the Lambda0 candidates in xy plane.
It reproduces the
goodLambda()
function in Belle.goodBelleLambda
selection 1 (selected with:goodBelleLambda>0
) should be used withatcPIDBelle(4,2) > 0.6
, andgoodBelleLambda
selection 2 (goodBelleLambda>1
) can be used without a proton PID cut. The former cut is looser than the latter.”.Warning
goodBelleLambda
is not optimized or tested on Belle II data.See also
BN-684 Lambda selection at Belle. K F Chen et al.
The
FindLambda
class can be found at/belle_legacy/findLambda/findLambda.h
PID for B2BII¶
Warning
These variables are to be used only when analysing converted Belle samples.
- atcPIDBelle(i, j)¶
returns Belle’s PID atc variable:
atc_pid(3,1,5,i,j).prob()
. Parameters i,j are signal and background hypothesis: (0 = electron, 1 = muon, 2 = pion, 3 = kaon, 4 = proton)
- eIDBelle¶
returns Belle’s electron ID
eid(3,-1,5).prob()
variable.
- muIDBelle¶
returns Belle’s PID
Muon_likelihood()
variable.
- muIDBelleQuality¶
returns true if Belle’s PID
Muon_likelihood()
is usable (reliable).
Miscellaneous¶
Other variable that can be handy in development:
- False¶
returns always 0, used for testing and debugging.
- True¶
returns always 1, used for testing and debugging.
- decayTypeRecoil¶
type of the particle decay(no related mcparticle = -1, hadronic = 0, direct leptonic = 1, direct semileptonic = 2,lower level leptonic = 3.
- eventRandom¶
[Eventbased] Returns a random number between 0 and 1 for this event. Can be used, e.g. for applying an event prescale.
- infinity¶
returns std::numeric_limits<double>::infinity()
- mcMomTransfer2¶
Return the true momentum transfer to lepton pair in a B(semi -) leptonic B meson decay.
- nRemainingTracksInEvent¶
Number of tracks in the event - Number of tracks( = charged FSPs) of particle.
- printParticle¶
For debugging, print Particle and daughter PDG codes, plus MC match. Returns 0.
- random¶
return a random number between 0 and 1 for each candidate. Can be used, e.g. for picking a randomcandidate in the best candidate selection.
- trackMatchType¶
-1 particle has no ECL cluster
0 particle has no associated track
1 there is a matched track called connected - region(CR) track match
Note
Deprecated since version light-minos-2012.
Use better variables like
trackNECLClusters
,clusterTrackMatch
, andnECLClusterTrackMatches
.
Calibration¶
There are several variables also available for calibration experts who are working on cdst
format files.
Warning
Many of these will not work for- and should not be used by- normal analyses.
They have a [Calibration] pretag.
- eventT0¶
[Eventbased][Calibration] The Event t0, measured in ns, is the time of the event relative to the trigger time.
Note
The event time can be measured by several sub-detectors including the CDC, ECL, and TOP. This Event t0 variable is the final combined value of all the event time measurements. Currently only the CDC and ECL are used in this combination.
6.3.3. Collections and Lists¶
To avoid very long lists of variable names in variablesToNtuple
,
it is possible to use collections of variables or lists of variables instead.
Lists of variables are just python lists of variables names. One can use the list in the steering file as follows:
# Defining the list
my_list = ['p','E']
# Passing it as an argument to variablesToNtuple
modularAnalysis.variablesToNtuple(variables=my_list, ...)
It is also possible to create user-defined variable collections. The name of the variable collection can be treated as a variable name.
- variables.utils.add_collection(list_of_variables: Iterable[str], collection_name: str) → str[source]¶
The function creates variable collection from the given list of variables It wraps the
VariableManager.addCollection
method which is not particularly user-friendly.Example
Defining the collection >>> variables.utils.add_collection([‘p’,’E’], “my_collection”)
Passing it as an argument to variablesToNtuple >>> modularAnalysis.variablesToNtuple(variables=[‘my_collection’], …)
Predefined collections¶
We provide several predefined lists of variables. For each predefined list, there is a collection with the same name:
- variables.collections.belle_track_hit = ['BelleFirstCDCHitX', 'BelleFirstCDCHitY', 'BelleFirstCDCHitZ', 'BelleLastCDCHitX', 'BelleLastCDCHitY', 'BelleLastCDCHitZ']¶
Belle Track CDC hit variables
- variables.collections.cluster = ['clusterKlId', 'clusterPulseShapeDiscriminationMVA', 'clusterHasPulseShapeDiscrimination', 'clusterNumberOfHadronDigits', 'clusterDeltaLTemp', 'minC2TDist', 'nECLClusterTrackMatches', 'clusterZernikeMVA', 'clusterReg', 'clusterAbsZernikeMoment40', 'clusterAbsZernikeMoment51', 'clusterBelleQuality', 'clusterClusterID', 'clusterConnectedRegionID', 'clusterE1E9', 'clusterE9E21', 'clusterE9E25', 'clusterEoP', 'clusterErrorE', 'clusterErrorPhi', 'clusterErrorTheta', 'clusterErrorTiming', 'clusterHighestE', 'clusterHasFailedErrorTiming', 'clusterHasFailedTiming', 'clusterHasNPhotons', 'clusterHasNeutralHadron', 'clusterLAT', 'clusterNHits', 'clusterPhi', 'clusterR', 'clusterSecondMoment', 'clusterTheta', 'clusterTiming', 'clusterTrackMatch', 'goodBelleGamma']¶
Cluster-related variables
- variables.collections.cluster_average = ['maxWeightedDistanceFromAverageECLTime', 'weightedAverageECLTime']¶
Cluster averages
- variables.collections.dalitz_3body = ['daughterInvM(0, 1)', 'daughterInvM(0, 2)', 'daughterInvM(1, 2)']¶
Dalitz masses for three body decays
- variables.collections.deltae_mbc = ['Mbc', 'deltaE']¶
Replacement for DeltaEMbc
- variables.collections.event_kinematics = ['missingMomentumOfEvent', 'missingMomentumOfEvent_Px', 'missingMomentumOfEvent_Py', 'missingMomentumOfEvent_Pz', 'missingMomentumOfEvent_theta', 'missingMomentumOfEventCMS', 'missingMomentumOfEventCMS_Px', 'missingMomentumOfEventCMS_Py', 'missingMomentumOfEventCMS_Pz', 'missingMomentumOfEventCMS_theta', 'missingEnergyOfEventCMS', 'missingMass2OfEvent', 'visibleEnergyOfEventCMS', 'totalPhotonsEnergyOfEvent']¶
Variables created by event kinematics module
- variables.collections.event_level_cluster = ['nECLOutOfTimeCrystals', 'nECLOutOfTimeCrystalsBWDEndcap', 'nECLOutOfTimeCrystalsBarrel', 'nECLOutOfTimeCrystalsFWDEndcap', 'nRejectedECLShowers', 'nRejectedECLShowersBWDEndcap', 'nRejectedECLShowersBarrel', 'nRejectedECLShowersFWDEndcap']¶
Cluster-related event variables
- variables.collections.event_level_tracking = ['nExtraCDCHits', 'nExtraCDCHitsPostCleaning', 'hasExtraCDCHitsInLayer(0)', 'hasExtraCDCHitsInLayer(1)', 'hasExtraCDCHitsInLayer(2)', 'hasExtraCDCHitsInLayer(3)', 'hasExtraCDCHitsInLayer(4)', 'hasExtraCDCHitsInLayer(5)', 'hasExtraCDCHitsInLayer(6)', 'hasExtraCDCHitsInLayer(7)', 'nExtraCDCSegments', 'trackFindingFailureFlag']¶
Event level tracking variables
- variables.collections.event_shape = ['foxWolframR1', 'foxWolframR2', 'foxWolframR3', 'foxWolframR4', 'harmonicMomentThrust0', 'harmonicMomentThrust1', 'harmonicMomentThrust2', 'harmonicMomentThrust3', 'harmonicMomentThrust4', 'cleoConeThrust0', 'cleoConeThrust1', 'cleoConeThrust2', 'cleoConeThrust3', 'cleoConeThrust4', 'cleoConeThrust5', 'cleoConeThrust6', 'cleoConeThrust7', 'cleoConeThrust8', 'sphericity', 'aplanarity', 'thrust', 'thrustAxisCosTheta']¶
Event shape variables
- variables.collections.extra_energy = ['roeEextra()']¶
Extra energy variables
- variables.collections.flight_info = ['flightTime', 'flightDistance', 'flightTimeErr', 'flightDistanceErr']¶
Flight info variables
- variables.collections.inv_mass = ['M', 'ErrM', 'SigM', 'InvM']¶
Replacement for InvMass tool
- variables.collections.kinematics = ['px', 'py', 'pz', 'pt', 'p', 'E']¶
Replacement to Kinematics tool
- variables.collections.klm_cluster = ['klmClusterKlId', 'klmClusterTiming', 'klmClusterPositionX', 'klmClusterPositionY', 'klmClusterPositionZ', 'klmClusterInnermostLayer', 'klmClusterLayers', 'klmClusterEnergy', 'klmClusterMomentum', 'klmClusterIsBKLM', 'klmClusterIsEKLM', 'klmClusterIsForwardEKLM', 'klmClusterIsBackwardEKLM', 'klmClusterTheta', 'klmClusterPhi', 'nKLMClusterTrackMatches', 'nMatchedKLMClusters']¶
KLM cluster information
- variables.collections.mc_event_kinematics = ['genMissingMass2OfEvent', 'genMissingEnergyOfEventCMS', 'genMissingMomentumOfEventCMS', 'genTotalPhotonsEnergyOfEvent', 'genVisibleEnergyOfEventCMS']¶
Variables created by MC version of event kinematics module
- variables.collections.mc_flight_info = ['mcFlightTime', 'mcFlightDistance']¶
MC true flight info variables
- variables.collections.mc_kinematics = ['mcE', 'mcP', 'mcPT', 'mcPX', 'mcPY', 'mcPZ', 'mcPhi']¶
Replacement for MCKinematics tool
- variables.collections.mc_tag_vertex = ['mcDeltaTau', 'mcDeltaT', 'mcDeltaBoost', 'mcTagVLBoost', 'mcTagVOBoost', 'mcLBoost', 'mcOBoost', 'mcTagVx', 'mcTagVy', 'mcTagVz']¶
Tag-side related MC true variables
- variables.collections.mc_truth = ['isSignal', 'mcErrors', 'mcPDG']¶
Replacement for MCTruth tool
- variables.collections.mc_variables = ['genMotherID', 'genMotherP', 'genMotherPDG', 'genParticleID', 'isCloneTrack', 'mcDecayVertexX', 'mcDecayVertexY', 'mcDecayVertexZ', 'mcDecayTime', 'mcE', 'mcErrors', 'mcInitial', 'mcP', 'mcPDG', 'mcPT', 'mcPX', 'mcPY', 'mcPZ', 'mcPhi', 'mcVirtual', 'nMCMatches']¶
Truth-matching related variables
- variables.collections.mc_vertex = ['mcDecayVertexX', 'mcDecayVertexY', 'mcDecayVertexZ', 'mcDecayVertexFromIPDistance', 'mcDecayVertexRho', 'mcProductionVertexX', 'mcProductionVertexY', 'mcProductionVertexZ']¶
Replacement for MCVertex tuple tool
- variables.collections.momentum_uncertainty = ['E_uncertainty', 'pxErr', 'pyErr', 'pzErr']¶
Replacement for MomentumUnertainty tool
- variables.collections.pid = ['kaonID', 'pionID', 'protonID', 'muonID', 'electronID', 'electronID_noTOP', 'deuteronID', 'binaryPID(211, 13)', 'binaryPID(211, 321)', 'binaryPID(211, 2212)', 'binaryPID(321, 2212)']¶
PID variables
- variables.collections.reco_stats = ['nTracks']¶
Replacement for RecoStats tool
- variables.collections.recoil_kinematics = ['pRecoil', 'eRecoil', 'mRecoil', 'pRecoilPhi', 'pRecoilTheta', 'pxRecoil', 'pyRecoil', 'pzRecoil']¶
Recoil kinematics related variables
- variables.collections.roe_kinematics = ['roeE()', 'roeM()', 'roeP()', 'roeMbc()', 'roeDeltae()']¶
Rest-Of-Event kinematics
- variables.collections.roe_multiplicities = ['nROE_Charged()', 'nROE_Photons()', 'nROE_NeutralHadrons()']¶
Replacement for ROEMultiplicities tool
- variables.collections.tag_vertex = ['DeltaT', 'DeltaTErr', 'DeltaZ', 'DeltaZErr', 'DeltaBoost', 'DeltaBoostErr', 'TagVLBoost', 'TagVLBoostErr', 'TagVOBoost', 'TagVOBoostErr', 'TagVpVal', 'TagVNDF', 'TagVChi2', 'TagVChi2IP', 'TagVx', 'TagVxErr', 'TagVy', 'TagVyErr', 'TagVz', 'TagVzErr']¶
CPV and Tag-side related variables
- variables.collections.track = ['dr', 'dx', 'dy', 'dz', 'd0', 'z0', 'pValue', 'ndf']¶
Tracking variables, replacement for Track tool
- variables.collections.track_hits = ['nCDCHits', 'nPXDHits', 'nSVDHits', 'nVXDHits']¶
Replacement for TrackHits tool
- variables.collections.vertex = ['distance', 'significanceOfDistance', 'dx', 'dy', 'dz', 'x', 'y', 'z', 'x_uncertainty', 'y_uncertainty', 'z_uncertainty', 'dr', 'dphi', 'dcosTheta', 'prodVertexX', 'prodVertexY', 'prodVertexZ', 'prodVertexXErr', 'prodVertexYErr', 'prodVertexZErr', 'chiProb']¶
Replacement for Vertex tuple tool
6.3.4. Operations with variable lists¶
It is possible to create new variable lists using meta-variables. For example,
one can define list of kinematic variables in LAB frame and create another
lists of kinematic variables in CMS using useCMSFrame(variable)
meta-variable:
from variables.utils import create_aliases
# Replacement to Kinematics tool
kinematics = ['px', 'py', 'pz', 'pt', 'p', 'E']
# Kinematic variables in CMS
cms_kinematics = create_aliases(kinematics, "useCMSFrame({variable})", "CMS")
Now we can use the list of aliases cms_kinematics
and add them to the
output in one go or modify them further. The following functions are provided
to help to easily create aliases.
- variables.utils.create_aliases(list_of_variables: Iterable[str], wrapper: str, prefix: str) → List[str][source]¶
The function creates aliases for variables from the variables list with given wrapper and returns list of the aliases.
If the variables in the list have arguments (like
useLabFrame(p)
) all non-alphanumeric characters in the variable will be replaced by underscores (for exampleuseLabFrame_x
) for the alias name.>>> list_of_variables = ['M','p','matchedMC(useLabFrame(px))'] >>> wrapper = 'daughter(1,{variable})' >>> prefix = 'pref' >>> print(create_aliases(list_of_variables, wrapper, prefix)) ['pref_M', 'pref_p', 'pref_matchedMC_useLabFrame_px'] >>> from variables import variables >>> variables.printAliases() [INFO] ===================================== [INFO] The following aliases are registered: [INFO] pref_M --> daughter(1,M) [INFO] pref_matchedMC_useLabFrame_px --> daughter(1,matchedMC(useLabFrame(px))) [INFO] pref_p --> daughter(1,p) [INFO] =====================================
- Parameters
- Returns
new variables list
- Return type
- variables.utils.create_aliases_for_selected(list_of_variables: List[str], decay_string: str, prefix: Optional[Union[str, List[str]]] = None, *, use_names=True, always_include_indices=False, use_relative_indices=False) → List[str][source]¶
The function creates list of aliases for given variables so that they are calculated for particles selected in decay string. That is for each particle selected in the decay string an alias is created to calculate each variable in the
list_of_variables
.If
use_names=True
(the default) then the names of the aliases are assigned as follows:If names are unambiguous, it’s semi-laconic DecayString style: The aliases will be prefixed with the names of all parent particle names separated by underscore. For example given the decay string
B0 -> [D0 -> ^pi+ K-] pi0
the aliases for thepi+` will start with ``D0_pi_
followed by the variable name.>>> list_of_variables = ['M','p'] >>> decay_string = 'B0 -> [D0 -> ^pi+ K-] pi0' >>> create_aliases_for_selected(list_of_variables, decay_string) ['D0_pi_M', 'D0_pi_p'] >>> from variables import variables >>> variables.printAliases() [INFO] ========================= [INFO] Following aliases exists: [INFO] 'D0_pi_M' --> 'daughter(0,daughter(0,M))' [INFO] 'D0_pi_p' --> 'daughter(0,daughter(0,p))' [INFO] =========================
If names are ambiguous because there are multiple daughters with the same name these particles will be followed by their daughter index. For example given the decay string
B0 -> [D0 -> ^pi+:1 ^pi-:2 ^pi0:3 ] ^pi0:4
will create aliases with the following prefixes for particle with the corresponding number as list name:D0_pi_0_
D0_pi_1_
D0_pi0_
pi0_
>>> list_of_variables = ['M','p'] >>> decay_string = 'B0 -> [D0 -> ^pi+ ^pi- ^pi0] ^pi0' >>> create_aliases_for_selected(list_of_variables, decay_string) ['D0_pi_0_M', 'D0_pi_0_p', 'D0_pi_1_M', 'D0_pi_1_p', 'D0_pi0_M', 'D0_pi0_p', 'pi0_M', 'pi0_p'] >>> from variables import variables >>> variables.printAliases() [INFO] ========================= [INFO] Following aliases exists: [INFO] 'D0_pi0_M' --> 'daughter(0,daughter(2,M))' [INFO] 'D0_pi0_p' --> 'daughter(0,daughter(2,p))' [INFO] 'D0_pi_0_M' --> 'daughter(0,daughter(0,M))' [INFO] 'D0_pi_0_p' --> 'daughter(0,daughter(0,p))' [INFO] 'D0_pi_1_M' --> 'daughter(0,daughter(1,M))' [INFO] 'D0_pi_1_p' --> 'daughter(0,daughter(1,p))' [INFO] 'D0_pi_M' --> 'daughter(0,daughter(0,M))' [INFO] 'D0_pi_p' --> 'daughter(0,daughter(0,p))' [INFO] 'pi0_M' --> 'daughter(1,M)' [INFO] 'pi0_p' --> 'daughter(1,p)' [INFO] =========================
The user can select to always include the index even for unambiguous particles by passing
always_include_indices=True
The user can choose two different numbering schemes: If
use_relative_indices=False
the original decay string indices will be used if a index is added to a particle name.But if
use_relative_indices=True
the indices will just start at zero for each particle which is part of the prefixes. For example forB0-> e+ ^e-
>>> create_aliases_for_selected(['M'], 'B0-> mu+ e- ^e+ ^e-', use_relative_indices=False) ['e_2_M', 'e_3_M'] >>> create_aliases_for_selected(['M'], 'B0-> mu+ e- ^e+ ^e-', use_relative_indices=True) ['e_0_M', 'e_1_M']
If
use_names=False
the aliases will just start with the daughter indices of all parent particles prefixed with ad
and separated by underscore. So for the previous exampleB0 -> [D0 -> ^pi+:1 ^pi-:2 ^pi0:3 ] ^pi0:4
this would result in aliases starting withd0_d0_
d0_d1_
d0_d2_
d1_
In this case the
always_include_indices
anduse_relative_indices
arguments are ignored.The naming can be modified by providing a custom prefix for each selected particle. In this case the parameter
prefix
needs to be either a simple string if only one particle is selected or a list of strings with one prefix for each selected particle.>>> list_of_variables = ['M','p'] >>> decay_string = 'B0 -> [D0 -> ^pi+ ^pi- pi0] pi0' >>> create_aliases_for_selected(list_of_variables, decay_string, prefix=['pip', 'pim']) ['pip_M', 'pip_p', 'pim_M', 'pim_p'] >>> from variables import variables >>> variables.printAliases() [INFO] ========================= [INFO] Following aliases exists: [INFO] 'pim_M' --> 'daughter(0,daughter(1,M))' [INFO] 'pim_p' --> 'daughter(0,daughter(1,p))' [INFO] 'pip_M' --> 'daughter(0,daughter(0,M))' [INFO] 'pip_p' --> 'daughter(0,daughter(0,p))' [INFO] =========================
If the mother particle itself is selected the input list of variables will also be added to the returned list of created aliases. If custom prefixes are supplied then aliases will be created for the mother particle as well:
>>> create_aliases_for_selected(['M', 'p'], '^B0 -> pi+ ^pi-') ['M', 'p', 'pi_M', 'pi_p'] >>> create_aliases_for_selected(['M', 'p'], '^B0 -> pi+ ^pi-', prefix=['MyB', 'MyPi']) ['MyB_M', 'MyB_p', 'MyPi_M', 'MyPi_p']
- Parameters
decay_string (str) – Decay string with selected particles
prefix (str, list(str)) – Custom prefix for all selected particles
use_names (bool) – Include the names of the particles in the aliases
always_include_indices (bool) – If
use_names=True
include the decay index of the particles in the alias name even if the particle could be uniquely identified without them.use_relative_indices (bool) – If
use_names=True
use a relative indicing which always starts at 0 for each particle appearing in the alias names independent of the absolute position in the decay string
- Returns
new variables list
- Return type
- variables.utils.create_daughter_aliases(list_of_variables: Iterable[str], indices: Union[int, Iterable[int]], prefix='', include_indices=True) → List[str][source]¶
Create Aliases for all variables for a given daughter hierarchy
- Parameters
list_of_variables (list(str)) – list of variables to create aliases for
indices (int or list(int)) – index of the daughter, grand-daughter, grand-grand-daughter, and so forth
prefix (str) – optional prefix to prepend to the aliases
include_indices (bool) – if set to True (default) the aliases will contain the daughter indices as dX_dY_dZ…
- Returns
new variables list
- Return type
create aliases for the second daughter as “d1_E”, “d1_M” (daughters start at 0)
>>> create_daughter_aliases(["E", "m"], 1) ['d1_E', 'd1_m'] >>> from variables import variables >>> variables.printAliases() [INFO] ========================= [INFO] Following aliases exists: [INFO] 'd1_E' --> 'daughter(1,E)' [INFO] 'd1_m' --> 'daughter(1,m)' [INFO] =========================
create aliases for the first grand daughter of the second daughter, starting with “my” and without including the indices, resulting in “my_E”, “my_m”
>>> create_daughter_aliases(["E", "m"], [1, 0], prefix="my", include_indices=False) ['my_E', 'my_m'] >>> from variables import variables >>> variables.printAliases() [INFO] ========================= [INFO] Following aliases exists: [INFO] 'my_E' --> 'daughter(1,daughter(0,E))' [INFO] 'my_m' --> 'daughter(1,daughter(0,m))' [INFO] =========================
create aliases for the second grand grand daughter of the third grand daughter of the fifth daugther, starting with my and including the indices, resulting in “my_d4_d2_d1_E”, “my_d4_d2_d1_m”
>>> create_daughter_aliases(["E", "m"], [4, 2, 1], prefix="my") ['my_d4_d2_d1_E', 'my_d4_d2_d1_m'] >>> from variables import variables >>> variables.printAliases() [INFO] ========================= [INFO] Following aliases exists: [INFO] 'my_d4_d2_d1_E' --> 'daughter(4,daughter(2,daughter(1,E))' [INFO] 'my_d4_d2_d1_m' --> 'daughter(4,daughter(2,daughter(1,m))' [INFO] =========================
- variables.utils.create_mctruth_aliases(list_of_variables: Iterable[str], prefix='mc') → List[str][source]¶
The function wraps variables from the list with ‘matchedMC()’.
>>> list_of_variables = ['M','p'] >>> create_mctruth_aliases(list_of_variables) ['mc_M', 'mc_p'] >>> from variables import variables >>> variables.printAliases() [INFO] ========================= [INFO] Following aliases exists: [INFO] 'mc_M' --> 'matchedMC(M)' [INFO] 'mc_p' --> 'matchedMC(p)' [INFO] =========================
- variables.utils.create_isSignal_alias(aliasName, flags)[source]¶
Make a
VariableManager
alias for a customizedisSignal
, which accepts specified mc match errors.See also
see MC matching for a definition of the mc match error flags.
The following code defines a new variable
isSignalAcceptMissingGammaAndMissingNeutrino
, which is same asisSignal
, but also accepts missing gamma and missing neutrino>>> create_isSignal_alias("isSignalAcceptMissingGammaAndMissingNeutrino", [16, 8])
Logically, this
isSignalAcceptMissingGammaAndMissingNeutrino
=isSignalAcceptMissingGamma
||isSignalAcceptMissingNeutrino
.In the example above, create_isSignal_alias() creates
isSignalAcceptMissingGammaAndMissingNeutrino
by unmasking (setting bits to zero) thec_MissGamma
bit (16 or 0b00010000) andc_MissNeutrino
bit (8 or 0b00001000) in mcErrors.For more information, please check this example script.
6.3.5. Miscellaneous helpers for using variables¶
6.3.6. Writing your own variable¶
The code of VariableManager lives inside the analysis package. If you want to write your own variables you have a couple of options. You can (and should) try to make your variables general, so that they are useful for many collaborators. In this case, we recommend you make a pull request. Then your variables will be made available in a central release to many people.
In case you have something really analysis-specific that no one else will need. You can still use the VariableManager.
Below are step-by-step instructions for implementation of helicity angle for arbitrary granddaughter particle.
Step 1. Check whether your function would fit in any of the existing source files¶
If yes, go to the next step.
If not, create new header/source files. In case of our example, we will create AngularVariables.h
and AngularVariables.cc
AngularVariables.h
in analysis/VariableManager/include/
:
#pragma once
// include VariableManager
#include <analysis/VariableManager/Manager.h>
// include the Belle II Particle class
#include <analysis/dataobjects/Particle.h>
// put variable in the Belle2::Variable namespace
namespace Belle2 {
namespace Variable {
// Your code goes here
} // Variable namespace
} // Belle2 namespace
AngularVariables.cc
in analysis/VariableManager/src/
:
// Own include
#include <analysis/VariableManager/AngularVariables.h>
// put variable in the Belle2::Variable namespace
namespace Belle2 {
namespace Variable {
// Your code goes here
} // Variable namespace
} // Belle2 namespace
Step 2. Add function definition in the header file¶
Here we define a method helicityAngle that has 3 arguments:
pointer to a Particle
index of the daughter Particle
index of the granddaughter (daughter’s daughter) Particle
in the AngularVariable.h
header file. The return value of every variable has to be double.
/**
* returns cosine of the helicity angle: angle between granddaughter and this particle in the daughter's rest frame.
* The daughter and granddaughter particles are specified with the additional parameter.
*/
double helicityAngle(const Particle* particle, const std::vector<double>& daughter_indices);
Step 3. Implement the function in the source file¶
Info on getters for the Particle class
Info on getters for the TLorentzVector class
Pictorial definition of the helicity angle
double helicityAngle(const Particle* particle, const std::vector<double>& daughter_indices) {
// for the calculation of the helicity angle we need particle (=particle in the argument)
// its daughter and granddaughter. The particle is given as an argument, but the daughter
// and granddaughter are specified as the indices in the vector (second argument)
// daughter_indices[0] = index of the daughter
// daughter_indices[1] = index of the granddaughter
if (!particle)
return std::numeric_limits<float>::quiet_NaN();
int nDaughters = particle->getNDaughters();
if(nDaughters < 2)
return std::numeric_limits<float>::quiet_NaN();
if (daughter_indices.size() != 2)
return std::numeric_limits<float>::quiet_NaN();
// get the daughter particle
int daughterIndex = daughter_indices[0];
const Particle *daughter = particle->getDaughter(daughterIndex);
nDaughters = daughter->getNDaughters();
if(nDaughters < 2)
return std::numeric_limits<float>::quiet_NaN();
// get the granddaughter
int grandDaughterIndex = daughter_indices[1];
const Particle *grandDaughter = daughter->getDaughter(grandDaughterIndex);
// do the calculation
TLorentzVector particle4Vector = particle->get4Vector();
TLorentzVector daughter4Vector = daughter->get4Vector();
TLorentzVector gDaughter4Vector = grandDaughter->get4Vector();
TVector3 boost2daughter = -(daughter4Vector.BoostVector());
particle4Vector.Boost(boost2daughter);
gDaughter4Vector.Boost(boost2daughter);
TVector3 particle3Vector = particle4Vector.Vect();
TVector3 gDaughter3Vector = gDaughter4Vector.Vect();
double numerator = gDaughter3Vector.Dot(particle3Vector);
double denominator = (gDaughter3Vector.Mag())*(particle3Vector.Mag());
return numerator/denominator;
}
Step 4. Register the new variable¶
At the end of the source file, add the following lines:
VARIABLE_GROUP("AngularVariables");
REGISTER_VARIABLE("helicityAngle(i,j)", helicityAngle,
"cosine of the angle between particle->getDaughter(i)->getDaughter(j) and this particle in the particle->getDaughter(i) rest frame.");
Step 5. Compile¶
Execute scons in your local release directory
Step 6. Done!¶
You can check if your variable is visible to VariableManager
>>> basf2 analysis/scripts/variables.py
AngularVariables: helicityAngle(i,j) cosine of the angle between particle->getDaughter(i)->getDaughter(j) and this particle in the particle->getDaughter(i) rest frame.
You can use your variable in the same way as you use standard variables.
How to use my variable at grid?¶
Prepare the environment with the
b2analysis-create
tool.
>>> b2analysis-create myanalysis <current central release, e.g. release-04-00-00>
>>> cd myanalysis
>>> setupana
Define the new variables/functions in a .cc and register them with the variable manager. This means that in the new .cc you should add:
#include <framework/core/Module.h>
#include <analysis/VariableManager/Manager.h>
#include <analysis/dataobjects/Particle.h>
namespace Belle2 {
namespace Variable {
double myVarFunction(const Particle* particle) { **your code** }
VARIABLE_GROUP("CUSTOM_VARIABLES");
REGISTER_VARIABLE("myVar", myVarFunction, "My custom variable");
}
// Create an empty module which does nothing at all. What it does is allowing
// basf2 to easily find the library and load it from the steering file
class EnableMyVariableModule: public Module {}; // And register this module to create a .map lookup file.
REG_MODULE(EnableMyVariable);
}
Then:
Run scons and you will get a
.so
and a.b2modmap
files inmodules/Linux_x86_64/opt
.Load the libraries and make the variables available you need to add these lines to your steering file:
import basf2
basf2.register_module("EnableMyVariable") # This is the relevant line: now you can use your variable
from variables import variables
print(variables.getVariable("myVar").description)
These lines will add the local directory to the module search path and instantiate the module we created. This is enough to load the library and register the variables. Now you should be able to use your custom variables for your analysis and there is no need to add this module to the path, it just needs to be registered to load the library.
In the end you can run your analysis on the grid adding the .so
and .map
files to the input sandbox
with the -f option of gbasf2
:
>>> gbasf2 ./steering.py -p project -i dataset -f myanalysis.so myanalysis.b2modmap
Warning
This line implies that you already have working gbasf2
installation and gbasf2
syntax didn’t
change since the moment of writing. Please refer gbasf2 documentation for more details.