D0: B semileptonic reconstruction
(Last revised: September 1, 2004 - Christos
Leonidopoulos)
Introduction
- Code description (v00-00-91)
The code (CVS package: bmixing_reco)
is designed as a generic B semileptonic wrapper class (Â
--> D + ì + ×) that can
load different "decay mode"-finders as plug-ins. It makes extensive use
of d0root utilities in:
- Reading-in data for event (currently using the TMBTree
data format)
- Making a list of good muons (matched to a central track)
- Finding the primary vertex (using the beamspot/average primary
vertex from a database as initial seed and a list of certified
muons for the best-PV selection)
- Fitting charged tracks into D, B mesons and decay vertices; in
particular:
- the VertexGlobalFitter
class, and
- the VertexMassConstraint::GetConstrainedCompositeTrack
method [combines list of tracks associated with a vertex to make a
charged/neutral track; it can be used to fit a reconstructed DS-
(from a Ê+ Ê- + ð- vertex) with a muon
to a vertex]
The first three steps are common in all B semileptonic decays and
implemented in the wrapper class. The last step involves different
classes for the several D0, D±, DS±
decay modes. The following B semileptonic modes are currently
implemented:
- D0 --> K- ð+ and D*(2010)±
--> D0 ð±
- D+ --> K- ð+ ð+
- DS- --> Ö(Ê+ Ê-) +
ð-
- DS- --> Ê*(Ê+ ð-)
+ Ê-
After identifying all the B candidates in the event, the code makes an
entry (one per B candidate) with kinematic information into a root-tuple. There is a separate branch
in the tree for every decay mode, so different channels can be studied
in
parallel for the same data sample.
A call to the B-flavor tagging class (bflavor_tag)
gives the flavor of the reconstructed B at the time of production
(currently using three tagging algorithms: Soft-muon, jet-charge and
soft-pion/same-side tagging). The tagging information is also stored
in the root-tuple.
A diagram with the code architecture of the B semileptonic
reconstruction can found here.
Installation - How to use
- Copy and run the installation
script.
This will:
- Setup a new working area (Default name:
Bsemil_studies_v91, release: p14.06.00)
- Check out the
d0root packages (Default version:
9.2)
- Check out the B-flavor tagging code (Default version:
bflavor_tag v00-00-80)
- Check out the B
reconstruction code (Default version:
bmixing_reco v00-00-91)
- Install all the above
- Copy example macros to the top directory.
- You are now ready to run!
You can have a look at the example
macro ("user code": run.C) and modify it if you wish. The
code is executed by running Make.C (the "makefile") with
root:
% root Make.C
- If you prefer to do it
yourself:
Some
explanation of the makefile:
TString incpath =
gSystem->GetIncludePath();
incpath.Append("
-I$SRT_LOCAL/include -I$SRT_PUBLIC_CONTEXT/include -I$SRT_PUBLIC_CONTEXT");
gSystem->SetIncludePath(incpath.Data());TString libpath =
gSystem->GetLinkedLibs()();
libpath.Append("
-L$SRT_LOCAL/lib/$BFARCH -L$SRT_PUBLIC_CONTEXT/lib/$BFARCH");
gSystem->SetLinkedLibs(libpath.Data());Physics" and "TMBTree"
libraries:
gSystem->Load("libPhysics.so");
gSystem->Load("$SRT_LOCAL/TMBTreeClasses_C.so");
- Remember
to load the d0root code:
gSystem->ProcessLine(".X d0root_load.C");
Using
the reconstruction code in your
macro:
#include
"bmixing_reco/BmixingRecoWrapper.hpp"
-
Construct
& use a GenericDMu_Finder object:
// instantiate with: input TMBTree (could be chain), reco version,
// minimum muon pt and (muon-id) quality,
// dR cone-size, tree in output root-tuple
// *** additional muon requirement: match to track ***
GenericDMu_Finder b_finder(chain, 14.03, MUON_PT, MUON_QUAL,
dR_cone_size, root_tree);
// instantiate D plug-ins here (default: all turned off)
// Ds-->Phi+Pi
b_finder.loadPhiPiFinder(true);
// Ds-->K*+K
b_finder.loadKstarKFinder(false);
// D0-->K+Pi
b_finder.loadPhiPiFinder(true);
// D+/- -->K+Pi+Pi
b_finder.loadKPiPiFinder(false);
// set abs[dca/sigma(dca)] cuts for muon, pion, kaon
// *** Implemented only for D0->Kpi mode for now ****
b_finder.setKPiFinderCut(SIGNIF_DCA_MUON, 1.0);
b_finder.setKPiFinderCut(SIGNIF_DCA_PION, 1.0);
b_finder.setKPiFinderCut(SIGNIF_DCA_KAON, 1.0);
-
Event loop
for(int i = 0; i != _nevents; ++i)
{
// find B candidates here
if(b_finder.findB(jentry))
root_tree->Fill();
} // event loop
A list
of access methods & more documentation can be found here
Description of the
output root-file structure: There
is a
base class (B) that contains the most basic kinematic information
(common in all decay modes). This is typically stored in a separate
sub-branch. In the parent directory one can find the remaining
variables that are unique to the specific decay mode. The current root version requires
this implementation if all leaves are to be accessible with a TBrowser.
More details can
be found here
(click on the "source file" of the
class page linked off the index).
Technical
stuff:
- To disable some
of the decay modes, use the
loadXXXFinder(false) methods.
This is
important if you are only interested in a particular decay, or if you
want to speed things up.
- The maximum # of B candidates per decay mode per event can be set
in DMuCandidate.hpp (currently using a very large
number because of the large combinatorics of the D+ --> K-
ð+ ð+ decay: this is a non-resonance mode, so
there are less constraints and therefore more D/B candidates per event)
Versioning
history:
Here
Older
versions of this page:
v00-00-50 (November 20,
2003)
v00-00-23 (November 18,
2003)
v00-00-15 (September 20,
2003)
v00-00-11 (September 11,
2003)
Please send questions, comments and corrections to Christos
Leonidopoulos