Python SelectionSequence.outputLocation方法代码示例

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
#                                  TopSelection = tau_selection)
                                   #EventPreSelector = prescaler)


############################################################

############################################################
## Make tuple
############################################################

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


tuple = DecayTreeTuple() # I can put as an argument a name if I use more than a DecayTreeTuple
tuple.Inputs = [ tau_sequence.outputLocation() ]
tuple.Decay = dec
tuple.ToolList = ['TupleToolKinematic',
                  'TupleToolEventInfo',
                  'TupleToolTrackInfo',
                  'TupleToolPid',
                  'TupleToolGeometry', 
                  'TupleToolAngles', # Helicity angle
                  #'TupleToolP2VV', # various angles, not useful in my analysis because only default values
                  'TupleToolPropertime', #proper time TAU of reco particles
                  #'TupleToolPrimaries', #num primary vertices and coords
                  ]

# Track isolation
tuple.addTupleTool('TupleToolTrackIsolation/TrackIsolation')
tuple.TrackIsolation.MinConeAngle = 0.5

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
### Gaudi sequence
SeqBs2JpsiKpi = SelectionSequence("SeqBs2JpsiKpi", TopSelection = Bs2JpsiKpi)
seq = SeqBs2JpsiKpi.sequence()

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

# from Configurables import  OfflineVertexFitter

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

tuple = DecayTreeTuple( "Bs2JpsiKpiTree" )
tuple.Inputs = [ SeqBs2JpsiKpi.outputLocation() ]


#----------begin former Xb2JpsiXTree.py-----------------#

########################################################################
#
# J/psi n-tuple
#
# @author Bilas Pal
# @date 2010-11-01
######
########################################################################
from Gaudi.Configuration import *
#
# DecayTreeTuple

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
                         Preambulo=preambulo,
                         DecayDescriptors = ['[B+ -> eta_prime pi+]cc'],
                         CombinationCut="(AM>3000.0) & (AM<10000.0) & (ACUTDOCA(0.04*mm,''))",
                         MotherCut ="(VFASPF(VCHI2/VDOF)<20.0)" 
                         )

Bu_sel = Selection("Bu_sel",
                   Algorithm= makeBu,
                   RequiredSelections=[etap_selection,pion_Sel]
                   )

Bu_selSeq = SelectionSequence("Bu_selSeq",TopSelection=Bu_sel)

from Configurables import PrintDecayTree

pt= PrintDecayTree(Inputs=[Bu_selSeq.outputLocation()])

from Configurables import SubstitutePID
SubKToPi = SubstitutePID (name = "SubKToPi",
                          Code = "DECTREE('[(B+ -> eta_prime pi+),(B- -> eta_prime pi-)]')",
                          Substitutions = {
                                  'B+ -> eta_prime ^pi+' : 'K+',
                                  'B- -> eta_prime ^pi-' : 'K-',
                          }
                          )
BuK_Sel=Selection("BuK_Sel",Algorithm=SubKToPi,RequiredSelections=[Bu_sel])

BuKFilter= FilterDesktop("BuKFilter",Code="(M>4900.0) & (M<5600.0) & (VFASPF(VCHI2/VDOF)<6.0)")

BuKFilteredSel = Selection("BuKFilteredSel",Algorithm=BuKFilter,RequiredSelections=[BuK_Sel])

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
tuple.B.TupleToolTISTOS.VerboseHlt2 = True
tuple.B.TupleToolTISTOS.VerboseL0 = True
tuple.B.TupleToolTISTOS.TriggerList = myTriggerList

from Configurables import TupleToolDecayTreeFitter
tuple.B.ToolList +=  ["TupleToolDecayTreeFitter/MassFit",
                     ]         # fit with eta_prime mass onstraint
tuple.B.addTool(TupleToolDecayTreeFitter,name="MassFit")
tuple.B.MassFit.constrainToOriginVertex = False
tuple.B.MassFit.daughtersToConstrain = [ "eta_prime" ]
tuple.B.MassFit.Verbose = True
tuple.B.MassFit.UpdateDaughters = True



tuple.Inputs= [B2EtapKFil_Seq.outputLocation()]

DaVinci().InputType = 'DST'
# MC 2012
DaVinci().DDDBtag =  "dddb-20130929-1"
DaVinci().CondDBtag= "sim-20130522-1-vc-md100"
DaVinci().DataType = "2012"
DaVinci().EvtMax = 10000
DaVinci().PrintFreq = 10000
DaVinci().HistogramFile = "DVHistos.root"
DaVinci().Simulation = True
DaVinci().TupleFile = "B2ETAPK_MC.root"
DaVinci().appendToMainSequence([B2EtapKFil_Seq,tuple])


from GaudiConf import IOHelper

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
#--------------------------------------------------------------------------
# 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" #!
DaVinci().CondDBtag = "Sim08-20130503-1-vc-md100" #!

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
class strippingLine:
    """
    Class to store information about stripping line that I will need to make nTuple
    """
    def __init__(self,name, lineName, dec, branches):
        self.name = name
        self.lineName = lineName
        self.dec = dec 
        self.branches = branches 
        self.lineLocation = "Phys/"+lineName+"/Particles"
        
         
    def select(self):
        """
        Get data and selection
        """

        from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand, AutomaticData
        # from StandardParticles import StdLooseMuons, StdLooseKaons
        from Configurables import FilterDesktop, CombineParticles, OfflineVertexFitter, LoKi__HDRFilter 
        from GaudiKernel.PhysicalConstants import c_light

        evtPreselectors = []

        if dataSample.isPrescaled != False:
            if dataSample.isPrescaled == True:
                dataSample.isPrescaled = 0.1
            prescaler =  DeterministicPrescaler("Prescaler", AcceptFraction = dataSample.isPrescaled)
            evtPreselectors.append(prescaler)


        # # Stripping filter
        strippingFilter = LoKi__HDRFilter( 'StripPassFilter', Code="HLT_PASS('Stripping"+self.lineName+"Decision')", Location="/Event/Strip/Phys/DecReports" )
        evtPreselectors.append(strippingFilter)


        stripped_data = AutomaticData(Location = self.lineLocation)
        
        # Trigger selection
        from Configurables import TisTosParticleTagger
        _tisTosFilter = TisTosParticleTagger( self.name + "Triggered" )
        _tisTosFilter.TisTosSpecs = { 'L0Global%TUS' : 0,
                                      'L0Global%TIS' : 0,
                                      }
        for trigger in trigger_list:
            for tistos in ['TIS', 'TUS']:
                _tisTosFilter.TisTosSpecs['{0}%{1}'.format(trigger, tistos)] = 0
        
        triggered_data =  Selection( self.name+'TriggerSelection',
                                     Algorithm = _tisTosFilter,
                                     RequiredSelections = [ stripped_data ],
                                     )
        
        Candidate_selection = stripped_data #triggered_data 
        
        self.sequence = SelectionSequence('Seq'+self.name,
                                          TopSelection = Candidate_selection,
                                          EventPreSelector = evtPreselectors)
        
    def makeTuple(self):
        """
        Make tuple
        """

        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
        

        tuple = DecayTreeTuple('Tuple'+self.name) # I can put as an argument a name if I use more than a DecayTreeTuple
        tuple.Inputs = [ self.sequence.outputLocation() ]
        tuple.Decay = self.dec
        tuple.ToolList = ['TupleToolKinematic',
                          'TupleToolEventInfo', 
                          'TupleToolTrackInfo',
                          'TupleToolPid',
                          'TupleToolGeometry', 
                          'TupleToolAngles', # Helicity angle
                          # 'TupleToolPropertime', #proper time TAU of reco particles
                          ]

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


        # Other event infos
        tuple.addTupleTool('LoKi::Hybrid::EvtTupleTool/LoKi_Evt')
        tuple.LoKi_Evt.VOID_Variables = {
            #"nSPDHits" :  " CONTAINS('Raw/Spd/Digits')  " ,
            'nTracks' :  " CONTAINS ('Charm/Rec/Track/Best') "  ,
            }
        
        # # Other variables
        # tuple.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_All')
        # tuple.LoKi_All.Variables = {
        #     'BPVIPCHI2' : 'BPVIPCHI2()',
        #     'BPVDIRA' : 'BPVDIRA',
        #     'BPVLTFITCHI2' : 'BPVLTFITCHI2()',           
        #     } 
        
        tuple.addBranches(self.branches)
        
#.........这里部分代码省略.........

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
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")
#CondDB().IgnoreHeartBeat = True

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
# get the selection(s) created by the stripping
strippingSels = [DataOnDemand(Location=tesLoc)]

# create a selection using the substitution algorithm
selSub = Selection(
    'Dst2D0pi_D02pipi_Sel',
    Algorithm=subs,
    RequiredSelections=strippingSels
)

selSeq = SelectionSequence('SelSeq', TopSelection=selSub)

# Create an ntuple to capture D*+ decays from the new selection
from Configurables import DecayTreeTuple
dtt = DecayTreeTuple('TupleDstToD0pi_D0Topipi')
dtt.Inputs = [selSeq.outputLocation()]
# note the redefined decay of the D0
dtt.Decay = '[D*(2010)+ -> ^(D0 -> ^pi- ^pi+) ^pi+]CC'

# add our new selection and the tuple into the sequencer
from Configurables import GaudiSequencer, DaVinci
seq = GaudiSequencer('MyTupleSeq')
seq.Members += [selSeq.sequence()]
seq.Members += [dtt]
DaVinci().appendToMainSequence([seq])

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

DaVinci().Simulation   = False

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]

#.........这里部分代码省略.........
    ( TRGHOSTPROB < 0.4    ) &
    ( PT          > 200 * MeV               ) &
    in_range ( 2          , ETA , 4.9       ) &
    in_range ( 3.2 * GeV  , P   , 150 * GeV ) &
    HASRICH                  &
    ( PROBNNk      > 0.15  ) &
    ( MIPCHI2DV()  > 9.    )
    """

    from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
    _alg_pi = FilterDesktop(
        ##
        Code=_PionCut_,
        ##
    )

    from PhysSelPython.Wrappers import Selection
    from StandardParticles import StdAllNoPIDsPions as input_pions
    pions = Selection(
        "SelPiForBQ",
        Algorithm=_alg_pi,
        RequiredSelections=[input_pions]
    )

    from GaudiConfUtils.ConfigurableGenerators import FilterDesktop
    _alg_k = FilterDesktop(
        ##
        Code=_KaonCut_,
        ##
    )

    from PhysSelPython.Wrappers import Selection
    from StandardParticles import StdAllNoPIDsKaons as input_kaons
    kaons = Selection(
        "SelKForBQ",
        Algorithm=_alg_k,
        RequiredSelections=[input_kaons]
    )

    def _kaons_(self):
        return kaons

    def _pions_(self):
        return pions

    #
    ## get the selections
    #

    for s in [PsiX]:
        s.pions = _pions_
        s.kaons = _kaons_

    logger.warning("Redefine PsiX.kaons          ")
    logger.warning("Redefine PsiX.kaons          ")

    psix = PsiX('PsiX', {})

    for s in [psix.psi_3Kpi()]:
        a = s.algorithm()
        a.ParticleCombiners = {'': 'LoKi::VertexFitter:PUBLIC'}

    from PhysSelPython.Wrappers import SelectionSequence
    sel_seq = SelectionSequence('B2Psi3Kpi', psix . psi_3Kpi())


    davinci = DaVinci(
        InputType     = 'DST'    ,
        Simulation    = True     ,
        PrintFreq     = 1000     ,
        EvtMax        = -1       , 
        Lumi          = True     ,
        DataType = params['Year'],
        DDDBtag = params['DDDB'],
        CondDBtag = params['SIMCOND'],
        # HistogramFile = 'DVHistos.root' ,
        TupleFile     = 'DVNtuples.root' ,
    )
    

    my_name = "Bplus"
    from Configurables import GaudiSequencer
    
    davinci.UserAlgorithms = [ sel_seq.sequence() , my_name ] 
    
    setData ( datafiles , catalogs , castor )
    
    gaudi = appMgr()

    print 'seq.outputLocation()= ', sel_seq.outputLocation()    # Phys/SelPsi3KPiForPsiX/Particles
    # create local algorithm:
    alg = MCAnalysisAlgorithm(
        my_name,
        Inputs = [
        sel_seq.outputLocation()
        ] ,
        PP2MCs = [ 'Relations/Rec/ProtoP/Charged' ]
    )

    return SUCCESS

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
seqK = SeqKst2K.sequence()
SeqKst2pi = SelectionSequence("SeqKst2pi", TopSelection = Kst2pi)
seqpi= SeqKst2pi.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

tuple =   DecayTreeTuple( "B02JpsiKpiTree" )
tuple.Inputs =   [ SeqB02JpsiKpi.outputLocation() ]

#----------begin former Xb2JpsiXTree.py-----------------#

########################################################################
#
# J/psi n-tuple
#
# @author Bilas Pal
# @date 2010-11-01
######
########################################################################
from Gaudi.Configuration import *
#
# DecayTreeTuple
#

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
###########################################################################
# 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("Bs2JpsiXTreeMC.py")


tupleLb = DecayTreeTuple( "Lb2JpsipKTree" )
tupleLb.Inputs = [ SeqLb2JpsipK.outputLocation() ]
#fmc = MCDecayTreeTuple("MyMCDecayTreeTuple")

DaVinci().Simulation   = True
DaVinci().EvtMax = -1                        # Number of events
DaVinci().DataType = "2012"
DaVinci().CondDBtag = "Sim08-20130503-1-vc-md100"
DaVinci().DDDBtag = "Sim08-20130503-1"
DaVinci().TupleFile = "mc.root"
DaVinci().PrintFreq = 50000
DaVinci().Lumi = False
#DaVinci().UserAlgorithms = [ seq, tuple, fmc]
DaVinci().UserAlgorithms = [ seqLb, tupleLb]
#DaVinci().UserAlgorithms = [ seq, tuple, tuple1]

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]

#.........这里部分代码省略.........
        RequiredSelections=[jpsi, pions]
    )

    from PhysSelPython.Wrappers import SelectionSequence

    Bc_1PI = SelectionSequence("PSIPi", TopSelection=Bc_1p)
    Bc_3PI = SelectionSequence("PSI3Pi", TopSelection=Bc_3p)
    Bc_Ds = SelectionSequence("PSIDs", TopSelection=BDs_sel)

    # Read only fired events to speed up
    from PhysConf.Filters import LoKi_Filters
    fltrs = LoKi_Filters(
        STRIP_Code="HLT_PASS_RE('Stripping.*DiMuonJpsi2MuMuDeta.*')",
        VOID_Code="""
        0.5 < CONTAINS('%s')
        """ % jpsi_location
    )

    # =====================================================================
    from Configurables import DaVinci  # needed for job configuration

    the_year = '2011'

    davinci = DaVinci(
        EventPreFilters=fltrs.filters('FilterMC'),
        DataType=the_year,
        InputType='DST',
        Simulation=True,
        PrintFreq=1000,
        EvtMax=-1,
        #
        HistogramFile='BcMC_Histos.root',
        TupleFile='BcMC.root',
        ## HistogramFile = 'BcMC1pi_Histos.root' ,
        ## TupleFile     = 'BcMC1pi.root'        ,
        #
        # for Ds
        #DDDBtag   = 'MC2011-20120727'          ,
        #CondDBtag = 'MC2011-20120727-vc-mu100' ,
        #
        # for  pi
        # DDDBtag   =  'MC11-20111102' ,
        # CondDBtag =  'sim-20111111-vc-md100' ,
        #
        ## Lumi          = True ,
        #
    )

    from Configurables import GaudiSequencer
    seqDs = GaudiSequencer(
        'DS',
        Members=[Bc_Ds   . sequence(),
                 "MCBc2Ds"]
    )
    from Configurables import GaudiSequencer
    seq1pi = GaudiSequencer(
        'Pi1',
        Members=[Bc_1PI . sequence(),
                 "MCBc1Pi"]
    )

    from Configurables import TrackSmearState
    state_smear = TrackSmearState(
        'StateSmear',
        ## RootInTES  = rootInTES  ,
    )

    davinci.UserAlgorithms = [state_smear, seqDs]

    ## davinci.UserAlgorithms = [ seq1pi ]

    # from Configurables import CondDB
    # CondDB ( LatestGlobalTagByDataType = the_year )

    # ------- decoding set-up start ----------
    # from BenderTools.MicroDST import uDstConf
    # uDstConf ( rootInTES )
    # ------- decoding set-up end  -----------

    # come back to Bender
    setData(datafiles, catalogs, castor)

    #
    # start Gaudi
    #
    gaudi = appMgr()

    alg1 = MCBc(
        'MCBc2Ds',  # Algorithm name ,
        Inputs=[Bc_Ds.outputLocation()],
        PP2MCs=['Relations/Rec/ProtoP/Charged']
    )

    alg2 = MCBc1Pi(
        'MCBc1Pi',  # Algorithm name ,
        Inputs=[Bc_1PI.outputLocation()],
        PP2MCs=['Relations/Rec/ProtoP/Charged']
    )

    return SUCCESS

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
_mainpions = DataOnDemand(Location='Phys/StdMCPions/Particles')

#
# MC matching
#

matchD2KKPi = "(mcMatch('D_s+  ==> K- K+ pi+'))"
#matchKaons = "(mcMatch('[K+]cc'))"
#matchPions = "(mcMatch('[pi+]cc'))"

_maind2kkpi = CombineParticles("d2kkpiMain")
_maind2kkpi.DecayDescriptor = "D_s+ -> K+ K- pi+"
#_d2kkpi.DaughtersCuts = { "pi+" : matchPions, "K+" : matchKaons}
_maind2kkpi.MotherCut = matchD2KKPi
_maind2kkpi.Preambulo = [
    "from LoKiPhysMC.decorators import *",
    "from PartProp.Nodes import CC" ]

selD2KKPiMain = Selection( "DsPlusCandidates",
                            Algorithm = _maind2kkpi,
                            RequiredSelections=[_mainkaons, _mainpions])  

seqD2KKPiMain = SelectionSequence('MCFilterMain',TopSelection = selD2KKPiMain)

maintuple = DecayTreeTuple("out")
maintuple.Decay = "[D_s+ -> K- K+ pi+]CC"
maintuple.Inputs = [seqD2KKPiMain.outputLocation()]
mcTruth = maintuple.addTupleTool("TupleToolMCTruth")
maintuple.addTupleTool("TupleToolPropertime")

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
#_d2kkpi.DaughtersCuts = { "pi+" : matchPions, "K+" : matchKaons}
_d2kkpi.MotherCut = matchD2KKPi
_d2kkpi.Preambulo = [
    "from LoKiPhysMC.decorators import *",
    "from PartProp.Nodes import CC" ]

SelD2KKPi = Selection( "SelD2KKPi",
                        Algorithm = _d2kkpi,
                        RequiredSelections=[_kaons,_pions])  

dumpAlg = DumpAddr(OutputFile='eventaddr.txt', ObjectPath='/Event')
SeqD2KKPi = SelectionSequence('MCFilter',TopSelection = SelD2KKPi, PostSelectionAlgs=[dumpAlg])

tuple = DecayTreeTuple("out")
tuple.Decay = "[D_s+ -> K- K+ pi+]CC"
tuple.Inputs = [SeqD2KKPi.outputLocation()]
mcTruth = tuple.addTupleTool("TupleToolMCTruth")
tuple.addTupleTool("TupleToolPropertime")

checkPV = CheckPV()

dstWriter = SelDSTWriter("MyDSTWriter",
                         SelectionSequences = [SeqD2KKPi],
                         OutputFileSuffix = 'EXTRA'
                         )

from Gaudi.Configuration import *

from Configurables import DaVinci
DaVinci().EvtMax = 10000
DaVinci().PrintFreq = 10

# 需要导入模块: from PhysSelPython.Wrappers import SelectionSequence [as 别名]
# 或者: from PhysSelPython.Wrappers.SelectionSequence import outputLocation [as 别名]
subsel = Selection("subsel",Algorithm = subalg, RequiredSelections = [_selDimuons])

# Try and make B->J/psi K
_B = CombineParticles()
_B.DaughtersCuts = { "K+" : "(PT>500*MeV)&(MIPCHI2DV(PRIMARY) > 9)" }
_B.MotherCut = "(DMASS('B+')<5000*MeV) & (VFASPF(VCHI2)/VFASPF(VDOF)<5.0) & (BPVDIRA > 0.999)" #need to check these cuts
_B.DecayDescriptors = [ "[B+ -> J/psi(1S) K+]cc" ]


_BdecaySelection = Selection( "TurboB", Algorithm = _B, RequiredSelections = [subsel,kaons] )
SeqB = SelectionSequence('SeqB', TopSelection = _BdecaySelection)

# Here we just put the output candidates in an Tuple

tupleB = DecayTreeTuple("bae-muon-data")
tupleB.Inputs = [SeqB.outputLocation()]
tupleB.Decay = "[B+ -> ^K+ ^(J/psi(1S) -> ^mu+ ^mu-)]CC"


tupleB.ToolList =  [
      "TupleToolKinematic"
    , "TupleToolEventInfo"
    , "TupleToolRecoStats"
    ,    "TupleToolTrigger",
        "TupleToolPid",
        "TupleToolPrimaries",
        "TupleToolAngles",
        "TupleToolEventInfo",
        "TupleToolGeometry",
        "TupleToolKinematic",
        "TupleToolPropertime",