 # Difference: DecayTreeFitter (9 vs. 10)

#### Revision 102015-11-13 - WouterHulsbergen

Line: 1 to 1

 META TOPICPARENT name="LHCbComputing"

# Decay-tree-fitter

Line: 171 to 171
}
>
>

## Fitting with missing particles

DecayTreeFitter can also deal with final state particles that do not have any external information, for example a neutrino. Of course, if all you have is a single decay vertex, then the parameters of that particle would not be constrained. So, how meaningful the fit is depends on the topology.

As an example, take B->KD0 with D0 decaying to Kmunu. The D0 flies and has a well reconstructed vertex. The B vertex has only one track. The constraint of the D0 direction of flight to that track fixes one parameter of the neutrino direction. Hence, you may hope to constrain one of three neutrino momentum parameters. With a PV constraint for the B, you can constrain yet another two. So, by exploiting the D0 and B lifetime, you can constrain the neutrino momentum even without any mass constraints.

Now, there is one big caveat to 'fitting' with missing particles: unless the decay is fully constrained, there is more than one solution. The fit will find the solution closest to its starting point. So, if you use DTF for estimating the parameters of a missing particle, makes sure those parameters are initialized as well as possible to the parameters that you would estimate with a back of the envelop calculation.

To use DTF with missing particles, you need to first create the decay. Currently, you cannot specify missing particles in decay descriptors. That makes this a bit complicated: you need to create the decay chain yourself. The following (untested, uncompiled) code snippet serves as an example:

```   // get these from somewhere else
const LHCb::Particle* myKFromD0 = ... ;
const LHCb::Particle* myMuFromD0 = ... ;
const LHCb::Particle* myKFromB0 = ... ;

// create a particle that represents neutrino. make sure to give it the right PID
LHCb::Particle* myNeutrino = new LHCb::Particle() ;
myNeutrino.setParticleID ( muonNeutrinoId ) ;
// initialize its momentum. one solution, reasonably suitable for this case:
// choose its momentum vector parallel to the KMu momentum. now choose
// momentum such that  you get mass of B. Of all solutions consistent with the B mass, this is the one that gives the smallest D0 mass.
const auto muKp4 = myKFromD0->momentum() + myMuFromD0 ->momentum()  ;
const auto muKKp4 = muKp4 +  myKFromB0->momemtum() ;
const auto dir =   muKp4.Vect().Unit() ;
const double dM2 = pdgBMass*pdgBMass - muKKp4.M2() ;
const double E = 0.5 * dM2 / (muKKp4.E() - muKKp4.Vect().Dot(dir)) ;
myNeutrino.setMomentum( Gaudi::LorentzVector( E* dir.x(), E*dir.y(), E*dir.z(), E) ) ;

// create the D0 particle. you could use a particle combiner here, but I'll do it by hand.
LHCb::Particle* myD0 = new LHCb::Particle() ;
myD0->setParticleID ( ...)
myD0->setMomentum( myNeutrino.momentum() + muKp4 ) ;
myD0->addToDaughters( myKFromD0 ) ;
myD0->addToDaughters( myNeutrino ) ;

// you probably want to create a vertex, too.
LHCb::Vertex* vd0 = new LHCb::Vertex() ;
myD0->setEndVertex( vd0) ;
// it would be best to initialize this with the poca of the kaon and muon, but I'll leave that as an exercise.

// now create the B+ in the same way
LHCb::Particle* myB = new LHCb::Particle() ;
myB->setParticleID ( ...)
myB->setMomentum( myD0.momentum() + muKp4 ) ;
myB->addToDaughters( myD0 ) ;

// now the fitting part
DecayTreeFit::Fitter fitter( *myB, myPV, myTrackStateProvider ) ;

// make sure to give the neutrino a mass constraint
fitter.setMassConstraint( myNeutrino ) ;

// eventually do the same for the B or the D

// now fit, and extract parameters as in examples above
fitter.fit()
```
-- WouterHulsbergen - 13 May 2009 \ No newline at end of file

Copyright &© 2008-2019 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback