MicroDST

The purpose of the MicroDST is to select and store a sub-set of data of interest from a file in the LHCb DST format, in a smaller file of the same format. Storing only the information of interest to a given analysis significantly reduces the size of the DST. The amount of space saved depends of course on the given analysis, i.e. it is beneficial to have a dedicated MicroDST per given analysis or per group of (closely) related analyses. The MicroDST code is written with flexibility and configurability in mind, such that it should be easy to define the contents of a MicroDST and configure a program that creates it. Since the MicroDST is in the LHCb DST format, it is even possible to run on a MicroDST and produce an even smaller file in the same format, ad infinitum. Furthermore, it is possible, at each stage of "reduction", to add new information not present in the original DST or MicroDST, as long as this information is in the form of supported Event Model classes.

Framework principles

The MicroDST code is based on specialized tools and template algorithms that clone Event Model objects from a TES location into a parallel location. By default, objects from TES location "/Event/XXX/YYY/ZZZ" are cloned into location "/Event/microDST/XXX/YYY/ZZZ". Standard job options are set such that everything under "/Event/microDST" is written to a file. For clarity, this location shall be refered to as the "!MicroDST TES" in the following discussion. The framework is split into a set of Gaudi tools (MicroDSTTool) that perform the cloning and storing operations, and parent Gaudi algorithms (MicroDSTAlgorithm) that control these tools and take care of complexities arising from inter-dependencies between objects in different TES locations. Technically, the software is split into link libraries containing common code, base classes, and public interfaces for the cloning tools, and component libraries containing implementations of the cloning tools and the controlling MicroDSTAlgorithms. For most cases, the user only needs to configure a Gaudi job via options or Configurables. However, the generic and modular design of the software allows to easily add new types to the MicroDST and to change the cloning function of the cloner tools.

The MicroDST algorithms

From DaVinci v23r0 onwards, all MicroDSTAlgorithms provided are specialisations of three generic template classes:

MicroDST::ObjectClonerAlg

This covers the simplest case, a self-contained DataObject is cloned and stored on the MicroDST TES. Implementations exist for
Event Model Class MicroDSTAlgorithm Class Comments
LHCb::HltDecReports: CopyHltDecReports Python access to individual HltDecReports only via decision name. Iteration not implemented.
LHCb::L0DUReport CopyL0DUReport LHCb::L0DUConfig pointer not copied to the MicroDST. If there is a use-case for this, please inform the MicroDST software people ASAP.
LHCb::MCHeader: CopyMCHeader  
LHCb::ODIN CopyODIN  
LHCb::RecHeader CopyRecHeader  

This is how one of these is now defined in C++ (doxygen comments removed for clarity):

#include "MicroDST/ObjectClonerAlg.h"
#include "Event/RecHeader.h"
//=============================================================================
// These lines are not necessary for the RecHeader, just here to show that you can
// pick a cloner functor at compile time. BasicCopy<T> is the default.
template <> struct BindType2Cloner<LHCb::RecHeader> 
{
  typedef LHCb::RecHeader type;
  typedef MicroDST::BasicCopy<LHCb::RecHeader> cloner;
};
//=============================================================================
template <> struct Location<LHCb::RecHeader> 
{
  const static std::string Default;
};
const std::string Location<LHCb::RecHeader>::Default = LHCb::RecHeaderLocation::Default;
//=============================================================================
typedef MicroDST::ObjectClonerAlg<LHCb::RecHeader> CopyRecHeader;
// Declaration of the Algorithm Factory
DECLARE_NAMED_ALGORITHM_FACTORY( CopyRecHeader )

MicroDST::KeyedContainerClonerAlg

This template class is intended to clone all the KeyedObject in a KeyedContainer in the TES into the MicroDST TES. It also allows for the cloning of related KeyedObject, either from SmartRefs or pointers. The algorithm contains a pointer to a pure virtual cloner tool.

The depth and scope of the cloning operation is controlled by the implementation of this cloner tool. Specialisations exist for

Event Model Class MicroDSTALgorithm Class Comments
LHCb::FlavourTag CopyFlavourTag  
LHCb::MCParticle CopyMCParticles  
LHCb::Particle CopyParticles  
LHCb::ProtoParticle CopyProtoParticles  
LHCb::RecVertex CopyPrimaryVertices  
The following example shows how the LHCb::Particle cloning algorithm is defined:
#include "MicroDST/KeyedContainerClonerAlg.h"
#include <MicroDST/ICloneParticle.h>
#include "MicroDST/BindType2ClonerDef.h"
//=============================================================================
template <> struct BindType2Cloner<LHCb::Particle> 
{
  typedef LHCb::Particle type;
  typedef ICloneParticle cloner;
};
//=============================================================================
template<> struct Defaults<LHCb::Particle>
{
  const static std::string clonerType;
};
const std::string Defaults<LHCb::Particle>::clonerType = "ParticleCloner";
//=============================================================================
template<> struct Location<LHCb::Particle>
{
  const static std::string Default;
};
const std::string Location<LHCb::Particle>::Default = LHCb::ParticleLocation::Production;
//=============================================================================
typedef MicroDST::KeyedContainerClonerAlg<LHCb::Particle> CopyParticles;
DECLARE_NAMED_ALGORITHM_FACTORY( CopyParticles );
#endif // COPYPRIMARYVERTICES_H

MicroDST::RelationsClonerAlg

This template takes as input a Relations table T, seeks the T::From objects from the MicroDST transient event store, and copies them and the corresponding T::To. It also creates and copies a new relations table to the MicroDST. T::To that are not already in the MicroDST TES are not cloned. This requires that the user create the necessary relations and clone the To before running the RelationsClonerAlg. A typical example is the cloning of the MCParticles related to a set of Particles. A typical job would run a selection, run some Monte Carlo association resulting in the production of a relations table, and clone the selected Particles to the MicroDST. Running the RelationsClonerAlg would take care of the MCParticles and the Relations table in one action. There exist implementations for
Event Model Class MicroDSTAlgorithm Class Comments
Particle2MCParticle::Table (LHCb::Relation1D<LHCb::Particle, LHCb::MCParticle >) CopyParticle2MCRelations For unweighted LHCb::Particle to LHCb::MCParticle associations
Particle2Vertex::Table (LHCb::RelationWeighted1D<LHCb::Particle, LHCb::VertexBase, double> ) CopyParticle2PVRelations For LHCb::Particle to primary vertex weighted relations. Used for "best vertex" finding.

The MicroDSTTools

There are a series of virtual tool interfaces with signatures
T* operator()(const T*);
T* clone(const T*);
for all the event model types requiring non-trivial cloning actions. Each implementation controls the cloning action, so it is possible to affect the contents of a MicroDST by the choice of different implementations of a single interface. The interfaces and available implementations are summarised below. Each of the implementation inherits common functionality via the MicroDSTTool common base class.

Interface MicroDSTTool implementation Master MicroDSTAlgorithm or MicroDSTTool
ICloneFlavourTag FlavourTagCloner CopyFlavourTag
ICloneMCParticle MCParticleCloner CopyMCParticles, CopyParticle2MCRelations, MCVertexCloner
ICloneMCVertex MCVertexCloner CopyMCParticles, CopyParticle2MCRelations, MCParticleCloner
ICloneParticle ParticleCloner CopyParticles, VertexCloner
ICloneProtoParticle ProtoParticleCloner CopyProtoParticles, ParticleCloner
ICloneRecVertex RecVertexCloner, RecVertexClonerWithTracks CopyPrimaryVertices, CopyParticle2PVRelations
ICloneTrack TrackCloner ProtoParticleCloner, RecVertexClonerWithTracks
ICloneVertex VertexCloner ParticleCloner

List of supported Event Model classes

Event Model Class Cloning mechanisms
LHCb::HltDecReports: CopyHltDecReports
LHCb::L0DUReport CopyL0DUReport
LHCb::MCHeader: CopyMCHeader takes care of this, storing SmartRefs to the original primary LHCb::MCVertices. There is no runtime configurability implemented here.
LHCb::ODIN CopyODIN
LHCb::RecHeader CopyRecHeader
LHCb::Particle Performed by CopyParticles. By default, recursively clones particles and their descendants by using ParticleCloner, which in turn uses pointers to a ICloneVertex and an ICloneProtoParticle to store each LHCb::Particle's related LHCb::Vertices and LHCb::ProtoParticle. If these pointers are not set, then SmartRefs are stored instead.
LHCb::RecVertex Controlled by CopyPrimaryVertices. This uses one of the two implementations of ICloneRecVertex: RecVertexCloner, which clones everything to the MicroDST, except for the LHCb::Tracks that make the vertex, for which it stores SmartRefs, or RecVertexClonerWithTracks which clones everything to the MicroDST, including the LHCb::Tracks making the vertex.
LHCb::Vertex Cloned as a by-product of the cloning of LHCb::Particles, when CopyParticles uses the ParticleCloner implementation of ICloneParticle. The actual cloning is delegated to implementations of !ICloneVertex, the only implementation provided by the framework being !VertexCloner.
LHCb::Track Individual LHCb::Tracks are cloned by implementations of the ICloneTrack interface. At the moment, MicroDSTTools ProtoParticleCloner and RecVertexClonerWithTracks are the only ones to use this.
LHCb::ProtoParticle Cloned directly by CopyProtoParticles, or indirectly by the ParticleCloner implementation of the ICloneParticle interface. Both of these call an implementation of the ICloneProtoParticle interface. In the case where the CopyProtoParticles MicroDSTAlgorithm is used, all the LHCb::ProtoParticles stores in the input TES location are cloned and copied to the MicroDST. In the case of cloning via the ParticleCloner, only the ProtoParticle that is related to a given LHCb::Particle already being copied is cloned.
LHCb::FlavourTag Copied by CopyFlavourTag. This requires that the LHCb::FlavourTag objects be created and placed on the TES. Also, the pointer to the tagged candidate LHCb::Particle must be set correctly.
LHCb::MCParticle The action of cloning a single LHCb::MCParticle onto the MicroDST is performed by any implementation of the ICloneMCParticle interface. There are three MicroDSTAlgorithms or MicroDSTTools that use an ICloneMCParticle: CopyMCParticles, CopyParticle2MCRelations, and MCVertexCloner. At the moment, there is only one implementation of ICloneMCPrticle: the MCParticleCloner. As can be seen from the doxygen documentation, this in turn makes use of an ICloneMCVertex implementation to clone the decay end vertices.
LHCb::MCVertex Cloned as a by-product of the cloning of LHCb::MCParticles, where a simple copy of the particle's origin vertex is performed. If the MCParticleCloner implemementation of ICloneMCParticles is used, an !ICloneMCVertex pointer can be used to clone the decay vertices.
LHCb::Particle to LHCb::RecVertex association Copied using CopyParticle2PVRelations, which internally uses an ICloneRecVertex.
LHCb::Particle to LHCb::MCParticle association CopyParticle2MCRelations

Creating a MicroDST

There are two ways to create a MicroDST:

1. Use the MicroDSTWriter configurable.

The MicroDSTWriter configurable is a light-weight configurable designed for a "typical" physics use-case, but has limited flexibility and hides away many details of what is going on. There is an example script in Ex/MicroDSTExample/options/TestMicroDSTMakeNewConf.py, where one can clearly see how it is standalone and requires some interplay with another LHCb application configurable, in this case, DaVinci(). The MicroDSTWriter requires that the selections that are to be used to write the MicroDST be in the form of SelectionSequences. For more details on how to write selections like that, see the Particle Selections page and DaVinci Tutorial 4.

from Gaudi.Configuration import *
from Configurables import DaVinci, MicroDSTWriter

importOptions("$STDOPTS/PreloadUnits.opts")
# Grab a selection from a selection module.
from MicroDSTExample.Selections import SeqBs2Jpsi2MuMuPhi2KK
selSequence = SeqBs2Jpsi2MuMuPhi2KK.SeqBs2Jpsi2MuMuPhi2KK # this is a SelectionSequence object.

conf = MicroDSTWriter("MicroDST0")
conf.OutputFileSuffix = "Test"
conf.CopyProtoParticles = False
conf.SelectionSequences = [selSequence]
conf.CopyL0DUReport = False
conf.CopyHltDecReports = False
conf.CopyMCTruth = True
conf.CopyBTags = True
microDST0Seq = conf.sequence() # this is a GaudiSequencer with everything that is needed.
The above configures the writer and makes a GaudiSequencer available via the MicroDSTWriter.sequence() method. This is then picked up by the application:
dv = DaVinci()
dv.DataType = 'DC06'
dv.EvtMax = 100
dv.UserAlgorithms = [microDST0Seq]
dv.Input =  [ ....... ]

2. Configure and add MicroDSTAlgorithms to selection sequence

Manually set up all the necessary MicroDSTAlgorithms and MicroDSTTools, plus populate the TES with the objects that one wants to store. This is the approach taken in Ex/MicroDSTExample/options/TestMicroDSTMake.py, which is an opitons file covering a "typical" physics analysis scenario. It is well worth looking at this example to understand what is really going on and to see the clear distinction between running algorithms that populate the TES with objects, and running MicroDSTAlgorithms that clone these objects onto the MicroDST TES. The doxygen documentation of the relevant MicroDSTAlgorithms has explanations on how to use them. Besides that, the general structure of a MicroDST-making job is something like
from Gaudi.Configuration import *
from Configurables import OutputStream
from Configurables import SomeOfTheMicroDSTAlgorithms
#=================================================================
# get some signal data.
importOptions( "$MICRODSTEXAMPLEROOT/options/JpsiPhiDataPFN.py")
# Import a selection and get it's sequencer
importOptions( "SomeSelection.py"  )
MySelection = GaudiSequencer('SelectionAlgoName')
# base location of selection's Particles and Vertices
mainLocation = "Phys/SelectionAlgoOutputLocation"
#=================================================================
# Set up special MicroDST output stream
importOptions('$MICRODSTOPTS/MicroDSTStream.py')
MicroDSTStream=OutputStream('MicroDSTStream')
ApplicationMgr().OutStream.append(MicroDSTStream)
MicroDSTStream.Output = "DATAFILE='MicroDSTTest.dst'  TYP='POOL_ROOTTREE' OPT='REC'"
# add MicroDTSAlgorithms to the sequencer
copyPV=CopyPrimaryVertices('CopyPrimaryVertices')
copyPV.OutputLevel = 4
MySelection.Members += [copyPV]
# and so on

Read a MicroDST

Python

Ex/MicroDSTExample/python/MicroDSTReadingExample.py (replace "python" in the path for "scripts" from DaVinci v23r1p1 onwards) is a script reads a MicroDST and does some very basic analysis. It is possible to steer its behavior via arguments:

Usage: python -i MicroDSTReadingExample [options]
Options:

        --input         Input MicroDST file
                             Default ''
        --selection     DV Selection run to make the MicroDST.
                              Default 'DC06selBs2JpsiPhi_unbiased'
        --root          TES root of everything.
                            Default 'Event/microDST'

Ex/MicroDSTExample uses modules AnalysisPython.Helpers, AnalysisPython.Functors, and AnalysisPython.HistoUtils (the latter borrowed from GaudiPython) to aid in the reading of MictoDSTs and DSTs. The MicroDSTReadingExample.py script uses these extensively.

Note that here we do not use the DVAlgorithm and its vast tool set to do anything. Tasks can be performed by creating our own instances of tools. The file contains the initialisation required, the only step needed by the user is to correctly set the environment using SetupProject. It is intended simply to provide an example on how the contents can be retrieved, including complex objects like LHCb::Particle to LHCb::RecVertex and LHCb::MCParticle relations. It also includes an example on how to fit the proper time of a particle from the standard and "best" primary vertex.

C++

When creating the MicroDST, the algorithms replicate the structure of the transient event store (TES) in a new branch and store the information about the relevant particles, etc. there. By default, this new branch has the prefix 'MicroDST', so everything is stored under '/Event/MicroDST'. Since DValgorithm and PhysDesktop use partial TES locations for various things, it is better to use the RootInTES property instead of setting the input locations with full paths.

There are a few important points to note:

  • Beware of tools that require more information than is stored on the MicroDST. Some DaVinci tools might require more information than appears at first sight.
  • You can specify the RootInTES of a GaudiSequencer. This will propagate to all the members.

To specify the input location for the DVAlgorithm, use

YourAlg.RootInTES = '/Event/<sequence name>'
YourAlg.InputLocations = ["Path/to/Your/orig/Alg"]
However, if the algorithm is in a sequencer, you can use relative paths for your algorithms, and set RootInTES only for the sequencer:
YourAlg0 = ...
YourAlg0.InputLocations = ["Path/to/Your/orig/Alg0"]
YourAlg1 = ...
YourAlg1.InputLocations = ["Path/to/Your/orig/Alg1"]
YourSequencer = GaudiSequencer("MySeq", Members = [YourAlg0, YourAlg1])
YourSequencer.RootInTES = '/Event/MicroDST'
If needed/wanted, you can then also add the ROOT/POOL catalogue to the options file, e.g.
PoolDbCacheSvc.Catalog = {
  "xmlcatalog_file:DSTCatalog.xml",
  "xmlcatalog_file:CatalogueOfInputFilesToMicroDST"
};
The first line holds the information about the objects used in the MicroDST, the further line(s) contain the catalogue(s) for the input files from which the microDST was created. If you have access to these files, you can follow the SmartRefs on the microDST to access the information stored on the full DST (even if it is not available on the MicroDST). A possible use-case for this could be that you want to update the file or some plot with further information or that you have the full DST available but instead of reading in the complete event, only the relevant information (e.g. the B candidate) is read from the microDST and further information (say, track hits) are then obtained via the SmartRefs.

Running TisTos on a MicroDST produced in the stripping

Certain stripping lines produce MicroDSTs as output. These contain raw banks for the HltSelReports and HltDecReports. It is necessary to unpack these, and put the resulting objects also in /Event/<stream name>/, so that they are found by algorithms and tools for which RootInTES has been set as suggested above. This can be achieved with the following configuration lines:

The location where these are stored has been optimized for the reprocessing:

  • Stripping16 and under in /Event/<stream name>/.
  • Stripping17 and over in /Event/Trigger/RawEvent/

locationRoot = '/Event/<sequence name>/'

# Set up on-demand unpacking of HLT report banks for TisTos                                                                                                                              
from Configurables import HltSelReportsDecoder, HltDecReportsDecoder, DataOnDemandSvc, ANNDispatchSvc

rawEventLoc = locationRoot + 'DAQ/RawEvent'
decReportLoc = locationRoot +"Hlt/DecReports"
selReportLoc = locationRoot + "Hlt/SelReports"

# get HltSelReports raw bank from rawEventLoc and put HltSelReports in selReportLoc                                                                                                      
selReportsDecoder = HltSelReportsDecoder( InputRawEventLocation = rawEventLoc,
                                          OutputHltSelReportsLocation = selReportLoc)

# get HltDecReports raw bank from rawEventLoc and put HltSelReports in decReportLoc                                                                                                      
decReportsDecoder = HltDecReportsDecoder( InputRawEventLocation = rawEventLoc,
                                          OutputHltDecReportsLocation = decReportLoc)

DataOnDemandSvc().AlgMap[selReportLoc] = selReportsDecoder
DataOnDemandSvc().AlgMap[decReportLoc] = decReportsDecoder

ANNDispatchSvc().RawEventLocation = rawEventLoc

The stripping MicroDST contains L0 trigger information in standard locations, '/Event/Trig/L0/L0DUReport', '/Event/Trig/L0/MuonBCSU', and '/Event/Trig/L0/FullCalo' , but tools configured as suggested above expect them on the RootInTES. Therefore we need a different approach to ensure that the L0 decision reports end up where they are expected:

from Configurables import L0DecReportsMaker, L0SelReportsMaker

l0DecReportsLoc = locationRoot + 'HltLikeL0/DecReports'
l0SelReportsLoc = locationRoot + 'HltLikeL0/SelReports'

l0DecReportsMaker = L0DecReportsMaker(OutputHltDecReportsLocation = l0DecReportsLoc)
l0SelReportsMaker = L0SelReportsMaker(OutputHltSelReportsLocation = l0SelReportsLoc)

DataOnDemandSvc().AlgMap[l0DecReportsLoc] = l0DecReportsMaker
DataOnDemandSvc().AlgMap[l0SelReportsLoc] = l0SelReportsMaker

Note , that you also need to set up L0 decoding. This is done by DaVinci automaticaly for DSTs , but not for microDSTs . Read https://twiki.cern.ch/twiki/bin/view/LHCb/MicroDSTTisTos

Finally, it is necessary to access the LHCb::LHCbIDs that the particle under investigation has been built from. In a full DST, this information is obtained by navigating back, via the particle's ProtoParticle, to the LHCb::Track, LHCb::CaloHypos, LHCb::RichPID, and LHCb::MuonPID. A map linking each particle to an std::vector<LHCb::LHCbID> is stored in /Particle2LHCbIDMap.

#include "Kernel/Particle2LHCbIDs.h"

...
   // get the Particle->vector<LHCbID> map
   const DaVinci::Particle2LHCbIDs* p2LHCbIDs =
                 get<DaVinci::Particle2LHCbIDs>("/Event/StreamX/Phys/SelY/Particle2LHCbIDMap");

   // get one of the candidates
   const LHCb::Particle* cand = ...;
   // get its LHCbIDs
   const std::vector<LHCb::LHCbID>& signalIDs = (*p2LHCbIDs)(cand);

   // get your favourite TisTosTool
   ITriggerTisTos* tisTosTool = ...;

   tisTosTool->setOfflineInput(); // erase the signal definition 
   tisTosTool->addToOfflineInput(signalIDs); // set signal to particle cand's IDs

In the future, with the release of DaVinci v26r3, it will be possible to achieve skip the C++ steps and configure the ITriggerTisTos directly. This is currently available in Phys/TisTosTobbing revision 90050, which is compatible with DaVinci v26r2. The configuration works as follows:

tisTosTool = ... # Configurable of something that inherits from ITriggerTisTos
tisTosTool.UseParticle2LHCbIDsMap = 2

If you use DecayTreeTuple with TupleToolTISTOS, bear in mind that this TupleTool used two private instances if an ITriggerTisTos, namely TriggerTisTos and L0TriggerTisTos. To be able to TisTos with tuple tools you would have to configure your DecayTreeTuple's TupleToolTisTos suitably. Configuring a tool of a tool of an algorithm is a daunting task, but this link should make it easier.

-- JuanPalacios - 23-Oct-2010

Accessing MC truth information from MicroDST in TupleTools

Provided MC truth information has been stored in a standard way, there should be a relations table linking particles in a given location to their associated MCParticles. From DaVinci v26r3p2 onwards, it is also possible to read back stored background catagory values for candidates. First, let's start with an example on how to configure a job to configure TupleToolMCTruth to find the associates MCParticles. Here we assume the MicroDST contains candidates in location "/Event/MicroDST/MyCandidates/Particles", and that the DecayTreeTuples get added to a sequence with RootInTES='/Event/MicroDST'.

Recently for the latest DecayTreeTuple >=v3r11p1 we added helper decorators to make configuation a little easier...

from DecayTreeTuple.Configuration import *
from Configurables import MCMatchObjP2MCRelator
decayTreeTuple = DecayTreeTuple(.....)
# configure the TupleToolMCTruth
MCTruth=decayTreeTuple.addTupleTool("TupleToolMCTruth")
# change the associator type to something that can read the stored associaitons from the MicroDST
MCTruth.IP2MCPAssociatorType = 'MCMatchObjP2MCRelator'
# configure the associator
MCTruth.addTool(MCMatchObjP2MCRelator,
                              name="IP2MCPAssociatorType")
# tell it where to find the Particle->MCParticle relations
MCTruth.IP2MCPAssociatorType.RelTableLocations = ['Phys/MyCandidates/P2MCPRelations']

Next, we can see how to obtain the background categiries for each particle via TupleToolMCBackgroundInfo:

from Configurables import BackgroundCategoryViaRelations
BackCat=decayTreeTuple.addTupleTool("TupleToolMCBackgroundInfo")
BackCat.IBackgroundCategoryType = 'BackgroundCategoryViaRelations'
BackCat.addTool(BackgroundCategoryViaRelations,
                             name="IBackgroundCategoryType")
BackCat.IBackgroundCategoryType.inputTable = ['Phys/MyCandidates/P2BCRelations']

-- JuanPalacios - 20-Jan-2011

Examples of reading microDST in C++

Examples of reading MicroDST in C++ within the DaVinci framework can be found from MultiVariateSelections page and in Ex/MicroDSTExample/options/TestMicroDSTRead.py, which forms the basis for the example below. Note that here we create a SelectionSequence on the fly, and we use the SelectionSequence used to make the MicroDST just to get the particles' location.

from MicroDSTExample.Selections import SeqBs2Jpsi2MuMuPhi2KK
selSequence = SeqBs2Jpsi2MuMuPhi2KK.SeqBs2Jpsi2MuMuPhi2KK
particleLocation = selSequence.outputLocation()

from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence

BsSel = AutomaticData(Location = particleLocation)

filterCuts = "......."

from Configurables import FilterDesktop
_bsFilter = FilterDesktop('_bsFilter',
                          Code = filterCuts)

BsFilterSel = Selection('HelloWorld',
                        Algorithm = _bsFilter,
                        RequiredSelections = [BsSel] )

BsSeq = SelectionSequence('Bs', TopSelection = BsFilterSel)
seq = BsSeq.sequence() # this is a GaudiSequencer
seq.RootInTES = '/Event/' + selSequence.name() + '/' # All members of the sequence get their RootInTES set

dv=DaVinci()
dv.EvtMax=-1
dv.DataType="MC09"
dv.UserAlgorithms = [seq]
dv.InputType='MDST'

Note that this requires that DaVinci() recognise InputType='MDST', which will only be possible with DaVinci v24r4 or higher.

Work in progress and known issues

  • Storage of Particle -> primary vertex relations in case of PV re-fitting needs to be re-designed.
  • Storage of neutral proto-particles (and associated MC truth) is not yet tested
  • ProcStatus information
  • Task to implement MicroDST formats for MC data

Presentations

-- JuanPalacios - 22 Sep 2008
Topic attachments
I Attachment History Action Size Date Who Comment
Texttxt AnalysisMicroDST.py.txt r1 manage 2.1 K 2008-04-04 - 10:40 UlrichKerzel Simple analysis script
Texttxt InitGaudi.py.txt r1 manage 3.4 K 2008-04-04 - 10:39 UlrichKerzel Initialise Gaudi
Texttxt InitialisePyGaudi.py.txt r1 manage 1.8 K 2007-08-14 - 13:27 UnknownUser Initialise Gaudi - Python session
Unknown file formatopts JpsiPhiData.opts r1 manage 30.6 K 2008-09-22 - 17:40 JuanPalacios Data card containing Bs -> J/Psi Phi MC signal. Used by TestMicroDSTMake.opts
Texttxt MicroDSTReadingExample.py.txt r1 manage 5.9 K 2008-09-22 - 17:43 JuanPalacios Simple (and messy) python script to read a "typical" MicroDST and make some plots.
Edit | Attach | Watch | Print version | History: r67 < r66 < r65 < r64 < r63 | Backlinks | Raw View | WYSIWYG | More topic actions
Topic revision: r67 - 2013-03-28 - MarcoCattaneo
 
    • Cern Search Icon Cern Search
    • TWiki Search Icon TWiki Search
    • Google Search Icon Google Search

    LHCb All webs login

This site is powered by the TWiki collaboration platform Powered by PerlCopyright & 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