Python Configurables.DecayTreeTuple类代码示例

def makeDecayTreeTuple( location, decay, alg_name, tuple_name ):
  tuple = DecayTreeTuple( alg_name )
  dectype = alg_name[-2:]
  #triggerList = list(l0hlt1List)
  #if 'KK' == dectype:
  #  for trigger in hlt2List_KK:
  #    triggerList.append( trigger + 'Decision')
  #elif 'Pi' == dectype:
  #  for trigger in hlt2List_Pi:
  #    triggerList.append( trigger + 'Decision')
  #elif 'RS' == dectype or 'WS' == dectype:
  #  for trigger in hlt2List_KPi:
  #    triggerList.append( trigger + 'Decision')
  print alg_name, triggerList    

  #tuple = DecayTreeTuple('TupleKK')
  tuple.ToolList = [ "TupleToolPropertime", "TupleToolKinematic", #"TupleToolPropertime/MyPropertimeTool", 
                     "TupleToolGeometry", "TupleToolEventInfo", "TupleToolPrimaries", "TupleToolTISTOS", #"TupleToolTrigger",
                     "TupleToolPid", "TupleToolTrackInfo", "TupleToolRecoStats", #"TupleToolGeneration"
                      ]
  #tuple.addTool( TupleToolPropertime( name="MyPropertimeTool" ) )
  #tuple.MyPropertimeTool.ToolName = "PropertimeFitter/MyPropertimeFitter"
  #tuple.MyPropertimeTool.ExtraName = "MassConstraint"
  #tuple.MyPropertimeTool.addTool( PropertimeFitter( name = "MyPropertimeFitter" ) )
  #tuple.MyPropertimeTool.MyPropertimeFitter.applyBMassConstraint = True
  
  tuple.Inputs = [ location ]#_strippingOutput]
  #tuple.InputLocations = [ location ]#_strippingOutput]
  tuple.Decay = decay
  #tuple.Decay = "[D0 -> ^K- ^pi+]CC"
  tuple.TupleName = tuple_name
  #tuple.TupleName = "D0KKTuple"
  
  tuple.addTool( TupleToolPropertime() )
  tuple.TupleToolPropertime.FitToPV = True

  #tuple.addTool( TupleToolTrigger() )
  #tuple.TupleToolTrigger.TriggerList = triggerList
  #tuple.TupleToolTrigger.VerboseL0 = True
  #tuple.TupleToolTrigger.VerboseHlt1 = True
  #tuple.TupleToolTrigger.VerboseHlt2 = True
  #tuple.TupleToolTrigger.Verbose = True
  
  tuple.addTool( TupleToolTISTOS() )
  tuple.TupleToolTISTOS.VerboseL0 = True
  tuple.TupleToolTISTOS.VerboseHlt1 = True
  tuple.TupleToolTISTOS.VerboseHlt2 = True
  tuple.TupleToolTISTOS.Verbose = True
  tuple.TupleToolTISTOS.TriggerList = triggerList
  return tuple

                      MaxCandidates = 2000,
                      AcceptBadEvents = False,
                      BadEventSelection = filterBadEvents)

    DaVinci().appendToMainSequence([event_node_killer,sc.sequence()])
    

            
##################Creating NTuples#####################################
from Configurables import DecayTreeTuple
from Configurables import TupleToolL0Calo
from DecayTreeTuple.Configuration import *

line = 'B2XEtaLb2pKeta3piLine'

tuple=DecayTreeTuple()
tuple.Decay="[Lambda_b0 -> ^p+ ^K- ^(eta -> ^pi+ ^pi- ^(pi0 -> ^gamma ^gamma))]CC"
tuple.Branches={"Lambda_b0":"[Lambda_b0 -> p+ K- (eta -> pi+ pi- (pi0 -> gamma gamma))]CC"}
tuple.Inputs=['/Event/Phys/{0}/Particles'.format(line)]
tuple.addTool(TupleToolL0Calo())
tuple.TupleToolL0Calo.TriggerClusterLocation="/Event/Trig/L0/Calo"
tuple.TupleToolL0Calo.WhichCalo="HCAL"


tuple.ToolList += [
    "TupleToolGeometry"
    , "TupleToolDira"
    , "TupleToolAngles"
   # , "TupleToolL0Calo"
    , "TupleToolPid"
    , "TupleToolKinematic"

# Stripping 21r1:

# Phys/D2XMuMu_KOSLine/Particles 
# Phys/D2XMuMu_KSSLine/Particles 

# Source: http://lhcb-release-area.web.cern.ch/LHCb-release-area/DOC/stripping/config/stripping21/index.html#charm

rootInTes = "/Event/AllStreams"

#----------------------------------------
# 1) The code that makes the ntuple
#----------------------------------------

from Configurables import DecayTreeTuple, LoKi__Hybrid__TupleTool, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolSelResults, TupleToolTrackInfo, TupleToolEventInfo, TupleToolVtxIsoln, TupleToolTrackIsolation, TupleToolAngles, TupleToolRecoStats

tuple = DecayTreeTuple()

tuple.ToolList += [

    "TupleToolGeometry"
    , "TupleToolKinematic"
    , "TupleToolPropertime"
    , "TupleToolPrimaries"
    , "TupleToolPid"
    , "TupleToolEventInfo"
    , "TupleToolTrackInfo"
    , "TupleToolTrigger"
    , "TupleToolTISTOS"
    , "TupleToolAngles"
    , "TupleToolVtxIsoln"
    , "TupleToolTrackIsolation"

#
# Configure the dst writers for the output
#
enablePacking = True




from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolSubMass
from Configurables import TupleToolTISTOS, CondDB, SelDSTWriter
from Configurables import TupleToolTrackInfo, TupleToolRICHPid, TupleToolGeometry, TupleToolPid
from Configurables import TupleToolANNPID
from DecayTreeTuple.Configuration import *

tupleB = DecayTreeTuple("bae-"+tuplename+"-mc")


tupleB.Inputs = ["Phys/B2KLLXInclusive_InclKLLLine_NoHadronPID/Particles"]

#decay = ""
if LeptonType == "Muons" : 
    decay =  "[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC"
    tupleB.addBranches ({
            "Kplus"  :  "[B+ -> ^K+ (J/psi(1S) -> mu+ mu-)]CC",
            "Jpsi"   :  "[B+ -> K+ ^(J/psi(1S) -> mu+ mu-)]CC",
            "lplus"  :  "[B+ -> K+ (J/psi(1S) -> ^mu+ mu-)]CC",
            "lminus" :  "[B+ -> K+ (J/psi(1S) -> mu+ ^mu-)]CC",
            "Bplus"  : "[B+ -> K+ J/psi(1S)]CC",
            })

seq = SeqFilterL.sequence()

#--------------------------------------------------------------------------
# Configure DaVinci
#-------------------------------------------------------------------------
from Configurables import DaVinci

# DaVinci().appendToMainSequence( [sc.sequence() ] )   # Append the stripping selection sequence to DaVinci

from Configurables import  OfflineVertexFitter

from Configurables import  DecayTreeTuple, MCDecayTreeTuple
importOptions("Xb2JpsiXTreeMC.py")


tuple = DecayTreeTuple( "L2ppiTree" )
tuple.Inputs = [ SeqFilterL.outputLocation() ]



# from PhysConf.Filters import LoKi_Filters #!
# fltrs = LoKi_Filters(STRIP_Code = "(HLT_PASS_RE('StrippingFullDSTDiMuonJpsi2MuMuDetachedLineDecision'))" ) #!

from Configurables import DaVinci #!
DaVinci().Simulation   = True
DaVinci().EvtMax = -1                        # Number of events
#DaVinci().EventPreFilters = fltrs.filters('Filter') #!
DaVinci().UserAlgorithms = [ seq, tuple  ]
from Configurables import CondDB #!
DaVinci().DataType = "2012"
DaVinci().DDDBtag   = "Sim08-20130503-1" #!

def execute_option_file(path):
    # ================= BEGIN EDIT AREA =======================
    tuplename = "Bu2LLK_meLine"
    simulation_inputstring = "/Event/AllStreams/Phys/Bu2LLK_meLine/Particles"
    data_inputstring = "/Event/Leptonic/Phys/Bu2LLK_meLine/Particles"

    decaydescriptor = "[B+ -> ^[J/psi(1S) -> ^mu+ ^e-]CC ^K+]CC"
    branches = {    # Dictionary for the branches to write in the tuple
        "B"         : "[B+ -> [J/psi(1S) -> mu+ e-]CC K+]CC",
        "Psi"       : "[B+ -> ^[J/psi(1S) -> mu+ e-]CC K+]CC",
        "muplus"    : "[B+ -> [J/psi(1S) -> ^mu+ e-]CC K+]CC",
        "eminus"    : "[B+ -> [J/psi(1S) -> mu+ ^e-]CC K+]CC",
        "Kplus"     : "[B+ -> [J/psi(1S) -> mu+ mu-]CC ^K+]CC"
    }

    toollist = [  "TupleToolBremInfo"       #Bremsstrahlung information
                #, "TupleToolGeometry"       #geometry of vertex locations (ENDVERTEX, OWNPV, IP_OWNPV, FD_OWNPV, DIRA_OWNPV)
                , "TupleToolKinematic"      #kinematic variables (inv. mass MM, kin. mass M/sqrt(E^2-p^2), P, PX/Y/Z/E, PT)
                #, "TupleToolEventInfo"      #Event information such as run number, polarity, GPS time etc.
                #, "TupleToolPropertime"     #proper lifetime of reconstructed particles
                #, "TupleToolAngles"        #decay angles of charged tracks
                #, "TupleToolTrigger"
                #, "TupleToolTrackInfo"      #GhostProb of track and track type (TYPE) - 0 = unknown, 1 = velo track...
                #, "TupleToolPrimaries"      #Number and coordinates of all primary vertices
                #, "TupleToolDira"
                #, "TupleToolTrackPosition"  #Plot the X/Y position at a given Z (default: 2500 = TTstation)
                #, "TupleToolRecoStats"
                #, "TupleToolIsolationTwoBody"  #degree of isolation of two particles with common mother from Bsmumu
                #, "TupleToolANNPID"         #V2,V3,... ProbNN variables
                #, "TupleToolCaloHypo"
                #, "TupleToolL0Calo"
                ]
    # ================= END EDIT AREA =======================




    # ================= BEGIN DO NOT EDIT HERE =======================
    from Configurables import GaudiSequencer
    MySequencer = GaudiSequencer('Sequence')



    #Check whether it is a DST or MDST file
    import os.path
    extension = os.path.splitext(path)[1]
    print extension
    if extension.lower() == ".dst":
        DaVinci().InputType = 'DST'
    elif extension.lower() == ".mdst":
        DaVinci().InputType = 'MDST'
    else:
        raise Exception("Extension {extension} of {path} does not match .mdst or .dst".format(extension, path))

    #Kill some nodes if micro dst-file
    if DaVinci().InputType == 'MDST':
        from Configurables import EventNodeKiller
        eventNodeKiller = EventNodeKiller('DAQkiller')
        eventNodeKiller.Nodes = ['/Event/DAQ','/Event/pRec']
        MySequencer.Members+=[eventNodeKiller]



    #DecayTreeTuple -> Fills information about particles, vertices and daughters
    ntuple = DecayTreeTuple(tuplename)



    if DaVinci().Simulation is True: # for MC
        ntuple.Inputs = [simulation_inputstring]
    elif DaVinci().Simulation is False: # for Tuple
        ntuple.Inputs = [data_inputstring]
    else:
        raise Exception(" `DaVinci().Simulation` not set.")

    ntuple.Decay = decaydescriptor
    ntuple.addBranches(branches)

    ntuple.TupleName = "DecayTree"


    #Tools added to the ToolList can not be modified i.e. no other options than the defaults can be used
    ntuple.ToolList = toollist

    MySequencer.Members.append(ntuple)






    # ================= END DO NOT EDIT HERE =======================




    if DaVinci().Simulation is True:
        from Configurables import BackgroundCategory
        backgroundinfo = ntuple.addTupleTool("TupleToolMCBackgroundInfo")           #Fills the background category
        backgroundinfo.addTool(BackgroundCategory('BackgroundCategory'))
#.........这里部分代码省略.........

B2EtapKSel = Selection("B2EtapKSel", Algorithm = SubKToPi, RequiredSelections = [B2etap_piSub])

#B2EtapKSeq = SelectionSequence("B2EtapKSeq", TopSelection = B2EtapKSel)

#Code="(M>4800 *MeV) & (M<5700 *MeV) & (VFASPF(VCHI2/VDOF)<9.) & (PT> 1500.*MeV)"
B2EtapKFil= FilterDesktop("B2EtapKFil",  Code="(M>4800 *MeV) & (M<5700 *MeV) & (VFASPF(VCHI2/VDOF)<9.)")# & (PT> 1500.*MeV)") 
B2EtapKFil_Sel= Selection('B2EtapKFil_Sel', Algorithm=B2EtapKFil, RequiredSelections=[B2EtapKSel])
B2EtapKFil_Seq = SelectionSequence("B2etap_pi_FilSeq", TopSelection =B2EtapKFil_Sel) 




# Fill Tuple
from Configurables import DecayTreeTuple

tuple = DecayTreeTuple("B2_ETAPK")

 
tuple.ToolList += [
       "TupleToolGeometry",
       "TupleToolPhotonInfo",
       "TupleToolPid",
       "TupleToolMCTruth",
       "TupleToolRICHPid",
       "TupleToolKinematic",
       "TupleToolPrimaries",
       "TupleToolEventInfo",
       "TupleToolTrackInfo",
       "TupleToolAngles",
       "TupleToolPropertime",
       "TupleToolVtxIsoln",

        }

LoKi_psi = LoKi__Hybrid__TupleTool("LoKi_psi")
LoKi_psi.Variables = {
    "q_PV_constr_B_constr" : "DTF_FUN ( M , True , 'B+' )" ,
    "q_PV_constr" : "DTF_FUN ( M , True )" ,
    "q_B_constr"  : "DTF_FUN ( M , False , 'B+' )" ,
    "q_no_constr" : "DTF_FUN ( M , False )" ,
    }

LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu")
LoKi_Mu.Variables =  {
    "NSHAREDMU" : "NSHAREDMU"
    }

tuple_B2Kmumu = DecayTreeTuple("Tuple_B2Kmumu")
tuple_B2Kmumu.Inputs = [ location ]
tuple_B2Kmumu.ToolList = tupletools[:]
tuple_B2Kmumu.Decay = '[B+ -> ^(J/psi(1S) -> ^mu+ ^mu-) ^K+]CC'
tuple_B2Kmumu.Branches = {
        "B"      : "[B+ ->  (J/psi(1S) ->  mu+  mu-)  K+]CC",
        "Kplus"  : "[B+ ->  (J/psi(1S) ->  mu+  mu-) ^K+]CC",
        "psi"    : "[B+ -> ^(J/psi(1S) ->  mu+  mu-)  K+]CC",
        "muplus" : "[B+ ->  (J/psi(1S) -> ^mu+  mu-)  K+]CC",
        "muminus": "[B+ ->  (J/psi(1S) ->  mu+ ^mu-)  K+]CC",
    }
for particle in ["B", "Kplus", "psi", "muplus", "muminus"]:
        tuple_B2Kmumu.addTool(TupleToolDecay, name = particle)

# List of the reconstructed tuples
tuples = [ tuple_B2Kmumu

    "PX_proton_constr1" : "DTF_FUN ( CHILD(PX, 2) , True  , strings(['J/psi(1S)']) )",
    "PY_proton_constr1" : "DTF_FUN ( CHILD(PY, 2) , True  , strings(['J/psi(1S)']) )",
    "PZ_proton_constr1" : "DTF_FUN ( CHILD(PZ, 2) , True  , strings(['J/psi(1S)']) )",
    "PE_proton_constr1" : "DTF_FUN ( CHILD( E, 2) , True  , strings(['J/psi(1S)']) )",
    "PX_kaon_constr1"   : "DTF_FUN ( CHILD(PX, 3) , True  , strings(['J/psi(1S)']) )",
    "PY_kaon_constr1"   : "DTF_FUN ( CHILD(PY, 3) , True  , strings(['J/psi(1S)']) )",
    "PZ_kaon_constr1"   : "DTF_FUN ( CHILD(PZ, 3) , True  , strings(['J/psi(1S)']) )",
    "PE_kaon_constr1"   : "DTF_FUN ( CHILD( E, 3) , True  , strings(['J/psi(1S)']) )",
    }

LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu")
LoKi_Mu.Variables =  {
    "NSHAREDMU" : "NSHAREDMU"
    }

tuple_B2Kmumu = DecayTreeTuple("Tuple")
tuple_B2Kmumu.Inputs = [ location ]
tuple_B2Kmumu.ToolList = tupletools[:]
tuple_B2Kmumu.Decay = '[Lambda_b0 ->  ^(J/psi(1S) -> ^mu+ ^mu-) ^p+ ^K-]CC'
tuple_B2Kmumu.Branches = {
        "Lambda_b0" : "[Lambda_b0 ->   (J/psi(1S) ->  mu+  mu-)  p+  K-]CC",
        "Jpsi"      : "[Lambda_b0 ->  ^(J/psi(1S) ->  mu+  mu-)  p+  K-]CC",
        "muplus"    : "[Lambda_b0 ->   (J/psi(1S) -> ^mu+  mu-)  p+  K-]CC",
        "muminus"   : "[Lambda_b0 ->   (J/psi(1S) ->  mu+ ^mu-)  p+  K-]CC",
        "proton"    : "[Lambda_b0 ->   (J/psi(1S) ->  mu+  mu-) ^p+  K-]CC",
        "kaon"      : "[Lambda_b0 ->   (J/psi(1S) ->  mu+  mu-)  p+ ^K-]CC",
	}
for particle in ["Lambda_b0", "Jpsi", "muplus", "muminus", "proton", "kaon"]:
        tuple_B2Kmumu.addTool(TupleToolDecay, name = particle)

# List of the reconstructed tuples

### Gaudi sequence
SeqLb2JpsiS = SelectionSequence("SeqLb2JpsiS", TopSelection = Lb2JpsiS)
seq = SeqLb2JpsiS.sequence()

#--------------------------------------------------------------------------
# Configure DaVinci
#-------------------------------------------------------------------------
from Configurables import DaVinci

from Configurables import  OfflineVertexFitter

from Configurables import  DecayTreeTuple, MCDecayTreeTuple
importOptions("Xb2JpsiXTree.py")


tuple = DecayTreeTuple( "Lb2JpsiSTree" )
tuple.Inputs = [ SeqLb2JpsiS.outputLocation() ]



from PhysConf.Filters import LoKi_Filters
fltrs = LoKi_Filters(STRIP_Code = "(HLT_PASS_RE('StrippingFullDSTDiMuonJpsi2MuMuDetachedLineDecision'))" )

from Configurables import DaVinci
DaVinci().Simulation   = False
DaVinci().EvtMax = -1                        # Number of events
DaVinci().EventPreFilters = fltrs.filters('Filter')
DaVinci().UserAlgorithms = [ seq, tuple  ]
from Configurables import CondDB
#CondDB(UseOracle = True)
#importOptions("$APPCONFIGOPTS/DisableLFC.py")

    "DIRA"            : "BPVDIRA",
    "DTF_CTAU"        : "DTF_CTAU( 0, True )",
    "DTF_CTAUS"       : "DTF_CTAUSIGNIFICANCE( 0, True )",
    "DTF_CHI2NDOF"    : "DTF_CHI2NDOF( True )",
    "DTF_CTAUERR"     : "DTF_CTAUERR( 0, True )",
    "DTF_MASS_constr1"  : "DTF_FUN ( M , True , strings(['J/psi(1S)']) )" ,
    "DTF_MASS_constr2"  : "DTF_FUN ( M , True , strings(['psi(2S)']) )" ,
    "DTF_VCHI2NDOF"     : "DTF_FUN ( VFASPF(VCHI2/VDOF) , True )",
    }

LoKi_Mu = LoKi__Hybrid__TupleTool("LoKi_Mu")
LoKi_Mu.Variables =  {
    "NSHAREDMU" : "NSHAREDMU"
    }

tuple_B2Kmumu = DecayTreeTuple("Tuple")
tuple_B2Kmumu.Inputs = [ location ]
tuple_B2Kmumu.ToolList = tupletools[:]
tuple_B2Kmumu.Decay = '[B0 -> ^(J/psi(1S) -> ^mu+ ^mu-) ^(omega(782) -> ^pi+ ^pi- ^pi0)]CC'
tuple_B2Kmumu.Branches = {
        "Lambda_b0" : "[Lambda_b0 ->  (chi_c1(1P) ->  (J/psi(1S) ->  mu+  mu-)  gamma)  p+  K-]CC",
        "chi_c"     : "[Lambda_b0 -> ^(chi_c1(1P) ->  (J/psi(1S) ->  mu+  mu-)  gamma)  p+  K-]CC",
        "Jpsi"      : "[Lambda_b0 ->  (chi_c1(1P) -> ^(J/psi(1S) ->  mu+  mu-)  gamma)  p+  K-]CC",
        "gamma"     : "[Lambda_b0 ->  (chi_c1(1P) ->  (J/psi(1S) ->  mu+  mu-) ^gamma)  p+  K-]CC",
        "muplus"    : "[Lambda_b0 ->  (chi_c1(1P) ->  (J/psi(1S) -> ^mu+  mu-)  gamma)  p+  K-]CC",
        "muminus"   : "[Lambda_b0 ->  (chi_c1(1P) ->  (J/psi(1S) ->  mu+ ^mu-)  gamma)  p+  K-]CC",
        "proton"    : "[Lambda_b0 ->  (chi_c1(1P) ->  (J/psi(1S) ->  mu+  mu-)  gamma) ^p+  K-]CC",
        "kaon"      : "[Lambda_b0 ->  (chi_c1(1P) ->  (J/psi(1S) ->  mu+  mu-)  gamma)  p+ ^K-]CC",
	}
for particle in ["Lambda_b0", "chi_c", "Jpsi", "gamma", "muplus", "muminus", "proton", "kaon"]:
        tuple_B2Kmumu.addTool(TupleToolDecay, name = particle)

from Gaudi.Configuration import *
from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand

from Configurables import DecayTreeTuple, FitDecayTrees, TupleToolRecoStats, TupleToolTrigger, TupleToolTISTOS, CondDB
from DecayTreeTuple.Configuration import *

tuple = DecayTreeTuple("Jpsi_Tuple")

tuple.Inputs = ["/Event/Leptonic/Phys/Bu2LLK_eeLine/Particles"]

tuple.ToolList =  [
      "TupleToolKinematic"
    , "TupleToolEventInfo"
    , "TupleToolRecoStats"
    , "TupleBuKmmFit"
]

tuple.addBranches ({
      "Bplus"        :  "[B+ ->  K+ ( J/psi(1S) ->  e+  e-)]CC",
      "Kplus"        :  "[B+ -> ^K+ ( J/psi(1S) ->  e+  e-)]CC",
      "Jpsi"         :  "[B+ ->  K+ (^J/psi(1S) ->  e+  e-)]CC",
      "muplus"       :  "[B+ ->  K+ ( J/psi(1S) -> ^e+  e-)]CC",
      "muminus"      :  "[B+ ->  K+ ( J/psi(1S) ->  e+ ^e-)]CC",
})

LoKi_All = tuple.addTupleTool("LoKi::Hybrid::TupleTool/LoKi_All")
LoKi_All.Variables = {
        'MINIPCHI2' : "MIPCHI2DV(PRIMARY)",
        'MINIP' : "MIPDV(PRIMARY)",
        'IPCHI2_OWNPV' : "BPVIPCHI2()",
        'IP_OWNPV' : "BPVIP()"

Ds_sequence = SelectionSequence('SeqDs2PhiPi',
                                 TopSelection = Ds_Sel
                                 )
 

#This filter is used just to speed up the process, nothing happens if there
# # is no stripped candidates at that location.
# from PhysConf.Filters import LoKi_Filters
# fltrs = LoKi_Filters(
#   STRIP_Code = "HLT_PASS('StrippingPhiToKSKS_PhiToKsKsLineDecision')")


from Configurables import FitDecayTrees, DecayTreeTuple, TupleToolDecayTreeFitter, TupleToolDecay, TupleToolTrigger, TupleToolTISTOS, TupleToolPropertime, PropertimeFitter, TupleToolKinematic, TupleToolGeometry, TupleToolEventInfo, TupleToolPrimaries, TupleToolPid, TupleToolTrackInfo, TupleToolRecoStats, TupleToolMCTruth,  LoKi__Hybrid__TupleTool, LoKi__Hybrid__EvtTupleTool
from Configurables import LoKi__LifetimeFitter

tuple = DecayTreeTuple("TuplePhi2KsKs")

#Give DecayTreeTuple the location of your stripped candidates
#If you apply a selection, this will be the output of a selection sequence object.
tuple.Inputs = [Ds_sequence.outputLocation()]
tuple.ToolList =  ['TupleToolKinematic',
                    'TupleToolEventInfo', 
                    'TupleToolTrackInfo',
                    'TupleToolPid',
                    'TupleToolGeometry', 
                    'TupleToolAngles',
]

tuple.InputPrimaryVertices = '/Event/Charm/Rec/Vertex/Primary'

from Configurables import TupleToolPropertime, DecayTreeTuple, TupleToolTISTOS, TupleToolDecayTreeFitter

tupleNames = 'Dst2010ToD0ToKpipipipiTuple', 'Dst2010ToD0ToKKKpipiTuple', \
    'Dst2010ToD0TopipipipipiTuple', 'Dst2010ToD0ToKKpipipiTuple'
for tupleName in tupleNames :
    TupleToolPropertime(tupleName + '.TupleToolPropertime').FitToPV = True
    dtt = DecayTreeTuple(tupleName)
    #dtt.lab0.setName('Dstar')
    #dtt.Branches['Dstar'] = dtt.Branches['lab0']
    #del dtt.Branches['lab0']
    dtt.addBranches({'D0' : dtt.Decay.replace('^', '').replace('(D0', '^(D0')})
    tt_tistos = filter(lambda tool : tool.__class__.__name__ == 'TupleToolTISTOS', dtt.lab0.getTools())[0]
    dtt.D0.addTupleTool(TupleToolTISTOS('D0_TISTOS', TriggerList = tt_tistos.TriggerList,
                                        Verbose = True, VerboseL0 = True, VerboseHlt1 = True, 
                                        VerboseHlt2 = True))
    ttdtf = dtt.lab0.addTupleTool(TupleToolDecayTreeFitter('tt_dtf'))
    ttdtf.Verbose = True
    ttdtfvtx = dtt.lab0.addTupleTool(TupleToolDecayTreeFitter('tt_dtf_vtx'))
    ttdtfvtx.Verbose = True
    ttdtfvtx.constrainToOriginVertex = True
    

    TupleToolPropertime,
    PropertimeFitter,
    TupleToolKinematic,
    TupleToolGeometry,
    TupleToolEventInfo,
    TupleToolPrimaries,
    TupleToolPid,
    TupleToolTrackInfo,
    TupleToolRecoStats,
    TupleToolMCTruth,
    LoKi__Hybrid__TupleTool,
    LoKi__Hybrid__EvtTupleTool,
)


tuple = DecayTreeTuple("TupleJPsi2KsKs")

# Give DecayTreeTuple the location of your stripped candidates
# If you apply a selection, this will be the output of a selection sequence object.
tuple.Inputs = [seq.outputLocation()]
tuple.ToolList = [
    "TupleToolKinematic",
    "TupleToolEventInfo",
    "TupleToolTrackInfo",
    "TupleToolPid",
    "TupleToolGeometry",
    "TupleToolAngles",
]

tuple.InputPrimaryVertices = "/Event/Charm/Rec/Vertex/Primary"