def _strippingLine ( self, name , # the base name for the Line prescale = 1.0 , # prescale factor ODIN = None , # ODIN predicate L0DU = None , # L0DU predicate HLT = None , # HltDecReports predicate FILTER = None , # 'VOID'-predicate, e.g. Global Event Cut checkPV = True , # Check PV before running algos algos = None , # the list of stripping members selection = None , postscale = 1.0 , # postscale factor MaxCandidates = "Override", # Maxumum number MaxCombinations = "Override", # Maxumum number HDRLocation = None ) : # other configuration parameters # { if (prescale > 0) and (postscale > 0) : # { line = StrippingLine( name, prescale = prescale, ODIN = ODIN, L0DU = L0DU, HLT = HLT, FILTER = FILTER, checkPV = checkPV, algos = algos, selection = selection, postscale = postscale, MaxCandidates = MaxCandidates, MaxCombinations = MaxCombinations, HDRLocation = HDRLocation ) self.registerLine(line) return line # } else : return False
def make_line(self, name, selection, prescale, postscale, **kwargs): """Create the stripping line defined by the selection. Keyword arguments: name -- Base name for the Line selection -- Selection instance prescale -- Fraction of candidates to randomly drop before stripping postscale -- Fraction of candidates to randomly drop after stripping **kwargs -- Keyword arguments passed to StrippingLine constructor """ # Only create the line with positive pre- and postscales # You can disable each line by setting either to a negative value if prescale > 0 and postscale > 0: line = StrippingLine( name, selection=selection, prescale=prescale, postscale=postscale, **kwargs ) self.registerLine(line) return line else: return False
def __init__(self, name, config): self.name = name LineBuilder.__init__(self, name, config) _trkFilter = FilterDesktop( Code="(TRCHI2DOF < 4) & (MIPCHI2DV(PRIMARY) > 16) & (PT > 250*MeV)" ) self.TrackList = Selection('TrackList' + self.name, Algorithm=_trkFilter, RequiredSelections=[StdNoPIDsPions]) self.DiTrackList = mkDiTrackList( name="DiTracksForCharmlessB" + self.name, trkList=self.TrackList, MinPTCut=config['Q2BResMinPT'], MinPCut=config['Q2BResMinP'], MaxMassCut=config['Q2BResMaxMass'], VtxChi2DOFCut=config['Q2BResVtxChiDOF']) Bs2Q2BName = self.name self.B2CharmlessQ2B4pi = mkBs2Q2B4pi( Bs2Q2BName, diTrkList=self.DiTrackList, MinMassCut=config['Q2BBMinM'], MaxMassCut=config['Q2BBMaxM'], MinCorrMCut=config['Q2BBMinCorrM'], MaxCorrMCut=config['Q2BBMaxCorrM'], VtxChi2DOFCut=config['Q2BBVtxChi2DOF'], MinTrkPTCut=config['Q2BBMinTrkPT'], BIPchi2Cut=config['Q2BIPCHI2']) self.Q2B4piLine = StrippingLine(Bs2Q2BName + "Line", prescale=config['Q2BPrescale'], selection=self.B2CharmlessQ2B4pi) self.registerLine(self.Q2B4piLine)
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 __init__(self, name, config): LineBuilder.__init__(self, name, config) dd_name = name + 'DD' ll_name = name + 'LL' GECCode = { 'Code': "(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %s)" % config['GEC_MaxTracks'], 'Preambulo': ["from LoKiTracks.decorators import *"] } Hlt1Filter = { 'Code': "HLT_PASS_RE('%s')" % config['HLT1Dec'], 'Preambulo': ["from LoKiCore.functions import *"] } Hlt2Filter = { 'Code': "HLT_PASS_RE('%s')" % config['HLT2Dec'], 'Preambulo': ["from LoKiCore.functions import *"] } relInfo = [{ "Type": "RelInfoConeVariables", "ConeAngle": config['ConeAngle10'], "Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'], 'Location': 'P2ConeVar10_B', "DaughterLocations": { "[B+ -> ^pi+ pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar10_1', "[B+ -> pi+ ^pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar10_2', "[B+ -> pi+ pi- (K*(892)+ -> ^KS0 pi+)]CC": 'P2ConeVar10_3', "[B+ -> pi+ pi- (K*(892)+ -> KS0 ^pi+)]CC": 'P2ConeVar10_4' } }, { "Type": "RelInfoConeVariables", "ConeAngle": config['ConeAngle15'], "Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'], 'Location': 'P2ConeVar15_B', "DaughterLocations": { "[B+ -> ^pi+ pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar15_1', "[B+ -> pi+ ^pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar15_2', "[B+ -> pi+ pi- (K*(892)+ -> ^KS0 pi+)]CC": 'P2ConeVar15_3', "[B+ -> pi+ pi- (K*(892)+ -> KS0 ^pi+)]CC": 'P2ConeVar15_4' } }, { "Type": "RelInfoConeVariables", "ConeAngle": config['ConeAngle17'], "Variables": ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'], 'Location': 'P2ConeVar17_B', "DaughterLocations": { "[B+ -> ^pi+ pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar17_1', "[B+ -> pi+ ^pi- (K*(892)+ -> KS0 pi+)]CC": 'P2ConeVar17_2', "[B+ -> pi+ pi- (K*(892)+ -> ^KS0 pi+)]CC": 'P2ConeVar17_3', "[B+ -> pi+ pi- (K*(892)+ -> KS0 ^pi+)]CC": 'P2ConeVar17_4' } }, { "Type": "RelInfoVertexIsolation", "Location": 'VtxIsolationVar' }] self.pions = Pions self.makeKS2DD('KSfor' + dd_name, config) self.makeKS2LL('KSfor' + ll_name, config) self.makeKst2KSDDpi('Kstfor' + dd_name, config) self.makeKst2KSLLpi('Kstfor' + ll_name, config) self.makeBu2KstDDhh(dd_name, config) self.makeBu2KstLLhh(ll_name, config) self.dd_line = StrippingLine(dd_name + "Line", prescale=config['Prescale'], postscale=config['Postscale'], selection=self.selBu2KstDDhh, HLT1=Hlt1Filter, HLT2=Hlt2Filter, FILTER=GECCode, RelatedInfoTools=relInfo, EnableFlavourTagging=True, MDSTFlag=True) self.ll_line = StrippingLine(ll_name + "Line", prescale=config['Prescale'], postscale=config['Postscale'], selection=self.selBu2KstLLhh, HLT1=Hlt1Filter, HLT2=Hlt2Filter, FILTER=GECCode, RelatedInfoTools=relInfo, EnableFlavourTagging=True, MDSTFlag=True) self.registerLine(self.dd_line) self.registerLine(self.ll_line)
def _Lb2PhipK_X_Line(self, name, config): # Cuts on the phi and KK pair Phi2KK_DC = "(TRGHOSTPROB < 0.5) & (PT>%(KaonPT)s*MeV)&(MIPCHI2DV(PRIMARY)>%(KaonIPCHI2)s)" % config Phi2KK_CC = "(AM<(%(PhiMassMax)s+30)*MeV)&(ADOCACHI2CUT(40, ''))" % config Phi2KK_MassCut = "&(ADMASS('phi(1020)')<%(PhiMassWindow)s*MeV)" % config Phi2KK_MC = "(VFASPF(VCHI2/VDOF)<%(PhiVertexCHI2pDOF)s)" % config + Phi2KK_MassCut # Same cuts are applied to both the proton and kaon in the pK pair pK_DC = "(TRGHOSTPROB < 0.5) & (PT>%(KaonPT)s*MeV)&(MIPCHI2DV(PRIMARY)>%(KaonIPCHI2)s)" % config pK_CC = "(AM<(4600)*MeV)&(ADOCACHI2CUT(40, ''))" % config pK_MC = "(VFASPF(VCHI2/VDOF)<%(PhiVertexCHI2pDOF)s)" % config # Cuts on the Lambda_b Lb2PhipK_DC = "(PT>%(PhiPT)s*MeV)" % config Lb2PhipK_CC = "(ADAMASS('Lambda_b0')<((%(BsMassWindow)s+30)*MeV))&(ACHILD(PT,1)*ACHILD(PT,2)>%(PhiPTsq)s*GeV*GeV)" % config Lb2PhipK_MC = "(BPVDIRA > 0.999) & (VFASPF(VCHI2/VDOF)<%(BsVertexCHI2pDOF)s)&(ADMASS('Lambda_b0')<%(BsMassWindow)s*MeV)" % config ps = 1.0 _Lb2PhipKLooseDetachedPhi2KK = CombineParticles( DecayDescriptor="phi(1020) -> K+ K-", DaughtersCuts={"K+": Phi2KK_DC}, CombinationCut=Phi2KK_CC, MotherCut=Phi2KK_MC) # Lambda(1520)0 used as nominal intermediary particle for the pK pair _Lb2PhipKLooseDetachedpK = CombineParticles( DecayDescriptor="Lambda(1520)0 -> p+ K-", DaughtersCuts={ "K-": pK_DC, "p+": pK_DC }, CombinationCut=pK_CC, MotherCut=pK_MC) _Lb2PhipK = CombineParticles( DecayDescriptor="Lambda_b0 -> Lambda(1520)0 phi(1020)", DaughtersCuts={ "phi(1020)": Lb2PhipK_DC, "Lambda(1520)0": Lb2PhipK_DC }, CombinationCut=Lb2PhipK_CC, MotherCut=Lb2PhipK_MC) Lb2PhipKLooseDetachedPhi2KK = Selection( name + "_LoosePhi2KK", Algorithm=_Lb2PhipKLooseDetachedPhi2KK, RequiredSelections=[MyLooseKaons]) Lb2PhipKLooseDetachedpK = Selection( name + "_LoosepK", Algorithm=_Lb2PhipKLooseDetachedpK, RequiredSelections=[MyLooseKaons, MyLooseProtons]) Lb2PhipK = Selection(name, Algorithm=_Lb2PhipK, RequiredSelections=[ Lb2PhipKLooseDetachedPhi2KK, Lb2PhipKLooseDetachedpK ]) return StrippingLine(name + "Line", prescale=ps, postscale=1, selection=Lb2PhipK, EnableFlavourTagging=False)
def _lines_psiX(self): """ Get all psiX lines """ sel = self._selection('PsiX_Lines') if sel: return sel # sel = [ # ================================================================= # ## 1h # StrippingLine("B2PsiPiFor" + self.name(), prescale=self['B2PsiPiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_pi()]), ## StrippingLine("B2PsiKFor" + self.name(), prescale=self['B2PsiKPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_K()]), # ## 2h # StrippingLine("B2Psi2PiFor" + self.name(), prescale=self['B2Psi2PiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_2pi()]), ## StrippingLine("B2PsiKPiFor" + self.name(), prescale=self['B2PsiKPiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_Kpi()]), # StrippingLine("B2Psi2KFor" + self.name(), prescale=self['B2Psi2KPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_2K()]), # ## 3h # StrippingLine("B2Psi3KFor" + self.name(), prescale=self['B2Psi3KPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_3K()]), ## StrippingLine("B2Psi3PiFor" + self.name(), prescale=self['B2Psi3PiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_3pi()]), ## StrippingLine("B2Psi3KPiFor" + self.name(), prescale=self['B2Psi3KPiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_3Kpi()]), # ## 4h # StrippingLine("B2Psi4PiFor" + self.name(), prescale=self['B2Psi4PiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_4pi()]), ## StrippingLine("B2Psi4KPiFor" + self.name(), prescale=self['B2Psi4KPiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_4Kpi()]), ## StrippingLine("B2Psi4KFor" + self.name(), prescale=self['B2Psi4KPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_4K()]), # ## 5h # StrippingLine("B2Psi5PiFor" + self.name(), prescale=self['B2Psi5PiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_5pi()]), ## StrippingLine("B2Psi5KPiFor" + self.name(), prescale=self['B2Psi5KPiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_5Kpi()]), # ## 6h # StrippingLine("B2Psi6PiFor" + self.name(), prescale=self['B2Psi6PiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_5pi()]), ## StrippingLine("B2Psi6KPiFor" + self.name(), prescale=self['B2Psi6KPiPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_5Kpi()]), ## # ================================================================= # Helper line to study gamma/pi0 reconstruction efficiency # ================================================================= StrippingLine("B2PsiKstFor" + self.name(), prescale=self['B2PsiKstPrescale'], checkPV=self['CheckPV'], FILTER=self['FILTER'], ODIN=self['ODIN'], L0DU=self['L0DU'], HLT=self['L0DU'], algos=[self.psi_Kst()]), ## # ================================================================= ] ## return self._add_selection('PsiX_Lines', sel)
def __init__(self, NAME, CONFIG): ## Required the explicit name/dconfig, no default allow LineBuilder.__init__(self, NAME, CONFIG) ## Prepare raw particle for identification preambulo = CONFIG['preambulo'] ditau_pcomb = CONFIG['ditau_pcomb'] input_e = [AutomaticData(Location=CONFIG['TES_e'])] input_mu = [AutomaticData(Location=CONFIG['TES_mu'])] input_pi = [AutomaticData(Location=CONFIG['TES_pi'])] ## Make pre-selection tau candidates, no isolation here. ## Merge these together (parallel, not sequential selection) tau_noiso = MergedSelection('TauNoiso', [ selection_filt(CONFIG['tau_e'], preambulo, input_e, 'SelTauNoiso_e'), selection_filt(CONFIG['tau_mu'], preambulo, input_mu, 'SelTauNoiso_mu'), selection_filt(CONFIG['tau_h1'], preambulo, input_pi, 'SelTauNoiso_h1'), selection_tau_h3(CONFIG, preambulo, input_pi), ]) # ## Cut on isolation: RelInfoConeVariables + AddRelatedInfo + FilterDesktop tau_iso = selection_tauiso(tau_noiso, CONFIG['tau_isolation']) ## Prepare selection of ditau # Selections, indexed by dcname (for emu sharing). Think of it as caching. sels_ditau = {} ## Loop over all lines, make groupping for linename, condict in CONFIG['CONSTRUCTORS'].iteritems(): ## Make the fullname: e.g., 'Ditau' + 'EXss' + 'Line' fullname = NAME + linename + 'Line' ## Get list of decay, indexed by Line's name dcdict = lines_decays[linename] ## Make list of selections to be put in single line sels = [] for dcname, decay in dcdict.iteritems(): ## Make selection if it hasn't been done. if dcname not in sels_ditau: dtype = dcname.split('_')[0] # eh1_ss --> eh1 config = CONFIG['DITAU'][ dtype] # Same ditau-level config for OS/SS inputs = [tau_noiso if 'noiso' in linename else tau_iso] # inputs = [ tau_noiso ] sel = selection_ditau(config, preambulo, ditau_pcomb, dcname, decay, inputs) sels_ditau[dcname] = sel sels.append(sels_ditau[dcname]) ## Finally, merged it selection = MergedSelection('Sel' + linename, sels) # ## Adding isolation cut on the ditau level. # filt = None # if 'noiso' not in linename: # filt = rif_isolation( fullname, CONFIG['tau_isolation'] ) ## Finally, compose a stripping line, register self.registerLine( StrippingLine( fullname, selection=selection, # RelatedInfoFilter = filt, **CONFIG['CONSTRUCTORS'][linename]))
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="(PT>1.2*GeV)"), RequiredSelections=[self.selmuon]) self.selmuontight = Selection( "Mutightfor" + name, Algorithm=FilterDesktop(Code="(MIPCHI2DV(PRIMARY)> 100)"), RequiredSelections=[self.selmuonhighPT]) 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.seld02kpi = Selection( "D02KPifor" + name, Algorithm=self._D02KPiFilter(), RequiredSelections=[self.selKaon, self.selPion]) 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.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.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.selmuon, 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.selmuon, 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.selmuon, DSel=self.sellambdac, BVCHI2DOF=config['BVCHI2DOF'], BDIRA=config['BDIRA'], DZ=config['DZ']) self.b2D0MuXLine = StrippingLine( 'b2D0MuX' + name + 'Line' #, HLT = " HLT_PASS_RE('Hlt.*(Muon|MuTrack).*Decision') " , prescale=1, selection=self.selb2D0MuX) self.b2D0MuXK3PiLine = StrippingLine( 'b2D0MuXK3Pi' + name + 'Line' # , HLT = " HLT_PASS_RE('Hlt.*(Muon|MuTrack).*Decision') " , 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.registerLine(self.b2D0MuXLine) self.registerLine(self.b2DpMuXLine) self.registerLine(self.b2DsMuXLine) self.registerLine(self.b2LcMuXLine) self.registerLine(self.b2D0MuXK3PiLine)
def __init__(self, moduleName, config): LineBuilder.__init__(self, moduleName, config) selD02hhhh = makeD02hhhh( moduleName = moduleName ,combMassWin = config['CombD0MassWin'] ,massWin = config['D0MassWin'] ,maxDOCA = config['D0MaxDOCA'] ,pt = config['D0Pt'] ,dauPt = config['D0DauPt'] ,dauMom = config['D0DauP'] ,vtxChi2DOF = config['D0VtxChi2DOF'] ,FDChi2 = config['D0FDChi2'] ,IPChi2 = config['D0IPChi2'] ,dauMaxIPChi2 = config['D0DauMaxIPChi2'] ,dauIPChi2 = config['D0DauIPChi2'] ,DIRA = config['D0DIRA'] ,trackChi2DOF = config['TrackChi2DOF'] ,applyKaonPIDK = config['ApplyKaonPIDK'] ,kaonPIDK = config['KaonPIDK'] ,applyPionPIDK = config['ApplyPionPIDK'] ,pionPIDK = config['PionPIDK'] ,applyGhostProbCut = config['ApplyGhostProbCut'] ,ghostProbCut = config['GhostProbCut'] ,runK3pi = config['RunK3pi'] ,run4pi = config['Run4pi'] ,run2K2pi = config['Run2K2pi'] ,run3Kpi = config['Run3Kpi'] ) selPromptDstar = makePromptDstar( moduleName = moduleName ,selection = selD02hhhh ,combDelmLower = config['CombDelmLower'] ,combDelmUpper = config['CombDelmUpper'] ,delmLower = config['DelmLower'] ,delmUpper = config['DelmUpper'] ,DOCA = config['DstarDOCA'] ,vertexChi2DOF = config['DstarVtxChi2DOF'] ,pt = config['DstarPt'] ,slowPionPt = config['SlowPionPt'] ,trackChi2DOF = config['TrackChi2DOF'] ) _GECfilter = None if config['ApplyGECs']: _filter = "" nLong = config["MaxLongTracks"] if nLong is not None: if _filter != "": _filter+=" & " _filter += "( recSummaryTrack(LHCb.RecSummary.nLongTracks,TrLONG) < %s )" %nLong nDigits = config["MaxSpdDigits"] if nDigits is not None: if _filter != "": _filter+=" & " _filter += "( recSummary(LHCb.RecSummary.nSpdhits,'Raw/Spd/Digits') < %s )" %nDigits nClusters = config["MaxITClusters"] if nClusters is not None: if _filter != "": _filter+=" & " _filter += " ( recSummary(LHCb.RecSummary.nITClusters,'Raw/IT/Clusters') < %s )" %nClusters nVELO = config["MaxVeloTracks"] if nVELO is not None: if _filter != "": _filter+=" & " _filter += "( recSummaryTrack(LHCb.RecSummary.nVeloTracks,TrVELO) < %s )" %nVELO if _filter != "": _GECfilter = {'Code' : _filter, 'Preambulo' : ["from LoKiTracks.decorators import *", 'from LoKiNumbers.decorators import *', 'from LoKiCore.functions import *'] } self.line_tagged_d02hhhh = StrippingLine( moduleName+"Line" ,prescale=config['Prescale'] ,postscale=config['Postscale'] ,selection=selPromptDstar ,checkPV=config['CheckPV'] ,RelatedInfoTools = [ { 'Type' : 'RelInfoConeVariables', 'ConeAngle' : 1.5, 'Variables' : ['CONEANGLE', 'CONEMULT', 'CONEPTASYM'], 'RecursionLevel' : 1, 'Locations' : { selPromptDstar : 'P2CVDstar1', selD02hhhh : 'P2CVD1', } }, ] ,FILTER=_GECfilter) self.registerLine(self.line_tagged_d02hhhh)
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) 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 line = StrippingLine( lLineName, prescale=self.validatedGetProps(lShortName, ["PreScale"])["PreScale"] # these lines MUST have an HLT filter , HLT=self.validatedGetProps("HLT", [lShortName])[lShortName], selection=withVeloCandidates) 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='Tau23Mu', config=None): LineBuilder.__init__(self, name, config) #checkConfig(Bs2MuMuLinesConf.__configuration_keys__,config) tau_name = name + 'Tau23Mu' ds23PiTIS_name = name + 'Ds23PiTIS' ds23Pi_name = name + 'Ds23Pi' ds2PhiPi_name = name + 'Ds2PhiPi' tau25_name = name + 'Tau25Mu' tau2pmm_name = name + 'Tau2PMuMu' self.selTau23Mu = makeTau23Mu(tau_name, config) #self.selDs23PiTIS = makeDs23PiTIS(self,ds23PiTIS_name) self.selDs23Pi = makeDs23Pi(ds23Pi_name, config) self.selDs2PhiPi = makeDs2PhiPi(ds2PhiPi_name, config) self.selTau25Mu = makeTau25Mu(tau25_name, config) self.selTau2PMuMu = makeTau2pmm(tau2pmm_name, config) self.tau23MuLine = StrippingLine( tau_name + "Line", prescale=config['TauPrescale'], postscale=config['TauPostscale'], MDSTFlag=True, RequiredRawEvents=["Calo"], algos=[self.selTau23Mu], RelatedInfoTools=[{ 'Type': 'RelInfoConeVariables', 'ConeAngle': 1., 'Variables': ['CONEANGLE', 'CONEMULT', 'CONEPT', 'CONEPTASYM'], 'Location': 'ConeIsoInfo', 'DaughterLocations': { '[tau+ -> ^mu+ mu+ mu-]CC': 'MuonConeVarInfo1', '[tau+ -> mu+ ^mu+ mu-]CC': 'MuonConeVarInfo2', '[tau+ -> mu+ mu+ ^mu-]CC': 'MuonConeVarInfo3' } }, { 'Type': 'RelInfoVertexIsolation', 'Location': 'VtxIsoInfo' }, { 'Type': 'RelInfoTrackIsolationBDT', 'Variables': 0, 'Location': 'TrackIsoInfo', 'DaughterLocations': { '[tau+ -> ^mu+ mu+ mu-]CC': 'MuonTrackIsoBDTInfo1', '[tau+ -> mu+ ^mu+ mu-]CC': 'MuonTrackIsoBDTInfo2', '[tau+ -> mu+ mu+ ^mu-]CC': 'MuonTrackIsoBDTInfo3' } }]) #self.ds23PiTISLine = StrippingLine(ds23PiTIS_name+"Line", # prescale = config['Ds23PiTISPrescale'], # postscale = config['TauPostscale'], # algos = [ self.selDs23PiTIS ] # ) self.ds23PiLine = StrippingLine(ds23Pi_name + "Line", prescale=config['Ds23PiPrescale'], postscale=config['TauPostscale'], MDSTFlag=True, RequiredRawEvents=[], algos=[self.selDs23Pi]) self.ds2PhiPiLine = StrippingLine( ds2PhiPi_name + "Line", prescale=config['Ds2PhiPiPrescale'], postscale=config['TauPostscale'], MDSTFlag=True, RequiredRawEvents=["Calo"], algos=[self.selDs2PhiPi], RelatedInfoTools=[{ 'Type': 'RelInfoConeVariables', 'ConeAngle': 1., 'Variables': ['CONEANGLE', 'CONEMULT', 'CONEPT', 'CONEPTASYM'], 'Location': 'ConeIsoInfo', 'DaughterLocations': { '[D_s+ -> ^pi+ mu+ mu-]CC': 'PionConeVarInfo', '[D_s+ -> pi+ ^mu+ mu-]CC': 'MuonConeVarInfo1', '[D_s+ -> pi+ mu+ ^mu-]CC': 'MuonConeVarInfo2' } }, { 'Type': 'RelInfoVertexIsolation', 'Location': 'VtxIsoInfo' }, { 'Type': 'RelInfoTrackIsolationBDT', 'Variables': 0, 'Location': 'TrackIsoInfo', 'DaughterLocations': { '[D_s+ -> ^pi+ mu+ mu-]CC': 'PionTrackIsoBDTInfo', '[D_s+ -> pi+ ^mu+ mu-]CC': 'MuonTrackIsoBDTInfo1', '[D_s+ -> pi+ mu+ ^mu-]CC': 'MuonTrackIsoBDT_mu_2' } }]) self.tau25MuLine = StrippingLine(tau25_name + "Line", prescale=config['Tau25Prescale'], postscale=config['TauPostscale'], MDSTFlag=True, RequiredRawEvents=[], algos=[self.selTau25Mu]) self.tau2PMuMuLine = StrippingLine( tau2pmm_name + "Line", prescale=config['Tau2PMuMuPrescale'], postscale=config['TauPostscale'], MDSTFlag=True, RequiredRawEvents=["Calo"], algos=[self.selTau2PMuMu], RelatedInfoTools=[{ 'Type': 'RelInfoConeVariables', 'ConeAngle': 1., 'Variables': ['CONEANGLE', 'CONEMULT', 'CONEPT', 'CONEPTASYM'], 'Location': 'ConeIsoInfo', 'DaughterLocations': { "[[ tau+ -> ^p+ mu+ mu- ]CC, [ tau+ -> ^p~- mu+ mu+ ]CC, [ Lambda_c+ -> ^p+ mu+ mu- ]CC, [ Lambda_c+ -> ^p~- mu+ mu+ ]CC]": 'ProtonConeVarInfo', "[[ tau+ -> p+ ^mu+ mu- ]CC, [ tau+ -> p~- ^mu+ mu+ ]CC, [ Lambda_c+ -> p+ ^mu+ mu- ]CC, [ Lambda_c+ -> p~- ^mu+ mu+ ]CC]": 'MuonConeVarInfo1', "[[ tau+ -> p+ mu+ ^mu- ]CC, [ tau+ -> p~- mu+ ^mu+ ]CC, [ Lambda_c+ -> p+ mu+ ^mu- ]CC, [ Lambda_c+ -> p~- mu+ ^mu+ ]CC]": 'MuonConeVarInfo2' } }, { 'Type': 'RelInfoVertexIsolation', 'Location': 'VtxIsoInfo' }, { 'Type': 'RelInfoTrackIsolationBDT', 'Variables': 0, 'Location': 'TrackIsoInfo', 'DaughterLocations': { "[[ tau+ -> ^p+ mu+ mu- ]CC, [ tau+ -> ^p~- mu+ mu+ ]CC, [ Lambda_c+ -> ^p+ mu+ mu- ]CC, [ Lambda_c+ -> ^p~- mu+ mu+ ]CC]": 'ProtonTrackIsoBDTInfo', "[[ tau+ -> p+ ^mu+ mu- ]CC, [ tau+ -> p~- ^mu+ mu+ ]CC, [ Lambda_c+ -> p+ ^mu+ mu- ]CC, [ Lambda_c+ -> p~- ^mu+ mu+ ]CC]": 'MuonTrackIsoBDTInfo1', "[[ tau+ -> p+ mu+ ^mu- ]CC, [ tau+ -> p~- mu+ ^mu+ ]CC, [ Lambda_c+ -> p+ mu+ ^mu- ]CC, [ Lambda_c+ -> p~- mu+ ^mu+ ]CC]": 'MuonTrackIsoBDTInfo2' } }]) self.registerLine(self.tau23MuLine) #self.registerLine(self.ds23PiTISLine) self.registerLine(self.ds23PiLine) self.registerLine(self.ds2PhiPiLine) self.registerLine(self.tau25MuLine) self.registerLine(self.tau2PMuMuLine)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) prescaled_name = name + 'Prescaled' self.selMuons = makeMuons('MuonsFor' + prescaled_name, TRACK_Chi2=config['TRACK_Chi2'], MUON_MinPT=config['MUON_MinPT'], MUON_PIDmu=config['MUON_PIDmu']) self.selKaons = makeKaons('KaonsFor' + prescaled_name, TRACK_Chi2=config['TRACK_Chi2'], KAON_PIDK=config['KAON_PIDK'], KAON_MinPT=config['KAON_MinPT']) self.selPions = makePions('PionsFor' + prescaled_name, TRACK_Chi2=config['TRACK_Chi2'], PION_PIDmu=config['PION_PIDmu'], PION_PIDK=config['PION_PIDK'], PION_MinPT=config['PION_MinPT']) self.selSlowPions = makeSlowPions('SlowPionsFor' + prescaled_name, TRACK_Chi2=config['TRACK_Chi2'], PION_PIDmu=config['PION_PIDmu']) self.selKstar = makeKstar('KstarFor' + prescaled_name, pionSel=self.selPions, kaonSel=self.selKaons, Kstar_MinPT=config['Kstar_MinPT'], Kstar_MassMax=config['Kstar_MassMax'], Kstar_MassMin=config['Kstar_MassMin']) self.selRho = makeRho('RhoFor' + prescaled_name, pionSel=self.selPions, Rho_MinPT=config['Rho_MinPT'], Rho_MassMax=config['Rho_MassMax'], Rho_MassMin=config['Rho_MassMin']) self.selDplus2KstarMuNu = makeDplus2KstarMuNu( 'Dplus2RhoMuNuFor' + prescaled_name, muonSel=self.selMuons, KstarSel=self.selKstar, PAIR_SumPTMin=config['PAIR_SumPTMin'], D_MassMax=config['D_MassMax'], D_DIRA=config['D_DIRA'], D_DOCA=config['D_DOCA'], D_MinP=config['D_MinP'], Dplus_FD=config['Dplus_FD'], D_MCORR_MIN=config['D_MCORR_MIN'], D_MCORR_MAX=config['D_MCORR_MAX'], D_BPVVDZ=config['D_BPVVDZ'], D_VtxChi2=config['D_VtxChi2']) self.selDplus2RhoMuNu = makeDplus2RhoMuNu( 'Dplus2KstarMuNuFor' + prescaled_name, muonSel=self.selMuons, RhoSel=self.selRho, PAIR_SumPTMin=config['PAIR_SumPTMin'], D_MassMax=config['D_MassMax'], D_DIRA=config['D_DIRA'], D_DOCA=config['D_DOCA'], D_MinP=config['D_MinP'], Dplus_FD=config['Dplus_FD'], D_MCORR_MIN=config['D_MCORR_MIN'], D_MCORR_MAX=config['D_MCORR_MAX'], D_BPVVDZ=config['D_BPVVDZ'], D_VtxChi2=config['D_VtxChi2']) self.selD02PiMuNu = makeD02PiMuNu( 'D0PiMuNuFor' + prescaled_name, muonSel=self.selMuons, pionSel=self.selPions, PAIR_SumPTMin=config['PAIR_SumPTMin'], D_MassMax=config['D_MassMax'], D_DIRA=config['D_DIRA'], D_DOCA=config['D_DOCA'], D_MinP=config['D_MinP'], D0_FD=config['D0_FD'], D_MCORR_MIN=config['D_MCORR_MIN'], D_MCORR_MAX=config['D_MCORR_MAX'], D_BPVVDZ=config['D_BPVVDZ'], D_VtxChi2=config['D_VtxChi2']) self.selDstarD02PiMuNu = makeDstarD02PiMuNu( 'DstarD0PiMuNuFor' + prescaled_name, D02PiMuNuSel=self.selD02PiMuNu, slowPionSel=self.selSlowPions, Dstar_MassMin=config['Dstar_MassMin'], Dstar_DOCA=config['Dstar_DOCA'], Dstar_VtxChi2=config['Dstar_VtxChi2'], Dstar_DeltaMass=config['Dstar_DeltaMass']) self.prescaled_lineKstarMuNu = StrippingLine( prescaled_name + "KstarMuNuLine", prescale=config['PrescaledKstarLinePrescale'], postscale=config['PrescaledLinePostscale'], selection=self.selDplus2KstarMuNu) self.prescaled_lineRhoMuNu = StrippingLine( prescaled_name + "RhoMuNuLine", prescale=config['PrescaledRhoLinePrescale'], postscale=config['PrescaledLinePostscale'], selection=self.selDplus2RhoMuNu) self.prescaled_linePiMuNu = StrippingLine( prescaled_name + "PiMuNuLine", prescale=config['PrescaledPiLinePrescale'], postscale=config['PrescaledLinePostscale'], selection=self.selDstarD02PiMuNu) self.registerLine(self.prescaled_lineKstarMuNu) self.registerLine(self.prescaled_lineRhoMuNu) self.registerLine(self.prescaled_linePiMuNu)
def __init__(self, name, config) : LineBuilder.__init__(self, name, config) prescaled_name = name + 'Nominal' self.selKaons = makeKaons ( 'KaonFor'+prescaled_name, K_PT = config['K_PT'], K_TRCHI2 = config['K_TRCHI2'], K_IPCHI2 = config['K_IPCHI2'] ) self.selPions = makePions ( 'PionFor'+prescaled_name, pi_PT = config['pi_PT'], pi_TRCHI2 = config['pi_TRCHI2'], pi_IPCHI2 = config['pi_IPCHI2'] ) self.selPhi2KK = makePhi2KK ( 'PhiFor'+prescaled_name, kaons = self.selKaons, phi_VDZ = config['phi_VDZ'], phi_PT = config['phi_PT'], phi_IPCHI2 = config['phi_IPCHI2'], phi_VCHI2_VDOF = config['phi_VCHI2_VDOF'] ) self.selPhi2KKForEtac = makePhi2KKForEtac ( 'PhiForEtacFor'+prescaled_name, kaons = self.selKaons, phi_etac_VDZ = config['phi_etac_VDZ'], phi_etac_VCHI2_VDOF = config['phi_etac_VCHI2_VDOF'] ) self.selRho2PiPiForEtac = makeRho2PiPiForEtac ( 'RhoForEtacFor'+prescaled_name, pions = self.selPions, rho_etac_VDZ = config['rho_etac_VDZ'], rho_etac_VCHI2_VDOF = config['rho_etac_VCHI2_VDOF'] ) self.selEtac2RhoPhi = makeEtac2RhoPhi ( 'EtacFor'+prescaled_name, phiForEtacSel = self.selPhi2KKForEtac, rhoForEtacSel = self.selRho2PiPiForEtac, etac_VDZ = config['etac_VDZ'], etac_PT = config['etac_PT'], etac_IPCHI2 = config['etac_IPCHI2'], etac_VCHI2_VDOF = config['etac_VCHI2_VDOF'] ) self.selBs2EtacPhi = makeBs2EtacPhi ( prescaled_name, etacSel = self.selEtac2RhoPhi, phiSel = self.selPhi2KK, Bs_VDZ = config['Bs_VDZ'], Bs_DIRA = config['Bs_DIRA'], Bs_IPCHI2 = config['Bs_IPCHI2'], Bs_VCHI2_VDOF = config['Bs_VCHI2_VDOF'] ) self.prescaled_line = StrippingLine ( prescaled_name+"Line", prescale = config['Prescale'], postscale = config['Postscale'], algos = [ self.selBs2EtacPhi ] ) self.registerLine(self.prescaled_line)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self.name = name self.config = config self.SelKaons = self.createSubSel( OutputList=self.name + "SelKaons", InputList=DataOnDemand(Location='Phys/StdLooseKaons/Particles'), Cuts=config['KaonCuts']) self.SelPions = self.createSubSel( OutputList=self.name + "SelPions", InputList=DataOnDemand(Location='Phys/StdLoosePions/Particles'), Cuts=config['PionCuts']) """ Etac-> K K Pi Pi """ self.SelEtac2KKPiPi = self.createN4BodySel( OutputList=self.name + "SelEtac2KKPiPi", DaughterLists=[self.SelKaons, self.SelPions], DecayDescriptor="eta_c(1S) -> K+ K- pi+ pi-", ComAMCuts=config['EtacComAMCuts'], PreVertexCuts=config['EtacComN4Cuts'], PostVertexCuts=config['EtacMomN4Cuts']) """ Etac-> K K K K """ self.SelEtac2KKKK = self.createN4BodySel( OutputList=self.name + "SelEtac2KKKK", DaughterLists=[self.SelKaons], DecayDescriptor="eta_c(1S) -> K+ K- K+ K-", ComAMCuts=config['EtacComAMCuts'], PreVertexCuts=config['EtacComN4Cuts'], PostVertexCuts=config['EtacMomN4Cuts']) """ Etac-> Pi Pi Pi Pi """ self.SelEtac2PiPiPiPi = self.createN4BodySel( OutputList=self.name + "SelEtac2PiPiPiPi", DaughterLists=[self.SelPions], DecayDescriptor="eta_c(1S) -> pi+ pi- pi+ pi-", ComAMCuts=config['EtacComAMCuts'], PreVertexCuts=config['EtacComN4Cuts'], PostVertexCuts=config['EtacMomN4Cuts']) """ Eta_c """ from PhysSelPython.Wrappers import MergedSelection self.SelEtac = MergedSelection(self.name + "SelEtac", RequiredSelections=[ self.SelEtac2KKPiPi, self.SelEtac2KKKK, self.SelEtac2PiPiPiPi ]) """ Phi """ self.SelPhi = self.createSubSel( OutputList=self.name + "SelPhi", InputList=DataOnDemand(Location='Phys/StdTightPhi2KK/Particles'), Cuts=config['PhiCuts']) """ Kshort """ # Both LL and DD self.InputKs = MergedSelection( self.name + "InputKs", RequiredSelections=[ DataOnDemand(Location="Phys/StdLooseKsDD/Particles"), DataOnDemand(Location="Phys/StdLooseKsLL/Particles") ]) self.SelKs = self.createSubSel(OutputList=self.name + "SelKs", InputList=self.InputKs, Cuts=config['KsCuts']) # Eta_c -> KS0 K Pi self.SelEtac2KsKPi = self.createCombinationSel( OutputList=self.name + "SelEtac2KsKPi", DecayDescriptor="[eta_c(1S) -> KS0 K+ pi-]cc", DaughterLists=[self.SelKs, self.SelKaons, self.SelPions], PreVertexCuts=config['EtacComCuts'], PostVertexCuts=config['EtacMomN4Cuts']) """ Bs->Eta_c(KsKPi) Phi """ self.SelBs2EtacPhi_KsKPi = self.createCombinationSel( OutputList=self.name + "SelBs2EtacPhi_KsKPi", DecayDescriptor="B_s0 -> eta_c(1S) phi(1020)", DaughterLists=[self.SelPhi, self.SelEtac2KsKPi], PreVertexCuts=config['BsComCuts'], PostVertexCuts=config['BsMomCuts']) self.Bs2EtacPhi_KsKPiLine = StrippingLine( self.name + '_KsKPiLine', prescale=config['Prescale'], HLT2=config['HLTCuts'], algos=[self.SelBs2EtacPhi_KsKPi], EnableFlavourTagging=True) #, MDSTFlag = True ) self.registerLine(self.Bs2EtacPhi_KsKPiLine) """ Bs->Eta_c Phi """ self.SelBs2EtacPhi = self.createCombinationSel( OutputList=self.name + "SelBs2EtacPhi", DecayDescriptor="B_s0 -> eta_c(1S) phi(1020)", DaughterLists=[self.SelPhi, self.SelEtac], PreVertexCuts=config['BsComCuts'], PostVertexCuts=config['BsMomCuts']) """ Apply MVA """ self.Bs2EtacPhiVars = { 'sqrt(Kp_Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1, 1) )", 'sqrt(Km_Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1, 2) )", 'sqrt(Pip_Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1, 3) )", 'sqrt(Pim_Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1, 4) )", 'sqrt(Kp_Phi_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 2, 1) )", 'sqrt(Km_Phi_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 2, 2) )", 'EtacSumIPCHI2': "sqrt( CHILD(MIPCHI2DV(), 1, 1)+CHILD(MIPCHI2DV(), 1, 2)+CHILD(MIPCHI2DV(), 1, 3)+CHILD(MIPCHI2DV(), 1, 4))", 'sqrt(Etac_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 1 ) )", 'sqrt(Phi_IPCHI2_OWNPV)': "sqrt( CHILD(MIPCHI2DV(), 2 ) )", 'log(Kp_Etac_PT)': "log( CHILD(PT, 1, 1) )", 'log(Km_Etac_PT)': "log( CHILD(PT, 1, 2) )", 'log(Pip_Etac_PT)': "log( CHILD(PT, 1, 3) )", 'log(Pim_Etac_PT)': "log( CHILD(PT, 1, 4) )", 'log(Kp_Phi_PT)': "log( CHILD(PT, 2, 1) )", 'log(Km_Phi_PT)': "log( CHILD(PT, 2, 2) )", 'log(Etac_PT)': "log( CHILD(PT, 1 ) )", 'log(Phi_PT)': "log( CHILD(PT, 2 ) )", 'Etac_ENDVERTEX_CHI2': "CHILD(VFASPF(VCHI2/VDOF), 1)", 'Phi_ENDVERTEX_CHI2': "CHILD(VFASPF(VCHI2/VDOF), 2)", 'sqrt(B_IPCHI2_OWNPV)': "sqrt( BPVIPCHI2() )", 'B_DIRA_OWNPV': "BPVDIRA", 'B_LOKI_FDS': "BPVDLS", 'B_PVFit_chi2[0]': "DTF_CHI2 ( True )" } self.MvaBs2EtacPhi = self.applyMVA( self.name + "MvaBs2EtacPhi", SelB=self.SelBs2EtacPhi, MVAVars=self.Bs2EtacPhiVars, MVACutValue=config['Bs2EtacPhiMVACut'], MVAxmlFile=config['Bs2EtacPhiXmlFile']) self.Bs2EtacPhiBDTLine = StrippingLine( self.name + 'Line', prescale=config['Prescale'], HLT2=config['HLTCuts'], algos=[self.MvaBs2EtacPhi], EnableFlavourTagging=True) #, MDSTFlag = True ) self.registerLine(self.Bs2EtacPhiBDTLine)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) myKaons = StdTightKaons myPions = StdTightPions allPions = StdAllNoPIDsPions d2kpi_name = name + 'PromptD2KPiPi0' d0RS_name = name + 'PromptD0RSPi0' d0WS_name = name + 'PromptD0WSPi0' d2KK_name = name + 'PromptD2KKPi0' d2pipi_name = name + 'PromptD2PiPiPi0' dst2Dpipi_name = name + 'PromptDst2D2PiPiPi0' dst2DKK_name = name + 'PromptDst2D2KKPi0' dst2DRS_name = name + 'PromptDst2D2RSPi0' dst2DWS_name = name + 'PromptDst2D2WSPi0' # D0 -> hh' selections self.selD2WSR = makeD2hhAsymm( d0WS_name + 'R', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K+ pi-', inputSel=[myPions, myKaons], useResolved=True, TOSFilter='TOS') self.selD2WSM = makeD2hhAsymm( d0WS_name + 'M', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K+ pi-', inputSel=[myPions, myKaons], useResolved=False, TOSFilter='TOS') self.selD2KpiR = makeD2hhAsymm( d2kpi_name + 'R', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K- pi+', inputSel=[myPions, myKaons], useResolved=True, TOSFilter='TOS') self.selD2KpiM = makeD2hhAsymm( d2kpi_name + 'M', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K- pi+', inputSel=[myPions, myKaons], useResolved=False, TOSFilter='TOS') self.selD2KpiRSS = makeD2hhAsymm( d2kpi_name + 'RSS', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K- pi-', inputSel=[myPions, myKaons], useResolved=True, TOSFilter='NONE') self.selD2KpiMSS = makeD2hhAsymm( d2kpi_name + 'MSS', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K- pi-', inputSel=[myPions, myKaons], useResolved=False, TOSFilter='NONE') self.selD2KKR = makeD2hhAsymm( d2KK_name + 'R', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K- K+', inputSel=[myKaons], useResolved=True, TOSFilter='TOS') self.selD2KKM = makeD2hhAsymm( d2KK_name + 'M', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K- K+', inputSel=[myKaons], useResolved=False, TOSFilter='TOS') self.selD2KKRSS = makeD2hhAsymm( d2KK_name + 'RSS', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K- K-', inputSel=[myKaons], useResolved=True, TOSFilter='NONE') self.selD2KKMSS = makeD2hhAsymm( d2KK_name + 'MSS', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='K- K-', inputSel=[myKaons], useResolved=False, TOSFilter='NONE') self.selD2pipiR = makeD2hhAsymm( d2pipi_name + 'R', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='pi- pi+', inputSel=[myPions], useResolved=True, TOSFilter='TOS') self.selD2pipiM = makeD2hhAsymm( d2pipi_name + 'M', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='pi- pi+', inputSel=[myPions], useResolved=False, TOSFilter='TOS') self.selD2pipiRSS = makeD2hhAsymm( d2pipi_name + 'RSS', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='pi- pi-', inputSel=[myPions], useResolved=True, TOSFilter='NONE') self.selD2pipiMSS = makeD2hhAsymm( d2pipi_name + 'MSS', config, KPIDK_string=' & (PIDK > %(HighPIDK)s)', PiPIDK_string=' & (PIDK < %(LowPIDK)s)', Mass_low_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string= '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', Kst_Mass_high_string= '& (DAMASS(%(KstMassWindowCentre)s* MeV) < %(KstKPiMassWindowWidthHigh)s* MeV)', CombPIDK_string='', DecayDescriptor='pi- pi-', inputSel=[myPions], useResolved=False, TOSFilter='NONE') # Dstar -> D0 pi selections self.selDstRSR = makeDstar2D0Pi(dst2DRS_name + 'R', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2KpiR, allPions]) self.selDstRSM = makeDstar2D0Pi(dst2DRS_name + 'M', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2KpiM, allPions]) self.selDstWSR = makeDstar2D0Pi(dst2DWS_name + 'R', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2WSR, allPions]) self.selDstWSM = makeDstar2D0Pi(dst2DWS_name + 'M', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2WSM, allPions]) self.selDstRSRSS = makeDstar2D0Pi( dst2DRS_name + 'RSS', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2KpiRSS, allPions]) self.selDstRSMSS = makeDstar2D0Pi( dst2DRS_name + 'MSS', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2KpiMSS, allPions]) self.selDstKKR = makeDstar2D0Pi(dst2DKK_name + 'R', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2KKR, allPions]) self.selDstKKM = makeDstar2D0Pi(dst2DKK_name + 'M', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2KKM, allPions]) self.selDstKKRSS = makeDstar2D0Pi(dst2DKK_name + 'RSS', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2KKRSS, allPions]) self.selDstKKMSS = makeDstar2D0Pi(dst2DKK_name + 'MSS', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2KKMSS, allPions]) self.selDstpipiR = makeDstar2D0Pi(dst2Dpipi_name + 'R', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2pipiR, allPions]) self.selDstpipiM = makeDstar2D0Pi(dst2Dpipi_name + 'M', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2pipiM, allPions]) self.selDstpipiRSS = makeDstar2D0Pi( dst2Dpipi_name + 'RSS', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2pipiRSS, allPions]) self.selDstpipiMSS = makeDstar2D0Pi( dst2Dpipi_name + 'MSS', config, '[D*(2010)+ -> D0 pi+]cc', inputSel=[self.selD2pipiMSS, allPions]) # Tagged lines self.dstRSR_line = StrippingLine( dst2DRS_name + "RLine", prescale=config['TaggedRSLinePrescale'], postscale=config['TaggedRSLinePostscale'], selection=self.selDstRSR) self.dstRSM_line = StrippingLine( dst2DRS_name + "MLine", prescale=config['TaggedRSLinePrescale'], postscale=config['TaggedRSLinePostscale'], selection=self.selDstRSM) self.dstWSR_line = StrippingLine( dst2DWS_name + "RLine", prescale=config['TaggedWSLinePrescale'], postscale=config['TaggedWSLinePostscale'], selection=self.selDstWSR) self.dstWSM_line = StrippingLine( dst2DWS_name + "MLine", prescale=config['TaggedWSLinePrescale'], postscale=config['TaggedWSLinePostscale'], selection=self.selDstWSM) self.dstRSRSS_line = StrippingLine( dst2DRS_name + "RSSLine", prescale=config['TaggedRSLinePrescale'], postscale=config['TaggedRSLinePostscale'], selection=self.selDstRSRSS) self.dstRSMSS_line = StrippingLine( dst2DRS_name + "MSSLine", prescale=config['TaggedRSLinePrescale'], postscale=config['TaggedRSLinePostscale'], selection=self.selDstRSMSS) self.dstKKR_line = StrippingLine( dst2DKK_name + "RLine", prescale=config['TaggedSCSLinePrescale'], postscale=config['TaggedSCSLinePostscale'], selection=self.selDstKKR) self.dstKKM_line = StrippingLine( dst2DKK_name + "MLine", prescale=config['TaggedSCSLinePrescale'], postscale=config['TaggedSCSLinePostscale'], selection=self.selDstKKM) self.dstKKRSS_line = StrippingLine( dst2DKK_name + "RSSLine", prescale=config['TaggedSCSLinePrescale'], postscale=config['TaggedSCSLinePostscale'], selection=self.selDstKKRSS) self.dstKKMSS_line = StrippingLine( dst2DKK_name + "MSSLine", prescale=config['TaggedSCSLinePrescale'], postscale=config['TaggedSCSLinePostscale'], selection=self.selDstKKMSS) self.dstpipiR_line = StrippingLine( dst2Dpipi_name + "RLine", prescale=config['TaggedSCSLinePrescale'], postscale=config['TaggedSCSLinePostscale'], selection=self.selDstpipiR) self.dstpipiM_line = StrippingLine( dst2Dpipi_name + "MLine", prescale=config['TaggedSCSLinePrescale'], postscale=config['TaggedSCSLinePostscale'], selection=self.selDstpipiM) self.dstpipiRSS_line = StrippingLine( dst2Dpipi_name + "RSSLine", prescale=config['TaggedSCSLinePrescale'], postscale=config['TaggedSCSLinePostscale'], selection=self.selDstpipiRSS) self.dstpipiMSS_line = StrippingLine( dst2Dpipi_name + "MSSLine", prescale=config['TaggedSCSLinePrescale'], postscale=config['TaggedSCSLinePostscale'], selection=self.selDstpipiMSS) # register lines if config['RunSameSign']: self.registerLine(self.dstRSRSS_line) self.registerLine(self.dstRSMSS_line) self.registerLine(self.dstKKRSS_line) self.registerLine(self.dstKKMSS_line) self.registerLine(self.dstpipiRSS_line) self.registerLine(self.dstpipiMSS_line) if config['RunDefault']: self.registerLine(self.dstRSR_line) self.registerLine(self.dstRSM_line) self.registerLine(self.dstWSR_line) self.registerLine(self.dstWSM_line) self.registerLine(self.dstKKR_line) self.registerLine(self.dstKKM_line) self.registerLine(self.dstpipiR_line) self.registerLine(self.dstpipiM_line)
def __init__(self, name, config) : LineBuilder.__init__(self, name, config) self.name = name # Bd2KstartMuMu cuts definitions self.BdCombCut = "(AM > %(B_Comb_MassLow)s * MeV) & (AM < %(B_Comb_MassHigh)s * MeV)" %config self.BdCut = "(abs(SUMQ) < 3) & " \ "(M > %(B_MassLow)s * MeV) & " \ "(M < %(B_MassHigh)s * MeV) & " \ "(VFASPF(VCHI2/VDOF) < %(B_VertexCHI2)s) & " \ "(BPVIPCHI2() < %(B_IPCHI2)s) & " \ "(BPVDIRA> %(B_DIRA)s) & " \ "(BPVVDCHI2 > %(B_FlightCHI2)s) & " \ "(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(B_Dau_MaxIPCHI2)s )" %config DaughterCuts = "(VFASPF(VCHI2/VDOF) < %(Dau_VertexCHI2)s) & " \ "(BPVDIRA> %(Dau_DIRA)s)" %config self.KstarCombCut = "(AM > %(Kstar_Comb_MassLow)s * MeV) & " \ "(AM < %(Kstar_Comb_MassHigh)s * MeV) & " \ "(ADOCACHI2CUT(20.,''))" %config self.KstarCut = DaughterCuts + " & (M > %(Kstar_MassLow)s * MeV) & " \ "(M < %(Kstar_MassHigh)s * MeV) & " \ "(BPVVDCHI2 > %(Kstar_FlightChi2)s) & " \ "(MIPCHI2DV(PRIMARY) > %(Kstar_MinIPCHI2)s) & " \ "(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(Kstar_Dau_MaxIPCHI2)s )" %config self.DiMuonCombCut = "(AM < %(DimuonUPPERMASS)s *MeV)" %config self.DiMuonCut = DaughterCuts + " & (BPVVDCHI2 > %(Dimu_FlightChi2)s) & " \ "(MAXTREE(ISBASIC,MIPCHI2DV(PRIMARY))> %(Dimu_Dau_MaxIPCHI2)s )" %config self.TrackCuts = "(TRCHI2DOF < %(Track_CHI2nDOF)s) & (TRGHP < %(Track_GhostProb)s)" %config #self.TrackCuts = "(TRCHI2DOF < %(Track_CHI2nDOF)s)" %config self.HadronCuts = "(MIPCHI2DV(PRIMARY) > %(Hadron_MinIPCHI2)s) & (HASRICH)" %config self.KaonCut = self.TrackCuts + " & " + self.HadronCuts self.PionCut = self.TrackCuts + " & " + self.HadronCuts self.MuonCut = self.TrackCuts + " & (MIPCHI2DV(PRIMARY) > %(Muon_MinIPCHI2)s) & (PIDmu> %(MuonPID)s)" %config #self.KstarFilterCut = self.KstarCut + " & (INTREE(ABSID=='K+') & " + self.KaonCut + ") & (INTREE(ABSID=='pi+') & " + self.PionCut + ")" self.Dimuon = self.__Dimuon__(config) self.Protons = self.__Protons__(config) self.Kaons = self.__Kaons__(config) self.Pions = self.__Pions__(config) self.Kshort = self.__Kshort__(config) self.Dplus = self.__Dplus__(config) self.Dzero = self.__Dzero__(config) self.Lambda = self.__Lambda__(config) self.Pi0 = self.__Pi0__(config) self.Rho = self.__Rho__(self.Pions, config) self.F2 = self.__F2__(self.Rho, config) self.Phi = self.__Phi__(self.Rho, config) self.Kstar = self.__Kstar__(self.Rho, config) self.Lambdastar = self.__Lambdastar__(self.Rho, config) self.Kstar2KsPi = self.__Kstar2KsPi__(self.Kshort, self.Pions, config) self.Kstar2KPi0 = self.__Kstar2KPi0__(self.Kaons, self.Pi0, config) self.Dstar = self.__Dstar__(config) self.A1 = self.__A1__(self.Pions, config) self.K1 = self.__K1__(self.A1, config) self.K2 = self.__K2__(self.A1, config) self.AvailableDaughters = { 'K*(892)0' : [ self.Kstar ] , 'rho(770)0' : [ self.Rho ] , 'f_2(1950)' : [ self.F2 ] , 'KS0' : [ self.Kshort] , 'D~0' : [ self.Dzero ] , 'K+' : [ self.Kaons ] , 'pi+' : [ self.Pions ] , 'K*(892)+' : [ self.Kstar2KsPi, self.Kstar2KPi0 ], 'D+' : [ self.Dplus ] , 'D*(2010)+' : [ self.Dstar ] , 'Lambda0' : [ self.Lambda ] , 'Lambda(1520)0' : [ self.Lambdastar ] , 'pi0' : [ self.Pi0 ] , 'a_1(1260)' : [ self.A1 ], 'K_1(1270)' : [ self.K1 ], 'K_2(1770)' : [ self.K2 ] } self.DeclaredDaughters = [] for d in config['DECAYS']: for k in self.AvailableDaughters.keys(): if k in d: self.DeclaredDaughters += self.AvailableDaughters.pop(k) self.Bs = self.__Bs__( self.Dimuon, daughters = self.DeclaredDaughters, conf = config) self.line = StrippingLine( self.name+"_Line", prescale = 1, FILTER = { 'Code' : " ( recSummary(LHCb.RecSummary.nSPDhits,'Raw/Spd/Digits') < %(SpdMult)s )" %config , 'Preambulo' : [ "from LoKiNumbers.decorators import *", "from LoKiCore.basic import LHCb" ] }, algos=[self.Bs] ) self.registerLine(self.line)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self._myname = name #Define the cuts _mucut1 = '(PT>%(mupt1)s*MeV)&(TRPCHI2>%(mutrkpchi2)s)&(MIPDV(PRIMARY)/MIPCHI2DV(PRIMARY)<%(muipdvchi2ratio)s)&((PIDmu-PIDpi)>%(mupidreq)s)' % config _mucut2 = '(PT>%(mupt2)s*GeV)&(TRPCHI2>%(mutrkpchi2)s)&(MIPDV(PRIMARY)/MIPCHI2DV(PRIMARY)<%(muipdvchi2ratio)s)' % config _DY1MassCut = '((MM>%(DY1MinMass)s*GeV)&(MM<%(DY1jpsiexclow)s*GeV))|((MM>%(DY1jpsiexchigh)s*GeV)&(MM<%(DY1MaxMass)s*GeV))' % config _DY1MassCutHlt = '((MM>%(DY1MinMass)s*GeV)&(MM<%(DY1jpsiexclow)s*GeV))|((MM>%(DY1jpsiexchigh)s*GeV))' % config _DY2MassCut = '(MM>%(DY2MinMass)s*GeV)&(MM<%(DY2MaxMass)s*GeV)' % config _DY2MassCutHlt = '(MM>%(DY2MinMass)s*GeV)' % config _DY3MassCut = '(MM>%(DY3MinMass)s*GeV)&(MM<%(DY3MaxMass)s*GeV)' % config _DY4MassCut = '(MM>%(DY4MinMass)s*GeV)&(MM<%(DY4MaxMass)s*GeV)' % config self.selDY2MuMu1 = makeDY2MuMu1(self._myname + 'DYDecay1_ps', _DY1MassCut, _mucut1) self.selDY2MuMu1_Hlt = makeDY2MuMu1(self._myname + 'DYDecay1_Hlt', _DY1MassCutHlt, _mucut1) self.DY2MuMu_line1_ps = StrippingLine( self._myname + "Line1_ps", prescale=config['DY2MuMu1Line_psPrescale'], postscale=config['DY2MuMu1LinePostscale'], selection=self.selDY2MuMu1) self.DY2MuMu_line1_Hlt = StrippingLine( self._myname + "Line1_Hlt", prescale=config['DY2MuMu1Line_HltPrescale'], postscale=config['DY2MuMu1LinePostscale'], HLT="HLT_PASS_RE('Hlt2DiMuonDY.*Decision')", selection=self.selDY2MuMu1_Hlt) self.DY2MuMu_line1_Hlta = StrippingLine( self._myname + "Line1_Hlta", prescale=config['DY2MuMu1Line_HltaPrescale'], postscale=config['DY2MuMu1LinePostscale'], HLT="HLT_PASS_RE('Hlt2(MuonFromHLT1|PassThrough).*Decision')", selection=self.selDY2MuMu1_Hlt) self.registerLine(self.DY2MuMu_line1_ps) self.registerLine(self.DY2MuMu_line1_Hlt) self.registerLine(self.DY2MuMu_line1_Hlta) self.selDY2MuMu2 = makeDY2MuMu2(self._myname + 'DYDecay2', _DY2MassCut, _mucut2) self.selDY2MuMu2_Hlt = makeDY2MuMu2(self._myname + 'DYDecay2_Hlt', _DY2MassCutHlt, _mucut1) self.DY2MuMu_line2 = StrippingLine( self._myname + "Line2", prescale=config['DY2MuMu2LinePrescale'], postscale=config['DY2MuMu2LinePostscale'], selection=self.selDY2MuMu2) self.DY2MuMu_line2_Hlt = StrippingLine( self._myname + "Line2_Hlt", prescale=config['DY2MuMu2Line_HltPrescale'], postscale=config['DY2MuMu2LinePostscale'], HLT="HLT_PASS_RE('Hlt2DiMuonDY.*Decision')", selection=self.selDY2MuMu2_Hlt) self.DY2MuMu_line2_Hlta = StrippingLine( self._myname + "Line2_Hlta", prescale=config['DY2MuMu2Line_HltaPrescale'], postscale=config['DY2MuMu2LinePostscale'], HLT="HLT_PASS_RE('Hlt2(MuonFromHLT1|PassThrough).*Decision')", selection=self.selDY2MuMu2_Hlt) self.registerLine(self.DY2MuMu_line2) self.registerLine(self.DY2MuMu_line2_Hlt) self.registerLine(self.DY2MuMu_line2_Hlta) self.selDY2MuMu3 = makeDY2MuMu3(self._myname + 'DY2MuMuDecay3', _DY3MassCut, _mucut2) self.DY2MuMu_line3 = StrippingLine( self._myname + "Line3", prescale=config['DY2MuMu3LinePrescale'], postscale=config['DY2MuMu3LinePostscale'], selection=self.selDY2MuMu3) self.registerLine(self.DY2MuMu_line3) self.selDY2MuMu4 = makeDY2MuMu4(self._myname + 'DY2MuMuDecay4', _DY4MassCut, _mucut2) self.DY2MuMu_line4 = StrippingLine( self._myname + "Line4", prescale=config['DY2MuMu4LinePrescale'], postscale=config['DY2MuMu4LinePostscale'], selection=self.selDY2MuMu4) self.registerLine(self.DY2MuMu_line4)
def _Bs2PhiPhi_X_Line( self, name, config, wide ) : Phi2KK_DC = "(PT>%(KaonPT)s*MeV)&(MIPCHI2DV(PRIMARY)>%(KaonIPCHI2)s)" % config Phi2KK_CC = "(AM<(%(PhiMassMax)s+30)*MeV)&(ADOCACHI2CUT(40, ''))" % config Phi2KK_MassCut = "" if wide == False : Phi2KK_MassCut = "&(ADMASS('phi(1020)')<%(PhiMassWindow)s*MeV)" % config else : Phi2KK_MassCut = "&(MM<%(PhiMassMax)s*MeV)" % config Phi2KK_MC = "(VFASPF(VCHI2/VDOF)<%(PhiVertexCHI2pDOF)s)" % config + Phi2KK_MassCut Bs2PhiPhi_DC = "(PT>%(PhiPT)s*MeV)" % config Bs2PhiPhi_CC = "(ADAMASS('B_s0')<((%(BsMassWindow)s+30)*MeV))&(ACHILD(PT,1)*ACHILD(PT,2)>%(PhiPTsq)s*GeV*GeV)" % config Bs2PhiPhi_MC = "(VFASPF(VCHI2/VDOF)<%(BsVertexCHI2pDOF)s)&(ADMASS('B_s0')<%(BsMassWindow)s*MeV)" % config ps = 1.0 if wide == True : ps = config['WidePrescale'] #print "Cuts for "+name+"Line" #print Phi2KK_DC #print Phi2KK_CC #print Phi2KK_MC #print Bs2PhiPhi_DC #print Bs2PhiPhi_CC #print Bs2PhiPhi_MC #print "Prescale: ", ps #_stdLooseKaons = DataOnDemand(Location = "Phys/StdLooseKaons/Particles") _Bs2PhiPhiLooseDetachedPhi2KK = CombineParticles( DecayDescriptor = "phi(1020) -> K+ K-" , DaughtersCuts = {"K+": Phi2KK_DC} , CombinationCut = Phi2KK_CC , MotherCut = Phi2KK_MC ) _Bs2PhiPhi = CombineParticles( DecayDescriptor = "B_s0 -> phi(1020) phi(1020)" , DaughtersCuts = {"phi(1020)" : Bs2PhiPhi_DC} , CombinationCut = Bs2PhiPhi_CC , MotherCut = Bs2PhiPhi_MC ) Bs2PhiPhiLooseDetachedPhi2KK = Selection( name+ "_LoosePhi2KK", Algorithm = _Bs2PhiPhiLooseDetachedPhi2KK, RequiredSelections = [MyLooseKaons]) Bs2PhiPhi = Selection( name, Algorithm = _Bs2PhiPhi, RequiredSelections = [Bs2PhiPhiLooseDetachedPhi2KK]) return StrippingLine(name+"Line" , prescale = ps , postscale = 1 , selection = Bs2PhiPhi )
def __init__(self, name, config): # { LineBuilder.__init__(self, name, config) from Configurables import LoKi__VoidFilter as VoidFilter from Configurables import LoKi__Hybrid__CoreFactory as CoreFactory modules = CoreFactory('CoreFactory').Modules for i in ['LoKiTracks.decorators']: if i not in modules: modules.append(i) d02KKmumu_name = 'D0For' + name dstar_name = name self.inPions = DataOnDemand(Location="Phys/StdLoosePions/Particles") self.inMuons = DataOnDemand(Location="Phys/StdLooseMuons/Particles") self.inKaons = DataOnDemand(Location="Phys/StdLooseKaons/Particles") self.selD02KKmumu = makeD02KKmumu( d02KKmumu_name, inputSel=[self.inMuons, self.inKaons], TrackChi2max=config['TrackChi2max'], DDauKPTmin=config['DDauKPTmin'], DDauKPmin=config['DDauKPmin'], DDauMuPTmin=config['DDauMuPTmin'], DDauMuPmin=config['DDauMuPmin'], DDauKDelPIDmin=config['DDauKDelPIDmin'], DDauMuDelPIDmin=config['DDauMuDelPIDmin'], DCombMassWind=config['DCombMassWind'], DCombAMAXDOCAmax=config['DCombAMAXDOCAmax'], DMothPTmin=config['DMothPTmin'], DMothBPVDIRAmin=config['DMothBPVDIRAmin'], DMothMIPDVmax=config['DMothMIPDVmax'], DMothMIPCHI2DVmax=config['DMothMIPCHI2DVmax'], DMothBPVVDmin=config['DMothBPVVDmin'], DMothBPVDCHI2min=config['DMothBPVDCHI2min'], DMothBPVVDZmin=config['DMothBPVVDZmin'], DMothVFASPFmax=config['DMothVFASPFmax']) self.selDstar2D0Pi_D02KKmumu = makeDstar2D0Pi( dstar_name, inputSel=[self.inPions, self.selD02KKmumu], DstarCombMassWind=config['DstarCombMassWind'], DstarCombAMAXDOCAmax=config['DstarCombAMAXDOCAmax'], DstarMothVFASPFmax=config['DstarMothVFASPFmax'], DstarMothPTmin=config['DstarMothPTmin'], DstarMothDMmin=config['DstarMothDMmin'], DstarMothDMmax=config['DstarMothDMmax'], DstarMothSlpiMIPDVmax=config['DstarMothSlpiMIPDVmax'], DstarMothSlpiMIPCHI2DVmax=config['DstarMothSlpiMIPCHI2DVmax'], DstarMothSlpiPTmin=config['DstarMothSlpiPTmin']) self.line_Dstar2D0Pi_D02KKmumu = StrippingLine( dstar_name + "Line", prescale=config['LinePrescale'], postscale=config['LinePostscale'], FILTER={ "Code": "(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < %s )" % config['NTracksLim'], "Preambulo": ["from LoKiTracks.decorators import *"] }, algos=[self.selDstar2D0Pi_D02KKmumu]) self.registerLine(self.line_Dstar2D0Pi_D02KKmumu)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) # Select photons self.selPhotons = { '': self.makePhoton('GammaFor' + name, config['photonPT']), '_CNVLL': self.makePhotonConv('CNVGammaLLFor' + name, config['MaxMass_CNV_LL'], config['MaxVCHI2_CNV_LL'], config['MinPT_CNV_LL'], [StdAllLooseGammaLL]), '_CNVDD': self.makePhotonConv('CNVGammaDDFor' + name, config['MaxMass_CNV_DD'], config['MaxVCHI2_CNV_DD'], config['MinPT_CNV_DD'], [StdAllLooseGammaDD]) } self.HHForD2XGamma, self.D2XGamma, self.Dst2D0pi, self.lineDstarD2XGamma = {}, {}, {}, {} decays = { 'PiPiGamma': { 'HHdesc': ['rho(770)0 -> pi+ pi-'], 'D0desc': ['D0 -> rho(770)0 gamma'] }, 'KPiGamma': { 'HHdesc': ['K*(892)0 -> K- pi+', 'K*(892)0 -> K+ pi-'], 'D0desc': ['D0 -> K*(892)0 gamma'] }, 'KKGamma': { 'HHdesc': ['phi(1020) -> K+ K-'], 'D0desc': ['D0 -> phi(1020) gamma'] }, } for decay, decayDescriptors in decays.iteritems(): # make the various stripping selections DstarD2XGammaName = name + "DstarD2" + decay D2XGammaName = name + "D2" + decay HHCombName = name + "HHForD2" + decay inputs = [StdNoPIDsPions] if decays == 'PiPiGamma' else [ StdNoPIDsPions, StdNoPIDsKaons ] # Create the 2-body candidate self.HHForD2XGamma[decay] = self.makeHH( HHCombName, decayDescriptors['HHdesc'], config['TrChi2'], config['TrGhostProb'], config['MinTrkPT'], config['MinTrkIPChi2'], config['HighPIDK'], config['LowPIDK'], config['CombMassLow_HH'], # FIXME!!!! config['CombMassHigh_HH'], config['MinCombPT'], config['MaxADOCACHI2'], config['MinVDCHI2_HHComb'], config['MassLow_HH'], config['MassHigh_HH'], config['MaxVCHI2NDOF_HH'], config['MinVDCHI2_HH'], inputs) for phName, photons in self.selPhotons.iteritems(): # Create the D0 candidate self.D2XGamma[decay + phName] = self.makeD2XGamma( D2XGammaName + phName, decayDescriptors['D0desc'], config['CombMassLow'], config['CombMassHigh'], config['MassLow'], config['MassHigh'], config['MinPT'], config['MaxVCHI2NDOF'], config['MinBPVDIRA'], config['MinBPVTAU'], inputSel=[self.HHForD2XGamma[decay], photons]) # Create the D* candidate self.Dst2D0pi[decay + phName] = self.makeDstar2D0Pi( DstarD2XGammaName + phName, config, ['D*(2010)+ -> D0 pi+', 'D*(2010)- -> D0 pi-'], inputSel=[self.D2XGamma[decay + phName], StdNoPIDsPions]) # Create the stripping line self.lineDstarD2XGamma[decay + phName] = StrippingLine( DstarD2XGammaName + phName + "Line", prescale=config['PrescaleDstarD2' + decay + phName], selection=self.Dst2D0pi[decay + phName], HLT1=config['Hlt1Filter'], HLT2=config['Hlt2Filter']) # Register the line self.registerLine(self.lineDstarD2XGamma[decay + phName])
def __init__(self, name, config) : LineBuilder.__init__(self, name, config) stdNoPIDsKaons = StdAllNoPIDsKaons stdNoPIDsPions = StdAllNoPIDsPions d2kpi_name = name+'PromptD2KPi' d0RS_name = name+'PromptD0RS' d0WS_name = name+'PromptD0WS' d2kk_name = name+'PromptD2KK' d2pipi_name = name+'PromptD2PiPi' dst2DPiPi_name = name+'PromptDst2D2PiPi' dst2DKK_name = name+'PromptDst2D2KK' dst2DRS_name = name+'PromptDst2D2RS' dst2DWS_name = name+'PromptDst2D2WS' dPartial_name = name+'PromptDPartial' dstarPartial_name = name+'PromptDstarPartial' pseudoPsi_name = name+'PromptD0D0FromDstarPartial' # D0 -> hh' selections self.selD2Kpi = makeD2hhAsymm(d2kpi_name, config, KPIDK_string = ' & (PIDK > %(HighPIDK)s)', PiPIDK_string = ' & (PIDK < %(LowPIDK)s)', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', CombPIDK_string = '', DecayDescriptor = '[D0 -> K- pi+]cc', inputSel = [stdNoPIDsPions, stdNoPIDsKaons], useTOS = config['UseTOSFilter'], Hlt1TOS = config['Hlt1TOS'], Hlt2TOS = config['Hlt2TOSKPi'] ) self.selD0KK = makeD2hhAsymm(d2kk_name, config, KPIDK_string = ' & (PIDK > %(LowPIDK)s)', PiPIDK_string = '', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KKMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KKMassWindowWidthHigh)s* MeV)', CombPIDK_string = ' & (AHASCHILD( PIDK > %(HighPIDK)s ) )', DecayDescriptor = 'D0 -> K+ K-', inputSel = [stdNoPIDsKaons], useTOS = config['UseTOSFilter'], Hlt1TOS = config['Hlt1TOS'], Hlt2TOS = config['Hlt2TOSKK'] ) self.selD0PiPi = makeD2hhAsymm(d2pipi_name, config, KPIDK_string = '', PiPIDK_string = ' & (PIDK < %(LowPIDK)s)', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0PiPiMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0PiPiMassWindowWidthHigh)s* MeV)', CombPIDK_string = '', DecayDescriptor = 'D0 -> pi+ pi-', inputSel = [stdNoPIDsPions], useTOS = config['UseTOSFilter'], Hlt1TOS = config['Hlt1TOS'], Hlt2TOS = config['Hlt2TOSPiPi'] ) self.selD2KpiSS = makeD2hhAsymm(d2kpi_name+'SS', config, KPIDK_string = ' & (PIDK > %(HighPIDK)s)', PiPIDK_string = ' & (PIDK < %(LowPIDK)s)', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', CombPIDK_string = '', DecayDescriptor = '[D0 -> K- pi-]cc', inputSel = [stdNoPIDsPions, stdNoPIDsKaons], useTOS = False, Hlt1TOS = config['Hlt1TOS'], Hlt2TOS = config['Hlt2TOSKPi'] ) self.selD0KKSS = makeD2hhAsymm(d2kk_name+'SS', config, KPIDK_string = ' & (PIDK > %(LowPIDK)s)', PiPIDK_string = '', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KKMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KKMassWindowWidthHigh)s* MeV)', CombPIDK_string = ' & (AHASCHILD( PIDK > %(HighPIDK)s ) )', DecayDescriptor = 'D0 -> K- K-', inputSel = [stdNoPIDsKaons], useTOS = False, Hlt1TOS = config['Hlt1TOS'], Hlt2TOS = config['Hlt2TOSKK'] ) self.selD0PiPiSS = makeD2hhAsymm(d2pipi_name+'SS', config, KPIDK_string = '', PiPIDK_string = ' & (PIDK < %(LowPIDK)s)', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0PiPiMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0PiPiMassWindowWidthHigh)s* MeV)', CombPIDK_string = '', DecayDescriptor = 'D0 -> pi- pi-', inputSel = [stdNoPIDsPions], useTOS = False, Hlt1TOS = config['Hlt1TOS'], Hlt2TOS = config['Hlt2TOSPiPi'] ) self.selD2KpiTIS = makeD2hhAsymm(d2kpi_name+'TIS', config, KPIDK_string = ' & (PIDK > %(HighPIDK)s)', PiPIDK_string = ' & (PIDK < %(LowPIDK)s)', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KPiMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KPiMassWindowWidthHigh)s* MeV)', CombPIDK_string = '', DecayDescriptor = '[D0 -> K- pi+]cc', inputSel = [stdNoPIDsPions, stdNoPIDsKaons], useTOS = True, Hlt1TOS = { 'Hlt1Global%TIS' : 0 }, Hlt2TOS = { 'Hlt2Global%TIS' : 0 } ) self.selD0KKTIS = makeD2hhAsymm(d2kk_name+'TIS', config, KPIDK_string = ' & (PIDK > %(LowPIDK)s)', PiPIDK_string = '', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0KKMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0KKMassWindowWidthHigh)s* MeV)', CombPIDK_string = ' & (AHASCHILD( PIDK > %(HighPIDK)s ) )', DecayDescriptor = 'D0 -> K+ K-', inputSel = [stdNoPIDsKaons], useTOS = True, Hlt1TOS = { 'Hlt1Global%TIS' : 0 }, Hlt2TOS = { 'Hlt2Global%TIS' : 0 } ) self.selD0PiPiTIS = makeD2hhAsymm(d2pipi_name+'TIS', config, KPIDK_string = '', PiPIDK_string = ' & (PIDK < %(LowPIDK)s)', Mass_low_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) > %(D0PiPiMassWindowWidthLow)s* MeV)', Mass_high_string = '& (DAMASS(%(D0MassWindowCentre)s* MeV) < %(D0PiPiMassWindowWidthHigh)s* MeV)', CombPIDK_string = '', DecayDescriptor = 'D0 -> pi+ pi-', inputSel = [stdNoPIDsPions], useTOS = True, Hlt1TOS = { 'Hlt1Global%TIS' : 0 }, Hlt2TOS = { 'Hlt2Global%TIS' : 0 } ) from Configurables import ConjugateNeutralPID from PhysSelPython.Wrappers import Selection _localConj_KPi = ConjugateNeutralPID('Conjugate'+d0WS_name) _localConj_KK = ConjugateNeutralPID('Conjugate'+d2kk_name) _localConj_PiPi = ConjugateNeutralPID('Conjugate'+d2pipi_name) self.selD0WS = Selection(d0WS_name, Algorithm=_localConj_KPi, RequiredSelections=[self.selD2Kpi]) self.selD0ConjKK = Selection('SelConjugate'+d2kk_name, Algorithm = _localConj_KK, RequiredSelections = [self.selD0KK]) self.selD0ConjPiPi = Selection('SelConjugate'+d2pipi_name, Algorithm = _localConj_PiPi, RequiredSelections = [self.selD0PiPi]) _localConj_KKSS = ConjugateNeutralPID('Conjugate'+d2kk_name+'SS') _localConj_PiPiSS = ConjugateNeutralPID('Conjugate'+d2pipi_name+'SS') self.selD0ConjKKSS = Selection('SelConjugate'+d2kk_name+'SS', Algorithm = _localConj_KKSS, RequiredSelections = [self.selD0KKSS]) self.selD0ConjPiPiSS = Selection('SelConjugate'+d2pipi_name+'SS', Algorithm = _localConj_PiPiSS, RequiredSelections = [self.selD0PiPiSS]) # Dstar -> D0 pi selections self.selDstRS = makeDstar2D0Pi( dst2DRS_name , config , '[D*(2010)+ -> D0 pi+]cc' , inputSel = [self.selD2Kpi, stdNoPIDsPions] ) self.selDstWS = makeDstar2D0Pi( dst2DWS_name , config , '[D*(2010)+ -> D0 pi+]cc' , inputSel = [self.selD0WS, stdNoPIDsPions] ) self.selDstKK = makeDstar2D0Pi( dst2DKK_name , config , '[D*(2010)+ -> D0 pi+]cc' , inputSel = [self.selD0KK, self.selD0ConjKK, stdNoPIDsPions] ) self.selDstPiPi = makeDstar2D0Pi( dst2DPiPi_name , config , '[D*(2010)+ -> D0 pi+]cc' , inputSel = [self.selD0PiPi, self.selD0ConjPiPi, stdNoPIDsPions] ) self.selDstRSSS = makeDstar2D0Pi( dst2DRS_name+'SS' , config , '[D*(2010)+ -> D0 pi+]cc' , inputSel = [self.selD2KpiSS, stdNoPIDsPions] ) self.selDstKKSS = makeDstar2D0Pi( dst2DKK_name+'SS' , config , '[D*(2010)+ -> D0 pi+]cc' , inputSel = [self.selD0KKSS, self.selD0ConjKKSS, stdNoPIDsPions] ) self.selDstPiPiSS = makeDstar2D0Pi( dst2DPiPi_name+'SS' , config , '[D*(2010)+ -> D0 pi+]cc' , inputSel = [self.selD0PiPiSS, self.selD0ConjPiPiSS, stdNoPIDsPions] ) self.selDPartial = makeDPartial( dPartial_name , config , '[D- -> K- pi- pi+]cc' , inputSel = [stdNoPIDsPions, stdNoPIDsKaons] ) self.selDstarPartial = makeDstarPartial( dstarPartial_name , config , '[D*(2010)+ -> D- pi+]cc' , inputSel = [self.selDPartial, stdNoPIDsPions] ) self.selPseudoPsi = makePseudoPsi( pseudoPsi_name , config , '[psi(3770) -> D0 D*(2010)+]cc' , inputSel = [self.selD2Kpi, self.selDstarPartial] #, inputSel = [self.selD0PiPi, self.selD0ConjPiPi, self.selD0KK, self.selD0ConjKK, self.selD2Kpi, self.selD0WS, self.selDstarPartial] ) # Untagged lines self.d2kpi_line = StrippingLine(d2kpi_name+"Line", prescale = config['UntaggedCFLinePrescale'], postscale = config['UntaggedCFLinePostscale'], selection = self.selD2Kpi ) self.d2kk_line = StrippingLine(d2kk_name+"Line", prescale = config['UntaggedSCSLinePrescale'], postscale = config['UntaggedSCSLinePostscale'], selection = self.selD0KK ) self.d2pipi_line = StrippingLine(d2pipi_name+"Line", prescale = config['UntaggedSCSLinePrescale'], postscale = config['UntaggedSCSLinePostscale'], selection = self.selD0PiPi ) # Untagged TIS lines self.d2kpiTIS_line = StrippingLine(d2kpi_name+"TISLine", prescale = config['UntaggedTISLinePrescale'], postscale = config['UntaggedTISLinePostscale'], selection = self.selD2KpiTIS ) self.d2kkTIS_line = StrippingLine(d2kk_name+"TISLine", prescale = config['UntaggedTISLinePrescale'], postscale = config['UntaggedTISLinePostscale'], selection = self.selD0KKTIS ) self.d2pipiTIS_line = StrippingLine(d2pipi_name+"TISLine", prescale = config['UntaggedTISLinePrescale'], postscale = config['UntaggedTISLinePostscale'], selection = self.selD0PiPiTIS ) # Tagged lines self.dstRS_line = StrippingLine(dst2DRS_name+"Line", prescale = config['TaggedRSLinePrescale'], postscale = config['TaggedRSLinePostscale'], selection = self.selDstRS ) self.dstWS_line = StrippingLine(dst2DWS_name+"Line", prescale = config['TaggedWSLinePrescale'], postscale = config['TaggedWSLinePostscale'], selection = self.selDstWS ) self.dstKK_line = StrippingLine(dst2DKK_name+"Line", prescale = config['TaggedSCSLinePrescale'], postscale = config['TaggedSCSLinePostscale'], selection = self.selDstKK ) self.dstPiPi_line = StrippingLine(dst2DPiPi_name+"Line", prescale = config['TaggedSCSLinePrescale'], postscale = config['TaggedSCSLinePostscale'], selection = self.selDstPiPi ) # Tagged same sign lines self.dstRSSS_line = StrippingLine(dst2DRS_name+"SSLine", prescale = config['TaggedRSLinePrescale'], postscale = config['TaggedRSLinePostscale'], selection = self.selDstRSSS ) self.dstKKSS_line = StrippingLine(dst2DKK_name+"SSLine", prescale = config['TaggedSCSLinePrescale'], postscale = config['TaggedSCSLinePostscale'], selection = self.selDstKKSS ) self.dstPiPiSS_line = StrippingLine(dst2DPiPi_name+"SSLine", prescale = config['TaggedSCSLinePrescale'], postscale = config['TaggedSCSLinePostscale'], selection = self.selDstPiPiSS ) # Pseudo Psi line self.pseudoPsi_line = StrippingLine(pseudoPsi_name+"Line", prescale = 1., postscale = 1., selection = self.selPseudoPsi ) # register lines if config['RunSameSign']: self.registerLine(self.dstRSSS_line) self.registerLine(self.dstKKSS_line) self.registerLine(self.dstPiPiSS_line) if config['RunTISLines']: self.registerLine(self.d2kpiTIS_line) self.registerLine(self.d2kkTIS_line) self.registerLine(self.d2pipiTIS_line) if config['RunDefault']: self.registerLine(self.d2kpi_line) if not config['UntaggedKpiOnly']: self.registerLine(self.d2kk_line) self.registerLine(self.d2pipi_line) self.registerLine(self.dstRS_line) self.registerLine(self.dstWS_line) self.registerLine(self.dstKK_line) self.registerLine(self.dstPiPi_line) if config['AddPartialD']: self.registerLine(self.pseudoPsi_line)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) # selPions = self._makePions(name="PionsFor" + name, config=config) selKaons = self._makeKaons(name="KaonsFor" + name, config=config) selMuons = self._makeMuons(name="MuonsFor" + name, config=config) # selTau = self._makeTau(name="TauFor" + name, pionSel=selPions, config=config) selD = self._makeD(name="DFor" + name, pionSel=selPions, kaonSel=selKaons, config=config) # selB2TauTau, selB2DD = self._makeB2XX(name=name, tauSel=selTau, DSel=selD, config=config) selB2TauMu, selB2DMu = self._makeB2XMu(name=name, tauSel=selTau, DSel=selD, muonSel=selMuons, config=config) # self.TauTau_TOSLine = StrippingLine( name + "_TauTau_TOSLine", #HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ", prescale=config['B2TauTau_TOSLinePrescale'], postscale=config['B2TauTau_TOSLinePostscale'], selection=self._makeTOS(name + "_TOSForTauTau", selB2TauTau)) self.DD_TOSLine = StrippingLine( name + "_DD_TOSLine", #HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ", prescale=config['B2DD_TOSLinePrescale'], postscale=config['B2DD_TOSLinePostscale'], selection=self._makeTOS(name + "_TOSForDD", selB2DD)) self.TauMu_TOSLine = StrippingLine( name + "_TauMu_TOSLine", #HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ", prescale=config['B2TauMu_TOSLinePrescale'], postscale=config['B2TauMu_TOSLinePostscale'], selection=self._makeTOS(name + "_TOSForTauMu", selB2TauMu)) self.DMu_TOSLine = StrippingLine( name + "_DMu_TOSLine", #HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ", prescale=config['B2DMu_TOSLinePrescale'], postscale=config['B2DMu_TOSLinePostscale'], selection=self._makeTOS(name + "_TOSForDMu", selB2DMu)) # self.TauTau_TISLine = StrippingLine( name + "_TauTau_TISLine", #HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ", prescale=config['B2TauTau_TISLinePrescale'], postscale=config['B2TauTau_TISLinePostscale'], selection=self._makeTIS(name + "_TISForTauTau", selB2TauTau)) self.DD_TISLine = StrippingLine( name + "_DD_TISLine", #HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ", prescale=config['B2DD_TISLinePrescale'], postscale=config['B2DD_TISLinePostscale'], selection=self._makeTIS(name + "_TISForDD", selB2DD)) self.TauMu_TISLine = StrippingLine( name + "_TauMu_TISLine", #HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ", prescale=config['B2TauMu_TISLinePrescale'], postscale=config['B2TauMu_TISLinePostscale'], selection=self._makeTIS(name + "_TISForTauMu", selB2TauMu)) self.DMu_TISLine = StrippingLine( name + "_DMu_TISLine", #HLT = " HLT_PASS_RE('"+HLT_DECISIONS+"') ", prescale=config['B2DMu_TISLinePrescale'], postscale=config['B2DMu_TISLinePostscale'], selection=self._makeTIS(name + "_TISForDMu", selB2DMu)) # self.registerLine(self.TauTau_TOSLine) self.registerLine(self.DD_TOSLine) self.registerLine(self.TauMu_TOSLine) self.registerLine(self.DMu_TOSLine) self.registerLine(self.TauTau_TISLine) self.registerLine(self.DD_TISLine) self.registerLine(self.TauMu_TISLine) self.registerLine(self.DMu_TISLine) print "Created lines"
def __init__(self, name, config): LineBuilder.__init__(self, name, config) self._myname = name # Define the cuts _pT = '(PT>%(pT)s*GeV)' % config #_pT = "(PT>%(pT)s*GeV) & (HASTRACK & TRCUT(0<TrIDC('isTT')))"%config _pTlow = '(PT>%(pTlow)s*GeV)' % config _pTvlow = '(PT>%(pTvlow)s*GeV)' % config _pTSingMuon10 = '(PT>%(SingMuon10_pT)s*GeV)' % config _pTSingMuon48 = '(PT>%(SingMuon48_pT)s*GeV)' % config #Single Muon Control Lines self.sel_Mu10 = makeFilter(self._myname + 'Mu10', StdAllLooseMuons, "from LoKiTracks.decorators import *", _pTSingMuon10) self.line_Mu10 = StrippingLine( self._myname + 'Control10Line', prescale=config['SingMuon10_Prescale'], postscale=config['WMu_Postscale'], checkPV=False, HLT="HLT_PASS('Hlt2SingleMuonHighPTDecision')", selection=self.sel_Mu10) self.registerLine(self.line_Mu10) self.sel_Mu48 = makeFilter(self._myname + 'Mu48', StdAllLooseMuons, "from LoKiTracks.decorators import *", _pTSingMuon48) self.line_Mu48 = StrippingLine( self._myname + 'Control4800Line', prescale=config['SingMuon48_Prescale'], postscale=config['WMu_Postscale'], checkPV=False, HLT="HLT_PASS('Hlt2SingleMuonLowPTDecision')", selection=self.sel_Mu48) self.registerLine(self.line_Mu48) # WMu signal self.sel_WMu = makeFilter(self._myname + 'WMu', StdAllLooseMuons, "from LoKiTracks.decorators import *", _pT) self.line_WMu = StrippingLine(self._myname + 'Line', prescale=config['WMu_Prescale'], postscale=config['WMu_Postscale'], checkPV=False, selection=self.sel_WMu) self.registerLine(self.line_WMu) # WMu control self.sel_WMuLow = makeFilter(self._myname + 'WMuLow', StdAllLooseMuons, "from LoKiTracks.decorators import *", _pTlow) self.line_WMuLow = StrippingLine(self._myname + 'LowLine', prescale=config['WMuLow_Prescale'], postscale=config['WMu_Postscale'], checkPV=False, selection=self.sel_WMuLow) self.registerLine(self.line_WMuLow) # WMu background self.sel_SingleTrackNoBias = makeFilter( self._myname + 'SingleTrackNoBias', StdAllNoPIDsMuons, "from LoKiTracks.decorators import *", _pTvlow) self.line_SingleTrackNoBias = StrippingLine( self._myname + 'SingleTrackNoBiasLine', prescale=config['STNB_Prescale'], postscale=config['WMu_Postscale'], checkPV=False, HLT="HLT_PASS( 'Hlt1MBNoBiasDecision' )", selection=self.sel_SingleTrackNoBias) self.registerLine(self.line_SingleTrackNoBias)
def __init__(self, name, config): '''The constructor of the configuration class. Requires a configuration dictionary, config, which must provide all the settings for cuts which are not hard coded''' LineBuilder.__init__(self, name, config) self._myname = name #define cuts #LL selection cuts self.LLPi_FilterCut_WS = "(P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(KSdaughterPiIPCHI2_LL)s)" % config self.KSLL_CombCut_WS = "(ADAMASS('KS0') < 25.*MeV) & (AMINDOCA('LoKi::TrgDistanceCalculator')<1.5)" self.KSLL_MotherCut_WS = "(ADMASS('KS0') < 20.*MeV) & (VFASPF(VCHI2/VDOF) < %(KSVertexCHI2_LL)s) & (BPVVDCHI2 > %(KSFlightCHI2_LL)s)" % config self.D_LL_DaughterCut_WS = "(P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(DdaughterIPCHI2_LL)s) " % config self.D_LL_CombCut_WS = "(ADAMASS('D0') < 38.*MeV) & (ADOCACUT(1.8, 'LoKi::TrgDistanceCalculator'))" self.D_LL_MotherCut_WS = "(ADMASS('D0') < 33.*MeV) & (VFASPF(VCHI2/VDOF) < %(DVertexCHI2_LL)s)" % config self.B_LL_BachCut_WS = "(PT > %(BachPt_LL)s *GeV ) & (P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(BachIPCHI2_LL)s )" % config self.B_LL_CombCut_WS = "(ADAMASS('B+') < 505.*MeV) & (AMINDOCA('LoKi::TrgDistanceCalculator')<0.5)" self.B_LL_MotherCut_WS = "(ADMASS('B+') < 500.*MeV) & (VFASPF(VCHI2/VDOF)<%(BVertexCHI2_LL)s) & (BPVIPCHI2() < %(BIPCHI2_LL)s) & (BPVVDCHI2 > %(BFlightCHI2_LL)s) & (BPVDIRA > %(BDIRA_LL)s)" % config #DD selection cuts self.DDPi_FilterCut_WS = "(ISDOWN) & (P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<10.) & (BPVIPCHI2() > %(KSdaughterPiIPCHI2_DD)s) & ((-PIDK) > 0.)" % config self.KSDD_CombCut_WS = "(ADAMASS('KS0') < 40.*MeV) & (AMINDOCA('LoKi::TrgDistanceCalculator')<22.)" self.KSDD_MotherCut_WS = "(ADMASS('KS0') < 28.*MeV) & (VFASPF(VCHI2/VDOF) < %(KSVertexCHI2_DD)s) & (BPVVDCHI2 > %(KSFlightCHI2_DD)s)" % config self.D_DD_DaughterCut_WS = " (P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(DdaughterIPCHI2_DD)s)" % config self.D_DD_CombCut_WS = "(ADAMASS('D0') < 45.*MeV) & (ADOCACUT(9.2, 'LoKi::TrgDistanceCalculator'))" self.D_DD_MotherCut_WS = "(ADMASS('D0') < 40.*MeV) & (VFASPF(VCHI2/VDOF) < %(DVertexCHI2_DD)s)" % config self.B_DD_BachCut_WS = "(PT > %(BachPt_DD)s *GeV) & (P > 2.*GeV) & (P < 100.*GeV) & (TRCHI2DOF<5.) & (BPVIPCHI2() > %(BachIPCHI2_DD)s)" % config self.B_DD_CombCut_WS = "(ADAMASS('B+') < 505.*MeV) & (AMINDOCA('LoKi::TrgDistanceCalculator')<0.5)" self.B_DD_MotherCut_WS = "(ADMASS('B+') < 500.*MeV) & (VFASPF(VCHI2/VDOF) < %(BVertexCHI2_DD)s) & (BPVIPCHI2() < %(BIPCHI2_DD)s) & (BPVVDCHI2 > %(BFlightCHI2_DD)s)& (BPVDIRA > %(BDIRA_DD)s)" % config #Make the selections self.LLPionFilterForBu2D0h_D02KShhAlg_WS() self.KSLLForBu2D0h_D02KShhAlg_WS() self.DForBu2D0h_D02KShh_KSLLAlg_WS() self.Bu2D0h_KShh_KSLLAlg_WS() self.DDPionFilterForBu2D0h_D02KShhAlg_WS() self.KSDDForBu2D0h_D02KShhAlg_WS() self.DForBu2D0h_D02KShh_KSDDAlg_WS() self.Bu2D0h_KShh_KSDDAlg_WS() ## ''' ## Define the GEC on number of long tracks, needed in order to control ## the time for the combinatorics (D in particular) ## ''' B2Dh_D2KShh_StrippingNumTracksGECLL_WS = { 'Code': "(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < 250)", 'Preambulo': ["from LoKiTracks.decorators import *"] } B2Dh_D2KShh_StrippingNumTracksGECDD_WS = { 'Code': "(recSummaryTrack(LHCb.RecSummary.nLongTracks, TrLONG) < 250)", 'Preambulo': ["from LoKiTracks.decorators import *"] } ## B2Dh_D2KShh_StrippingNumTracksGECLL_WS = {'Code' : "RECSUMMARY ( LHCb.RecSummary.nLongTracks , -1 ) < 250"} ## B2Dh_D2KShh_StrippingNumTracksGECDD_WS = {'Code' : "RECSUMMARY ( LHCb.RecSummary.nLongTracks , -1 ) < 250"} #Stripping lines self.Line_LL_Bu2D0h_D02KShh_WS = StrippingLine( self._myname + 'Bu2D0h_D02KShh_KSLL_WS', prescale=config['PrescaleLL'], postscale=config['PostscaleLL'], FILTER=B2Dh_D2KShh_StrippingNumTracksGECLL_WS, selection=self.Bu2D0h_LLSel_noPID_WS) self.Line_DD_Bu2D0h_D02KShh_WS = StrippingLine( self._myname + 'Bu2D0h_D02KShh_KSDD_WS', prescale=config['PrescaleDD'], postscale=config['PostscaleDD'], FILTER=B2Dh_D2KShh_StrippingNumTracksGECDD_WS, selection=self.Bu2D0h_DDSel_noPID_WS) self.registerLine(self.Line_LL_Bu2D0h_D02KShh_WS) self.registerLine(self.Line_DD_Bu2D0h_D02KShh_WS)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) PiOSLine_name = name + "_PiOS" PiSSLine_name = name + "_PiSS" KOSLine_name = name + "_KOS" KSSLine_name = name + "_KSS" # 1 : Make kaons selKaons = makeKaons(name="KaonsFor" + name, KaonP=config['KaonP'], KaonPT=config['KaonPT'], KaonMINIPCHI2=config['KaonMINIPCHI2']) # 2 : Make pions selPions = makePions(name="PionsFor" + name, PionP=config['PionP'], PionPT=config['PionPT'], PionMINIPCHI2=config['PionMINIPCHI2']) # 3 : Make muons selMuons = makeMuons(name="MuonsFor" + name, MuonP=config['MuonP'], MuonPT=config['MuonPT'], MuonMINIPCHI2=config['MuonMINIPCHI2']) # 4 : Combine selB2PiMuMuOS = self._makeB2PiMuMuOS(name=PiOSLine_name, pionSel=selPions, muonSel=selMuons, config=config) selB2PiMuMuSS = self._makeB2PiMuMuSS(name=PiSSLine_name, pionSel=selPions, muonSel=selMuons, config=config) selB2KMuMuOS = self._makeB2KMuMuOS(name=KOSLine_name, kaonSel=selKaons, muonSel=selMuons, config=config) selB2KMuMuSS = self._makeB2KMuMuSS(name=KSSLine_name, kaonSel=selKaons, muonSel=selMuons, config=config) # 5 : Declare Lines self.PiOSLine = StrippingLine( PiOSLine_name + "Line", prescale=config['B2PiMuMuOSLinePrescale'], postscale=config['B2PiMuMuOSLinePostscale'], selection=selB2PiMuMuOS) self.PiSSLine = StrippingLine( PiSSLine_name + "Line", prescale=config['B2PiMuMuSSLinePrescale'], postscale=config['B2PiMuMuSSLinePostscale'], selection=selB2PiMuMuSS) self.KOSLine = StrippingLine( KOSLine_name + "Line", prescale=config['B2KMuMuOSLinePrescale'], postscale=config['B2KMuMuOSLinePostscale'], selection=selB2KMuMuOS) self.KSSLine = StrippingLine( KSSLine_name + "Line", prescale=config['B2KMuMuSSLinePrescale'], postscale=config['B2KMuMuSSLinePostscale'], selection=selB2KMuMuSS) # 6 : register Line self.registerLine(self.PiOSLine) self.registerLine(self.PiSSLine) self.registerLine(self.KOSLine) self.registerLine(self.KSSLine) print "Created lines"
def __init__(self, name, config): LineBuilder.__init__(self, name, config) _2hName = name + '2h' _3hName = name + '3h' self.sel2hLoose = make2hLoose('2hLooseFor' + _2hName + 'Sel', _h_PT=config['_h_PT'], _h_P=config['_h_P'], _h_IPCHI2=config['_h_IPCHI2'], _h_TRCHI2DOF=config['_h_TRCHI2DOF'], _2hLoose_DOCA=config['_2hLoose_DOCA']) self.sel2h = make2h('2hFor' + _2hName + 'Sel', Sel2hLoose=self.sel2hLoose, _2h_PTmax=config['_2h_PTmax'], _2h_PTsum=config['_2h_PTsum'], _2h_PVIPCHI2sum=config['_2h_PVIPCHI2sum'], _2h_FDCHI2=config['_2h_FDCHI2'], _2h_DIRA=config['_2h_DIRA'], _2h_CORRMmax=config['_2h_CORRMmax'], _2h_CORRMmin=config['_2h_CORRMmin'], _2h_CharmVetoIPCHI2=config['_2h_CharmVetoIPCHI2'], _2h_CharmVetoM=config['_2h_CharmVetoM'], _2h_TRKCHIDOFmin=config['_2h_TRKCHIDOFmin'], _2h_Mmin=config['_2h_Mmin'], _2h_PVDOCAmin=config['_2h_PVDOCAmin'], _2h_CHI2=config['_2h_CHI2'], _2h_PTRANS=config['_2h_PTRANS']) self.sel3h = make3h('3hFor' + _3hName + 'Sel', Sel2hLoose=self.sel2hLoose, _h_PT=config['_h_PT'], _h_P=config['_h_P'], _h_IPCHI2=config['_h_IPCHI2'], _h_TRCHI2DOF=config['_h_TRCHI2DOF'], _3h_DOCA=config['_3h_DOCA'], _3h_PTmax=config['_3h_PTmax'], _3h_DIRA=config['_3h_DIRA'], _3h_FDCHI2=config['_3h_FDCHI2'], _3h_PVDOCAmin=config['_3h_PVDOCAmin'], _3h_CHI2=config['_3h_CHI2'], _3h_IP=config['_3h_IP'], _3h_PT=config['_3h_PT'], _3h_PTsum=config['_3h_PTsum'], _3h_PVIPCHI2sum=config['_3h_PVIPCHI2sum'], _3h_Charge=config['_3h_Charge'], _3h_CORRMmax=config['_3h_CORRMmax'], _3h_CORRMmin=config['_3h_CORRMmin'], _3h_Mmin=config['_3h_Mmin'], _3h_Mmax=config['_3h_Mmax']) self.gECFilter = globalEventCutFilter(name + 'GlobalEventCutFilter', MaxTrSIZE=config['MaxTrSIZE']) self.algos2h = [] if self.gECFilter != None: self.algos2h.append(self.gECFilter) self.algos2h.append(self.sel2h) self.algos3h = [] if self.gECFilter != None: self.algos3h.append(self.gECFilter) self.algos3h.append(self.sel3h) self.line2h = StrippingLine(_2hName + 'Line', prescale=config['2hLinePrescale'], postscale=config['2hLinePostscale'], algos=self.algos2h) self.line3h = StrippingLine(_3hName + 'Line', prescale=config['3hLinePrescale'], postscale=config['3hLinePostscale'], algos=self.algos3h) self.registerLine(self.line2h) self.registerLine(self.line3h)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) prescaled_name = name + 'Prescaled' self.selMuons = makeMuons('MuonsFor' + prescaled_name, MUON_MinPT=config['MUON_MinPT'], MUON_PIDmu=config['MUON_PIDmu']) self.selMuonsFromB = makeMuonsFromB( 'MuonsFromBFor' + prescaled_name, muonSel=self.selMuons, TRACK_MINIPCHI2=config['TRACK_MINIPCHI2']) self.selKaons = makeKaons('KaonsFor' + prescaled_name, KAON_PIDK=config['KAON_PIDK'], KAON_MinPT=config['KAON_MinPT']) self.selKaonsFromB = makeKaonsFromB( 'KaonsFromBFor' + prescaled_name, kaonSel=self.selKaons, TRACK_MINIPCHI2=config['TRACK_MINIPCHI2']) self.selPions = makePions('PionsFor' + prescaled_name, PION_PIDmu=config['PION_PIDmu'], PION_PIDK=config['PION_PIDK'], PION_MinPT=config['PION_MinPT']) self.selPionsFromB = makePionsFromB( 'PionsFromBFor' + prescaled_name, pionSel=self.selPions, TRACK_MINIPCHI2=config['TRACK_MINIPCHI2']) self.selSlowPions = makeSlowPions('SlowPionsFor' + prescaled_name, PION_PIDmu=config['PION_PIDmu']) self.selRho = makeRho('RhoFor' + prescaled_name, pionFromBSel=self.selPionsFromB, Rho_MinPT=config['Rho_MinPT'], Rho_MassMax=config['Rho_MassMax'], Rho_MassMin=config['Rho_MassMin']) self.selKstar = makeKstar('KstarFor' + prescaled_name, pionFromBSel=self.selPionsFromB, kaonFromBSel=self.selKaonsFromB, Kstar_MinPT=config['Kstar_MinPT'], Kstar_MassMax=config['Kstar_MassMax'], Kstar_MassMin=config['Kstar_MassMin']) self.selDplus2VMuNu = makeDplus2VMuNu( 'Dplus2VMuNuFor' + prescaled_name, muonFromBSel=self.selMuonsFromB, RhoSel=self.selRho, KstarSel=self.selKstar, PAIR_SumPTMin=config['PAIR_SumPTMin'], D_MassMax=config['D_MassMax'], D_DOCA=config['D_DOCA'], D_MinP=config['D_MinP'], Dplus_FD=config['Dplus_FD'], D_MCORR_MIN=config['D_MCORR_MIN'], D_MCORR_MAX=config['D_MCORR_MAX'], D_BPVVDZ=config['D_BPVVDZ'], D_VtxChi2=config['D_VtxChi2']) self.selBtoDplusVMuNu = makeBtoDplusVMuNu( 'BtoDplusVMuNu' + prescaled_name, Dplus2VMuNuSel=self.selDplus2VMuNu, PionsFromBSel=self.selPionsFromB, BtoD_DeltaMass_MIN=config['BtoD_DeltaMass_MIN'], BtoD_DeltaMass_MAX=config['BtoD_DeltaMass_MAX'], B_DIRA=config['B_DIRA'], B_FDCHI2=config['B_FDCHI2']) self.selD02HMuNu = makeD02HMuNu('D0HMuNuFor' + prescaled_name, muonSel=self.selMuons, pionSel=self.selPions, kaonSel=self.selKaons, PAIR_SumPTMin=config['PAIR_SumPTMin'], D_MassMax=config['D_MassMax'], D_DOCA=config['D_DOCA'], D_MinP=config['D_MinP'], D0_FD=config['D0_FD'], D_MCORR_MIN=config['D_MCORR_MIN'], D_MCORR_MAX=config['D_MCORR_MAX'], D_BPVVDZ=config['D_BPVVDZ'], D_VtxChi2=config['D_VtxChi2']) self.selDstarD02HMuNu = makeDstarD02HMuNu( 'DstarD0HMuNuFor' + prescaled_name, D02HMuNuSel=self.selD02HMuNu, slowPionSel=self.selSlowPions, Dstar_MassMin=config['Dstar_MassMin'], Dstar_DOCA=config['Dstar_DOCA'], Dstar_VtxChi2=config['Dstar_VtxChi2'], Dstar_DeltaMass=config['Dstar_DeltaMass']) self.prescaled_lineVMuNu = StrippingLine( prescaled_name + "VMuNuLine", prescale=config['PrescaledVLinePrescale'], HLT=config['HLT_FILTER_VMuNu'], selection=self.selBtoDplusVMuNu) self.prescaled_lineHMuNu = StrippingLine( prescaled_name + "HMuNuLine", prescale=config['PrescaledHLinePrescale'], HLT=config['HLT_FILTER_HMuNu'], selection=self.selDstarD02HMuNu) self.registerLine(self.prescaled_lineVMuNu) self.registerLine(self.prescaled_lineHMuNu)
def __init__(self, name, config): LineBuilder.__init__(self, name, config) ##################################################################################################################### self.lineL0DiHadron = StrippingLine( "L0DiHadron" + "Line", prescale=config['PrescaleL0DiHadron'], checkPV=False, EnableFlavourTagging=False, L0DU=config['DecisionL0DiHadron'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineL0DiHadron) self.lineL0DiEM = StrippingLine( "L0DiEM" + "Line", prescale=config['PrescaleL0DiEM'], checkPV=False, EnableFlavourTagging=False, L0DU=config['DecisionL0DiEM'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineL0DiEM) self.lineL0Photon = StrippingLine( "L0Photon" + "Line", prescale=config['PrescaleL0Photon'], checkPV=False, EnableFlavourTagging=False, L0DU=config['DecisionL0Photon'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineL0Photon) self.lineL0DiMuon = StrippingLine( "L0DiMuon" + "Line", prescale=config['PrescaleL0DiMuon'], checkPV=False, EnableFlavourTagging=False, L0DU=config['DecisionL0DiMuon'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineL0DiMuon) self.lineL0Muon = StrippingLine( "L0Muon" + "Line", prescale=config['PrescaleL0Muon'], checkPV=False, EnableFlavourTagging=False, L0DU=config['DecisionL0Muon'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineL0Muon) self.lineL0Electron = StrippingLine( "L0Electron" + "Line", prescale=config['PrescaleL0Electron'], checkPV=False, EnableFlavourTagging=False, L0DU=config['DecisionL0Electron'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineL0Electron) ################################################# self.lineLowMultL2pPi = StrippingLine( "LowMultL2pPi" + "Line", prescale=config['PrescaleLowMultL2pPi'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultL2pPi'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultL2pPi) self.lineLowMultD2KPi = StrippingLine( "LowMultD2KPi" + "Line", prescale=config['PrescaleLowMultD2KPi'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultD2KPi'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultD2KPi) self.lineLowMultD2KPiPi = StrippingLine( "LowMultD2KPiPi" + "Line", prescale=config['PrescaleLowMultD2KPiPi'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultD2KPiPi'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultD2KPiPi) self.lineLowMultD2KKPi = StrippingLine( "LowMultD2KKPi" + "Line", prescale=config['PrescaleLowMultD2KKPi'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultD2KKPi'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultD2KKPi) self.lineLowMultD2K3Pi = StrippingLine( "LowMultD2K3Pi" + "Line", prescale=config['PrescaleLowMultD2K3Pi'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultD2K3Pi'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultD2K3Pi) self.lineLowMultChiC2HH = StrippingLine( "LowMultChiC2HH" + "Line", prescale=config['PrescaleLowMultChiC2HH'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultChiC2HH'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultChiC2HH) self.lineLowMultChiC2HHHH = StrippingLine( "LowMultChiC2HHHH" + "Line", prescale=config['PrescaleLowMultChiC2HHHH'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultChiC2HHHH'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultChiC2HHHH) self.lineLowMultChiC2PP = StrippingLine( "LowMultChiC2PP" + "Line", prescale=config['PrescaleLowMultChiC2PP'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultChiC2PP'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultChiC2PP) ################################################# self.lineLowMultLMR2HH = StrippingLine( "LowMultLMR2HH" + "Line", prescale=config['PrescaleLowMultLMR2HH'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultLMR2HH'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultLMR2HH) self.lineLowMultLMR2HHHH = StrippingLine( "LowMultLMR2HHHH" + "Line", prescale=config['PrescaleLowMultLMR2HHHH'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultLMR2HHHH'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultLMR2HHHH) # self.lineLowMultLMR2HH_mediumPS = StrippingLine( "LowMultLMR2HH_mediumPS" + "Line", prescale=config['PrescaleLowMultLMR2HH_mediumPS'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultLMR2HH_mediumPS'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultLMR2HH_mediumPS) self.lineLowMultLMR2HH_mediumPSHH = StrippingLine( "LowMultLMR2HHHH_mediumPS" + "Line", prescale=config['PrescaleLowMultLMR2HHHH_mediumPS'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultLMR2HHHH_mediumPS'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultLMR2HH_mediumPSHH) # self.lineLowMultLMR2HH_heavyPS = StrippingLine( "LowMultLMR2HH_heavyPS" + "Line", prescale=config['PrescaleLowMultLMR2HH_heavyPS'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultLMR2HH_heavyPS'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultLMR2HH_heavyPS) self.lineLowMultLMR2HH_heavyPSHH = StrippingLine( "LowMultLMR2HHHH_heavyPS" + "Line", prescale=config['PrescaleLowMultLMR2HHHH_heavyPS'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultLMR2HHHH_heavyPS'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultLMR2HH_heavyPSHH) ################################################# self.lineLowMultHadron_noTrFilt = StrippingLine( "LowMultHadron_noTrFilt" + "Line", prescale=config['PrescaleLowMultHadron_noTrFilt'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultHadron_noTrFilt'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultHadron_noTrFilt) ################################################# self.lineLowMultDiMuon = StrippingLine( "LowMultDiMuon" + "Line", prescale=config['PrescaleLowMultDiMuon'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultDiMuon'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultDiMuon) self.lineLowMultDiMuon_PS = StrippingLine( "LowMultDiMuon_PS" + "Line", prescale=config['PrescaleLowMultDiMuon_PS'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultDiMuon_PS'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultDiMuon_PS) self.lineLowMultMuon = StrippingLine( "LowMultMuon" + "Line", prescale=config['PrescaleLowMultMuon'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultMuon'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultMuon) ################################################# self.lineLowMultDiElectron = StrippingLine( "LowMultDiElectron" + "Line", prescale=config['PrescaleLowMultDiElectron'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultDiElectron'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultDiElectron) self.lineLowMultDiElectron_noTrFilt = StrippingLine( "LowMultDiElectron_noTrFilt" + "Line", prescale=config['PrescaleLowMultDiElectron_noTrFilt'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultDiElectron_noTrFilt'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultDiElectron_noTrFilt) ################################################# self.lineLowMultDiPhoton = StrippingLine( "LowMultDiPhoton" + "Line", prescale=config['PrescaleLowMultDiPhoton'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultDiPhoton'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultDiPhoton) self.lineLowMultDiPhoton_HighMass = StrippingLine( "LowMultDiPhoton_HighMass" + "Line", prescale=config['PrescaleLowMultDiPhoton_HighMass'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultDiPhoton_HighMass'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultDiPhoton_HighMass) self.lineLowMultPi0 = StrippingLine( "LowMultPi0" + "Line", prescale=config['PrescaleLowMultPi0'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultPi0'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultPi0) ##### ##### self.lineLowMultNonBeamBeamNoBias = StrippingLine( "LowMultNonBeamBeamNoBias" + "Line", prescale=config['PrescaleLowMultNonBeamBeamNoBias'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultNonBeamBeamNoBias'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultNonBeamBeamNoBias) self.lineLowMultTechnical = StrippingLine( "LowMultTechnical" + "Line", prescale=config['PrescaleLowMultTechnical'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultTechnical'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultTechnical) ##### self.lineHlt1NoBiasNonBeamBeam = StrippingLine( "Hlt1NoBiasNonBeamBeam" + "Line", prescale=config['PrescaleHlt1NoBiasNonBeamBeam'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT1=config['DecisionHlt1NoBiasNonBeamBeam'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineHlt1NoBiasNonBeamBeam) self.lineHlt2PassThrough = StrippingLine( "Hlt2PassThrough" + "Line", prescale=config['PrescaleHlt2PassThrough'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionHlt2PassThrough'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineHlt2PassThrough) ##### self.lineLowMultTMP1 = StrippingLine( "LowMultTMP1" + "Line", prescale=config['PrescaleLowMultTMP1'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultTMP1'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultTMP1) self.lineLowMultTMP2 = StrippingLine( "LowMultTMP2" + "Line", prescale=config['PrescaleLowMultTMP2'], checkPV=False, EnableFlavourTagging=False, L0DU=None, HLT2=config['DecisionLowMultTMP2'], RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultTMP2) #################################################################################################### self.lineLowMultBXTYPE = StrippingLine( "LowMultBXTYPE" + "Line", prescale=config['PrescaleLowMultBXTYPE'], checkPV=False, EnableFlavourTagging=False, ODIN="( ODIN_BXTYP == LHCb.ODIN.NoBeam)", L0DU=None, HLT2=None, RequiredRawEvents=config["LowMultRequiredRawEvents"]) self.registerLine(self.lineLowMultBXTYPE)
def __init__(self, name, config ): LineBuilder.__init__(self, name, config) self.name = name self.config = config """ Di letpons """ from StandardParticles import StdDiElectronFromTracks, StdLooseDiMuon self.SelDiElectron = self.createSubSel( OutputList = self.name + "SelDiElectron", InputList = StdDiElectronFromTracks , Cuts = config['DiElectronCuts'] ) self.SelDiMuon = self.createSubSel( OutputList = self.name + "SelDiMuon", InputList = StdLooseDiMuon , Cuts = config['DiMuonCuts'] ) """ Basic particles, long tracks """ from StandardParticles import StdLooseANNPions, StdLooseANNKaons, StdLooseANNProtons self.SelPions = self.createSubSel( OutputList = self.name + "SelPions", InputList = StdLooseANNPions , Cuts = config['PionCuts'] ) self.SelKaons = self.createSubSel( OutputList = self.name + "SelKaons", InputList = StdLooseANNKaons, Cuts = config['KaonCuts'] ) self.SelProtons = self.createSubSel( OutputList = self.name + "SelProtons", InputList = StdLooseANNProtons, Cuts = config['ProtonCuts'] ) from StandardParticles import StdAllLooseANNPions self.SelPions4LP = self.createSubSel( OutputList = self.name + "SelPions4LP", InputList = StdAllLooseANNPions , Cuts = config['Pion4LPCuts'] ) """ Kstar """ from StandardParticles import StdVeryLooseDetachedKst2Kpi self.SelKstar = self.createSubSel( OutputList = self.name + "SelKstar", InputList = StdVeryLooseDetachedKst2Kpi, Cuts = config['KstarCuts'] ) """ Kshort, both LL and DD """ from StandardParticles import StdLooseKsDD, StdLooseKsLL self.SelKsDD = self.createSubSel( OutputList = self.name + "SelKsDD", InputList = StdLooseKsDD, Cuts = config['KsDDCuts'] ) """ self.SelKsLL = self.createSubSel( OutputList = self.name + "SelKsLL", InputList = StdLooseKsLL, Cuts = config['KsLLCuts'] ) """ self.SelKsLL = self.createCombinationSel( OutputList = self.name + "SelKsLL", DecayDescriptor = "KS0 -> pi+ pi-", DaughterLists = [ self.SelPions4LP ], PreVertexCuts = config['KsLLComCuts'], PostVertexCuts = config['KsLLCuts'] ) self.SelKs = MergedSelection( self.name + "SelKs", RequiredSelections = [ self.SelKsDD, self.SelKsLL ] ) """ Phi """ from StandardParticles import StdLoosePhi2KK self.SelPhi = self.createSubSel( OutputList = self.name + "SelPhi", InputList = StdLoosePhi2KK, Cuts = config['PhiCuts'] ) """ Lambda, both LL and DD """ from StandardParticles import StdLooseLambdaDD, StdLooseLambdaLL self.SelLambdaDD = self.createSubSel( OutputList = self.name + "SelLambdaDD", InputList = StdLooseLambdaDD, Cuts = config['LambdaDDCuts'] ) self.SelLambdaLL = self.createCombinationSel( OutputList = self.name + "SelLambdaLL", DecayDescriptor = "[Lambda0 -> p+ pi-]cc", DaughterLists = [ self.SelProtons, self.SelPions4LP ], PreVertexCuts = config['LambdaLLComCuts'], PostVertexCuts = config['LambdaLLCuts'] ) self.SelLambda = MergedSelection( self.name + "SelLambda", RequiredSelections = [ self.SelLambdaDD, self.SelLambdaLL ] ) """ Lambda* -> p K """ self.SelLambdastar = self.createCombinationSel( OutputList = self.name + "SelLambdastar", DecayDescriptor = "[Lambda(1520)0 -> p+ K-]cc", DaughterLists = [ self.SelProtons, self.SelKaons ], PreVertexCuts = config['LambdastarComCuts'], PostVertexCuts = config['LambdastarCuts'] ) # # Stripping lines here # self.B2LLHVars = { "sqrt(L1_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 1, 1))", "sqrt(L2_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 1, 2))", "sqrt(Jpsi_IPCHI2_OWNPV}" : "sqrt(CHILD(MIPCHI2DV(), 1 ))", "sqrt(H_IPCHI2_OWNPV}" : "sqrt(CHILD(MIPCHI2DV(), 2 ))", "sqrt(B_IPCHI2_OWNPV)" : "sqrt(BPVIPCHI2())" , "log(L1_PT)" : "log(CHILD(PT, 1, 1))", "log(L2_PT)" : "log(CHILD(PT, 1, 2))", "log(Jpsi_PT)" : "log(CHILD(PT, 1))", "log(H_PT)" : "log(CHILD(PT, 2))", "log(B_PT)" : "log(PT)", "sqrt(Jpsi_FDCHI2_OWNPV)" : "sqrt(CHILD(BPVVDCHI2,1))", "sqrt(B_FDCHI2_OWNPV)" : "sqrt(BPVVDCHI2)" , "B_DIRA_OWNPV" : "BPVDIRA" } """ Bu2eeK """ self.SelBu2eeK = self.createCombinationSel( OutputList = self.name + "SelBu2eeK", DecayDescriptor = "[B+ -> J/psi(1S) K+]cc", DaughterLists = [ self.SelDiElectron, self.SelKaons ], PreVertexCuts = config['BComCuts'], PostVertexCuts = config['BMomCuts'] ) self.MvaBu2eeK = self.applyMVA( self.name + "MvaBu2eeK", SelB = self.SelBu2eeK, MVAVars = self.B2LLHVars, MVACutValue = config['Bu2eeKMVACut'], MVAxmlFile = config['Bu2LLKXmlFile'] ) self.Bu2eeKLine = StrippingLine( self.name + '_Bu2eeKLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaBu2eeK ], MDSTFlag = True ) self.registerLine( self.Bu2eeKLine ) """ Bu2mumuK """ self.SelBu2mumuK = self.createCombinationSel( OutputList = self.name + "SelBu2mumuK", DecayDescriptor = "[B+ -> J/psi(1S) K+]cc", DaughterLists = [ self.SelDiMuon, self.SelKaons ], PreVertexCuts = config['BComCuts'], PostVertexCuts = config['BMomCuts'] ) self.MvaBu2mumuK = self.applyMVA( self.name + "MvaBu2mumuK", SelB = self.SelBu2mumuK, MVAVars = self.B2LLHVars, MVACutValue = config['Bu2mumuKMVACut'], MVAxmlFile = config['Bu2LLKXmlFile'] ) self.Bu2mumuKLine = StrippingLine( self.name + '_Bu2mumuKLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaBu2mumuK ], MDSTFlag = True ) self.registerLine( self.Bu2mumuKLine ) # # Bd2LLKstar # """ B2LLXVars """ self.B2LLXVars = { "sqrt(L1_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 1, 1))", "sqrt(L2_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 1, 2))", "sqrt(Jpsi_IPCHI2_OWNPV}" : "sqrt(CHILD(MIPCHI2DV(), 1 ))", "sqrt(H1_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 2, 1))", "sqrt(H2_IPCHI2_OWNPV)" : "sqrt(CHILD(MIPCHI2DV(), 2, 2))", "sqrt(X_IPCHI2_OWNPV}" : "sqrt(CHILD(MIPCHI2DV(), 2 ))", "sqrt(B_IPCHI2_OWNPV)" : "sqrt(BPVIPCHI2())" , "log(L1_PT)" : "log(CHILD(PT, 1, 1))", "log(L2_PT)" : "log(CHILD(PT, 1, 2))", "log(Jpsi_PT)" : "log(CHILD(PT, 1))", "log(H1_PT)" : "log(CHILD(PT, 2, 1))", "log(H2_PT)" : "log(CHILD(PT, 2, 2))", "log(X_PT)" : "log(CHILD(PT, 2))", "log(B_PT)" : "log(PT)", "sqrt(Jpsi_FDCHI2_OWNPV)" : "sqrt(CHILD(BPVVDCHI2,1))", "sqrt(X_FDCHI2_OWNPV)" : "sqrt(CHILD(BPVVDCHI2,2))", "sqrt(B_FDCHI2_OWNPV)" : "sqrt(BPVVDCHI2)" , "B_DIRA_OWNPV" : "BPVDIRA" } """ Bd2eeKstar """ self.SelBd2eeKstar = self.createCombinationSel( OutputList = self.name + "SelBd2eeKstar", DecayDescriptor = "[B0 -> J/psi(1S) K*(892)0]cc", DaughterLists = [ self.SelDiElectron, self.SelKstar ], PreVertexCuts = config['BComCuts'], PostVertexCuts = config['BMomCuts'] ) self.MvaBd2eeKstar = self.applyMVA( self.name + "MvaBd2eeKstar", SelB = self.SelBd2eeKstar, MVAVars = self.B2LLXVars, MVACutValue = config['Bd2eeKstarMVACut'], MVAxmlFile = config['Bd2LLKstarXmlFile'] ) self.Bd2eeKstarLine = StrippingLine( self.name + '_Bd2eeKstarLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaBd2eeKstar ], MDSTFlag = True ) self.registerLine( self.Bd2eeKstarLine ) """ Bd2mumuKstar """ self.SelBd2mumuKstar = self.createCombinationSel( OutputList = self.name + "SelBd2mumuKstar", DecayDescriptor = "[B0 -> J/psi(1S) K*(892)0]cc", DaughterLists = [ self.SelDiMuon, self.SelKstar ], PreVertexCuts = config['BComCuts'], PostVertexCuts = config['BMomCuts'] ) self.MvaBd2mumuKstar = self.applyMVA( self.name + "MvaBd2mumuKstar", SelB = self.SelBd2mumuKstar, MVAVars = self.B2LLXVars, MVACutValue = config['Bd2mumuKstarMVACut'], MVAxmlFile = config['Bd2LLKstarXmlFile'] ) self.Bd2mumuKstarLine = StrippingLine( self.name + '_Bd2mumuKstarLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaBd2mumuKstar ], MDSTFlag = True ) self.registerLine( self.Bd2mumuKstarLine ) """ Bd2eeKs """ self.SelBd2eeKs = self.createCombinationSel( OutputList = self.name + "SelBd2eeKs", DecayDescriptor = "B0 -> J/psi(1S) KS0", DaughterLists = [ self.SelDiElectron, self.SelKs ], PreVertexCuts = config['BComCuts'], PostVertexCuts = config['BMomCuts'] ) self.MvaBd2eeKs = self.applyMVA( self.name + "MvaBd2eeKs", SelB = self.SelBd2eeKs, MVAVars = self.B2LLXVars, MVACutValue = config['Bd2eeKsMVACut'], MVAxmlFile = config['Bd2LLKsXmlFile'] ) self.Bd2eeKsLine = StrippingLine( self.name + '_Bd2eeKsLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaBd2eeKs ], MDSTFlag = True ) self.registerLine( self.Bd2eeKsLine ) """ Bd2mumuKs """ self.SelBd2mumuKs = self.createCombinationSel( OutputList = self.name + "SelBd2mumuKs", DecayDescriptor = "B0 -> J/psi(1S) KS0", DaughterLists = [ self.SelDiMuon, self.SelKs ], PreVertexCuts = config['BComCuts'], PostVertexCuts = config['BMomCuts'] ) self.MvaBd2mumuKs = self.applyMVA( self.name + "MvaBd2mumuKs", SelB = self.SelBd2mumuKs, MVAVars = self.B2LLXVars, MVACutValue = config['Bd2mumuKsMVACut'], MVAxmlFile = config['Bd2LLKsXmlFile'] ) self.Bd2mumuKsLine = StrippingLine( self.name + '_Bd2mumuKsLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaBd2mumuKs ], MDSTFlag = True ) self.registerLine( self.Bd2mumuKsLine ) """ Bs2eePhi """ self.SelBs2eePhi = self.createCombinationSel( OutputList = self.name + "SelBs2eePhi", DecayDescriptor = "B_s0 -> J/psi(1S) phi(1020)", DaughterLists = [ self.SelDiElectron, self.SelPhi ], PreVertexCuts = config['BComCuts'], PostVertexCuts = config['BMomCuts'] ) self.MvaBs2eePhi = self.applyMVA( self.name + "MvaBs2eePhi", SelB = self.SelBs2eePhi, MVAVars = self.B2LLXVars, MVACutValue = config['Bs2eePhiMVACut'], MVAxmlFile = config['Bs2LLPhiXmlFile'] ) self.Bs2eePhiLine = StrippingLine( self.name + '_Bs2eePhiLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaBs2eePhi ], MDSTFlag = True ) self.registerLine( self.Bs2eePhiLine ) """ Bs2mumuPhi """ self.SelBs2mumuPhi = self.createCombinationSel( OutputList = self.name + "SelBs2mumuPhi", DecayDescriptor = "B_s0 -> J/psi(1S) phi(1020)", DaughterLists = [ self.SelDiMuon, self.SelPhi ], PreVertexCuts = config['BComCuts'], PostVertexCuts = config['BMomCuts'] ) self.MvaBs2mumuPhi = self.applyMVA( self.name + "MvaBs2mumuPhi", SelB = self.SelBs2mumuPhi, MVAVars = self.B2LLXVars, MVACutValue = config['Bs2mumuPhiMVACut'], MVAxmlFile = config['Bs2LLPhiXmlFile'] ) self.Bs2mumuPhiLine = StrippingLine( self.name + '_Bs2mumuPhiLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaBs2mumuPhi ], MDSTFlag = True ) self.registerLine( self.Bs2mumuPhiLine ) """ Lb2eeLambda """ self.SelLb2eeLambda = self.createCombinationSel( OutputList = self.name + "SelLb2eeLambda", DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda0]cc", DaughterLists = [ self.SelDiElectron, self.SelLambda ], PreVertexCuts = config['LbComCuts'], PostVertexCuts = config['LbMomCuts'] ) self.MvaLb2eeLambda = self.applyMVA( self.name + "MvaLb2eeLambda", SelB = self.SelLb2eeLambda, MVAVars = self.B2LLXVars, MVACutValue = config['Lb2eeLambdaMVACut'], MVAxmlFile = config['Lb2LLLambdaXmlFile'] ) self.Lb2eeLambdaLine = StrippingLine( self.name + '_Lb2eeLambdaLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaLb2eeLambda ], MDSTFlag = True ) self.registerLine( self.Lb2eeLambdaLine ) """ Lb2mumuLambda """ self.SelLb2mumuLambda = self.createCombinationSel( OutputList = self.name + "SelLb2mumuLambda", DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda0]cc", DaughterLists = [ self.SelDiMuon, self.SelLambda ], PreVertexCuts = config['LbComCuts'], PostVertexCuts = config['LbMomCuts'] ) self.MvaLb2mumuLambda = self.applyMVA( self.name + "MvaLb2mumuLambda", SelB = self.SelLb2mumuLambda, MVAVars = self.B2LLXVars, MVACutValue = config['Lb2mumuLambdaMVACut'], MVAxmlFile = config['Lb2LLLambdaXmlFile'] ) self.Lb2mumuLambdaLine = StrippingLine( self.name + '_Lb2mumuLambdaLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaLb2mumuLambda ], MDSTFlag = True ) self.registerLine( self.Lb2mumuLambdaLine ) # # Lb-> LL Kstar # """ Lb2eePK """ self.SelLb2eePK = self.createCombinationSel( OutputList = self.name + "SelLb2eePK", DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda(1520)0]cc", DaughterLists = [ self.SelDiElectron, self.SelLambdastar ], PreVertexCuts = config['LbComCuts'], PostVertexCuts = config['LbMomCuts'] ) self.MvaLb2eePK = self.applyMVA( self.name + "MvaLb2eePK", SelB = self.SelLb2eePK, MVAVars = self.B2LLXVars, MVACutValue = config['Lb2eePKMVACut'], MVAxmlFile = config['Lb2LLPKXmlFile'] ) self.Lb2eePKLine = StrippingLine( self.name + '_Lb2eePKLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaLb2eePK ], MDSTFlag = True ) self.registerLine( self.Lb2eePKLine ) """ Lb2mumuPK """ self.SelLb2mumuPK = self.createCombinationSel( OutputList = self.name + "SelLb2mumuPK", DecayDescriptor = "[Lambda_b0 -> J/psi(1S) Lambda(1520)0]cc", DaughterLists = [ self.SelDiMuon, self.SelLambdastar ], PreVertexCuts = config['LbComCuts'], PostVertexCuts = config['LbMomCuts'] ) self.MvaLb2mumuPK = self.applyMVA( self.name + "MvaLb2mumuPK", SelB = self.SelLb2mumuPK, MVAVars = self.B2LLXVars, MVACutValue = config['Lb2mumuPKMVACut'], MVAxmlFile = config['Lb2LLPKXmlFile'] ) self.Lb2mumuPKLine = StrippingLine( self.name + '_Lb2mumuPKLine', RelatedInfoTools = config['RelatedInfoTools'], algos = [ self.MvaLb2mumuPK ], MDSTFlag = True ) self.registerLine( self.Lb2mumuPKLine )