"""
Configuration file for 'Standard Loose Jpsi2MuMu'. Lifetime unbiased.
"""
__author__ = "Greig Cowan"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.9 $"
# =============================================================================
__all__ = ('StdLooseJpsi2MuMu', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
StdLooseJpsi2MuMu = CombineParticles("StdLooseJpsi2MuMu")
StdLooseJpsi2MuMu.Inputs = ["Phys/StdAllLooseMuons/Particles"]
StdLooseJpsi2MuMu.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
StdLooseJpsi2MuMu.CombinationCut = "(ADAMASS('J/psi(1S)') < 100.*MeV) & (ADOCACHI2CUT(30,''))"
StdLooseJpsi2MuMu.MotherCut = "(VFASPF(VCHI2) < 25.)"
## configure Data-On-Demand service
locations = updateDoD(StdLooseJpsi2MuMu)
## ============================================================================
if '__main__' == __name__:
print __doc__
print __author__
print __version__
print locationsDoD(locations)
__date__ = '08/12/2009'
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
import GaudiKernel.SystemOfUnits as Units
###########################
# StdLooseDiElectron #
###########################
"""
Standard Di-Electron maker from 2 electrons
"""
StdLooseDiElectron = CombineParticles("StdLooseDiElectron")
StdLooseDiElectron.DecayDescriptor = "J/psi(1S) -> e+ e-"
StdLooseDiElectron.Inputs = ["Phys/StdAllLooseElectrons/Particles"]
StdLooseDiElectron.DaughtersCuts = {"e+": "(PT>500*MeV)"}
StdLooseDiElectron.CombinationCut = "(AM>30*MeV) & (ADOCACHI2CUT(30,''))"
StdLooseDiElectron.MotherCut = "(VFASPF(VCHI2)<25)"
locations = updateDoD(StdLooseDiElectron)
"""
Using Olivier's Di-Electron Particle Maker
"""
###--- From Olivier's ParticleMaker
from Configurables import DiElectronMaker, ProtoParticleCALOFilter
from GaudiKernel.SystemOfUnits import *
dieLL = DiElectronMaker('StdDiElectronFromTracks')
dieLL.Particle = "J/psi(1S)"
selector = trackSelector(dieLL, trackTypes=["Long"])
dieLL.addTool(ProtoParticleCALOFilter('Electron'))
dieLL.Electron.Selection = ["RequiresDet='CALO' CombDLL(e-pi)>'-2.0'"]
"UV":"( ( ANUM( ( TRTYPE == 4 ) & ( ABSID == 'e-' ) ) == 1 ) & ( ANUM( ( TRTYPE == 1 ) & ( ABSID == 'e-' ) ) == 1 ) )"}
## build combinations
Ks2pipiee = {}
for name in combs:
Ks2pipiee[name] = CombineParticles("TrackSel"+name+"_Ks2pipiee")
Ks2pipiee[name].DecayDescriptor = "KS0 -> pi+ pi- e+ e-"
Ks2pipiee[name].Preambulo=["from LoKiPhysMC.decorators import *",
"from LoKiPhysMC.functions import mcMatch"]
## only take pions mctruth matched to pions from signal...
Ks2pipiee[name].DaughtersCuts = {"pi+" : "mcMatch('KS0 ==> ^pi+ pi- e+ e-' )",
"pi-" : "mcMatch('KS0 ==> pi+ ^pi- e+ e-' )"}
Ks2pipiee[name].CombinationCut = combs[name]
Ks2pipiee[name].MotherCut = "ALL"
## input all possible daughters
Ks2pipiee[name].Inputs =['Phys/StdAllNoPIDsPions', 'Phys/StdAllNoPIDsElectrons', 'Phys/StdNoPIDsUpElectrons', 'Phys/StdNoPIDsVeloElectrons']
DaVinci().UserAlgorithms +=[Ks2pipiee[name]]
DaVinci().EvtMax = 0
DaVinci().DataType = "2016"
DaVinci().Simulation = True
HOME = "/eos/lhcb/wg/RD/K0S2pipiee/dsts/MC2016/Priv/Sim09cMagUpLDST/"
DaVinci().Input = map(lambda x: 'PFN:root://eoslhcb.cern.ch/'+HOME+x,os.listdir(HOME))
#DaVinci().Input
gaudi = GaudiPython.AppMgr()
gaudi.initialize()
DEBUG = 0
TES = gaudi.evtsvc()
cbreak = 0
locations = {}
#create matching strings
matchJpsi2MuMu = "(mcMatch('J/psi(1S) ==> mu+ mu- '))"
matchpsi2s2MuMu = "(mcMatch('psi(2S) ==> mu+ mu- '))"
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
from CommonMCParticles import *
## ============================================================================
## create the algorithm
StdMCJpsi2MuMu = CombineParticles("StdMCJpsi2MuMu")
StdMCJpsi2MuMu.Inputs = [npmuons]
StdMCJpsi2MuMu.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
StdMCJpsi2MuMu.MotherCut = matchJpsi2MuMu
#tdMCJpsi2MuMu.DaughtersCuts = {"mu+" : matchmuons}
StdMCJpsi2MuMu.Preambulo = [
"from LoKiPhysMC.decorators import *", "from PartProp.Nodes import CC"
]
## configure Data-On-Demand service
locations.update(updateDoD(StdMCJpsi2MuMu))
## create the algorithm
StdMCpsi2s2MuMu = CombineParticles("StdMCpsi2s2MuMu")
StdMCpsi2s2MuMu.Inputs = [npmuons]
StdMCpsi2s2MuMu.DecayDescriptor = "psi(2S) -> mu+ mu-"
StdMCpsi2s2MuMu.MotherCut = matchpsi2s2MuMu
"""
__author__ = "Olivier Deschamps"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.3 $"
# =============================================================================
__all__ = ('StdLoosePi02gee', 'StdLoosePi024e', 'StdLooseDalitzPi0',
'locations')
# =============================================================================
from GaudiKernel.SystemOfUnits import MeV
from CommonParticles.Utils import *
from Configurables import CombineParticles
## create the algorithm : pi0 -> gg(ee) (1 conversion)
pi02gee = CombineParticles("StdLoosePi02gee",
DecayDescriptor='pi0 -> gamma gamma')
pi02gee.Inputs = [
"Phys/StdLooseAllPhotons/Particles", "Phys/StdAllLooseGammaLL/Particles",
"Phys/StdAllLooseGammaDD/Particles"
]
pi02gee.ParticleCombiners.update({"": "ParticleAdder"})
pi02gee.Preambulo += ["cnv = switch(INTES('StdLooseAllPhotons',False),1,0)"]
pi02gee.MotherCut = " (MM < 170*MeV) & (MM > 90*MeV) & (1 == CHILD(1,cnv)+CHILD(2,cnv) )"
locations = updateDoD(pi02gee)
StdLoosePi02gee = pi02gee
## create the algorithm : pi0 -> g(ee)g(ee) (2 conversions)
pi024e = CombineParticles("StdLoosePi024e",
DecayDescriptor='pi0 -> gamma gamma')
pi024e.Inputs = [
"Phys/StdAllLooseGammaLL", "Phys/StdAllLooseGammaDD/Particles"
]
pi024e.ParticleCombiners.update({"": "ParticleAdder"})
#pi024e.ParticleCombiners.update( {"" : "LoKi::VertexFitter"} )
# =============================================================================
__all__ = ('StdLooseDplus2KPiPi', 'StdLooseDplus2KKPi', 'StdLooseDplus2PiPiPi',
'StdLooseDplus2KPiPiOppSignPi', 'StdLooseDsplus2KKPi',
'StdLooseDplus2hhh', 'StdLooseDplus2KKK',
'StdLooseDsplus2KKPiOppSign', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
StdLooseDplus2KPiPi = CombineParticles('StdLooseDplus2KPiPi')
StdLooseDplus2KPiPi.Inputs = [
"Phys/StdLooseKaons/Particles", "Phys/StdLoosePions/Particles"
]
StdLooseDplus2KPiPi.DecayDescriptor = "[D+ -> K- pi+ pi+]cc"
StdLooseDplus2KPiPi.DaughtersCuts = {"K+": "(P > 2*GeV)", "pi+": "(P > 2*GeV)"}
#Need an upper mass window of 100 MeV for background estimation
#and a lower mass window of 200 to catch the D+ and Ds
StdLooseDplus2KPiPi.CombinationCut = "((AM>1760.*MeV) & (AM<2080.*MeV) & ((APT>1.*GeV) | (ASUM(PT)>1.*GeV)) & (ADOCAMAX('')<0.5*mm))"
StdLooseDplus2KPiPi.MotherCut = "((VFASPF(VCHI2) < 30 ) & (M>1770.*MeV) & (M < 2070.*MeV) & (BPVVDCHI2>36) & (BPVDIRA>0.98))"
## configure Data-On-Demand service
locations = updateDoD(StdLooseDplus2KPiPi)
##########################################################################################
# D+ -> K K Pi is a clone of D+ -> K Pi Pi
#
"""
__author__ = 'P. Koppenburg'
__date__ = '22/01/2010'
from Gaudi.Configuration import *
from Configurables import CombineParticles # , OfflineVertexFitter, OnOfflineTool
from CommonParticles.Utils import *
import GaudiKernel.SystemOfUnits as Units
###########################
# StdVeryLooseDetachetKst2Kpi #
###########################
StdVeryLooseDetachedKst2Kpi = CombineParticles("StdVeryLooseDetachedKst2Kpi")
StdVeryLooseDetachedKst2Kpi.DecayDescriptor = "[K*(892)0 -> K+ pi-]cc"
StdVeryLooseDetachedKst2Kpi.Inputs = [
"Phys/StdLooseKaons/Particles", "Phys/StdLoosePions/Particles"
]
## # IPCHI2>4 already applied on StdLoose{Kaons,Pions}
## StdVeryLooseDetachedKst2Kpi.DaughtersCuts = {
## "K+" :"(MIPCHI2DV(PRIMARY)>2.25)",
## "pi-":"(MIPCHI2DV(PRIMARY)>2.25)"
## }
StdVeryLooseDetachedKst2Kpi.CombinationCut = "(ADAMASS('K*(892)0')<300*MeV) & (ADOCACHI2CUT(30, ''))"
StdVeryLooseDetachedKst2Kpi.MotherCut = "(VFASPF(VCHI2)<25)"
locations = updateDoD(StdVeryLooseDetachedKst2Kpi)
__all__ = (
'StdLooseRhoPlus' ,
'locations'
)
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
StdLooseRhoPlus = CombineParticles ( 'StdLooseRhoPlus' )
StdLooseRhoPlus = CombineParticles("StdLooseRhoPlus")
StdLooseRhoPlus.Inputs = [ "Phys/StdLooseMergedPi0/Particles",
"Phys/StdLooseResolvedPi0/Particles",
"Phys/StdLoosePions/Particles",
"Phys/StdLooseKaons/Particles"]
StdLooseRhoPlus.DecayDescriptor = "[rho(770)- -> pi- pi0]cc"
StdLooseRhoPlus.DaughtersCuts = {"pi+" : "ALL", "K+" : "ALL",
"pi0" : "(PT>1000*MeV) & (P> 1500*MeV)"}
#Note
#The cut of 550 MeV around the K*(892)+ is NOT a typo, is motivated
#by the requirements of the B2DVec HLT2 selection
StdLooseRhoPlus.CombinationCut = "(ADAMASS('K*(892)+')<550*MeV)"
StdLooseRhoPlus.MotherCut = "ALL"
## configure Data-On-Demand service
locations = updateDoD ( StdLooseRhoPlus )
## ============================================================================
### @file
#
# Standard rho(770)0
#
##
from Gaudi.Configuration import *
from Configurables import CombineParticles
from HltLine.HltLine import bindMembers
from Hlt2SharedParticles.GoodParticles import GoodPions
__all__ = ('Rho0')
Hlt2SharedRho0 = CombineParticles("Hlt2SharedRho0")
Hlt2SharedRho0.Output = 'Hlt2/Hlt2SharedRho0/Particles'
Hlt2SharedRho0.Inputs = [GoodPions.outputSelection()]
Hlt2SharedRho0.DecayDescriptor = "[rho(770)0 -> pi+ pi-]cc"
Hlt2SharedRho0.DaughtersCuts = {"pi+": "TRUE", "pi-": "TRUE"}
Hlt2SharedRho0.CombinationCut = "(ADAMASS('rho(770)0')<100*MeV)"
Hlt2SharedRho0.MotherCut = "(BPVVDZ>0) & (VFASPF(VCHI2PDOF)<9) & (BPVDIRA>0.95) & (BPVVDCHI2>25)"
Rho0 = bindMembers(None, [GoodPions, Hlt2SharedRho0])
#--------------------------------------------------------------------
# rho(770) -> pi pi0
#--------------------------------------------------------------------
from Gaudi.Configuration import *
from Configurables import CombineParticles
from HltLine.HltLine import bindMembers
from Hlt2SharedParticles.GoodParticles import GoodPions, GoodKaons
from Hlt2SharedParticles.Pi0 import AllPi0s
__all__ = ('RhoPlus2PiPi0', 'RhoPlus2KPi0')
Hlt2SharedRhoPlus2PiPi0 = CombineParticles("Hlt2SharedRhoPlus2PiPi0")
# Special vertex fitter
Hlt2SharedRhoPlus2PiPi0.VertexFitters.update({"": "ParticleAdder"})
Hlt2SharedRhoPlus2PiPi0.Output = 'Hlt2/Hlt2SharedRhoPlus2PiPi0/Particles'
Hlt2SharedRhoPlus2PiPi0.Inputs = [GoodPions.outputSelection()
] + AllPi0s.outputSelection()
Hlt2SharedRhoPlus2PiPi0.DecayDescriptor = "[rho(770)- -> pi- pi0]cc"
Hlt2SharedRhoPlus2PiPi0.DaughtersCuts = {
"pi+": "ALL",
"pi0": "(PT>1000*MeV) & (P> 1500*MeV)"
}
#Note
#The cut of 550 MeV around the K*(892)+ is NOT a typo, is motivated
#by the requirements of the B2DVec HLT2 selection
Hlt2SharedRhoPlus2PiPi0.CombinationCut = "(ADAMASS('K*(892)+')<550*MeV)"
Hlt2SharedRhoPlus2PiPi0.MotherCut = "ALL"
RhoPlus2PiPi0 = bindMembers(None,
[GoodPions, AllPi0s, Hlt2SharedRhoPlus2PiPi0])
#--------------------------------------------------------------------
#rho(770) -> K pi0 is a clone of rho(770) -> pi pi0
ok = linker.firstReference(proto.key(), None ,LinkRef)
if not ok: return 0
return TES["MC/Particles"][LinkRef.objectKey()]
## DOWN DOWN KS0
MyMuonsDown = DataOnDemand(Location = 'Phys/StdNoPIDsDownMuons')
Ks2MuMuDown = CombineParticles("MCSel_Ks2MuMuDown")
Ks2MuMuDown.Preambulo=["from LoKiPhysMC.decorators import *",
"from LoKiPhysMC.functions import mcMatch"]
## build KS0->pipi
Ks2MuMuDown.DecayDescriptor = "KS0 -> mu+ mu-"
## only select real KS0s, matched to MCTruth muons
Ks2MuMuDown.DaughtersCuts = {"mu+" : " mcMatch( '[mu+]cc' )" }
Ks2MuMuDown.MotherCut = " mcMatch('KS0 ==> mu+ mu-' )"
Ks2MuMuDown.Inputs =['Phys/StdNoPIDsDownMuons']
DaVinci().UserAlgorithms +=[Ks2MuMuDown] ## downstream pions
DaVinci().EvtMax = 0
DaVinci().DataType = "Upgrade"
DaVinci().Simulation = True
DaVinci().DDDBtag = "upgrade/dddb-20171126"
DaVinci().CondDBtag = "upgrade/sim-20171127-vc-md100"
## CONFIGURATION FOR UPGRADE
MeasurementProvider().IgnoreVelo = True
MeasurementProvider().IgnoreTT = True
MeasurementProvider().IgnoreIT = True
##############################################################################
# $Id: Jpsi2MuPi.py,v 1.2 2009-05-29 17:30:19 pkoppenb Exp $
#
# Author: Patrick Koppenburg <*****@*****.**>
#
##############################################################################
from Configurables import GaudiSequencer
JpsiSeq = GaudiSequencer("JpsiMonitorSeq")
##############################################################################
#
# Make a J/psi with only one side mu-IDed
#
from Configurables import CombineParticles
Jpsi2MuPi = CombineParticles("Jpsi2MuPi")
Jpsi2MuPi.Inputs = [
"Phys/StdLooseMuons/Particles", "Phys/StdNoPIDsPions/Particles"
]
Jpsi2MuPi.DecayDescriptor = "[J/psi(1S) -> mu+ pi-]cc"
# a good muon and any pion
Jpsi2MuPi.DaughtersCuts = {
"pi+": "(P>1*GeV)",
"mu+": "(P>10*GeV) & (PT>1*GeV)"
}
Jpsi2MuPi.CombinationCut = "(ADAMASS('J/psi(1S)')<100*MeV)"
Jpsi2MuPi.MotherCut = "(ALL)"
JpsiSeq.Members += [Jpsi2MuPi]
##############################################################################
#
# Plot quantities
#
from Configurables import ParticleMonitor
DMotherCut = "(VFASPF(VCHI2/VDOF)<10) & (BPVVDCHI2>25) & (BPVDIRA>0.998)"
D0MotherCut = "(ADMASS('D0')<50*MeV) & " + DMotherCut
DpMotherCut = "(ADMASS('D+')<50*MeV) & " + DMotherCut
DstMotherCut = "(M-MAXTREE('D0'==ABSID,M)<165.5) & (VFASPF(VCHI2/VDOF)<25) & (BPVVDCHI2>25) & (BPVDIRA>0.998)"
LCMotherCut = "(ADMASS('Lambda_c+')<100*MeV) & (VFASPF(VCHI2/VDOF)<10) & (BPVVDCHI2>25) & (BPVDIRA>0.998)"
# =============================================================================
# D0 -> K Pi #
Tag_StdD02KPi = CombineParticles("Tag_StdD02KPi")
Tag_StdD02KPi.ParticleCombiners = {'' : 'LoKi::VertexFitter:PUBLIC' }
Tag_StdD02KPi.Preambulo = CharmPreambulo
Tag_StdD02KPi.DecayDescriptors = ["[D0 -> K- pi+]cc"]
Tag_StdD02KPi.CombinationCut = D0CombCut
Tag_StdD02KPi.MotherCut = D0MotherCut
Tag_StdD02KPi.Inputs = [OutputKaonList, OutputPionList]
Tag_StdD02KPi.Output = "Phys/" + Tag_StdD02KPi.name() + "/Particles"
locations.update(updateDoD(Tag_StdD02KPi))
#Tag_CharmRecSeq.Members += [Tag_StdD02KPi]
# =============================================================================
# D0 -> K Pi Pi Pi #
Tag_StdD02KPiPiPi = CombineParticles ("Tag_StdD02KPiPiPi")
Tag_StdD02KPiPiPi.ParticleCombiners = {'' : 'LoKi::VertexFitter:PUBLIC' }
Tag_StdD02KPiPiPi.Preambulo = CharmPreambulo
Tag_StdD02KPiPiPi.DecayDescriptors = ["[D0 -> K- pi+ pi+ pi-]cc"]
Tag_StdD02KPiPiPi.DaughtersCuts = {
"K+" : "(PT>150*MeV) & (PROBNNK > 0.1) & (BPVIPCHI2()>6.0)"
, "pi+" : "(PT>150*MeV) & (BPVIPCHI2()>6.0)"
, "pi-" : "(PT>150*MeV) & (BPVIPCHI2()>6.0)"
from Gaudi.Configuration import *
from Configurables import CombineParticles, FilterDesktop
from CommonParticles.Utils import *
from CommonMCParticles import StandardMCPions
#locations of nopidsparticles:
nppions = "Phys/StdMCPions/Particles"
npdownpions = "Phys/StdMCDownPions/Particles"
#Create matching strings
locations={}
matchKs = "(mcMatch('[KS0]cc ==> pi+ pi-'))"
## create the algorithm
StdMCKsLL = CombineParticles("StdMCKsLL")
StdMCKsLL.Inputs = [nppions]
StdMCKsLL.DecayDescriptor = "[KS0 -> pi+ pi-]cc"
StdMCKsLL.MotherCut = matchKs
#StdMCKsLL.DaughtersCuts = {"pi+" : matchpions}
StdMCKsLL.Preambulo = [
"from LoKiPhysMC.decorators import *",
"from PartProp.Nodes import CC" ]
## configure Data-On-Demand service
locations.update(updateDoD ( StdMCKsLL ))
## create the algorithm
StdMCKsDD = CombineParticles("StdMCKsDD")
StdMCKsDD.Inputs = [npdownpions]
StdMCKsDD.DecayDescriptor = "[KS0 -> pi+ pi-]cc"
__author__ = "Patrick Koppenburg"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.3 $"
# =============================================================================
__all__ = ('StdLooseDstarWithD02KPi', 'StdLooseDstarWithD02KPiDCS',
'StdLooseDstarWithD02PiPi', 'StdLooseDstarWithD02KK', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
StdLooseDstarWithD02KPi = CombineParticles('StdLooseDstarWithD02KPi')
StdLooseDstarWithD02KPi.Inputs = [
"Phys/StdAllLoosePions/Particles", "Phys/StdLooseD02KPi/Particles"
]
StdLooseDstarWithD02KPi.DecayDescriptor = "[D*(2010)+ -> pi+ D0]cc"
StdLooseDstarWithD02KPi.CombinationCut = "(ADAMASS('D*(2010)+')<50*MeV) & (APT>1250*MeV)"
StdLooseDstarWithD02KPi.MotherCut = "(VFASPF(VCHI2/VDOF)<25) & (M-MAXTREE('D0'==ABSID,M)<165.5)"
## configure Data-On-Demand service
locations = updateDoD(StdLooseDstarWithD02KPi)
################################################################################
# D* with Cabibbo-suppressed D0->K+Pi- is a clone of D* with D0->KPi
#
StdLooseDstarWithD02KPiDCS = StdLooseDstarWithD02KPi.clone(
"StdLooseDstarWithD02KPiDCS")
GaudiSequencer("SeqStdLooseDstarWithD02KPiDCS").Members += [
"""
__author__ = "Donal Hill, Conor Fitzpatrick, Christian Elsasser"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.0 $"
# =============================================================================
__all__ = ('StdLooseDetachedTau3piNonPhys', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm - non-physical tau+++ -> pi+ pi+ pi+
StdLooseDetachedTau3piNonPhys = CombineParticles(
'StdLooseDetachedTau3piNonPhys')
StdLooseDetachedTau3piNonPhys.Inputs = ["Phys/StdLoosePions/Particles"]
#Build physical tau and tau+++
StdLooseDetachedTau3piNonPhys.DecayDescriptors = ["[tau+ -> pi+ pi+ pi+]cc"]
StdLooseDetachedTau3piNonPhys.DaughtersCuts = {
"pi+":
"(PT>150.*MeV) & (MIPCHI2DV(PRIMARY) > 4.0) & (TRCHI2DOF<4) & (TRGHOSTPROB<0.4) & (PIDK < 8)"
}
#Need an upper mass window of 100 MeV for background estimation
#and a lower mass window of 200 to catch the D+ and Ds
StdLooseDetachedTau3piNonPhys.CombinationCut = "((AM>400.*MeV) & (AM<3500.*MeV)) & (ADOCAMAX('')<0.15*mm) & ((AM12<1670.*MeV) or (AM23<1670.*MeV)) & (ANUM(PT < 300*MeV) <= 1) & (1<ANUM( ('pi+'==ABSID) & (MIPCHI2DV(PRIMARY)>5)))"
StdLooseDetachedTau3piNonPhys.MotherCut = "(M>400.*MeV) & (M < 3500.*MeV) & (BPVDIRA>0.99) & (VFASPF(VCHI2) < 25 )"
## configure Data-On-Demand service
# =============================================================================
__all__ = ('StdLooseD02KsPiPi', 'StdLooseD02KsKK', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
##########################################################################################
# D0 -> Ks Pi Pi
#
StdLooseD02KsPiPi = CombineParticles("StdLooseD02KsPiPi")
StdLooseD02KsPiPi.Inputs = [
"Phys/StdLoosePions/Particles", "Phys/StdLooseKsLL/Particles"
]
StdLooseD02KsPiPi.DecayDescriptor = "[D0 -> KS0 pi+ pi-]cc"
StdLooseD02KsPiPi.DaughtersCuts = {"pi+": "(PT>400*MeV)", "KS0": "(PT>1*GeV)"}
StdLooseD02KsPiPi.CombinationCut = "(ADAMASS('D0')<80*MeV) & (APT>1800*MeV)"
StdLooseD02KsPiPi.MotherCut = "(VFASPF(VCHI2/VDOF)<10) & (MIPCHI2DV(PRIMARY)>1)"
## configure Data-On-Demand service
locations = updateDoD(StdLooseD02KsPiPi)
##########################################################################################
# D0 -> Ks K K is a clone of Ks Pi Pi
#
StdLooseD02KsKK = StdLooseD02KsPiPi.clone("StdLooseD02KsKK")
from CommonMCParticles import StandardMCPions, StandardMCProtons
#locations of nopidsparticles:
nppions = "Phys/StdMCPions/Particles"
npprotons = "Phys/StdMCProtons/Particles"
#matchProtons = "mcMatch( '[p+]cc' )"
#matchPions = "mcMatch( '[pi+]cc' )"
locations = {}
#Create matching strings
matchLambda02pPi = "(mcMatch('[Lambda0 ==> p+ pi-]CC'))"
## ============================================================================
## create the algorithm
StdMCLambda02pPi = CombineParticles("StdMCLambda02pPi")
StdMCLambda02pPi.Inputs = [nppions, npprotons]
StdMCLambda02pPi.DecayDescriptor = "[Lambda0 -> p+ pi-]cc"
StdMCLambda02pPi.MotherCut = matchLambda02pPi
#StdMCLambda02pPi.DaughtersCuts = {"p+" : matchProtons,"pi+" : matchPions}
StdMCLambda02pPi.Preambulo = [
"from LoKiPhysMC.decorators import *", "from PartProp.Nodes import CC"
]
## configure Data-On-Demand service
locations.update(updateDoD(StdMCLambda02pPi))
## ============================================================================
if '__main__' == __name__:
print __doc__
print __author__
"""
__author__ = "Patrick Koppenburg"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.2 $"
# =============================================================================
__all__ = ('StdLooseLambdaLL', 'StdLooseLambdaDD', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
StdLooseLambdaLL = CombineParticles('StdLooseLambdaLL')
StdLooseLambdaLL.Inputs = [
"Phys/StdLoosePions/Particles", "Phys/StdLooseProtons/Particles"
]
StdLooseLambdaLL.DecayDescriptor = "[Lambda0 -> p+ pi-]cc"
StdLooseLambdaLL.DaughtersCuts = {
"pi+": "(P>2*GeV) & (MIPCHI2DV(PRIMARY)>9)",
"p+": "(P>2*GeV) & (MIPCHI2DV(PRIMARY)>9)"
}
StdLooseLambdaLL.CombinationCut = "(ADAMASS('Lambda0')<50*MeV) & (ADOCACHI2CUT(30, ''))"
StdLooseLambdaLL.MotherCut = "(ADMASS('Lambda0')<35*MeV) & (VFASPF(VCHI2)<30)"
## configure Data-On-Demand service
locations = updateDoD(StdLooseLambdaLL)
## ============================================================================
"""
Configuration file for Standard Loose DiMuon
"""
__author__ = 'Rob Lambert'
__date__ = '07/07/2009'
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
import GaudiKernel.SystemOfUnits as Units
###########################
# StdLooseDiMuon #
###########################
StdLooseDiMuon = CombineParticles("StdLooseDiMuon")
StdLooseDiMuon.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
StdLooseDiMuon.Inputs = ["Phys/StdAllLooseMuons/Particles"]
StdLooseDiMuon.CombinationCut = "(ADOCACHI2CUT(30, ''))"
StdLooseDiMuon.MotherCut = "(VFASPF(VCHI2) < 25)"
locations = updateDoD(StdLooseDiMuon)
## ============================================================================
if '__main__' == __name__:
print __doc__
print __author__
print __version__
print locationsDoD(locations)
# =============================================================================
__all__ = (
'StdLooseLambdac2PKPi' ,
'locations'
)
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
StdLooseLambdac2PKPi = CombineParticles ( 'StdLooseLambdac2PKPi' )
StdLooseLambdac2PKPi.Inputs = [ "Phys/StdLooseKaons/Particles",
"Phys/StdLoosePions/Particles",
"Phys/StdLooseProtons/Particles" ]
StdLooseLambdac2PKPi.DecayDescriptor = "[Lambda_c+ -> K- p+ pi+]cc"
StdLooseLambdac2PKPi.DaughtersCuts = {
"K+" : "(P > 2*GeV)",
"pi+" : "(P > 2*GeV)",
"p+" : "(P > 2*GeV)"
}
StdLooseLambdac2PKPi.CombinationCut = "((ADAMASS('Lambda_c+')<110*MeV) & (APT>1.*GeV) & (ADOCAMAX('')<0.5*mm))"
StdLooseLambdac2PKPi.MotherCut = "((VFASPF(VCHI2) < 30) & (ADMASS('Lambda_c+')<100*MeV) & (BPVVDCHI2>36) & (BPVDIRA>0.98))"
## configure Data-On-Demand service
locations = updateDoD ( StdLooseLambdac2PKPi )
#locations of nopidsparticles:
npkaons = "Phys/StdMCKaons/Particles"
nppions = "Phys/StdMCPions/Particles"
locations = {}
#matchKaons = "mcMatch( '[K+]cc' )"
#matchPions = "mcMatch( '[pi+]cc' )"
#Create matching strings
matchD02KPi = "(mcMatch('[D0 ==> K- pi+ ]CC'))"
matchD02KK = "(mcMatch('[D0 ==> K- K+ ]CC'))"
matchD02PiPi = "(mcMatch('[D0 ==> pi- pi+ ]CC'))"
matchD02KPiDCS = "(mcMatch('[D0 ==> K+ pi- ]CC'))"
#Algorithms
StdMCD02KPi = CombineParticles('StdMCD02KPi')
StdMCD02KPi.Inputs = [npkaons, nppions]
StdMCD02KPi.DecayDescriptor = "[D0 -> K- pi+ ]cc"
StdMCD02KPi.MotherCut = matchD02KPi
#StdMCD02KPi.DaughtersCuts = {
# "K+" : matchKaons,
# "pi+" : matchPions
# }
StdMCD02KPi.Preambulo = [
"from LoKiPhysMC.decorators import *", "from PartProp.Nodes import CC"
]
locations.update(updateDoD(StdMCD02KPi))
StdMCD02KK = CombineParticles('StdMCD02KK')
StdMCD02KK.Inputs = [npkaons]
StdMCD02KK.DecayDescriptor = "[D0 -> K- K+ ]cc"
StdMCD02KK.MotherCut = matchD02KK
matchPizeroes = "mcMatch('pi0')"
#matchKshorts = "mcMatch('[KS0]cc')"
#Create matching strings
matchD02KKPiPi = "(mcMatch('[D0 ==> K+ K- pi+ pi-]CC'))"
matchD02KsKK = "(mcMatch('[D0 ==> KS0 K+ K-]CC'))"
matchD02KsPiPi = "(mcMatch('[D0 ==> KS0 pi+ pi-]CC'))"
matchD02KKAnyPi0 = "(mcMatch('[D0 ==> K- K+ {pi0}]CC'))"
matchD02KKPi0 = "(mcMatch('[D0 ==> K- K+ pi0]CC'))"
matchD02KPiAnyPi0 = "(mcMatch('[D0 ==> K- pi+ {pi0}]CC'))"
matchD02KPiPi0 = "(mcMatch('[D0 ==> K- pi+ pi0]CC'))"
#Algorithms
StdMCD02KKPiPi=CombineParticles ('StdMCD02KKPiPi')
StdMCD02KKPiPi.Inputs = [ npkaons, nppions]
StdMCD02KKPiPi.DecayDescriptor = "[D0 -> K+ K- pi+ pi-]cc"
StdMCD02KKPiPi.MotherCut = matchD02KKPiPi
#StdMCD02KKPiPi.DaughtersCuts = {
# "K+" : matchKaons,
# "pi+" : matchPions
# }
StdMCD02KKPiPi.Preambulo = [
"from LoKiPhysMC.decorators import *",
"from PartProp.Nodes import CC" ]
locations.update(updateDoD ( StdMCD02KKPiPi ))
#Algorithms
StdMCD02KsKK=CombineParticles ('StdMCD02KsKK')
StdMCD02KsKK.Inputs = [ npkaons, mcksll, mcksdd]
StdMCD02KsKK.DecayDescriptor = "[D0 -> KS0 K+ K-]cc"
"""
Configuration file for 'Standard Tight Dplus'"""
__author__ = "Sandra Amato"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.8 $"
# =============================================================================
__all__ = (
'StdTightDplus2KPiPiOppSignPi' ,
'StdVeryTightDsplus2KKPi',
'locations'
)
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
StdTightDplus2KPiPiOppSignPi = CombineParticles ( 'StdTightDplus2KPiPiOppSignPi')
StdTightDplus2KPiPiOppSignPi.Inputs = [ "Phys/StdLooseKaons/Particles",
"Phys/StdLoosePions/Particles" ]
StdTightDplus2KPiPiOppSignPi.DecayDescriptor = "[D+ -> pi- pi+ K+]cc"
StdTightDplus2KPiPiOppSignPi.DaughtersCuts = {
"K+" : "(P > 2*GeV) & ((PIDK-PIDpi) > 7.)",
"pi+" : "(P > 2*GeV) & ((PIDK-PIDpi) < 3.)"
}
StdTightDplus2KPiPiOppSignPi.CombinationCut = "((AM>1760.*MeV) & (AM<2080.*MeV) & ((APT>1.*GeV) | (ASUM(PT)>1.*GeV)) & (ADOCAMAX('')<0.5*mm))"
StdTightDplus2KPiPiOppSignPi.MotherCut = "((VFASPF(VCHI2) < 30 ) & (M>1770.*MeV) & (M < 2070.*MeV) & (BPVVDCHI2>36) & (BPVDIRA>0.98))"
locations = updateDoD ( StdTightDplus2KPiPiOppSignPi )
## ===========================================================================
StdVeryTightDsplus2KKPi = CombineParticles( 'StdVeryTightDsplus2KKPi' )
StdVeryTightDsplus2KKPi.Inputs = [ "Phys/StdLooseKaons/Particles", "Phys/StdLoosePions/Particles" ]
StdVeryTightDsplus2KKPi.DecayDescriptor = "[D_s+ -> K- K+ pi+]cc"
Configuration file for 'Standard Loose '
"""
__author__ = "Patrick Koppenburg"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.3 $"
# =============================================================================
__all__ = ('StdLooseRho0', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
StdLooseRho0 = CombineParticles('StdLooseRho0')
StdLooseRho0.Inputs = ["Phys/StdLoosePions/Particles"]
StdLooseRho0.DecayDescriptor = "[rho(770)0 -> pi+ pi-]cc"
StdLooseRho0.CombinationCut = "(ADAMASS('rho(770)0')<100*MeV)& (ADOCACHI2CUT(15, ''))"
StdLooseRho0.MotherCut = "(BPVVDZ>0) & (VFASPF(VCHI2)<9) & (BPVDIRA>0.95) & (BPVVDCHI2>25)"
## configure Data-On-Demand service
locations = updateDoD(StdLooseRho0)
## ============================================================================
if '__main__' == __name__:
print __doc__
print __author__
print __version__
print locationsDoD(locations)
"""
__author__ = "Roel Aaij"
__version__ = ""
# =============================================================================
__all__ = (
'StdMassConstrainedJpsi2MuMu' ,
'locations'
)
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
StdMassConstrainedJpsi2MuMu = CombineParticles("StdMassConstrainedJpsi2MuMu")
StdMassConstrainedJpsi2MuMu.Inputs = ["Phys/StdAllLooseMuons/Particles"]
StdMassConstrainedJpsi2MuMu.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
StdMassConstrainedJpsi2MuMu.DaughtersCuts = { 'mu+' : '(PIDmu > 0) & (PT > 0.5*GeV)' }
StdMassConstrainedJpsi2MuMu.CombinationCut = "(ADAMASS('J/psi(1S)') < 80.*MeV) & (ADOCACHI2CUT(20, ''))"
StdMassConstrainedJpsi2MuMu.MotherCut = "(VFASPF(VCHI2) < 16.) & (MFIT)"
## configure Data-On-Demand service
locations = updateDoD ( StdMassConstrainedJpsi2MuMu )
## ============================================================================
if '__main__' == __name__ :
print __doc__
print __author__
print __version__
print locationsDoD ( locations )
Configuration file for 'Standard Tight Detached Tau'
"""
__author__ = "Donal Hill, Conor Fitzpatrick, Christian Elsasser"
__version__ = "CVS tag $Name: not supported by cvs2svn $, version $Revision: 1.0 $"
# =============================================================================
__all__ = ('StdTightDetachedTau3pi', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm - physical tau+ -> pi+ pi- pi+
StdTightDetachedTau3pi = CombineParticles('StdTightDetachedTau3pi')
StdTightDetachedTau3pi.Inputs = ["Phys/StdLoosePions/Particles"]
#Build physical tau and tau+++
StdTightDetachedTau3pi.DecayDescriptors = ["[tau+ -> pi+ pi- pi+]cc"]
StdTightDetachedTau3pi.DaughtersCuts = {
"pi+":
"(PT>250.*MeV) & (P>2000.*MeV) & (MIPCHI2DV(PRIMARY) > 16.0) & (TRCHI2DOF<4) & (TRGHOSTPROB<0.4) & (PROBNNpi > 0.55)",
"pi-":
"(PT>250.*MeV) & (P>2000.*MeV) & (MIPCHI2DV(PRIMARY) > 16.0) & (TRCHI2DOF<4) & (TRGHOSTPROB<0.4) & (PROBNNpi > 0.55)"
}
StdTightDetachedTau3pi.CombinationCut = "(APT>800.*MeV) & ((AM>400.*MeV) & (AM<2100.*MeV)) & (AMAXDOCA('')<0.2*mm) & (ANUM(PT > 800*MeV) >= 1) "
StdTightDetachedTau3pi.MotherCut = "(PT>1000.*MeV) & (M>500.*MeV) & (M<2000.*MeV) & (BPVDIRA>0.99) & (VFASPF(VCHI2) < 16) & (BPVVDCHI2>16) & (BPVVDRHO>0.1*mm) & (BPVVDRHO<7.0*mm) & (BPVVDZ>5.0*mm)"
## configure Data-On-Demand service
locations = updateDoD(StdTightDetachedTau3pi)
# =============================================================================
"""
Configuration file for 'Standard Loose Lambdastar'. Useful for R_Lambda(*)
"""
__author__ = "Yasmine Amhis"
# =============================================================================
__all__ = ('StdLooseLambdastar2pK', 'locations')
# =============================================================================
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
## ============================================================================
## create the algorithm
StdLooseLambdastar2pK = CombineParticles("StdLooseLambdastar2pK")
StdLooseLambdastar2pK.Inputs = [
"Phys/StdAllLooseKaons/Particles", "Phys/StdAllLooseProtons/Particles"
]
StdLooseLambdastar2pK.DecayDescriptor = "[Lambda(1520)0 -> p+ K-]cc"
StdLooseLambdastar2pK.CombinationCut = "(AM < 2600.*MeV) & (ADOCACHI2CUT(30, ''))"
StdLooseLambdastar2pK.MotherCut = "(VFASPF(VCHI2) < 25.)"
## configure Data-On-Demand service
locations = updateDoD(StdLooseLambdastar2pK)
## ============================================================================
if '__main__' == __name__:
print __doc__
print __author__
print __version__
print locationsDoD(locations)
#matchKaons = "mcMatch('[K+]cc')"
#matchPions = "mcMatch('[pi+]cc')"
locations={}
#Create matching strings
matchDpKPiPi = "(mcMatch('[D- ==> K+ pi- pi-]CC'))"
matchDpKKPi = "(mcMatch('[D+ ==> K+ K+ pi-]CC'))"
matchDpPiPiPi = "(mcMatch('[D+ ==> pi- pi+ pi+]CC'))"
matchDpKKK = "(mcMatch('[D+ ==> K- K+ K+]CC'))"
matchDpKPiPiOppSignPi = "(mcMatch('[D- ==> K- pi+ pi-]CC'))"
matchDpKKPiOppSignK = "(mcMatch('[D- ==> K- K+ pi-]CC'))"
#Algorithms
StdMCDplus2KPiPi=CombineParticles ('StdMCDplus2KPiPi')
StdMCDplus2KPiPi.Inputs = [ npkaons, nppions]
StdMCDplus2KPiPi.DecayDescriptor = "[D+ -> K- pi+ pi+]cc"
StdMCDplus2KPiPi.MotherCut = matchDpKPiPi
#StdMCDplus2KPiPi.DaughtersCuts = {
# "K+" : matchKaons,
# "pi+" : matchPions
# }
StdMCDplus2KPiPi.Preambulo = [
"from LoKiPhysMC.decorators import *",
"from PartProp.Nodes import CC" ]
locations.update( updateDoD ( StdMCDplus2KPiPi ) )
StdMCDplus2KKPi=CombineParticles ('StdMCDplus2KKPi')
StdMCDplus2KKPi.Inputs = [ npkaons, nppions]
StdMCDplus2KKPi.DecayDescriptor = "[D+ -> K+ K+ pi-]cc"
__author__ = 'Rob Lambert'
__date__ = '07/07/2009'
from Gaudi.Configuration import *
from Configurables import CombineParticles
from CommonParticles.Utils import *
import GaudiKernel.SystemOfUnits as Units
###########################
# StdLooseDiMuon #
###########################
StdVeryLooseDiMuon = CombineParticles("StdVeryLooseDiMuon")
StdVeryLooseDiMuon.DecayDescriptor = "J/psi(1S) -> mu+ mu-"
StdVeryLooseDiMuon.Inputs = ["Phys/StdAllVeryLooseMuons/Particles"]
StdVeryLooseDiMuon.CombinationCut = "(ADAMASS('J/psi(1S)') < 3000.*MeV) & (ADOCACHI2CUT(30, ''))"
StdVeryLooseDiMuon.MotherCut = "(VFASPF(VCHI2) < 25.)"
locations = updateDoD(StdVeryLooseDiMuon)
## ============================================================================
if '__main__' == __name__ :
print __doc__
print __author__
print __version__
print locationsDoD ( locations )
