def __init__(self, name, config): LineBuilder.__init__(self, name, config) self.__confdict__ = config ####################### BASIC FINAL STATE PARTICLE SELECTIONS ########################## self.HadronCuts = "(P>%(HadronP)s) & (PT > %(HadronPT)s )"\ "& (TRCHI2DOF < %(TRCHI2)s)"\ "& (TRGHOSTPROB < %(TRGHOSTPROB)s)"\ "& (MIPCHI2DV(PRIMARY)> %(HadronIPCHI2)s)" % config self.MuonTrackCuts = "(PT > %(MuonPT)s ) & (P> %(MuonP)s)"\ "& (TRCHI2DOF < %(TRCHI2)s)"\ "& (TRGHOSTPROB < %(TRGHOSTPROB)s)"\ "& (MIPCHI2DV(PRIMARY)> %(MuonIPCHI2)s)" %config inputs = { "muons": StdLooseMuons, "pions": StdLoosePions, "kaons": StdLooseKaons, "protons": StdLooseProtons, "electrons": StdLooseElectrons, "fakemuons": StdNoPIDsMuons } if config["UseNoPIDsInputs"] == True: inputs["muons"] = StdNoPIDsMuons inputs["pions"] = StdNoPIDsPions inputs["kaons"] = StdNoPIDsKaons inputs["protons"] = StdNoPIDsProtons self.cuts = {"muons":self.MuonTrackCuts + " & (PIDmu > %(MuonPIDmu)s)" % config, "fakemuons":self.MuonTrackCuts + " & (INMUON) & (PIDmu < %(MuonPIDmu)s)" % config, "kaons":self.HadronCuts + " & (P>%(KaonP)s) & (PIDK> %(KaonPIDK)s)" % config, "pions":self.HadronCuts + " & (PIDK< %(PionPIDK)s)" % config, "protons":self.HadronCuts + "& (P>%(ProtonP)s)"\ "& (PIDp > %(ProtonPIDp)s) & (PIDp-PIDK > %(ProtonPIDpK)s)" % config, "electrons":self.MuonTrackCuts + " & (PT> %(ElectronPT)s) & (PIDe > %(ElectronPIDe)s)" % config } self.selMuon = Selection( "Mufor" + name, Algorithm=FilterDesktop(Code=self.cuts["muons"]), RequiredSelections=[inputs["muons"]]) self.selKaon = Selection( "Kfor" + name, Algorithm=FilterDesktop(Code=self.cuts["kaons"]), RequiredSelections=[inputs["kaons"]]) self.selPion = Selection( "Pifor" + name, Algorithm=FilterDesktop(Code=self.cuts["pions"]), RequiredSelections=[inputs["pions"]]) self.selProton = Selection( "ProtonsFor" + name, Algorithm=FilterDesktop(Code=self.cuts["protons"]), RequiredSelections=[inputs["protons"]]) self.selElectron = Selection( "efor" + name, Algorithm=FilterDesktop(Code=self.cuts["electrons"]), RequiredSelections=[inputs["electrons"]]) self.selMuonFakes = Selection( "FakeMuonsFor" + name, Algorithm=FilterDesktop(Code=self.cuts["fakemuons"]), RequiredSelections=[inputs["fakemuons"]]) D0_CONFIG = config.copy() D0_CONFIG[ "CharmComboCuts"] = "(ADAMASS('D0') < %(D_AMassWin)s )" % config D0_CONFIG[ "CharmMotherCuts"] = "(ADMASS('D0') < %(D_MassWin)s )" % config Dp_CONFIG = config.copy() Dp_CONFIG["CharmComboCuts"] = "(DAMASS('D_s+') < %(D_AMassWin)s )"\ "& (DAMASS('D+')> -%(D_AMassWin)s )" %config Dp_CONFIG["CharmMotherCuts"] = "(DMASS('D_s+') < %(D_MassWin)s )"\ "& (DMASS('D+')> -%(D_AMassWin)s )" %config Lc_CONFIG = config.copy() Lc_CONFIG[ "CharmComboCuts"] = "(ADAMASS('Lambda_c+') < %(D_AMassWin)s )" % config Lc_CONFIG[ "CharmMotherCuts"] = "(ADMASS('Lambda_c+') < %(D_MassWin)s )" % config Xic_CONFIG = config.copy() Xic_CONFIG[ "CharmComboCuts"] = "(ADAMASS('Xi_c+') < %(D_AMassWin)s )" % config Xic_CONFIG[ "CharmMotherCuts"] = "(ADMASS('Xi_c+') < %(D_MassWin)s )" % config Omegac_CONFIG = config.copy() Omegac_CONFIG["CharmComboCuts"] = "((ADAMASS('Omega_c0') < %(D_AMassWin)s )"\ "|(ADAMASS('Xi_c+') < %(D_AMassWin)s ))" % config Omegac_CONFIG["CharmMotherCuts"] = "((ADMASS('Omega_c0') < %(D_MassWin)s )"\ "|(ADMASS('Xi_c+') < %(D_MassWin)s ))" % config self.b2D0MuXLine = BtoDlnuLine( name, 'D0', ['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], ['[D0 -> K- pi+]cc'], D0_CONFIG, [self.selKaon, self.selPion], self.selMuon, self.selMuonFakes) self.b2D0eXLine = BtoDlnuLine(name, 'D0e', ['[B- -> D0 e-]cc'], ['[D0 -> K- pi+]cc'], D0_CONFIG, [self.selKaon, self.selPion], self.selElectron) self.b2D0MuXKKLine = BtoDlnuLine( name, 'D0toKK', ['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], ['D0 -> K- K+'], D0_CONFIG, [self.selKaon], self.selMuon) self.b2D0MuXpipiLine = BtoDlnuLine( name, 'D0topipi', ['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], ['D0 -> pi- pi+'], D0_CONFIG, [self.selPion], self.selMuon) self.b2DpMuXLine = BtoDlnuLine( name, 'Dp', ['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'], ['[D+ -> K- pi+ pi+]cc'], Dp_CONFIG, [self.selKaon, self.selPion], self.selMuon, self.selMuonFakes) self.b2DsMuXLine = BtoDlnuLine( name, 'Ds', ['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'], ['[D+ -> K+ K- pi+]cc'], Dp_CONFIG, [self.selKaon, self.selPion], self.selMuon, self.selMuonFakes) self.lb2LcMuXLine = BtoDlnuLine(name, "Lc", [ '[Lambda_b0 -> Lambda_c+ mu-]cc', '[Lambda_b0 -> Lambda_c+ mu+]cc' ], ['[Lambda_c+ -> K- p+ pi+]cc' ], Lc_CONFIG, [self.selProton, self.selKaon, self.selPion], self.selMuon, self.selMuonFakes) self.Xic_Line = BtoDlnuLine( name, "Xic", ['[Xi_b0 -> Xi_c+ mu-]cc', '[Xi_b0 -> Xi_c+ mu+]cc'], ['[Xi_c+ -> K- p+ pi+]cc'], Xic_CONFIG, [self.selProton, self.selKaon, self.selPion], self.selMuon, self.selMuonFakes) self.Omegac_Line = BtoDlnuLine( name, "Omegac", ['[Omega_b- -> Omega_c0 mu-]cc', '[Omega_b- -> Omega_c0 mu+]cc'], ['[Omega_c0 -> p+ K- K- pi+]cc'], Omegac_CONFIG, [self.selProton, self.selKaon, self.selPion], self.selMuon, self.selMuonFakes) ##### line registration self.registerLine(self.b2D0eXLine) for Mu in ["RealMuon", "FakeMuon"]: self.registerLine(self.b2D0MuXLine[Mu]) self.registerLine(self.b2DpMuXLine[Mu]) self.registerLine(self.b2DsMuXLine[Mu]) self.registerLine(self.lb2LcMuXLine[Mu]) self.registerLine(self.Omegac_Line[Mu]) self.registerLine(self.Xic_Line[Mu])
def createSubSel( self, OutputList, InputList, Cuts ) : '''create a selection using a FilterDesktop''' filter = FilterDesktop(Code = Cuts) return Selection( OutputList, Algorithm = filter, RequiredSelections = [ InputList ] )
'pi-': '(PT > 750*MeV) & (P > 4000*MeV) & (MIPCHI2DV(PRIMARY) > 4)', 'K+': '(PT > 750*MeV) & (P > 4000*MeV) & (MIPCHI2DV(PRIMARY) > 4)' } d0_comb = "(AMAXDOCA('') < 0.2*mm) & (ADAMASS('D0') < 100*MeV)" # We can split long selections across multiple lines d0_vertex = ('(VFASPF(VCHI2/VDOF)< 9)' '& (BPVDIRA > 0.9997)' "& (ADMASS('D0') < 70*MeV)") d0 = CombineParticles('Combine_D0', DecayDescriptor='([D0 -> pi- K+]CC)', DaughtersCuts=d0_decay_products, CombinationCut=d0_comb, MotherCut=d0_vertex) d0_sel = Selection('Sel_D0', Algorithm=d0, RequiredSelections=[Pions, Kaons]) dstar_decay_products = {'pi+': '(TRCHI2DOF < 3) & (PT > 100*MeV)'} dstar_comb = "(ADAMASS('D*(2010)+') < 400*MeV)" dstar_vertex = ("(abs(M-MAXTREE('D0'==ABSID,M)-145.42) < 10*MeV)" '& (VFASPF(VCHI2/VDOF)< 9)') dstar_sel = SimpleSelection('Sel_Dstar', ConfigurableGenerators.CombineParticles, [d0_sel, Pions], DecayDescriptor='[D*(2010)+ -> D0 pi+]cc', DaughtersCuts=dstar_decay_products, CombinationCut=dstar_comb, MotherCut=dstar_vertex) dstar_seq = SelectionSequence('Dstar_Seq', TopSelection=dstar_sel)
def GammaEE(self, Name, eDLLe, GammaEEChi2, GammaEEMass, GammaEETau): # cuts daughterCut = "PIDe > %(eDLLe)s" % locals() motherCut = "(VFASPF(VCHI2/VDOF)<%(GammaEEChi2)s) & (MM < %(GammaEEMass)s*MeV) & (abs(BPVLTIME()) < %(GammaEETau)s*ps )" % locals( ) # imports from Configurables import NoPIDsParticleMaker from CommonParticles.Utils import trackSelector, updateDoD from PhysSelPython.Wrappers import MergedSelection # # setup electrons # # TTrack electrons not OK yet ? algorithm = NoPIDsParticleMaker('StdNoPIDsTtrackElectrons', DecayDescriptor='Electron', Particle='electron') algorithm.AddBremPhotonTo = [] selector = trackSelector(algorithm, trackTypes=["Ttrack"]) locations = updateDoD(algorithm) StdNoPIDsTtrackElectrons = algorithm # switch off Bremsstrahlung correction until fully tuned algorithm = NoPIDsParticleMaker('StdAllNoPIDsElectrons', DecayDescriptor='Electron', Particle='electron') algorithm.AddBremPhotonTo = [] algorithm = NoPIDsParticleMaker('StdNoPIDsUpElectrons', DecayDescriptor='Electron', Particle='electron') algorithm.AddBremPhotonTo = [] algorithm = NoPIDsParticleMaker('StdNoPIDsDownElectrons', DecayDescriptor='Electron', Particle='electron') algorithm.AddBremPhotonTo = [] # all required electrons from CommonParticles import StdNoPIDsDownElectrons, StdNoPIDsUpElectrons, StdNoPIDsVeloElectrons eLong = DataOnDemand('Phys/StdAllNoPIDsElectrons/Particles') eUp = DataOnDemand('Phys/StdNoPIDsUpElectrons/Particles') eDown = DataOnDemand('Phys/StdoPIDsDownElectrons/Particles') eTtrack = DataOnDemand('Phys/StdNoPIDsTtrackElectrons/Particles') allElectrons = MergedSelection( 'allElectrons', RequiredSelections=[eLong, eUp, eDown, eTtrack]) from GaudiConfUtils.ConfigurableGenerators import FilterDesktop electronFilter = FilterDesktop(Code=daughterCut) myElectrons = Selection(Name + '_MuonSel', Algorithm=electronFilter, RequiredSelections=[allElectrons]) ConvFind = CombineParticles(DecayDescriptor="KS0 -> e+ e-", CombinationCut="(AM>0*MeV)", MotherCut=motherCut) #ConvFind.DecayDescriptor = "KS0 -> e+ e-" #ConvFind.DaughtersCuts = {"e+" : "ALL" } #ConvFind.CombinationCut = "(AM>0*MeV)" #ConvFind.MotherCut = motherCut GammaEESel = Selection(Name + "_GammaEESel", Algorithm=ConvFind, RequiredSelections=[myElectrons]) return GammaEESel
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self.__confdict__ = config self.selmuon = Selection("Mufor" + name, Algorithm=self._muonFilter(), RequiredSelections=[StdLooseMuons]) self.selmuonhighPT = Selection( "MuhighPTfor" + name, Algorithm=FilterDesktop( Code= "(TRCHI2DOF < %(TRCHI2)s) & (PT>1.2*GeV) & (MIPCHI2DV(PRIMARY)> 9.0)" % self.__confdict__), RequiredSelections=[self.selmuon]) self.selmuontight = Selection( "Mutightfor" + name, Algorithm=FilterDesktop(Code="(MIPCHI2DV(PRIMARY)> 100)"), RequiredSelections=[self.selmuonhighPT]) self.selmuonnew = Selection( "Munewfor" + name, Algorithm=FilterDesktop( Code="(MIPCHI2DV(PRIMARY)> 9.0) & (TRCHI2DOF < %(TRCHI2)s)" % self.__confdict__), RequiredSelections=[self.selmuon]) self.selmuonTOS = TOSFilter("MuTOS" + name, self.selmuontight, "Hlt2SingleMuonDecision") self.selKaon = Selection("Kfor" + name, Algorithm=self._kaonFilter(), RequiredSelections=[StdLooseKaons]) self.selPion = Selection("Pifor" + name, Algorithm=self._pionFilter(), RequiredSelections=[StdLoosePions]) self.selPionloose = Selection("Piloosefor" + name, Algorithm=self._pionlooseFilter(), RequiredSelections=[StdLoosePions]) self.selKaonloose = Selection("Kloosefor" + name, Algorithm=self._kaonlooseFilter(), RequiredSelections=[StdLooseKaons]) self.selphi2kk = Selection("Phi2KKfor" + name, Algorithm=self._Phi2KKFilter(), RequiredSelections=[self.selKaonloose]) self.seld02kpi = Selection( "D02KPifor" + name, Algorithm=self._D02KPiFilter(), RequiredSelections=[self.selKaon, self.selPion]) self.seld02kk = Selection("D02KKfor" + name, Algorithm=self._D02KKFilter(), RequiredSelections=[self.selKaon]) self.seld02k3pi = Selection( "D02K3Pifor" + name, Algorithm=self._D02K3PiFilter(), RequiredSelections=[self.selKaon, StdLoosePions]) self.seldp2kpipi = Selection( "Dp2KPiPifor" + name, Algorithm=self._Dp2KPiPiFilter(), RequiredSelections=[self.selKaon, self.selPion]) self.selds2kkpi = Selection( "Ds2KKPifor" + name, Algorithm=self._Ds2KKPiFilter(), RequiredSelections=[self.selKaon, self.selPion]) self.sellambdac = Selection( "Lc2PKPifor" + name, Algorithm=self._Lc2PKPiFilter(), RequiredSelections=[self.selKaon, self.selPion, StdLooseProtons]) self.selds2phipi = Selection( "Ds2PhiPifor" + name, Algorithm=self._Ds2PhiPiFilter(), RequiredSelections=[self.selphi2kk, self.selPionloose]) self.selb2D0MuX = makeb2DMuX( 'b2D0MuX' + name, DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], MuSel=self.selmuonhighPT, DSel=self.seld02kpi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2D0MuXKK = makeb2DMuX( 'b2D0MuXKK' + name, DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], MuSel=self.selmuon, DSel=self.seld02kk, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2D0MuXK3Pi = makeb2DMuX( 'b2D0MuXK3Pi' + name, DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], MuSel=self.selmuonTOS, DSel=self.seld02k3pi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2DpMuX = makeb2DMuX( 'b2DpMuX' + name, DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'], MuSel=self.selmuonnew, DSel=self.seldp2kpipi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2DsMuX = makeb2DMuX( 'b2DsMuX' + name, DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'], MuSel=self.selmuonnew, DSel=self.selds2kkpi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2LcMuX = makeb2DMuX('b2LcMuX' + name, DecayDescriptors=[ '[Lambda_b0 -> Lambda_c+ mu-]cc', '[Lambda_b0 -> Lambda_c+ mu+]cc' ], MuSel=self.selmuonnew, DSel=self.sellambdac, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2DsMuXPhiPi = makeb2DMuX( 'b2DsMuXPhiPi' + name, DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'], MuSel=self.selmuon, DSel=self.selds2phipi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.b2D0MuXLine = StrippingLine( 'b2D0MuX' + name + 'Line' #, HLT = " HLT_PASS_RE('Hlt.*(Muon|MuTrack).*Decision') " , prescale=config['PrescalD0Mu'], selection=self.selb2D0MuX) self.b2D0MuXKKLine = StrippingLine('b2D0MuXKK' + name + 'Line', prescale=1, selection=self.selb2D0MuXKK) self.b2D0MuXK3PiLine = StrippingLine('b2D0MuXK3Pi' + name + 'Line', prescale=1, selection=self.selb2D0MuXK3Pi) self.b2DpMuXLine = StrippingLine('b2DpMuX' + name + 'Line', prescale=1, selection=self.selb2DpMuX) self.b2DsMuXLine = StrippingLine('b2DsMuX' + name + 'Line', prescale=1, selection=self.selb2DsMuX) self.b2LcMuXLine = StrippingLine('b2LcMuX' + name + 'Line', prescale=1, selection=self.selb2LcMuX) self.b2DsMuXPhiPiLine = StrippingLine('b2DsMuXPhiPi' + name + 'Line', prescale=1, selection=self.selb2DsMuXPhiPi) self.registerLine(self.b2D0MuXLine) self.registerLine(self.b2DpMuXLine) self.registerLine(self.b2DsMuXLine) self.registerLine(self.b2LcMuXLine) self.registerLine(self.b2D0MuXK3PiLine) self.registerLine(self.b2D0MuXKKLine) self.registerLine(self.b2DsMuXPhiPiLine)
def applyBDT( self, name, config): if "DD" in name: _FilterB2KShh = FilterDesktop( Code = "FILTER('B2KShhBDTSelection/B2KShhBDTDD')" ) if "SameSign" in name: self.selB2KSDDhhBDTCut_SameSign = Selection( name, Algorithm = _FilterB2KShh, RequiredSelections = [ self.selB2KSLDhh_SameSign ] ) else: self.selB2KSDDhhBDTCut = Selection( name, Algorithm = _FilterB2KShh, RequiredSelections = [ self.selB2KSDDhh ] ) """ Name is special here, since this is the last algorithm, whose name seems to be the one of the stripping line.... """ from Configurables import B2KShhBDTSelection MyBDT = B2KShhBDTSelection( name + "Line.B2KShhBDTDD" ) MyBDT.BDTCut = config["DD_BDTCutValue"] MyBDT.WeightsFile = config["DD_BDTWeightsFile"] MyBDT.typeKS = "DD" elif "LL" in name: _FilterB2KShh = FilterDesktop( Code = "FILTER('B2KShhBDTSelection/B2KShhBDTLL')" ) if "SameSign" in name: self.selB2KSLLhhBDTCut_SameSign = Selection( name, Algorithm = _FilterB2KShh, RequiredSelections = [ self.selB2KSLLhh_SameSign ] ) else: self.selB2KSLLhhBDTCut = Selection( name, Algorithm = _FilterB2KShh, RequiredSelections = [ self.selB2KSLLhh ] ) """ Name is special here, since this is the last algorithm, whose name seems to be the one of the stripping line.... """ from Configurables import B2KShhBDTSelection MyBDT = B2KShhBDTSelection( name + "Line.B2KShhBDTLL" ) MyBDT.BDTCut = config["LL_BDTCutValue"] MyBDT.WeightsFile = config["LL_BDTWeightsFile"] MyBDT.typeKS = "LL" elif "LD" in name: _FilterB2KShh = FilterDesktop( Code = "FILTER('B2KShhBDTSelection/B2KShhBDTLD')" ) if "SameSign" in name: self.selB2KSLDhhBDTCut_SameSign = Selection( name, Algorithm = _FilterB2KShh, RequiredSelections = [ self.selB2KSLDhh_SameSign ] ) else: self.selB2KSLDhhBDTCut = Selection( name, Algorithm = _FilterB2KShh, RequiredSelections = [ self.selB2KSLDhh ] ) """ Name is special here, since this is the last algorithm, whose name seems to be the one of the stripping line.... """ from Configurables import B2KShhBDTSelection MyBDT = B2KShhBDTSelection( name + "Line.B2KShhBDTLD" ) MyBDT.BDTCut = config["LD_BDTCutValue"] MyBDT.WeightsFile = config["LD_BDTWeightsFile"] MyBDT.typeKS = "LD" else: print "\nHelp!! 'name' variable didn't have 'LL', 'LD' or 'DD' in it!\n"
def test_clone_sequence(): _sel00 = AutomaticData(Location='Phys/Sel00') _sel01 = AutomaticData(Location='Phys/Sel01') _sel02 = AutomaticData(Location='Phys/Sel02') _sel03 = AutomaticData(Location='Phys/Sel03') sel01 = Selection('00120', Algorithm=MockConfGenerator(), RequiredSelections=[_sel00, _sel01]) sel02 = Selection('00121', Algorithm=MockConfGenerator(), RequiredSelections=[_sel02, _sel03]) sel03 = Selection('00122', Algorithm=MockConfGenerator(), RequiredSelections=[sel01, sel02]) presel0 = MockConfGenerator() presel1 = MockConfGenerator() postsel0 = MockConfGenerator() postsel1 = MockConfGenerator() presels = [presel0, presel1] postsels = [postsel0, postsel1] seq = SelectionSequence('Seq03', TopSelection=sel03, EventPreSelector=presels, PostSelectionAlgs=postsels, sequencerType=DummySequencer) clone = seq.clone(name='clone') seqAlgos = clone.sequence().Members ref_algos = [ presel0, presel1, _sel00.algorithm(), _sel01.algorithm(), _sel02.algorithm(), _sel03.algorithm(), sel02.algorithm(), sel01.algorithm(), sel03.algorithm(), postsel0, postsel1 ] assert len(seqAlgos) == len(ref_algos) assert presels == seqAlgos[:len(presels)] assert postsels == seqAlgos[len(ref_algos) - len(postsels):] # sel03 must come just before the post selection algos. assert sel03.algorithm() == ref_algos[len(ref_algos) - (len(presels) + 1)] # order of sel01 and sel02 doesn't matter. for sel in [sel01, sel02]: assert sel.algorithm() in ref_algos[len(presels):len(ref_algos) - len(postsels)] seqAlgos = seq.algorithms() assert len(seqAlgos) == len(ref_algos) assert presels == seqAlgos[:len(presels)] assert postsels == seqAlgos[len(ref_algos) - len(postsels):] for sel in [sel01, sel02, sel03]: assert sel.algorithm() in ref_algos[len(presels):len(ref_algos) - len(postsels)]
def filterSelection(name, code, inputs): return Selection(name + 'Beauty2CharmFilter', Algorithm=FilterDesktop(Code=code), RequiredSelections=inputs)
def _pionFilter(self): _pi = FilterDesktop(Code=self._NominalPiSelection() % self._config) return Selection("Pi_for" + self._name, Algorithm=_pi, RequiredSelections=[StdLoosePions])
def _kaonFilter(self): _ka = FilterDesktop(Code=self._NominalKSelection() % self._config) return Selection("K_for" + self._name, Algorithm=_ka, RequiredSelections=[StdLooseKaons])
def _muonFilter(self): _mu = FilterDesktop(Code=self._NominalMuSelection() % self._config) return Selection("Mu_for" + self._name, Algorithm=_mu, RequiredSelections=[StdLooseMuons])
def makeFilter(name, _input, _preambulo, _code): _filter = FilterDesktop(Preambulo=[_preambulo], Code=_code) return Selection(name, Algorithm=_filter, RequiredSelections=[_input])
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self.__confdict__ = config ######### self.dauPions = Selection( "dauPifor" + name, Algorithm=FilterDesktop( Code= "(TRGHOSTPROB < %(GHOSTPROB_MAX)s) & (PIDK < %(PionPIDK)s) & (MIPCHI2DV(PRIMARY)> %(dau_MIPCHI2DV)s) & (TRCHI2DOF < %(TRCHI2)s) & (PT > %(dau_PT_MIN)s *MeV)" % config), RequiredSelections=[StdLoosePions]) self.dauKaons = Selection( "dauKfor" + name, Algorithm=FilterDesktop( Code= "(TRGHOSTPROB < %(GHOSTPROB_MAX)s) & (PIDK > %(KaonPIDK)s) & (MIPCHI2DV(PRIMARY)> %(dau_MIPCHI2DV)s) & (TRCHI2DOF < %(TRCHI2)s) & (PT > %(dau_PT_MIN)s *MeV)" % config), RequiredSelections=[StdLooseKaons]) ######### self.comb_D2PiPi = CombineParticles( DecayDescriptors=['[D- -> pi- pi-]cc'], CombinationCut= "(AM+10 > %(D_MASS_MIN)s *MeV) & (AM-10 < %(D_MASS_MAX)s *MeV) & (APT+20 > %(D_PT_MIN)s *MeV) & (AMAXDOCA('') < %(D_AMAXDOCA)s *mm) & (ADOCACHI2CUT(%(D_DOCACHI2_MAX)s,''))" % config, MotherCut= "(M > %(D_MASS_MIN)s *MeV) & (M < %(D_MASS_MAX)s *MeV) & (PT > %(D_PT_MIN)s *MeV) & (BPVDIRA>0.99) & (VFASPF(VCHI2/VDOF)< %(D_VFASPF)s) & (BPVVDCHI2>%(D_BPVVDCHI2)s)" % config) self.seld2pi = Selection("D2PiPifor" + name, Algorithm=self.comb_D2PiPi, RequiredSelections=[self.dauPions]) ######### self.comb_Lc2Kpi = CombineParticles( DecayDescriptors=['[Lambda_c+ -> K- pi+]cc'], CombinationCut= "(AM+10 > %(Lc_MASS_MIN)s *MeV) & (AM-10 < %(Lc_MASS_MAX)s *MeV) & (APT+20 > %(Lc_PT_MIN)s *MeV) & (AMAXDOCA('') < %(Lc_AMAXDOCA)s *mm) & (ADOCACHI2CUT(%(Lc_DOCACHI2_MAX)s,''))" % config, MotherCut= "(M > %(Lc_MASS_MIN)s *MeV) & (M < %(Lc_MASS_MAX)s *MeV) & (PT > %(Lc_PT_MIN)s *MeV) & (BPVDIRA>0.99) & (VFASPF(VCHI2/VDOF)< %(Lc_VFASPF)s) & (BPVVDCHI2>%(Lc_BPVVDCHI2)s)" % config) self.selLc2Kpi = Selection( "LcToKpifor" + name, Algorithm=self.comb_Lc2Kpi, RequiredSelections=[self.dauKaons, self.dauPions]) ######### self.comb_a2PiPiPi = CombineParticles( DecayDescriptors=['[a_1(1260)+ -> pi+ pi- pi+]cc'], CombinationCut= "(AM+10 > %(A1_MASS_MIN)s *MeV) & (AM-10 < %(A1_MASS_MAX)s *MeV) & (APT+20 > %(A1_PT_MIN)s *MeV) & (AMAXDOCA('') < %(A1_AMAXDOCA)s *mm) & (ADOCACHI2CUT(%(D_DOCACHI2_MAX)s,''))" % config, MotherCut= "(M > %(A1_MASS_MIN)s *MeV) & (M < %(A1_MASS_MAX)s *MeV) & (PT > %(A1_PT_MIN)s *MeV) & (VFASPF(VCHI2/VDOF)< %(A1_VFASPF)s) & (BPVVDCHI2>%(A1_BPVVDCHI2)s)" % config) self.sela3pi = Selection("A2PiPiPifor" + name, Algorithm=self.comb_a2PiPiPi, RequiredSelections=[self.dauPions]) ######### self.comb_B2Dhhh = CombineParticles( DecayDescriptor='[B0 -> D- a_1(1260)+]cc', CombinationCut= "(AM+10 > %(B_MASS_MIN)s *MeV) & (AM-10 < %(B_MASS_MAX)s *MeV) & (AM-AM1+10 > %(B_D_deltamass_MIN)s *MeV) & (AM-AM1-10 < %(B_D_deltamass_MAX)s *MeV) & (APT+20 > %(B_PT_MIN)s *MeV) & (ADOCACHI2CUT(%(B_DOCACHI2_MAX)s,''))" % config, MotherCut= "(M > %(B_MASS_MIN)s *MeV) & (M < %(B_MASS_MAX)s *MeV) & (PT > %(B_PT_MIN)s *MeV) & (BPVDIRA> 0.999) & (VFASPF(VCHI2/VDOF) < %(B_VFASPF)s) & (BPVVDCHI2>%(B_BPVVDCHI2)s) & (MINTREE(((ABSID=='D+')|(ABSID=='D0')|(ABSID=='Lambda_c+')) , VFASPF(VZ))-VFASPF(VZ) > %(B_DZ)s *mm )" % config) self.selB2Dhhh = Selection( "B2Dhhh_DPiPi_for" + name, Algorithm=self.comb_B2Dhhh, RequiredSelections=[self.seld2pi, self.sela3pi]) ######### self.diPiPi = PiPiMaker("PiPi_For" + name, config, [self.dauPions], ['rho(770)0 -> pi+ pi-']) self.comb_Lb2Lchhh = CombineParticles( DecayDescriptor='[Lambda_b0 -> Lambda_c+ rho(770)0 pi-]cc', CombinationCut= "(AM+10 > %(Lb_MASS_MIN)s *MeV) & (AM-10 < %(Lb_MASS_MAX)s *MeV) & (AM-AM1+10 > %(Lb_Lc_deltamass_MIN)s *MeV) & (AM-AM1-10 < %(Lb_Lc_deltamass_MAX)s *MeV) & (AM12-AM1+10 > %(LcStar_MASS_MIN)s *MeV) & (AM12-AM1-10 < %(LcStar_MASS_MAX)s *MeV) & (APT+20 > %(Lb_PT_MIN)s *MeV) & (ADOCACHI2CUT(%(Lb_DOCACHI2_MAX)s,''))" % config, MotherCut= "(M > %(Lb_MASS_MIN)s *MeV) & (M < %(Lb_MASS_MAX)s *MeV) & (PT > %(Lb_PT_MIN)s *MeV) & (BPVDIRA> 0.999) & (VFASPF(VCHI2/VDOF) < %(Lb_VFASPF)s ) & (BPVVDCHI2>%(Lb_BPVVDCHI2)s) & (MINTREE(((ABSID=='D+')|(ABSID=='D0')|(ABSID=='Lambda_c+')) , VFASPF(VZ))-VFASPF(VZ) > %(Lb_DZ)s *mm )" % config) self.selLb2Lchhh = Selection( "Lb2Lchhh_LcKpi_for" + name, Algorithm=self.comb_Lb2Lchhh, RequiredSelections=[self.selLc2Kpi, self.diPiPi, self.dauPions]) ######### self.selB2Dhhh_tos = TOSFilter("B2Dhhh_DPiPiTOS_for" + name, self.selB2Dhhh) self.selLb2Lchhh_tos = TOSFilter("Lb2Lchhh_LcKpiTOS_for" + name, self.selLb2Lchhh) ######### GECs = { "Code": "( recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %(GEC_nLongTrk)s )" % config, "Preambulo": ["from LoKiTracks.decorators import *"] } ######### self.B2DhhhLine = StrippingLine('B2DHHHwD2PiPi' + name + 'Line', prescale=config['PreScale'], FILTER=GECs, selection=self.selB2Dhhh_tos) self.Lb2LchhhLine = StrippingLine('Lb2LcHHHwLc2KPi' + name + 'Line', prescale=config['PreScale'], FILTER=GECs, selection=self.selLb2Lchhh_tos) self.registerLine(self.B2DhhhLine) self.registerLine(self.Lb2LchhhLine)
_jpsiFilter.addTool(PlotTool("InputPlots")) _jpsiFilter.InputPlots.Histos = { "P/1000": ('momentum', 0, 150), "PT/1000": ('pt_%1%', 0, 5, 750), "M": ('mass in MeV_%1%_%2%_%3%', 2.8 * Units.GeV, 3.2 * Units.GeV) } _jpsiFilter.addTool(PlotTool("OutputPlots")) _jpsiFilter.OutputPlots.Histos = { "P/1000": ('momentum', 0, 150), "PT/1000": ('pt_%1%', 0, 5, 750), "M": ('mass in MeV_%1%_%2%_%3%', 2.8 * Units.GeV, 3.2 * Units.GeV) } # JpsiFilterSel = Selection(name='JpsiFilterSel', Algorithm=_jpsiFilter, RequiredSelections=[JpsiSel]) JpsiSeq = SelectionSequence('SeqJpsi', TopSelection=JpsiFilterSel) seq = JpsiSeq.sequence() dv = DaVinci() dv.PrintFreq = 10 dv.HistogramFile = "DVHistos_Strip.root" dv.EvtMax = -1 dv.DataType = "MC09" dv.Simulation = True dv.RedoMCLinks = False dv.UserAlgorithms = [seq] dv.InputType = 'DST' # MC09
def test_instantiate_sequencer(): sel00 = AutomaticData(Location='Phys/Sel00') sel01 = AutomaticData(Location='Phys/Sel01') alg0 = MockConfGenerator() sel = Selection('00011', Algorithm=alg0, RequiredSelections=[sel00, sel01]) seq = SelectionSequence('Seq00', TopSelection=sel)
def tisTosSelection(sel): '''Filters Selection sel to be TOS OR TIS.''' tisTosFilter = makeTISTOSFilter(sel.name()) return Selection(sel.name() + 'TISTOS', Algorithm=tisTosFilter, RequiredSelections=[sel])
"Hlt2DiMuonDetachedJPsiDecision", "Hlt2DiMuonJPsiDecision" ] #### -- B mass cut -- #### from Configurables import FilterDesktop, CombineParticles from PhysSelPython.Wrappers import AutomaticData, Selection, SelectionSequence BMassSel = AutomaticData( Location='/Event/Bhadron/Phys/B02D0PiPiD2HHBeauty2CharmLine/Particles') _bmassFilter = FilterDesktop( 'bmassFilter', Code='(M<6000.*MeV) & (BPVIPCHI2()<15) & (BPVDIRA>0.9999)') BMassFilterSel = Selection(name='BMassFilterSel', Algorithm=_bmassFilter, OutputBranch=teslocation + 'Phys', RequiredSelections=[BMassSel]) BMassSeq = SelectionSequence('SeqBMass', TopSelection=BMassFilterSel) BMassseq = BMassSeq.sequence() ### Tuple part tuple = DecayTreeTuple() tuple.RootInTES = teslocation tuple.Inputs = ['Phys/BMassFilterSel/Particles'] #tuple.Inputs = [ '/Event/Bhadron/Phys/B02D0KPiD2HHBeauty2CharmLine/Particles' ] tuple.ToolList += [ "TupleToolGeometry", "TupleToolRecoStats", "TupleToolKinematic",
def makeA1(self,name,type) : """ Prompt A1 selection Arguments: name : name of the Selection. type : 0 (prompt), 1 (simple), 2 (detached) """ A1 = CombineParticles("Combine"+name) A1.DecayDescriptor = "KS0 -> mu+ mu-" # prompt if type==0: A1.DaughtersCuts = { "mu+" : "(TRCHI2DOF < %(MuTrackChi2DoF)s ) "\ "& ( TRGHOSTPROB < %(MuGhostProb)s ) " \ "& (PT > %(MupTprompt)s * MeV ) "\ "& (MIPCHI2DV(PRIMARY)< %(MuMaxIPchi2)s )" %self.config_dict } A1.CombinationCut = "(AM < %(A1maxMass)s * MeV ) "\ "& (AMAXDOCA('')<%(A1Doca)s * mm)" %self.config_dict A1.MotherCut = "(VFASPF(VCHI2)< %(A1Vchi2)s ) "\ "& (MM < %(A1maxMass)s * MeV)" %self.config_dict # simple: tighten DOCA and Vchi2, tighten muID cut elif type==1: A1.DaughtersCuts = { "mu+" : "(TRCHI2DOF < %(MuTrackChi2DoF)s ) "\ "& ( TRGHOSTPROB < %(MuGhostProb)s ) " \ "& (PIDmu > %(MuPIDdll)s ) "\ "& (PPINFO(LHCb.ProtoParticle.MuonNShared,99999)<= %(MuNShared)s ) " %self.config_dict } A1.CombinationCut = "(AM < %(A1maxMass)s * MeV ) "\ "& (AMAXDOCA('')<%(A1DocaTight)s * mm)" %self.config_dict A1.MotherCut = "(VFASPF(VCHI2)< %(A1Vchi2Tight)s ) "\ "& (MM < %(A1maxMass)s * MeV)" %self.config_dict #detached elif type==2: #A1.addTool( OfflineVertexFitter ) #A1.ParticleCombiners.update( { "" : "OfflineVertexFitter"} ) #A1.ReFitPVs = True A1.DaughtersCuts = { "mu+" : "(TRCHI2DOF < %(MuTrackChi2DoF)s ) "\ "& (PT > %(MupTdetached)s * MeV ) "\ "& ( TRGHOSTPROB < %(MuGhostProb)s ) " \ "& (MIPCHI2DV(PRIMARY)> %(MuMinIPchi2)s )" %self.config_dict } A1.CombinationCut = "(AM < %(A1maxMass)s * MeV ) "\ "& (AMAXDOCA('')<%(A1Doca)s * mm)" %self.config_dict A1.MotherCut = "(VFASPF(VCHI2)< %(A1Vchi2)s ) "\ "& (MM < %(A1maxMass)s * MeV)" \ "& (BPVDIRA > %(A1Dira)s )" \ "& (BPVIPCHI2() < %(A1maxIPchi2)s )" \ "& (BPVVDCHI2 > %(A1FDChi2)s )" %self.config_dict _stdAllLooseMuons = DataOnDemand(Location = "Phys/StdAllLooseMuons/Particles") if self.debug_cuts: print "DEBUG - A1 cuts for type", type print A1.DaughtersCuts print A1.MotherCut print A1.CombinationCut return Selection ("Sel"+name, Algorithm = A1, RequiredSelections = [ _stdAllLooseMuons ])
def __init__(self, name, config): self.name = name LineBuilder.__init__(self, name, config) modeName = "Bu2rho0rhoPlus" ### filters ---------------------------------------------------------------------------------------- _resVoidFilter = "((CONTAINS('Phys/StdLoosePions/Particles')>0) & (CONTAINS('Phys/StdLooseResolvedPi0/Particles')>0))" _mgdVoidFilter = "((CONTAINS('Phys/StdLoosePions/Particles')>0) & (CONTAINS('Phys/StdLooseMergedPi0/Particles')>0))" _hltFilter = "( HLT_PASS_RE('Hlt1TrackAllL0Decision') & HLT_PASS_RE('Hlt2Topo[23].*Decision') )" _TisTosTaggerSpecs = {'Hlt2Topo[23].*Decision%TOS': 0} if config["isMC"]: _hltFilter = None ### build cuts ------------------------------------------------------------------------------------- _trackCuts = ( "(MIPCHI2DV(PRIMARY) > %(trMinIPChi2PV)s) & (PROBNNpi > %(trMinProbNNpi)s) & (PROBNNK < %(trMaxProbNNK)s)" " & (TRCHI2DOF < %(trMaxChi2Dof)s) & (TRGHOSTPROB < %(trMaxGhostProb)s)" ) % locals()["config"] _rhoCombMassWindow = "(AM > %(rhoCombMassMin)s) & (AM < %(rhoCombMassMax)s)" % locals( )["config"] _rho0CombCuts = _rhoCombMassWindow + " & (ADOCACHI2CUT(%(rho0DauMaxDocaChi2)s,''))" % locals( )["config"] _rho0MotherCuts = ( "(M > %(rhoMothMassMin)s) & (M < %(rhoMothMassMax)s) & (BPVVDZ > %(rho0MinDeltaZ)s) & (VFASPF(VCHI2/VDOF) < %(rho0MinVChi2Dof)s)" " & (BPVDIRA > %(rho0MinDira)s) & (BPVVDCHI2 > %(rho0MinVDisplChi2)s)" ) % locals()["config"] _rhoPResDaughtersCuts = { "pi+": "ALL", "pi0": ("(P > %(pi0ResMinP)s) & (PT > %(pi0ResMinPT)s) & (CHILD(CL,1) > %(pi0ResDauMinCL)s) & (CHILD(CL,2) > %(pi0ResDauMinCL)s)" " & (CHILD(PT,1) > %(pi0ResDauMinPT)s) & (CHILD(PT,2) > %(pi0ResDauMinPT)s)" ) % locals()["config"] } _rhoPResMotherCuts = "(M > %(rhoMothMassMin)s) & (M < %(rhoMothMassMax)s) & (PT > %(rhoPResMinPT)s)" % locals( )["config"] _BuResCombCuts = "(ADAMASS('B0') < %(BuResCombMassWindow)s)" % locals( )["config"] _BuResMotherCuts = ( "(VFASPF(VCHI2/VDOF) < %(BuResMinVChi2Dof)s) & (ADMASS('B+') < %(BuResMothMassWindow)s)" " & (BPVDIRA > %(BuResMinDira)s) & (PT > %(BuResMinPT)s)" ) % locals()["config"] _rhoPMgdDaughtersCuts = { "pi+": "ALL", "pi0": "(PT > %(pi0MgdMinPT)s)" % locals()["config"] } _rhoPMgdMotherCuts = "ALL" _BuMgdCombCuts = "(AM > %(BuMgdCombMassMin)s) & (AM < %(BuMgdCombMassMax)s)" % locals( )["config"] _BuMgdMotherCuts = ( "(M > %(BuMgdMothMassMin)s) & (M < %(BuMgdMothMassMax)s) & (VFASPF(VCHI2/VDOF) < %(BuMgdMinVChi2Dof)s)" " & (BPVDIRA > %(BuMgdMinDira)s)") % locals()["config"] _extraInfoList = [{ "Type": "ConeVariables", "ConeAngle": 1.0, "ConeNumber": 3, "Variables": ['angle', 'mult', 'ptasy'] }, { "Type": "VertexIsolation" }] ### shared particles ------------------------------------------------------------------------------- _trackFilter = FilterDesktop(Code=_trackCuts) _tracks = Selection("tracks" + self.name, Algorithm=_trackFilter, RequiredSelections=[StdLoosePions]) _rho0 = CombineParticles(DecayDescriptor="rho(770)0 -> pi+ pi-", CombinationCut=_rho0CombCuts, MotherCut=_rho0MotherCuts) _selRho0 = Selection("selRho0", Algorithm=_rho0, RequiredSelections=[_tracks]) ### resolved line ---------------------------------------------------------------------------------- _selRhoPResolved = makeRhoP("RhoPResolved", DauCuts=_rhoPResDaughtersCuts, combCuts=_rhoCombMassWindow, mothCuts=_rhoPResMotherCuts, inputSel=[_tracks, StdLooseResolvedPi0]) _selBuResolved = makeBu2rho0rhoPlus( modeName + "Resolved", combCuts=_BuResCombCuts, mothCuts=_BuResMotherCuts, inputSel=[_selRho0, _selRhoPResolved]) if config["isMC"]: self.stripCandResolved = _selBuResolved else: # self.stripCandResolved = makeTisTosSelection( _selBuResolved, _TisTosTaggerSpecs ) self.stripCandResolved = _selBuResolved self.Bu2rho0rhoPlusResolvedLine = StrippingLine( modeName + "ResolvedLine", prescale=config["PrescaleBu2rho0rhoPlusResolved"], HLT=_hltFilter, FILTER=_resVoidFilter, checkPV=True, ExtraInfoTools=_extraInfoList, selection=self.stripCandResolved) self.registerLine(self.Bu2rho0rhoPlusResolvedLine) ### merged line ------------------------------------------------------------------------------------ _selRhoPMerged = makeRhoP("RhoPMerged", DauCuts=_rhoPMgdDaughtersCuts, combCuts=_rhoCombMassWindow, mothCuts=_rhoPMgdMotherCuts, inputSel=[_tracks, StdLooseMergedPi0]) _selBuMerged = makeBu2rho0rhoPlus(modeName + "Merged", combCuts=_BuMgdCombCuts, mothCuts=_BuMgdMotherCuts, inputSel=[_selRho0, _selRhoPMerged]) if config["isMC"]: self.stripCandMerged = _selBuMerged else: # self.stripCandMerged = makeTisTosSelection( _selBuMerged, _TisTosTaggerSpecs ) self.stripCandMerged = _selBuMerged self.Bu2rho0rhoPlusMergedLine = StrippingLine( modeName + "MergedLine", prescale=config["PrescaleBu2rho0rhoPlusMerged"], HLT=_hltFilter, FILTER=_mgdVoidFilter, checkPV=True, ExtraInfoTools=_extraInfoList, selection=self.stripCandMerged) self.registerLine(self.Bu2rho0rhoPlusMergedLine)
def __init__( self, name, config ): LineBuilder.__init__( self, name, config ) ####################################################################### ### ### ### VELO BASED VERTEXING SEQUENCE ### ### ### ####################################################################### bestTracks = AutomaticData("Rec/Track/Best") withVeloTracksForVertexing = bestTracks if self.configurationParameter("FilterVelo")["Apply"]: from GaudiConfUtils.ConfigurableGenerators import SelectVeloTracksNotFromPV veloWithIP = SelectVeloTracksNotFromPV() self.validatedSetProps( "FilterVelo", DisplVerticesLinesConf.veloWithIPCuts, veloWithIP ) withVeloTracksForVertexing = Selection( "%sVeloFilteredTracks" % self.name() , RequiredSelections = [ bestTracks ] , Algorithm = veloWithIP ) # Displaced Vertex reconstruction with best tracks (dominated by those with a Velo segment) from Configurables import PatPV3D, PVOfflineTool, PVSeed3DTool, LSAdaptPV3DFitter, LSAdaptPVFitter withVeloVertexFinder = PVOfflineTool( "%sWithVeloVertexFinder" % self.name() , PVsChi2Separation = 0 , PVsChi2SeparationLowMult = 0 , PVSeedingName = "PVSeed3DTool" , PVFitterName = "LSAdaptPV3DFitter" ) withVeloVertexFinder.addTool(PVSeed3DTool) withVeloVertexFinder.PVSeed3DTool.MinCloseTracks = 3 withVeloVertexFinder.addTool(LSAdaptPV3DFitter) withVeloVertexFinder.LSAdaptPV3DFitter.maxIP2PV = 2.0*units.mm withVeloVertexFinder.LSAdaptPV3DFitter.MinTracks = 4 withVeloVertexAlg = PatPV3D( "%sWithVeloVertexAlg" ) withVeloVertexAlg.addTool( withVeloVertexFinder, name="PVOfflineTool" ) withVeloVertexing = SelectionPatPV3DWrapper( "%sWithVeloVertexing" % self.name() , withVeloVertexAlg , RequiredSelections = [ withVeloTracksForVertexing ] ) # Make Particles out of the RecVertices from GaudiConfUtils.ConfigurableGenerators import LLParticlesFromRecVertices rv2pWithVelo = LLParticlesFromRecVertices( VerticesFromVeloOnly = False , WriteP2PVRelations = False , ForceP2PVBuild = False , VeloProtoParticlesLocation = "Phys/%s/VeloProtoP" % self.name() ) self.validatedSetProps( "RV2PWithVelo", DisplVerticesLinesConf.recoCuts + DisplVerticesLinesConf.singleCuts, rv2pWithVelo ) withVeloCandidates = Selection( "%sWithVeloCandidates" % self.name() , RequiredSelections = [ withVeloVertexing ] , Algorithm = rv2pWithVelo , InputDataSetter = "RecVertexLocations" ) ####################################################################### ### ### ### DOWNSTREAM VERTEXING SEQUENCE ### ### ### ####################################################################### from GaudiConfUtils.ConfigurableGenerators import CopyDownstreamTracks downTracks = Selection( "%sDownstreamTracks" % self.name() , RequiredSelections = [ bestTracks ] , Algorithm = CopyDownstreamTracks() ) # Displaced Vertex reconstruction from downstream tracks downVertexFinder = PVOfflineTool( "%sDownVertexFinder" % self.name() , RequireVelo = False , PVsChi2Separation = 0 , PVsChi2SeparationLowMult = 0 , PVSeedingName = "PVSeed3DTool" , PVFitterName = "LSAdaptPVFitter" ) downVertexFinder.addTool(PVSeed3DTool) downVertexFinder.PVSeed3DTool.TrackPairMaxDistance = 2.0*units.mm downVertexFinder.PVSeed3DTool.zMaxSpread = 20.0*units.mm downVertexFinder.PVSeed3DTool.MinCloseTracks = 4 downVertexFinder.addTool(LSAdaptPVFitter) downVertexFinder.LSAdaptPVFitter.MinTracks = 4 downVertexFinder.LSAdaptPVFitter.maxChi2 = 400.0 downVertexFinder.LSAdaptPVFitter.maxDeltaZ = 0.0005 *units.mm downVertexFinder.LSAdaptPVFitter.maxDeltaChi2NDoF = 0.002 downVertexFinder.LSAdaptPVFitter.acceptTrack = 0.000000001 downVertexFinder.LSAdaptPVFitter.trackMaxChi2 = 9 downVertexFinder.LSAdaptPVFitter.trackMaxChi2Remove = 64 downVertexAlg = PatPV3D( "%sDownVertexAlg" % self.name() ) downVertexAlg.addTool(downVertexFinder, name="PVOfflineTool") downVertexing = SelectionPatPV3DWrapper( "%sDownVertexing" % self.name() , downVertexAlg , RequiredSelections = [ downTracks ] ) # Make Particles out of the RecVertices rv2pDown = LLParticlesFromRecVertices( VerticesFromVeloOnly = False , WriteP2PVRelations = False , ForceP2PVBuild = False #, OutputLevel = VERBOSE ) self.validatedSetProps( "RV2PDown", DisplVerticesLinesConf.recoCuts + DisplVerticesLinesConf.singleCuts, rv2pDown ) downCandidates = Selection( "%sDownCandidates" % self.name() , RequiredSelections = [ downVertexing ] , Algorithm = rv2pDown , InputDataSetter = "RecVertexLocations" ) ####################################################################### ### ### ### LINE DEFINITIONS ### ### ### ####################################################################### ##============================== Single ===================================## singleLineNames = [ p.split("Single")[1].split("Selection")[0] for p in self.configKeys() if p.startswith("Single") and p.endswith("Selection") ] for lAcroName in singleLineNames: lShortName = "Single%s" % lAcroName # SingleMedium lSelName = "%sSelection" % lShortName # SingleMediumSelection lLineName = "%s%s" % (self.name(), lShortName) # DisplVerticesSingleMedium # Choose between Velo-based and downstream vertexing input candidates = withVeloCandidates code = None if "Down" in lAcroName: candidates = downCandidates code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.singleCuts + DisplVerticesLinesConf.downCuts) ) else: code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.singleCuts) ) lineFilter = FilterDesktop( DecayDescriptor = LLPLHCbName , Preambulo = DisplVerticesLinesConf.llpSelectionPreambulo , Code = code , WriteP2PVRelations = False , ForceP2PVBuild = False #, OutputLevel = VERBOSE ) lineSel = Selection( "".join(( self.name(), lSelName )) , RequiredSelections = [ candidates ] , Algorithm = lineFilter ) line = StrippingLine(lLineName , prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"] , selection = lineSel ## , FILTER = { "Preambulo" : [ "nVeloTracks = RECSUMMARY(13, 0)" ## , "nVeloClusters = RECSUMMARY(30, -1)" ## , "from LoKiCore.functions import *" ] ## , "Code" : "monitor( 1.*nVeloTracks/nVeloClusters , Gaudi.Histo1DDef('Number of Velo Tracks / Clusters', 0., 1., 100) , 'NumVeloTracksPerCluster' ) < 0.2" } ) if lShortName in self.configurationParameter("HLT"): line.HLT = self.configurationParameter("HLT")[lShortName] self.registerLine(line) ##============================== Double ===================================## doubleLineNames = [ p.split("Double")[1].split("Selection")[0] for p in self.configKeys() if p.startswith("Double") and p.endswith("Selection") ] for lAcroName in doubleLineNames: lShortName = "Double%s" % lAcroName lSelName = "%sSelection" % lShortName lLineName = "%s%s" % (self.name(), lShortName) combinationCut, motherCut = self.getResonanceSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.doubleResonanceCuts) ) lineFilter = CombineParticles( DecayDescriptor = "H_10 -> %s %s" % (LLPLHCbName, LLPLHCbName) , Preambulo = DisplVerticesLinesConf.llpSelectionPreambulo , DaughtersCuts = { LLPLHCbName : self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.singleCuts) ) } , CombinationCut = combinationCut , MotherCut = motherCut , WriteP2PVRelations = False , ForceP2PVBuild = False #, OutputLevel = VERBOSE ) lineSel = Selection( "".join(( self.name(), lSelName )) , RequiredSelections = [ withVeloCandidates ] , Algorithm = lineFilter ) line = StrippingLine(lLineName , prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"] , selection = lineSel ) if lShortName in self.configurationParameter("HLT"): line.HLT = self.configurationParameter("HLT")[lShortName] self.registerLine(line) ##============================== HLT PS ===================================## hltPSLineNames = [ p.split("HLTPS")[0] for p in self.configKeys() if p.endswith("HLTPS") ] for lAcroName in hltPSLineNames: lShortName = "%sHLTPS" % lAcroName lLineName = "%s%s" % (self.name(), lShortName) # DisplVerticesSingleMedium hltSelAlg = GaudiSequenceroid(ModeOR = True, ShortCircuit = False, Members = [ GaudiSequencer( "%sHltFilterTCK%s-%s" % (lLineName, tckBegin, tckEnd), Members = [ ODINFilter("%sODINFilterTCK%s-%s" % (lLineName, tckBegin, tckEnd), Code="( ODIN_TCK >= %s ) & ( ODIN_TCK <= %s )" % (tckBegin, tckEnd)) , HltFilter("%sHltDecisionFilterTCK%s-%s" % (lLineName, tckBegin, tckEnd), Code=hltFilter) ]) for (tckBegin, tckEnd), hltFilter in self.validatedGetProps("HLT", [lShortName])[lShortName] ] ) hltSelection = EventSelection( "%sHltFilter" % lLineName , Algorithm = hltSelAlg ) line = StrippingLine(lLineName , prescale = self.validatedGetProps(lShortName, ["PreScale"])["PreScale"] , selection = hltSelection ) self.registerLine(line) ##============================== OTHER ===================================## hltEffLineNames = [ p.split("HltEff")[1].split("Selection")[0] for p in self.configKeys() if p.startswith("HltEff") and p.endswith("Selection") ] for lShortName in hltEffLineNames: lSelName = "HltEff%sSelection" % lShortName lLineName = "%s%s" % (self.name(), lShortName) # HltEff lines are single, Velo-vertexing based lines lineFilter = FilterDesktop( DecayDescriptor = LLPLHCbName , Preambulo = DisplVerticesLinesConf.llpSelectionPreambulo , Code = self.getLLPSelection( self.validatedGetProps(lSelName, DisplVerticesLinesConf.singleCuts) ) , WriteP2PVRelations = False , ForceP2PVBuild = False #, OutputLevel = VERBOSE ) lineSel = Selection( "".join(( self.name(), lSelName )) , RequiredSelections = [ withVeloCandidates ] , Algorithm = lineFilter ) line = StrippingLine(lLineName , prescale = self.validatedGetProps(lSelName, ["PreScale"])["PreScale"] # these lines MUST have an HLT filter , HLT = self.configurationParameter("HLT")[lShortName] , selection = lineSel ) self.registerLine(line)
def __init__(self, name, config): """Initialise this LineBuilder instance.""" self.name = name self.config = config LineBuilder.__init__(self, name, config) # Line names lambdac_name = '{0}Lambdac2PKPi'.format(name) lambdac_pKK_name = '{0}Lambdac2PKK'.format(name) lambdac_ppipi_name = '{0}Lambdac2PPiPi'.format(name) lambdac_ppiK_name = '{0}Lambdac2PPiKWS'.format(name) sigmacz_name = '{0}Sigmacz2LambdacPi'.format(name) sigmacpp_name = '{0}Sigmacpp2LambdacPi'.format(name) # Build pion, kaon, and proton cut strings daugCuts = ('(PT > {0[Daug_All_PT_MIN]})' '& (BPVIPCHI2() > {0[Daug_All_BPVIPCHI2_MIN]})').format( self.config) pidFiducialCuts = ( '(in_range({0[Daug_P_MIN]}, P, {0[Daug_P_MAX]}))' '& (in_range({0[Daug_ETA_MIN]}, ETA, {0[Daug_ETA_MAX]}))').format( self.config) protonPIDCuts = ( pidFiducialCuts + '& ((PIDp - PIDpi) > {0[Proton_PIDpPIDpi_MIN]})' '& ((PIDp - PIDK) > {0[Proton_PIDpPIDK_MIN]})').format(self.config) kaonPIDCuts = (pidFiducialCuts + '& ((PIDK - PIDpi) > {0[K_PIDK_MIN]})').format( self.config) pionPIDCuts = (pidFiducialCuts + '& ((PIDK - PIDpi) < {0[Pi_PIDK_MAX]})').format( self.config) pionCuts = '{0} & {1}'.format(daugCuts, pionPIDCuts) kaonCuts = '{0} & {1}'.format(daugCuts, kaonPIDCuts) protonCuts = '{0} & {1}'.format(daugCuts, protonPIDCuts) # Filter StdAllNoPIDs particles self.inPions = Selection('PionsFor{0}'.format(name), Algorithm=FilterDesktop( 'FilterPionsFor{0}'.format(name), Code=pionCuts), RequiredSelections=[StdAllNoPIDsPions]) self.inKaons = Selection('KaonsFor{0}'.format(name), Algorithm=FilterDesktop( 'FilterKaonsFor{0}'.format(name), Code=kaonCuts), RequiredSelections=[StdAllNoPIDsKaons]) self.inProtons = Selection('ProtonsFor{0}'.format(name), Algorithm=FilterDesktop( 'FilterProtonsFor{0}'.format(name), Code=protonCuts), RequiredSelections=[StdAllNoPIDsProtons]) # Don't used filtered pions for soft pions, cut would be too tight self.inSoftPions = StdAllNoPIDsPions self.selLambdac2PKPi = self.makeLambdac2PHH( name=lambdac_name, inputSel=[self.inProtons, self.inKaons, self.inPions], decDescriptors=self.Lambdac2PKPi) self.selLambdac2PKPiMVA = self.makeMVASelection( '{0}MVASelection'.format(lambdac_name), self.selLambdac2PKPi) self.selLambdac2PKK = self.makeLambdac2PHH( name=lambdac_pKK_name, inputSel=[self.inProtons, self.inKaons], decDescriptors=self.Lambdac2PKK) self.selLambdac2PKKMVA = self.makeMVASelection( '{0}MVASelection'.format(lambdac_pKK_name), self.selLambdac2PKK) self.selLambdac2PPiPi = self.makeLambdac2PHH( name=lambdac_ppipi_name, inputSel=[self.inProtons, self.inPions], decDescriptors=self.Lambdac2PPiPi) self.selLambdac2PPiPiMVA = self.makeMVASelection( '{0}MVASelection'.format(lambdac_ppipi_name), self.selLambdac2PPiPi) self.selLambdac2PPiKWS = self.makeLambdac2PHH( name=lambdac_ppiK_name, inputSel=[self.inProtons, self.inKaons, self.inPions], decDescriptors=self.Lambdac2PPiKWS) self.selLambdac2PPiKWSMVA = self.makeMVASelection( '{0}MVASelection'.format(lambdac_ppiK_name), self.selLambdac2PPiKWS) self.selSigmacz2LambdacPi = self.makeSigmac2LambdacPi( name=sigmacz_name, inputSel=[self.selLambdac2PKPiMVA, self.inSoftPions], decDescriptors=self.Sigmacz2LambdacPi) self.selSigmacpp2LambdacPi = self.makeSigmac2LambdacPi( name=sigmacpp_name, inputSel=[self.selLambdac2PKPiMVA, self.inSoftPions], decDescriptors=self.Sigmacpp2LambdacPi) self.line_Lambdac2PKPi = self.make_line( name='{0}Line'.format(lambdac_name), selection=self.selLambdac2PKPiMVA, prescale=config['PrescaleLambdac2PKPi'], postscale=config['PostscaleLambdac2PKPi'], HLT1=config['Hlt1Filter'], HLT2=config['Hlt2Filter']) self.line_Lambdac2PKK = self.make_line( name='{0}Line'.format(lambdac_pKK_name), selection=self.selLambdac2PKKMVA, prescale=config['PrescaleLambdac2PKK'], postscale=config['PostscaleLambdac2PKK'], HLT1=config['Hlt1Filter'], HLT2=config['Hlt2Filter']) self.line_Lambdac2PPiPi = self.make_line( name='{0}Line'.format(lambdac_ppipi_name), selection=self.selLambdac2PPiPiMVA, prescale=config['PrescaleLambdac2PPiPi'], postscale=config['PostscaleLambdac2PPiPi'], HLT1=config['Hlt1Filter'], HLT2=config['Hlt2Filter']) self.line_Lambdac2PPiKWS = self.make_line( name='{0}Line'.format(lambdac_ppiK_name), selection=self.selLambdac2PPiKWSMVA, prescale=config['PrescaleLambdac2PPiKWS'], postscale=config['PostscaleLambdac2PPiKWS'], HLT1=config['Hlt1Filter'], HLT2=config['Hlt2Filter']) self.line_Sigmacz2LambdacPi = self.make_line( name='{0}Line'.format(sigmacz_name), selection=self.selSigmacz2LambdacPi, prescale=config['PrescaleSigmacz2LambdacPi'], postscale=config['PostscaleSigmacz2LambdacPi'], HLT1=config['Hlt1Filter'], HLT2=config['Hlt2Filter']) self.line_Sigmacpp2LambdacPi = self.make_line( name='{0}Line'.format(sigmacpp_name), selection=self.selSigmacpp2LambdacPi, prescale=config['PrescaleSigmacpp2LambdacPi'], postscale=config['PostscaleSigmacpp2LambdacPi'], HLT1=config['Hlt1Filter'], HLT2=config['Hlt2Filter'])
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self.__confdict__ = config ############### MUON SELECTIONS ################### self.selmuon = Selection("Mufor" + name, Algorithm=self._muonFilter(), RequiredSelections=[StdAllLooseMuons]) self.selFakemuon = Selection("FakeMufor" + name, Algorithm=self._FakemuonFilter(), RequiredSelections=[StdAllNoPIDsMuons]) ############### KAON AND PION SELECTIONS ################ self.selKaon = Selection("Kfor" + name, Algorithm=self._kaonFilter(), RequiredSelections=[StdLooseKaons]) self.selPion = Selection("Pifor" + name, Algorithm=self._pionFilter(), RequiredSelections=[StdLoosePions]) ################ D0 -> HH SELECTION ########################## self.seld02kpi = Selection( "D02KPifor" + name, Algorithm=self._D02KPiFilter(), RequiredSelections=[self.selKaon, self.selPion]) self.selb2D0MuX = makeb2DMuX( 'b2D0MuX' + name, DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], MuSel=self.selmuon, DSel=self.seld02kpi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA']) self.selFakeb2D0MuX = makeFakeb2DMuX( 'b2D0MuXFake' + name, DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], FakeMuSel=self.selFakemuon, DSel=self.seld02kpi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA']) ################# DECLARE THE STRIPPING LINES ################################# GECs = { "Code": " ( recSummary(LHCb.RecSummary.nSPDhits,'Raw/Spd/Digits') < %(SPDmax)s )" % config, "Preambulo": ["from LoKiTracks.decorators import *"] } ########## D0 -> HH ########### self.B2DMuForTauMu = StrippingLine('b2D0MuX' + name + 'Line', prescale=1, selection=self.selb2D0MuX, FILTER=GECs) self.registerLine(self.B2DMuForTauMu) self.FakeB2DMuForTauMu = StrippingLine('b2D0MuXFake' + name + 'Line', prescale=0.08, selection=self.selFakeb2D0MuX, FILTER=GECs) self.registerLine(self.FakeB2DMuForTauMu)
def filterKst(): kst = DataOnDemand(Location='Phys/StdLooseDetachedKst2Kpi/Particles') code = '(MIPCHI2DV(PRIMARY) > 25)' return Selection('KstDarkBosonFilter', Algorithm=FilterDesktop(Code=code), RequiredSelections=[kst])
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self.__confdict__ = config xic_PKPi_name = name + 'Xic2PKPi' xic_pKK_name = name + 'Xic2PKK' theta_pks_name = name + 'Theta2PKS0' xic_klam_name = name + 'Xic2KLam' self.KS0LL = DataOnDemand(Location="Phys/StdLooseKsLL/Particles") self.KS0DD = DataOnDemand(Location="Phys/StdLooseKsDD/Particles") self.LamLL = DataOnDemand(Location="Phys/StdLooseLambdaLL/Particles") self.LamDD = DataOnDemand(Location="Phys/StdLooseLambdaDD/Particles") ############### PROTON SELECTIONS ######################################### self.inProtons = Selection("Protonsfor" + name, Algorithm=self._protonFilter(), RequiredSelections=[StdAllNoPIDsProtons]) ############### PIONS, Lambda0, KS0 and KAONS SELECTIONS ################## self.inPions = Selection("Pionsfor" + name, Algorithm=self._pionFilter(), RequiredSelections=[StdNoPIDsPions]) self.KS0 = Selection("KSfor" + name, Algorithm=self._ksFilter(), RequiredSelections=[self.KS0LL]) self.Lam = Selection("Lambdafor" + name, Algorithm=self._lamFilter(), RequiredSelections=[self.LamLL, self.LamDD]) self.inKaons = Selection("Kaonsfor" + name, Algorithm=self._kaonFilter(), RequiredSelections=[StdNoPIDsKaons]) ############################################################### self.selXic2PKPi = makeXic2PKPi( name=xic_PKPi_name, inputSel=[self.inProtons, self.inKaons, self.inPions], Daug_All_PT_MIN=config['Daug_All_PT_MIN'], Daug_1of3_BPVIPCHI2_MIN=config['Daug_1of3_BPVIPCHI2_MIN'], Daug_P_MIN=config['Daug_P_MIN'], Daug_TRCHI2DOF_MAX=config['Daug_TRCHI2DOF_MAX'], Comb_MASS_MIN=2190. * MeV, Comb_MASS_MAX=2570. * MeV, Comb_ADOCAMAX_MAX=config['Comb_ADOCAMAX_MAX'], Xic_PT_MIN=config['Xic_PT_MIN'], Xic_VCHI2VDOF_MAX=config['Xic_VCHI2VDOF_MAX'], Xic_BPVVDCHI2_MIN=config['Xic_BPVVDCHI2_MIN'], Xic_BPVDIRA_MIN=config['Xic_BPVDIRA_MIN'], Xic_BPVIPCHI2_MAX=config['Xic_BPVIPCHI2_MAX'], Xic_BPVLTIME_MAX=config['Xic_BPVLTIME_MAX'], Xic_BPVLTIME_MIN=config['Xic_BPVLTIME_MIN']) self.selXic2PKK = makeXic2PKPi( name=xic_pKK_name, inputSel=[self.inKaons, self.inProtons], Daug_All_PT_MIN=config['Daug_All_PT_MIN'], Daug_1of3_BPVIPCHI2_MIN=config['Daug_1of3_BPVIPCHI2_MIN'], Daug_P_MIN=config['Daug_P_MIN'], Daug_TRCHI2DOF_MAX=config['Daug_TRCHI2DOF_MAX'], Comb_MASS_MIN=config['Comb_MASS_MIN'], Comb_MASS_MAX=2800. * MeV, Comb_ADOCAMAX_MAX=config['Comb_ADOCAMAX_MAX'], Xic_PT_MIN=config['Xic_PT_MIN'], Xic_VCHI2VDOF_MAX=config['Xic_VCHI2VDOF_MAX'], Xic_BPVVDCHI2_MIN=config['Xic_BPVVDCHI2_MIN'], Xic_BPVDIRA_MIN=config['Xic_BPVDIRA_MIN'], Xic_BPVIPCHI2_MAX=config['Xic_BPVIPCHI2_MAX'], Xic_BPVLTIME_MAX=config['Xic_BPVLTIME_MAX'], Xic_BPVLTIME_MIN=config['Xic_BPVLTIME_MIN'], decDescriptors=["[Lambda_c+ -> p+ K- K+]cc"]) self.selTheta2PKS0 = makeTheta2PKS0( name=theta_pks_name, inputSel=[self.KS0, self.inProtons], Daug_All_PT_MIN=config['Daug_All_PT_MIN'], Daug_P_MIN=config['Daug_P_MIN'], Daug_TRCHI2DOF_MAX=config['Daug_TRCHI2DOF_MAX'], Comb_MASS_MIN=1440. * MeV, Comb_MASS_MAX=1800. * MeV, Comb_ADOCAMAX_MAX=1.0 * mm, Xic_PT_MIN=config['Xic_PT_MIN'], Xic_BPVDIRA_MIN=-100., Xic_BPVIPCHI2_MAX=config['Xic_BPVIPCHI2_MAX'], Xic_BPVLTIME_MAX=config['Xic_BPVLTIME_MAX'], Xic_BPVLTIME_MIN=config['Xic_BPVLTIME_MIN'], decDescriptors=["[Lambda_c+ -> p+ KS0]cc"]) self.selXic2KLam = makeXic2KLam( name=xic_klam_name, inputSel=[self.Lam, self.inKaons], Daug_All_PT_MIN=config['Daug_All_PT_MIN'], Daug_P_MIN=config['Daug_P_MIN'], Daug_TRCHI2DOF_MAX=config['Daug_TRCHI2DOF_MAX'], Comb_MASS_MIN=2100. * MeV, Comb_MASS_MAX=2800. * MeV, Comb_ADOCAMAX_MAX=0.5 * mm, Xic_PT_MIN=config['Xic_PT_MIN'], Xic_BPVDIRA_MIN=-100., Xic_BPVIPCHI2_MAX=config['Xic_BPVIPCHI2_MAX'], Xic_BPVLTIME_MAX=config['Xic_BPVLTIME_MAX'], Xic_BPVLTIME_MIN=config['Xic_BPVLTIME_MIN'], decDescriptors=["[Lambda_c+ -> K+ Lambda0]cc"]) self.line_Xic2PKPi = self._strippingLine( name=xic_PKPi_name + 'Line', HLT=config['HltFilter'], prescale=config['PrescaleXic2PKPi'], postscale=config['PostscaleXic2PKPi'], ExtraInfoTools=config['ExtraInfoTools'], selection=self.selXic2PKPi, ) self.line_Xic2PKK = self._strippingLine( name=xic_pKK_name + 'Line', HLT=config['HltFilter'], prescale=config['PrescaleXic2PKK'], postscale=config['PostscaleXic2PKK'], ExtraInfoTools=config['ExtraInfoTools'], selection=self.selXic2PKK, ) self.line_Theta2PKS0 = self._strippingLine( name=theta_pks_name + 'Line', prescale=config['PrescaleXic2PV0'], postscale=config['PostscaleXic2PV0'], ExtraInfoTools=config['ExtraInfoTools'], selection=self.selTheta2PKS0, ) self.line_Xic2KLam = self._strippingLine( name=xic_klam_name + 'Line', prescale=config['PrescaleXic2KLam'], postscale=config['PostscaleXic2KLam'], selection=self.selXic2KLam)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self.__confdict__ = config ############### MUON SELECTIONS ################### self.selmuon = Selection("Mufor" + name, Algorithm=self._muonFilter(), RequiredSelections=[StdLooseMuons]) self.selmuonhighPT = Selection( "MuhighPTfor" + name, Algorithm=FilterDesktop( Code= "(TRCHI2DOF < %(TRCHI2)s) & (PT>1.2*GeV) & (MIPCHI2DV(PRIMARY)> 9.0)" % self.__confdict__), RequiredSelections=[self.selmuon]) self.selmuontight = Selection( "Mutightfor" + name, Algorithm=FilterDesktop(Code="(MIPCHI2DV(PRIMARY)> 100)"), RequiredSelections=[self.selmuonhighPT]) self.selmuonnew = Selection( "Munewfor" + name, Algorithm=FilterDesktop( Code="(MIPCHI2DV(PRIMARY)> 9.0) & (TRCHI2DOF < %(TRCHI2)s)" % self.__confdict__), RequiredSelections=[self.selmuon]) self.selmuonTOS = TOSFilter("MuTOS" + name, self.selmuontight, "Hlt2SingleMuonDecision") ############### KAON AND PION SELECTIONS ################ self.selKaon = Selection("Kfor" + name, Algorithm=self._kaonFilter(), RequiredSelections=[StdLooseKaons]) self.selPion = Selection("Pifor" + name, Algorithm=self._pionFilter(), RequiredSelections=[StdLoosePions]) self.selPionTight = Selection( "PiTightfor" + name, Algorithm=FilterDesktop(Code="(PIDK< %(PionPIDKTight)s)" % self.__confdict__), RequiredSelections=[self.selPion]) self.selPionloose = Selection("Piloosefor" + name, Algorithm=self._pionlooseFilter(), RequiredSelections=[StdNoPIDsPions]) self.selKaonloose = Selection("Kloosefor" + name, Algorithm=self._kaonlooseFilter(), RequiredSelections=[StdLooseKaons]) self.selpion_fakes = Selection("Pion_fakes_for" + name, Algorithm=self._pionFilter_fakes(), RequiredSelections=[StdLoosePions]) ################ PHI->KK SELECTION ########################### self.selphi2kk = Selection("Phi2KKfor" + name, Algorithm=self._Phi2KKFilter(), RequiredSelections=[self.selKaonloose]) self.selphi2kk_forfakes = Selection( "Phi2KK_forfakes_for" + name, Algorithm=self._Phi2KK_forfakes_Filter(), RequiredSelections=[self.selKaonloose]) ################ D0 -> HH SELECTION ########################## self.seld02kpi = Selection( "D02KPifor" + name, Algorithm=self._D02KPiFilter(), RequiredSelections=[self.selKaon, self.selPionTight]) self.seld02kk = Selection("D02KKfor" + name, Algorithm=self._D02KKFilter(), RequiredSelections=[self.selKaon]) self.seld02pipi = Selection("D02PiPifor" + name, Algorithm=self._D02PiPiFilter(), RequiredSelections=[self.selPionTight]) ################ D0 -> 4H SELECTION ########################## self.seld02k3pi = Selection( "D02K3Pifor" + name, Algorithm=self._D02K3PiFilter(), RequiredSelections=[self.selKaon, StdLoosePions]) ################ D+/Ds+ -> HHH SELECTIONS ########################## self.seldp2kpipi = Selection( "Dp2KPiPifor" + name, Algorithm=self._Dp2KPiPiFilter(), RequiredSelections=[self.selKaon, self.selPion]) self.selds2kkpi = Selection( "Ds2KKPifor" + name, Algorithm=self._Ds2KKPiFilter(), RequiredSelections=[self.selKaon, self.selPion]) self.selds2phipi = Selection( "Ds2PhiPifor" + name, Algorithm=self._Ds2PhiPiFilter(), RequiredSelections=[self.selphi2kk, self.selPionloose]) self.selds2phipi_forfakes = Selection( "Ds2PhiPi_forfakes_for" + name, Algorithm=self._Ds2PhiPi_forfakes_Filter(), RequiredSelections=[self.selphi2kk_forfakes, self.selPionloose]) ############ Lambda_c+ -> pKpi ######################## self.sellambdac = Selection( "Lc2PKPifor" + name, Algorithm=self._Lc2PKPiFilter(), RequiredSelections=[self.selKaon, self.selPion, StdLooseProtons]) ################ MAKE THE B CANDIDATES ################################# self.selb2D0MuX = makeb2DMuX('b2D0MuX' + name, DecayDescriptors=['[B- -> D0 mu-]cc'], MuSel=self.selmuonhighPT, DSel=self.seld02kpi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZLoose']) self.selb2D0MuXKpiDCS = makeb2DMuX( 'b2D0MuXKpiDCS' + name, DecayDescriptors=['[B+ -> D0 mu+]cc'], MuSel=self.selmuonhighPT, DSel=self.seld02kpi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZLoose']) self.selb2D0MuXKK = makeb2DMuX( 'b2D0MuXKK' + name, DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], MuSel=self.selmuon, DSel=self.seld02kk, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZLoose']) self.selb2D0MuXpipi = makeb2DMuX( 'b2D0MuXpipi' + name, DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], MuSel=self.selmuon, DSel=self.seld02pipi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZLoose']) self.selb2D0MuXK3Pi = makeb2DMuX( 'b2D0MuXK3Pi' + name, DecayDescriptors=['[B- -> D0 mu-]cc', '[B+ -> D0 mu+]cc'], MuSel=self.selmuonTOS, DSel=self.seld02k3pi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2DpMuX = makeb2DMuX( 'b2DpMuX' + name, DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'], MuSel=self.selmuonnew, DSel=self.seldp2kpipi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2DsMuX = makeb2DMuX( 'b2DsMuX' + name, DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'], MuSel=self.selmuonnew, DSel=self.selds2kkpi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2LcMuX = makeb2DMuX('b2LcMuX' + name, DecayDescriptors=[ '[Lambda_b0 -> Lambda_c+ mu-]cc', '[Lambda_b0 -> Lambda_c+ mu+]cc' ], MuSel=self.selmuonnew, DSel=self.sellambdac, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.selb2DsMuXPhiPi = makeb2DMuX( 'b2DsMuXPhiPi' + name, DecayDescriptors=['[B0 -> D- mu+]cc', '[B0 -> D- mu-]cc'], MuSel=self.selmuon, DSel=self.selds2phipi, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) ################ Using another Algo for DHadron ################ self.selb2DsPi_PhiPi_fakes = makeb2DX( 'b2DsPi_PhiPi_fakes' + name, DecayDescriptors=['[B0 -> D- pi+]cc', '[B0 -> D- pi-]cc'], HadSel=self.selpion_fakes, DSel=self.selds2phipi_forfakes, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) ################# DECLARE THE STRIPPING LINES ################################# ########## D0 -> HH ########### self.b2D0MuXLine = StrippingLine('b2D0MuX' + name + 'Line', prescale=config['PrescalD0Mu'], selection=self.selb2D0MuX) self.b2D0MuXKpiDCSLine = StrippingLine('b2D0MuXKpiDCS' + name + 'Line', prescale=1, selection=self.selb2D0MuXKpiDCS) self.b2D0MuXKKLine = StrippingLine('b2D0MuXKK' + name + 'Line', prescale=1, selection=self.selb2D0MuXKK) self.b2D0MuXpipiLine = StrippingLine('b2D0MuXpipi' + name + 'Line', prescale=1, selection=self.selb2D0MuXpipi) ######## Lines for time integrated A_SL ######### self.b2DpMuXLine = StrippingLine('b2DpMuX' + name + 'Line', prescale=1, selection=self.selb2DpMuX) self.b2DsMuXLine = StrippingLine('b2DsMuX' + name + 'Line', prescale=1, selection=self.selb2DsMuX) self.b2DsMuXPhiPiLine = StrippingLine('b2DsMuXPhiPi' + name + 'Line', prescale=1, selection=self.selb2DsMuXPhiPi) self.b2DsPi_PhiPi_fakesLine = StrippingLine( 'b2DsPi_PhiPi_fakes' + name + 'Line', HLT="HLT_PASS_RE('Hlt2IncPhi.*Decision')", prescale=config['PrescalDsPi_fakes'], selection=self.selb2DsPi_PhiPi_fakes) ########### D0 -> HHHHH self.b2D0MuXK3PiLine = StrippingLine('b2D0MuXK3Pi' + name + 'Line', prescale=1, selection=self.selb2D0MuXK3Pi) ########## Lambda_c+ -> p HH self.b2LcMuXLine = StrippingLine('b2LcMuX' + name + 'Line', prescale=1, selection=self.selb2LcMuX) ############## REGISTER THE LINES ##################### ######### lines from stripping 17 ####### self.registerLine(self.b2D0MuXLine) self.registerLine(self.b2D0MuXKpiDCSLine) self.registerLine(self.b2DpMuXLine) self.registerLine(self.b2DsMuXLine) self.registerLine(self.b2LcMuXLine) self.registerLine(self.b2D0MuXK3PiLine) self.registerLine(self.b2D0MuXKKLine) self.registerLine(self.b2D0MuXpipiLine) self.registerLine(self.b2DsMuXPhiPiLine) self.registerLine(self.b2DsPi_PhiPi_fakesLine)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self.pion = Pions self.proton = Protons trkFilterP = FilterDesktop( Code='(MIPCHI2DV(PRIMARY) > %(Trk_MinIPChi2)s) & \ (TRGHOSTPROB < %(Trk_MaxGhostProb)s) & \ (TRCHI2DOF < %(Trk_MaxChi2Ndof)s) & \ (P > %(Trk_MinP)s) & \ (PROBNNp > %(Trk_MinProbNNp)s)' % config) trkFilterPi = FilterDesktop( Code='(MIPCHI2DV(PRIMARY) > %(Trk_MinIPChi2)s) & \ (TRGHOSTPROB < %(Trk_MaxGhostProb)s) & \ (TRCHI2DOF < %(Trk_MaxChi2Ndof)s) & \ (P > %(Trk_MinP)s)' % config) self.myPions = Selection('PionsFor' + name, Algorithm=trkFilterPi, RequiredSelections=[self.pion]) self.myProtons = Selection('ProtonsFor' + name, Algorithm=trkFilterP, RequiredSelections=[self.proton]) self.makeXb2ppph(name + '_4body', config) self.lineXb2ppph = StrippingLine( 'Xb2ppphLine', prescale=config['Prescale'], postscale=config['Postscale'], selection=self.selXb2ppph, RelatedInfoTools=[{ "Type": "RelInfoConeVariables", "ConeAngle": 0.8, "Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'], "Location": "P2ConeVar08_0", "DaughterLocations": { '[Lambda_b0 -> ^p+ p~- p+ pi-]CC': 'P2ConeVar08_1', '[Lambda_b0 -> p+ ^p~- p+ pi-]CC': 'P2ConeVar08_2', '[Lambda_b0 -> p+ p~- ^p+ pi-]CC': 'P2ConeVar08_3', '[Lambda_b0 -> p+ p~- p+ ^pi-]CC': 'P2ConeVar08_4' } }, { "Type": "RelInfoConeVariables", "ConeAngle": 1.0, "Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'], "Location": "P2ConeVar10_0", "DaughterLocations": { '[Lambda_b0 -> ^p+ p~- p+ pi-]CC': 'P2ConeVar10_1', '[Lambda_b0 -> p+ ^p~- p+ pi-]CC': 'P2ConeVar10_2', '[Lambda_b0 -> p+ p~- ^p+ pi-]CC': 'P2ConeVar10_3', '[Lambda_b0 -> p+ p~- p+ ^pi-]CC': 'P2ConeVar10_4' } }, { "Type": "RelInfoConeVariables", "ConeAngle": 1.3, "Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'], "Location": "P2ConeVar13_0", "DaughterLocations": { '[Lambda_b0 -> ^p+ p~- p+ pi-]CC': 'P2ConeVar13_1', '[Lambda_b0 -> p+ ^p~- p+ pi-]CC': 'P2ConeVar13_2', '[Lambda_b0 -> p+ p~- ^p+ pi-]CC': 'P2ConeVar13_3', '[Lambda_b0 -> p+ p~- p+ ^pi-]CC': 'P2ConeVar13_4' } }, { "Type": "RelInfoConeVariables", "ConeAngle": 1.7, "Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'], "Location": "P2ConeVar17_0", "DaughterLocations": { '[Lambda_b0 -> ^p+ p~- p+ pi-]CC': 'P2ConeVar17_1', '[Lambda_b0 -> p+ ^p~- p+ pi-]CC': 'P2ConeVar17_2', '[Lambda_b0 -> p+ p~- ^p+ pi-]CC': 'P2ConeVar17_3', '[Lambda_b0 -> p+ p~- p+ ^pi-]CC': 'P2ConeVar17_4' } }, { "Type": "RelInfoVertexIsolation", "Location": "VertexIsoInfo" }]) self.registerLine(self.lineXb2ppph)
class StrippingHyperCPXConf(LineBuilder) : """ Helper class to construct stirppinglines for search Sigma+ -> p mu+ mu- """ __configuration_keys__ = tuple ( _default_configuration_.keys() ) ## get the default configuration @staticmethod def defaultConfiguration( key = None ) : """ Get the defualt configurtaion >>> conf = StrippingHyperCPXConf.defaultConfiguration() Get the elements of default configurtaion: >>> SigmaPrescale = StrippingHyperCPXConf.defaultConfiguration( 'SigmaPrescale' ) """ from copy import deepcopy _config_ = deepcopy ( _default_configuration_ ) if key : return _config_[ key ] return _config_ ## constructor def __init__( self , name , config ) : """ Constructor """ ## if isinstance ( config , dict ) : from copy import deepcopy _config_ = deepcopy ( _default_configuration_ ) _config_ . update ( config ) else : _config_ = config ## base class LineBuilder.__init__( self , name , _config_ ) for line in self._lines_private() : self.registerLine(line) ## define ``main'' selection for Sigma+ -> p mu+ mu- def sigma ( self ) : """ define ``main'' selection for Sigma+ -> p mu+ mu- """ if hasattr ( self , 'Sigma' ) : return self.Sigma _SigmaAlg = CombineParticles ( # DecayDescriptors = [ " [ Sigma+ -> p+ mu+ mu- ]cc " , # signal " [ Sigma~+ -> p~- mu+ mu+ ]cc " # background ] , # DaughtersCuts = { 'p+' : self._config['ProtonCuts'] } , # Preambulo = self._config [ 'Preambulo' ] , # CombinationCut = """ ADAMASS('Sigma+') < %s """ % self._config[ 'SigmaMass' ] , # MotherCut = """ ( chi2vx < 25 ) & ( ctau > %s ) """ % self._config['SigmaCTau'] ) self.Sigma = Selection ( 'SelSigma2pMuMuFor' + self.name() , Algorithm = _SigmaAlg , RequiredSelections = [ self.twoMuons () , StdLooseProtons ] ) return self.Sigma ## define ``normalization'' selection for Ds+ -> ( phi -> mu+ mu- ) pi+ def ds2PhiPi ( self ) : """ Define ``normalization'' selection for Ds+ -> ( phi -> mu+ mu- ) pi+ """ if hasattr ( self , 'PhiPi' ) : return self.PhiPi _PhiPiAlg = CombineParticles ( # DecayDescriptors = [ " [ D_s+ -> pi+ mu+ mu- ]cc " , # signal " [ D_s+ -> pi- mu+ mu+ ]cc " # backghround ] , # DaughtersCuts = { 'pi+' : self._config['PionCuts_forTau23Mu'] } , # Preambulo = self._config [ 'Preambulo' ] , # CombinationCut = """ ( ADAMASS ( 'D_s+' ) < %s ) & phi """ % self._config[ 'Ds2PhiPiMass' ] , # MotherCut = """ ( chi2vx < 20 ) & ( ctau_forDs > %s ) & ( BPVIPCHI2() < 225 ) """ % self._config['DsCTau'] ) self.PhiPi = Selection ( 'SelDs2PhiPiFor' + self.name() , Algorithm = _PhiPiAlg , RequiredSelections = [ self.twoMuons_forTau23Mu () , StdLoosePions ] ) return self.PhiPi ## define ``normalization'' selection for Ds+ -> pi+ pi- pi+ def ds2PiPiPi ( self ) : """ Define ``normalization'' selection for Ds+ -> pi+ pi- pi+ """ def makeTISTOS( name, _input, _trigger ) : from Configurables import TisTosParticleTagger _tisTosFilter = TisTosParticleTagger( name + "Tagger" ) _tisTosFilter.TisTosSpecs = { _trigger : 0 } #_tisTosFilter.ProjectTracksToCalo = False #_tisTosFilter.CaloClustForCharged = False #_tisTosFilter.CaloClustForNeutral = False #_tisTosFilter.TOSFrac = { 4:0.0, 5:0.0 } return Selection( name , Algorithm = _tisTosFilter , RequiredSelections = [ _input ] ) _PiPiPiAlg = CombineParticles ( # DecayDescriptors = [" [ D_s+ -> pi+ pi+ pi- ]cc " ] , # DaughtersCuts = { 'pi+' : self._config['PionCuts_forTau23Mu'] } , # Preambulo = self._config [ 'Preambulo' ] , # CombinationCut = """ ( ADAMASS ( 'D_s+' ) < %s ) """ % self._config[ 'Ds23PiMass' ] , # MotherCut = """ ( chi2vx < 20 ) & ( ctau_forDs > %s ) & ( BPVIPCHI2() < 225 ) """ % self._config['DsCTau'] ) self.combPiPiPi = Selection ( 'SelDs2PiPiPiFor' + self.name() , Algorithm = _PiPiPiAlg , RequiredSelections = [ StdLoosePions ] ) self.selDs23PiHlt1TIS = makeTISTOS( self.name() + "Ds23PiHlt1TIS" , self.combPiPiPi , "Hlt1.*Decision%TIS" ) self.selDs23PiHlt2TIS = makeTISTOS( self.name() + "Ds23PiHlt2TIS" , self.selDs23PiHlt1TIS , "Hlt2.*Decision%TIS" ) return self.selDs23PiHlt2TIS ## define selection for D+ -> pi mu+ mu- def d2PiMuMu ( self ) : """ Define selection for D+ -> pi mu+ mu- """ if hasattr ( self , 'PiMuMu' ) : return self.PiMuMu _PiMuMuAlg = CombineParticles ( # DecayDescriptors = [ " [ D+ -> pi+ mu+ mu- ]cc " , # signal " [ D+ -> pi- mu+ mu+ ]cc " # backghround ] , # DaughtersCuts = { 'pi+' : self._config['PionCuts'] } , # Preambulo = self._config [ 'Preambulo' ] , # CombinationCut = """ ( APT > 2 * GeV ) & ( ADAMASS ( 'D+' ) < %s ) """ % self._config[ 'DplusMass' ] , # MotherCut = """ ( chi2vx < 25 ) & ( ctau > %s ) """ % self._config['DplusCTau'] ) self.PiMuMu = Selection ( 'SelDplus2PiMuMuFor' + self.name() , Algorithm = _PiMuMuAlg , RequiredSelections = [ self.twoMuons () , StdLoosePions ] ) #return self.PhiPi#was bug ??? JA 20110825 return self.PiMuMu ## get the muon selection def twoMuons ( self ) : """ Get the proton selection """ if hasattr ( self , 'TwoMuons' ) : return self.TwoMuons _MuonFilter = FilterDesktop ( Code = " ( 'mu+' == ABSID ) & " + self._config['MuonCuts'] ) self.Muons = Selection ( 'SelMuonsFor' + self.name () , Algorithm = _MuonFilter , RequiredSelections = [ StdLooseMuons ] ) ## require at least 2 muons self.TwoMuons = VoidEventSelection ( "TwoMuonsFor" + self.name() , Code = """ CONTAINS('%s') > 1.5 """ % self.Muons.outputLocation() , RequiredSelection = self.Muons ) # return self.TwoMuons ## get the muon selection for Tau->3mu Ds Normalization Channels def twoMuons_forTau23Mu ( self ) : """ Get the proton selection """ if hasattr ( self , 'TwoMuons_forTau23Mu' ) : return self.TwoMuons_forTau23Mu _MuonFilter_forTau23Mu = FilterDesktop ( Code = " ( 'mu+' == ABSID ) & " + self._config['MuonCuts_forTau23Mu'] ) self.Muons_forTau23Mu = Selection ( 'Sel_T23Mu_MuonsFor' + self.name () , Algorithm = _MuonFilter_forTau23Mu , RequiredSelections = [ StdLooseMuons ] ) ## require at least 2 muons self.TwoMuons_forTau23Mu = VoidEventSelection ( "Two_T23Mu_MuonsFor" + self.name() , Code = """ CONTAINS('%s') > 1.5 """ % self.Muons_forTau23Mu.outputLocation() , RequiredSelection = self.Muons_forTau23Mu ) # return self.TwoMuons_forTau23Mu ## get all stripping lines def _lines_private ( self ) : if hasattr ( self , '_Lines' ) : return self._Lines self._Lines = [ ## StrippingLine ( "Sigma2PMuMuFor" + self.name() , prescale = self._config['SigmaPrescale' ] , ## ATTENTION! Prescale here !! checkPV = self._config['PrimaryVertices'] , algos = [ self.sigma() ] ) , ## #StrippingLine ( #"Ds2PhiPiFor" + self.name () , #prescale = self._config['DsPrescale' ] , ## ATTENTION! Prescale here !! #checkPV = self._config['PrimaryVertices'] , #algos = [ self.ds2PhiPi () ] #) , ## #StrippingLine ( #"Ds2PiPiPiFor" + self.name () , #prescale = self._config['Ds3PiPrescale' ] , ## ATTENTION! Prescale here !! #checkPV = self._config['PrimaryVertices'] , #algos = [ self.ds2PiPiPi () ] #) , ## StrippingLine ( "Dplus2PiMuMuFor" + self.name () , prescale = self._config['DplusPrescale' ] , ## ATTENTION! Prescale here !! checkPV = self._config['PrimaryVertices'] , algos = [ self.d2PiMuMu () ] ) ] # return self._Lines
def __apply_configuration__(self): from Configurables import (GaudiSequencer, CombineParticles, OfflineVertexFitter) from PhysSelPython.Wrappers import Selection, SelectionSequence, DataOnDemand seq = self.getProp("Sequencer") if seq == None: raise RuntimeError("ERROR : Sequence not set") if self.getProp("RunSelection"): # STD particles from StandardParticles import StdNoPIDsPions, StdNoPIDsKaons # phi -> K+ K- Phi2KKName = self.__sel_name__ + "_Phi2KK" Phi2KK = CombineParticles(Phi2KKName) Phi2KK.DecayDescriptor = "phi(1020) -> K+ K-" Phi2KK.CombinationCut = "(ADAMASS('phi(1020)')<75*MeV)" Phi2KK.MotherCut = "(ADMASS('phi(1020)')<50*MeV) & (BPVVDCHI2>60) & (MIPDV(PRIMARY)<0.5) & (VFASPF(VCHI2) < 20)" Phi2KK.DaughtersCuts = { "K+": "(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) < 0.5) & (BPVIPCHI2() > 20)", "K-": "(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) < 0.5) & (BPVIPCHI2() > 20)" } self.setOptions(Phi2KK) Phi2KKSel = Selection(Phi2KKName + 'Sel', Algorithm=Phi2KK, RequiredSelections=[StdNoPIDsKaons]) # Bs -> J/psi phi Ds2piPhiName = self.__sel_name__ Ds2piPhi = CombineParticles(Ds2piPhiName) Ds2piPhi.DecayDescriptor = "[D_s+ -> pi+ phi(1020)]cc" Ds2piPhi.addTool(OfflineVertexFitter) Ds2piPhi.ParticleCombiners.update({"": "OfflineVertexFitter"}) Ds2piPhi.OfflineVertexFitter.useResonanceVertex = True Ds2piPhi.CombinationCut = "(ADAMASS('D_s+')<75*MeV)" Ds2piPhi.MotherCut = "(ADMASS('D_s+')<50*MeV) & (BPVDIRA>0.9999) & (BPVVDCHI2>85) & (MIPDV(PRIMARY)<0.1) & (VFASPF(VCHI2) < 10)" Ds2piPhi.DaughtersCuts = { "pi+": "(PT>300*MeV) & (P>2*GeV) & (MIPDV(PRIMARY) >0.1) & (BPVIPCHI2() > 20)" } self.setOptions(Ds2piPhi) Ds2piPhiSel = Selection( Ds2piPhiName + 'Sel', Algorithm=Ds2piPhi, RequiredSelections=[Phi2KKSel, StdNoPIDsPions]) # Selection Sequence selSeq = SelectionSequence(self.__sel_name__ + 'Seq', TopSelection=Ds2piPhiSel) # Run the selection sequence. seq.Members += [selSeq.sequence()] # Particle Monitoring plots if self.getProp("RunMonitors"): from Configurables import ParticleMonitor plotter = ParticleMonitor(self.__sel_name__ + "Plots") if self.getProp("RunSelection"): plotter.Inputs = ['Phys/' + self.__sel_name__ + 'Sel'] else: plotter.Inputs = self.getProp("Candidates") plotter.PeakCut = "(ADMASS('D_s+')<100*MeV)" plotter.SideBandCut = "(ADMASS('D_s+')>100*MeV)" plotter.PlotTools = self.getProp("PlotTools") self.setOptions(plotter) seq.Members += [plotter] # Make a DST ? if self.getProp("MakeSelDST"): # Prescale from Configurables import DeterministicPrescaler scaler = DeterministicPrescaler( self.__sel_name__ + 'PreScale', AcceptFraction=self.getProp("DSTPreScaleFraction")) seq.Members += [scaler] # Write the DST MyDSTWriter = SelDSTWriter(self.__sel_name__ + "DST", SelectionSequences=[selSeq], OutputPrefix=self.__sel_name__) seq.Members += [MyDSTWriter.sequence()] # MC Performance checking ? if self.getProp("MCChecks"): from Configurables import ParticleEffPurMoni mcPerf = ParticleEffPurMoni(Ds2piPhiName + "MCPerf") mcPerf.Inputs = ['Phys/' + self.__sel_name__ + 'Sel'] self.setOptions(mcPerf) seq.Members += [mcPerf] # Ntuple ? if self.getProp("MakeNTuple"): outputLevel = INFO from Configurables import ( DecayTreeTuple, TupleToolDecay, TupleToolMCTruth, TupleToolMCBackgroundInfo, TupleToolGeometry, TupleToolKinematic, TupleToolPrimaries, TupleToolEventInfo, MCTupleToolHierarchy, MCTupleToolKinematic, TupleToolPid, TupleToolTrackInfo, TupleToolVtxIsoln, LoKi__Hybrid__TupleTool) Tuple = DecayTreeTuple(Ds2piPhiName + "Tuple") Tuple.Inputs = ["Phys/" + Ds2piPhiName] Tuple.Decay = "[D_s+ -> ^pi+ (^phi(1020) => ^K+ ^K-)]cc" Tuple.Branches = { "pion": "[D_s+ -> ^pi+ (phi(1020) => K+ K-)]cc", "kaonplus": "[D_s+ -> pi+ (phi(1020) => ^K+ K-)]cc", "kaonminus": "[D_s+ -> pi+ (phi(1020) => K+ ^K-)]cc", "phi": "[D_s+ -> pi+ (^phi(1020) => K+ K-)]cc", "D_s": "[D_s+]cc :[D_s+ -> pi+ (phi(1020) => K+ K-)]cc" } Tuple.addTool(TupleToolDecay, name='pion') Tuple.addTool(TupleToolDecay, name='phi') Tuple.addTool(TupleToolDecay, name='kaonplus') Tuple.addTool(TupleToolDecay, name='kaonminus') Tuple.addTool(TupleToolDecay, name='D_s') # k+ specific kaonplusLoKiTool = LoKi__Hybrid__TupleTool('kaonplusLoKiTool') kaonplusLoKiTool.Variables = { "LOKI_PIDK": "PIDK", "LOKI_PIDe": "PIDe", "LOKI_PIDpi": "PIDpi", "LOKI_PIDp": "PIDp", "LOKI_PIDmu": "PIDmu", "LOKI_PIDK_PIDpi": "PIDK-PIDpi", "LOKI_PIDK_PIDe": "PIDK-PIDe", "LOKI_PIDK_PIDmu": "PIDK-PIDmu", "LOKI_PIDK_PIDp": "PIDK-PIDp" } Tuple.kaonplus.addTool(kaonplusLoKiTool, name='kaonplusLoKiTool') Tuple.kaonplus.ToolList = [ 'LoKi::Hybrid::TupleTool/kaonplusLoKiTool' ] # k- specific kaonminusLoKiTool = LoKi__Hybrid__TupleTool('kaonminusLoKiTool') kaonminusLoKiTool.Variables = { "LOKI_PIDK": "PIDK", "LOKI_PIDe": "PIDe", "LOKI_PIDpi": "PIDpi", "LOKI_PIDp": "PIDp", "LOKI_PIDmu": "PIDmu", "LOKI_PIDK_PIDpi": "PIDK-PIDpi", "LOKI_PIDK_PIDe": "PIDK-PIDe", "LOKI_PIDK_PIDmu": "PIDK-PIDmu", "LOKI_PIDK_PIDp": "PIDK-PIDp" } Tuple.kaonminus.addTool(kaonminusLoKiTool, name='kaonminusLoKiTool') Tuple.kaonminus.ToolList = [ 'LoKi::Hybrid::TupleTool/kaonminusLoKiTool' ] # pi+ specific pionLoKiTool = LoKi__Hybrid__TupleTool('pionLoKiTool') pionLoKiTool.Variables = { "LOKI_PIDK": "PIDK", "LOKI_PIDe": "PIDe", "LOKI_PIDpi": "PIDpi", "LOKI_PIDp": "PIDp", "LOKI_PIDmu": "PIDmu", "LOKI_PIDpi_PIDK": "PIDpi-PIDK", "LOKI_PIDpi_PIDe": "PIDpi-PIDe", "LOKI_PIDpi_PIDmu": "PIDpi-PIDmu", "LOKI_PIDpi_PIDp": "PIDpi-PIDp" } Tuple.pion.addTool(pionLoKiTool, name='pionLoKiTool') Tuple.pion.ToolList = ['LoKi::Hybrid::TupleTool/pionLoKiTool'] # phi specific phiLoKiTool = LoKi__Hybrid__TupleTool('phiLoKiTool') phiLoKiTool.Variables = {} Tuple.phi.addTool(phiLoKiTool, name='phiLoKiTool') Tuple.phi.ToolList = ['LoKi::Hybrid::TupleTool/phiLoKiTool'] # D_s specific DsLoKiTool = LoKi__Hybrid__TupleTool('DsLoKiTool') DsLoKiTool.Variables = {} Tuple.D_s.addTool(DsLoKiTool, name='DsLoKiTool') Tuple.D_s.ToolList = ["LoKi::Hybrid::TupleTool/DsLoKiTool"] # Common to all particles LoKiTool = LoKi__Hybrid__TupleTool('LoKiTool') LoKiTool.Variables = { "LOKI_ABSID": "ABSID", "LOKI_BPVIPCHI2": "BPVIPCHI2()", "LOKI_BPVDIRA": "BPVDIRA", "LOKI_BPVLTFITCHI2": "BPVLTFITCHI2('PropertimeFitter/properTime:PUBLIC')", "LOKI_BPVLTCHI2": "BPVLTCHI2('PropertimeFitter/properTime:PUBLIC')", "LOKI_BPVLTIME": "BPVLTIME('PropertimeFitter/properTime:PUBLIC')", "LOKI_BPVVDCHI2": "BPVVDCHI2", "LOKI_ID": "ID", "LOKI_MIPDV_PRIMARY": "MIPDV(PRIMARY)", "LOKI_MIPCHI2DV_PRIMARY": "MIPCHI2DV(PRIMARY)", "LOKI_MM": "MM", "LOKI_M": "M", "LOKI_P": "P", "LOKI_PT": "PT", "LOKI_TRCHI2": "TRCHI2", "LOKI_TRCHI2DOF": "TRCHI2DOF", "LOKI_VFASPF_VCHI2": "VFASPF(VCHI2)", "LOKI_VFASPF_VDOF": "VFASPF(VDOF)" } Tuple.addTool(LoKiTool, name='LoKiTool') Tuple.ToolList = [ "LoKi::Hybrid::TupleTool/LoKiTool", "TupleToolEventInfo", "TupleToolGeometry", "TupleToolKinematic", "TupleToolMCBackgroundInfo", "TupleToolPid", "TupleToolPrimaries", "TupleToolTrackInfo", "TupleToolVtxIsoln", "TupleToolMCTruth" ] Tuple.addTool(TupleToolEventInfo) Tuple.TupleToolEventInfo.OutputLevel = outputLevel Tuple.addTool(TupleToolGeometry) Tuple.TupleToolGeometry.OutputLevel = outputLevel Tuple.addTool(TupleToolKinematic) Tuple.TupleToolKinematic.OutputLevel = outputLevel Tuple.addTool(TupleToolMCBackgroundInfo) Tuple.TupleToolMCBackgroundInfo.OutputLevel = outputLevel Tuple.addTool(MCTupleToolHierarchy) Tuple.MCTupleToolHierarchy.OutputLevel = outputLevel Tuple.addTool(TupleToolMCTruth) Tuple.TupleToolMCTruth.OutputLevel = outputLevel Tuple.TupleToolMCTruth.addTool(MCTupleToolKinematic()) Tuple.TupleToolMCTruth.addTool(MCTupleToolHierarchy()) Tuple.TupleToolMCTruth.ToolList = [ "MCTupleToolKinematic", "MCTupleToolHierarchy" ] Tuple.TupleToolMCTruth.MCTupleToolKinematic.StoreKineticInfo = True Tuple.TupleToolMCTruth.MCTupleToolKinematic.StoreVertexInfo = True Tuple.TupleToolMCTruth.MCTupleToolKinematic.StorePropertimeInfo = True Tuple.TupleToolMCTruth.MCTupleToolKinematic.OutputLevel = outputLevel Tuple.addTool(TupleToolPid) Tuple.TupleToolPid.OutputLevel = outputLevel Tuple.addTool(TupleToolPrimaries) Tuple.TupleToolPrimaries.OutputLevel = outputLevel Tuple.addTool(TupleToolTrackInfo) Tuple.TupleToolTrackInfo.OutputLevel = outputLevel Tuple.addTool(TupleToolVtxIsoln) Tuple.TupleToolVtxIsoln.OutputLevel = outputLevel seq.Members += [Tuple] Tuple.NTupleLUN = "DSPHIPI" from Configurables import NTupleSvc NTupleSvc().Output = [ "DSPHIPI DATAFILE='DsToPhiPi.root' TYP='ROOT' OPT='NEW'" ]
def makeB2nbody(name,PiSel,KSel,pSel,KsSel,LmSel,DzSel,DpSel,DsSel,LcSel,PhSel,KSSel,JpSel,DSSel, nbody,MinBMass,MaxBMass,MinBPt,MaxBVertChi2DOF,MinBPVVDChi2,MaxBPVIPChi2,MinBPVDIRA,MaxMass,MaxNtrk,MinNvc, doPi,doK,dop,doKs,doLm,doDz,doDp,doDs,doLc,doPh,doKS,doJp,doDS): # Define a class that contains all relevant particle properties class particle: def __init__(self,name,m,ntrk,nvc,q,b): self.name=name self.m=m #mass self.ntrk=ntrk # number of charged tracks in fian state self.nvc=nvc # number of vertex-contraining (pseudo)tracks self.Q=q # electrical charge self.B=b # baryon number self.cp=self def CP(self,name): p= particle(name,self.m,self.ntrk,self.nvc,-self.Q,-self.B) p.cp=self self.cp=p return p def isCP(self): if self.cp.name==self.name: return True else: return False # Define the particles particles=[] if doPi: particles.append(particle( "pi+" , 139.6,1,1, +1, 0)) if doPi: particles.append(particles[-1].CP("pi-" )) if doK: particles.append(particle( "K+" , 493.7,1,1, +1, 0)) if doK: particles.append(particles[-1].CP("K-" )) if dop: particles.append(particle( "p+" , 938.3,1,1, +1, +1)) if dop: particles.append(particles[-1].CP("p~-" )) if doKs: particles.append(particle( "KS0" , 497.6,2,0, 0, 0)) if doLm: particles.append(particle( "Lambda0" ,1115.7,2,0, 0, +1)) if doLm: particles.append(particles[-1].CP("Lambda~0" )) if doDz: particles.append(particle( "D0" ,1864.8,2,1, 0, 0)) if doDz: particles.append(particles[-1].CP("D~0" )) if doDp: particles.append(particle( "D+" ,1869.6,3,1, +1, 0)) if doDp: particles.append(particles[-1].CP("D-" )) if doDs: particles.append(particle( "D_s+" ,1968.5,3,1, +1, 0)) if doDs: particles.append(particles[-1].CP("D_s-" )) if doLc: particles.append(particle( "Lambda_c+" ,2286.5,3,1, +1, +1)) if doLc: particles.append(particles[-1].CP("Lambda_c~-")) if doPh: particles.append(particle( "phi(1020)" ,1019.5,2,2, 0, 0)) if doKS: particles.append(particle( "K*(892)0" , 895.9,2,2, 0, 0)) if doKS: particles.append(particles[-1].CP("K*(892)~0" )) if doJp: particles.append(particle( "J/psi(1S)" ,3096.9,2,2, 0, 0)) if doDS: particles.append(particle( "D*(2010)+" ,2010.2,3,2, +1, 0)) if doDS: particles.append(particles[-1].CP("D*(2010)-" )) # in itertools only since python 2.7 def combinations_with_replacement(iterable, r): pool = tuple(iterable) n = len(pool) if not n and r: return indices = [0] * r yield tuple(pool[i] for i in indices) while True: for i in reversed(range(r)): if indices[i] != n - 1: break else: return indices[i:] = [indices[i] + 1] * (r - i) yield tuple(pool[i] for i in indices) #alphabetically ordered name of particles def pname(ps): names=[] for p in ps: names.append(p.name) names.sort() result="" for name in names: result=result+name+' ' return result[:-1] descriptors = [] for comb in combinations_with_replacement(particles,nbody): #check for the mass m=0 for p in comb: m+=p.m if m>MaxMass: continue #check for the number of tracks in the final state ntrk=0 for p in comb: ntrk+=p.ntrk if ntrk>MaxNtrk: continue #check for the number of vertex-constraining (pseudo)tracks nvc=0 for p in comb: nvc+=p.nvc if nvc<MinNvc: continue #check for charge and baryon number Q=0 for p in comb: Q+=p.Q if abs(Q)>1: continue B=0 for p in comb: B+=p.B if abs(B)>1: continue #assign identity to mother mother="" if Q==0 and B==0: mother="B0" if Q==1 and B==0: mother="B+" if Q==0 and B==1: mother="Lambda_b0" if Q==-1 and B==1: mother="Xi_b-" if Q==+1 and B==1: mother="Xi_bc+" if mother=="": continue #check if final state is CP eigenstate ps=[p for p in comb if not p.isCP()] while True: doagain=False for p in ps: if ps.count(p.cp)>0: ps.remove(p) ps.remove(p.cp) doagain=True break if not doagain: break if len(ps)==0: CP=True else: CP=False #for B0 non-CP combinations come twice. if mother=="B0" and not CP: combcp=[x.cp for x in comb] if pname(comb)<pname(combcp):continue #build the decay descriptor descriptor=mother+" -> "+pname(comb) if not CP:descriptor="["+descriptor+"]cc" descriptors.append(descriptor) print "%s: %d channels"%(name,len(descriptors)) #for descriptor in descriptors: print "DESCRIPTOR:",descriptor #make a merge of the input selections AllSel=[] if doPi:AllSel.append(PiSel) if doK: AllSel.append(KSel) if dop: AllSel.append(pSel) if doKs:AllSel.append(KsSel) if doLm:AllSel.append(LmSel) if doDz:AllSel.append(DzSel) if doDp:AllSel.append(DpSel) if doDs:AllSel.append(DsSel) if doLc:AllSel.append(LcSel) if doPh:AllSel.append(PhSel) if doKS:AllSel.append(KSSel) if doJp:AllSel.append(JpSel) if doDS:AllSel.append(DSSel) InputSel= MergedSelection("InputFor"+name, RequiredSelections = AllSel ) _combinationCuts = "(in_range(%(MinBMass)s*MeV, AM, %(MaxBMass)s*MeV))" % locals() _combinationCuts += "& (APT>%(MinBPt)s*MeV)"%locals() _motherCuts = "(VFASPF(VCHI2/VDOF)<%(MaxBVertChi2DOF)s)"%locals() _motherCuts += "& (BPVVDCHI2 > %(MinBPVVDChi2)s)"% locals() _motherCuts += "& (BPVIPCHI2() < %(MaxBPVIPChi2)s)"%locals() _motherCuts += "& (BPVDIRA > %(MinBPVDIRA)s)"% locals() #make a selection _B=CombineParticles(DecayDescriptors = descriptors, CombinationCut = _combinationCuts, MotherCut = _motherCuts) #make a preselection _presel=VoidEventSelection("preselFor"+name, Code="(CONTAINS('%s')> %3.1f)"%(InputSel.outputLocation(),nbody-0.5 ), RequiredSelection=InputSel ) return Selection(name, Algorithm = _B, RequiredSelections = [_presel] )
if magnetPolarity not in ["Up", "Down"]: raise RuntimeError(magnetPolarity + " is not a valid magnet polarity") ###################################################################################################### from Configurables import CombineParticles KsPiPi= CombineParticles("KsPiPi") KsPiPi.DecayDescriptor = "KS0 -> pi+ pi-" KsPiPi.CombinationCut = "ADAMASS('KS0')<100*MeV" KsPiPi.MotherCut = "(VFASPF(VCHI2/VDOF)<10)" KsPiPi.DaughtersCuts = { "pi+" : "ALL", "pi-" : "ALL" } KsPiPi.MotherCut = "(M > 400) & (M < 600) & (BPVVDCHI2 > 100.) & (VFASPF(VCHI2/VDOF) < 10)" from PhysSelPython.Wrappers import Selection from StandardParticles import StdNoPIDsDownPions, StdLoosePions LooseKsPiPi = Selection("SelLooseKsPiPi", Algorithm = KsPiPi, RequiredSelections = [StdNoPIDsDownPions ]) #RequiredSelections = [StdLoosePions]) from PhysSelPython.Wrappers import SelectionSequence SeqKsPiPi = SelectionSequence('SeqKsPiPi', TopSelection = LooseKsPiPi) KsPiPiTuple = DecayTreeTuple("KsPiPiTuple") # input locations KsPiPiTuple.Inputs = [ LooseKsPiPi.outputLocation() ] # decay descriptors KsPiPiTuple.Decay = "KS0 -> ^pi+ ^pi-" # define the tools and configure them KsPiPiTuple.ToolList = [ "TupleToolKinematic"
def __init__(self, name, config): self.name = name LineBuilder.__init__(self, name, config) ################################################################################# # Configure trigger ################################################################################# l0 = None if config['L0']: l0 = "L0_CHANNEL_RE('%s')" % ('|'.join(config['L0'])) hlt1 = None if config['HLT1']: hlt1 = "HLT_PASS_RE('%s')" % ('|'.join(config['HLT1'])) hlt2 = None if config['HLT2']: hlt2 = "HLT_PASS_RE('%s')" % ('|'.join(config['HLT2'])) ################################################################################# # Build Lambda_0 ################################################################################# tracks_code = """(MAXTREE(TRCHI2DOF, HASTRACK) < %(Track_Chi2ndf_Max)s) & (MINTREE(TRCHI2DOF, HASTRACK) < %(Track_MinChi2ndf_Max)s) & (MAXTREE(TRGHOSTPROB, HASTRACK) < %(Track_GhostProb_Max)s) & (INTREE(('p+'==ABSID) & (PT > %(Proton_Pt_Min)s))) & (INTREE(('pi+'==ABSID) & (PT > %(Pion_Pt_Min)s))) & (INTREE(('p+'==ABSID) & (P > %(Proton_P_Min)s))) & (INTREE(('pi+'==ABSID) & (P > %(Pion_P_Min)s)))""" lambda0_ll_dod = DataOnDemand( Location='Phys/StdLooseLambdaLL/Particles') lambda0_ll_code = """(PT>%(Lambda0_Pt_Min)s*MeV) & (VFASPF(VCHI2/VDOF)<%(Lambda0_VtxChi2_Max)s) & (MINTREE(MIPCHI2DV(PRIMARY), ISLONG) > %(TrackLL_IPChi2_Min)s) & (MIPDV(PRIMARY) > %(Lambda0LL_IP_Min)s*mm) & (ADMASS('Lambda0') < %(Lambda0LL_MassWindow)s*MeV)""" lambda0_ll_code = (lambda0_ll_code + " & " + tracks_code) % config lambda0_ll_filter = FilterDesktop(Code=lambda0_ll_code) lambda0_ll = Selection("LooseLambda0LL", Algorithm=lambda0_ll_filter, RequiredSelections=[lambda0_ll_dod]) lambda0_dd_dod = DataOnDemand( Location='Phys/StdLooseLambdaDD/Particles') lambda0_dd_code = """(PT>%(Lambda0_Pt_Min)s*MeV) & (VFASPF(VCHI2/VDOF)<%(Lambda0_VtxChi2_Max)s) & (ADMASS('Lambda0') < %(Lambda0DD_MassWindow)s*MeV)""" lambda0_dd_code = (lambda0_dd_code + " & " + tracks_code) % config lambda0_dd_filter = FilterDesktop(Code=lambda0_dd_code) lambda0_dd = Selection("LooseLambda0DD", Algorithm=lambda0_dd_filter, RequiredSelections=[lambda0_dd_dod]) lambda0 = MergedSelection("LooseLambda0", RequiredSelections=[lambda0_ll, lambda0_dd]) ################################################################################# # Filter photons ################################################################################# photons_noncnv_filter = FilterDesktop( Code="(PT > %(Photon_PT_Min)s*MeV) & (CL > %(Photon_CL_Min)s)" % config) photons_noncnv = Selection("Photons_NonCnv", Algorithm=photons_noncnv_filter, RequiredSelections=[StdLooseAllPhotons]) photons_cnv_merged = MergedSelection( "Photons_Cnv_Merge", RequiredSelections=[StdAllLooseGammaDD, StdAllLooseGammaLL]) photons_cnv_code = """(HASVERTEX) & (MM < %(PhotonCnv_MM_Max)s*MeV) & (PT > %(PhotonCnv_PT_Min)s*MeV) & (VFASPF(VCHI2/VDOF)<%(PhotonCnv_VtxChi2_Max)s)""" % config photons_cnv_filter = FilterDesktop(Code=photons_cnv_code % config) photons_cnv = Selection("Photons_Cnv", Algorithm=photons_cnv_filter, RequiredSelections=[photons_cnv_merged]) ################################################################################# # Build Lambda_b ################################################################################# # With non-converted photons lambda_b_combine = CombineParticles("Lambdab_NonConv_Combine") lambda_b_combine.DecayDescriptor = "[Lambda_b0 -> Lambda0 gamma]cc" lambda_b_combine.DaughtersCuts = {'Lambda0': 'ALL', 'gamma': 'ALL'} lambda_b_combine.ParticleCombiners = {'': 'MomentumCombiner:PUBLIC'} lambda_b_combine.CombinationCut = """(ADAMASS('Lambda_b0') < %(Lambdab_MassWindow)s*MeV) & (ASUM(PT) > %(Lambdab_SumPt_Min)s )""" % config lambda_b_combine.MotherCut = """(PT > %(Lambdab_Pt_Min)s*MeV) & (MTDOCACHI2(1) < %(Lambdab_MTDOCAChi2_Max)s)""" % config lambda_b = Selection("Lambdab_NonConv_Sel", Algorithm=lambda_b_combine, RequiredSelections=[photons_noncnv, lambda0]) # With converted photons lambda_b_cnv_combine = CombineParticles("Lambdab_Conv_Combine") lambda_b_cnv_combine.DecayDescriptor = "[Lambda_b0 -> Lambda0 gamma]cc" lambda_b_cnv_combine.DaughtersCuts = {'Lambda0': 'ALL', 'gamma': 'ALL'} lambda_b_cnv_combine.ParticleCombiners = { "": "OfflineVertexFitter:PUBLIC" } lambda_b_cnv_combine.CombinationCut = "(ADAMASS('Lambda_b0') < 1.5*%(Lambdab_MassWindow)s*MeV)" % config lambda_b_cnv_combine.MotherCut = """(HASVERTEX) & (VFASPF(VCHI2/VDOF)<%(Lambdab_VtxChi2_Max)s) & (PT > %(Lambdab_Pt_Min)s*MeV) & (BPVIPCHI2() < %(Lambdab_IPChi2_Max)s) & (ADMASS('Lambda_b0') < %(Lambdab_MassWindow)s*MeV)""" % config #(MTDOCACHI2(1) < %(Lambdab_MTDOCAChi2_Max)s) & lambda_b_cnv = Selection("Lambdab_Conv_Sel", Algorithm=lambda_b_cnv_combine, RequiredSelections=[photons_cnv, lambda0]) ################################################################################# # Build lines ################################################################################# children = {'L0': '[Lambda_b0 -> ^Lambda0 gamma]CC'} self.line = StrippingLine("Lb2L0Gamma", prescale=config["Lb2L0GammaPrescale"], L0DU=l0, HLT1=hlt1, HLT2=hlt2, checkPV=True, RelatedInfoTools=[ self.get_cone_relinfo(1.7, children=children), self.get_cone_relinfo(1.35, children=children), self.get_cone_relinfo(1.0, children=children), ], RequiredRawEvents=['Calo'], MDSTFlag=True, selection=lambda_b) self.registerLine(self.line) self.line_cnv = StrippingLine( "Lb2L0GammaConverted", prescale=config["Lb2L0GammaPrescale"], L0DU=l0, HLT1=hlt1, HLT2=hlt2, checkPV=True, RelatedInfoTools=[ self.get_cone_relinfo(1.7, lambda_b_cnv, children), self.get_cone_relinfo(1.35, lambda_b_cnv, children), self.get_cone_relinfo(1.0, lambda_b_cnv, children), self.get_vtxisol_relinfo(lambda_b_cnv), ], RequiredRawEvents=['Calo'], MDSTFlag=True, selection=lambda_b_cnv) self.registerLine(self.line_cnv)