diff --git a/Phys/StrippingSelections/python/StrippingSelections/StrippingRD/StrippingB2XLTau1pi.py b/Phys/StrippingSelections/python/StrippingSelections/StrippingRD/StrippingB2XLTau1pi.py
index 69118403ccfbfea19c83ea42b13da40690805574..30600ea0f28e5cbb2b0995610b16c8be4a7291f9 100644
--- a/Phys/StrippingSelections/python/StrippingSelections/StrippingRD/StrippingB2XLTau1pi.py
+++ b/Phys/StrippingSelections/python/StrippingSelections/StrippingRD/StrippingB2XLTau1pi.py
@@ -205,17 +205,17 @@ class B2XLTau1piConf(LineBuilder):
             self.HadronCuts + " & (P > %(Hadron_P)s*MeV)" % config
         self.KaonCut = self.KaonCutBase + \
             " & (PIDK > %(KaonPID)s) & (~ISMUON) & (PROBNNK > %(Kaon_ProbNN)s)" % config
-        self.KaonCutNoPID = self.KaonCutBase + \
+        self.KaonCutReversePID = self.KaonCutBase + \
             " & (PIDK < %(KaonPID)s) & (PROBNNK < %(Kaon_ProbNN)s)" % config
         self.KaonCut_B2Kstar = self.KaonCutBase + \
             " & (PROBNNK * (1-PROBNNpi) > %(Kaon_Pion_ProbNN_B2Kstar)s) & (~ISMUON)" % config
-        self.KaonCutNoPID_B2Kstar = self.KaonCutBase + \
+        self.KaonCutReversePID_B2Kstar = self.KaonCutBase + \
             " & (PROBNNK * (1-PROBNNpi) < %(Kaon_Pion_ProbNN_B2Kstar)s)" % config
 
         self.PionCutBase = self.TrackCuts + " & " + self.HadronCuts
         self.PionCut_B2Kstar = self.PionCutBase + \
             " & (PROBNNpi > %(Pion_ProbNN_B2Kstar)s) & (~ISMUON)" % config
-        self.PionCutNoPID_B2Kstar = self.PionCutBase + \
+        self.PionCutReversePID_B2Kstar = self.PionCutBase + \
             " & (PROBNNpi < %(Pion_ProbNN_B2Kstar)s)" % config
 
         self.PionFromTauCutBase = self.TrackCuts + \
@@ -223,28 +223,28 @@ class B2XLTau1piConf(LineBuilder):
         self.PionFromTauCut = self.PionFromTauCutBase + \
         " & (PIDpi-PIDK > %(PionFromTau_PIDpiK_min)s) & (PIDpi-PIDp > %(PionFromTau_PIDpip_min)s) & (PIDpi-PIDmu > %(PionFromTau_PIDpimu_min)s) & (PIDpi-PIDe > %(PionFromTau_PIDpie_min)s) & (PROBNNpi > %(PionFromTau_ProbNN_min)s) & (~ISMUON)" % config #
 
-        self.PionFromTauCutNoPID = self.PionFromTauCutBase + \
-            " & (PIDpi-PIDK < %(PionFromTau_PIDpiK_min)s) & (PIDpi-PIDp < %(PionFromTau_PIDpip_min)s) & (PIDpi-PIDmu < %(PionFromTau_PIDpimu_min)s) & (PIDpi-PIDe < %(PionFromTau_PIDpie_min)s) & (PROBNNpi < %(PionFromTau_ProbNN_min)s)" % config  # 
+        self.PionFromTauCutReversePID = self.PionFromTauCutBase + \
+            " & (PIDpi-PIDK < %(PionFromTau_PIDpiK_min)s) | (PIDpi-PIDp < %(PionFromTau_PIDpip_min)s) | (PIDpi-PIDmu < %(PionFromTau_PIDpimu_min)s) | (PIDpi-PIDe < %(PionFromTau_PIDpie_min)s) | (PROBNNpi < %(PionFromTau_ProbNN_min)s)" % config  # 
 
         self.ProtonCutBase = self.TrackCuts + " & " + \
             self.HadronCuts + " & (P > %(Hadron_P)s * MeV)" % config
         self.ProtonCut = self.ProtonCutBase + \
             " & (PIDp > %(ProtonPID)s)  & (~ISMUON) & (PROBNNp > %(Proton_ProbNN)s)" % config
-        self.ProtonCutNoPID = self.ProtonCutBase + \
+        self.ProtonCutReversePID = self.ProtonCutBase + \
             " & (PIDp < %(ProtonPID)s) & (PROBNNp < %(Proton_ProbNN)s)" % config
 
         self.MuonCutBase = self.TrackCuts + \
             " & (MIPCHI2DV(PRIMARY) > %(Muon_MinIPCHI2)s)" % config
         self.MuonCut = self.MuonCutBase + \
             " & (PIDmu> %(MuonPID)s) & (ISMUON) & (PROBNNmu > %(Muon_ProbNN)s)" % config
-        self.MuonCutNoPID = self.MuonCutBase + \
+        self.MuonCutReversePID = self.MuonCutBase + \
             " & (PIDmu < %(MuonPID)s)  & (PROBNNmu < %(Muon_ProbNN)s)" % config
 
         self.MuonFromBCutBase = self.MuonCutBase + \
             " & (PT > %(MuonPT)s * MeV)" % config
         self.MuonFromBCut = self.MuonCut + \
             " & (PT > %(MuonPT)s * MeV)" % config
-        self.MuonFromBCutNoPID = self.MuonCutNoPID + \
+        self.MuonFromBCutReversePID = self.MuonCutReversePID + \
             " & (PT > %(MuonPT)s * MeV)" % config
 
 
@@ -252,14 +252,14 @@ class B2XLTau1piConf(LineBuilder):
             " & (MIPCHI2DV(PRIMARY) > %(Muon_MinIPCHI2)s)" % config
         self.MuonCut_Kstar = self.MuonCutBase_Kstar + \
             " & (PIDmu> %(MuonPID)s) & (ISMUON) & (PROBNNmu > %(Muon_ProbNN_Kstar)s)" % config
-        self.MuonCutNoPID_Kstar = self.MuonCutBase_Kstar + \
+        self.MuonCutReversePID_Kstar = self.MuonCutBase_Kstar + \
             " & (PIDmu < %(MuonPID)s)  & (PROBNNmu < %(Muon_ProbNN_Kstar)s)" % config
 
         self.MuonFromBCutBase_Kstar = self.MuonCutBase_Kstar + \
             " & (PT > %(MuonPT_Kstar)s * MeV)" % config
         self.MuonFromBCut_Kstar = self.MuonCut_Kstar + \
             " & (PT > %(MuonPT_Kstar)s * MeV)" % config
-        self.MuonFromBCutNoPID_Kstar = self.MuonCutNoPID_Kstar + \
+        self.MuonFromBCutReversePID_Kstar = self.MuonCutReversePID_Kstar + \
             " & (PT > %(MuonPT_Kstar)s * MeV)" % config
 
 
@@ -267,14 +267,14 @@ class B2XLTau1piConf(LineBuilder):
             " & (MIPCHI2DV(PRIMARY) > %(Electron_MinIPCHI2)s) " % config
         self.ElectronCut = self.ElectronCutBase + \
             " & (PIDe> %(ElectronPID)s) & (PROBNNe > %(Electron_ProbNN)s) & (~ISMUON)" % config
-        self.ElectronCutNoPID = self.ElectronCutBase + \
+        self.ElectronCutReversePID = self.ElectronCutBase + \
             " & (PIDe < %(ElectronPID)s) & (PROBNNe < %(Electron_ProbNN)s)" % config
 
         self.ElectronFromBCutBase = self.ElectronCutBase + \
             " & (PT > %(ElectronPT)s * MeV)" % config
         self.ElectronFromBCut = self.ElectronCut + \
             " & (PT > %(ElectronPT)s * MeV) " % config
-        self.ElectronFromBCutNoPID = self.ElectronCutNoPID + \
+        self.ElectronFromBCutReversePID = self.ElectronCutReversePID + \
             " & (PT > %(ElectronPT)s * MeV)" % config
 
 
@@ -307,119 +307,119 @@ class B2XLTau1piConf(LineBuilder):
 
         self.PhiMu = self.__PhiMu__(self.Phi, self.MuonsFromB)
         self.PhiMu_FakeKaon = self.__PhiMu__(
-            self.FakePhi, self.MuonsFromB, pid_selection='NoPIDK_')
+            self.FakePhi, self.MuonsFromB, pid_selection='ReversePIDK_')
         self.PhiMu_FakeMuon = self.__PhiMu__(
-            self.Phi,  self.FakeMuonsFromB, pid_selection='NoPIDmu_')
+            self.Phi,  self.FakeMuonsFromB, pid_selection='ReversePIDmu_')
 
         self.PhiE = self.__PhiE__(self.Phi, self.ElectronsFromB)
         self.PhiE_FakeKaon = self.__PhiE__(
-            self.FakePhi, self.ElectronsFromB, pid_selection='NoPIDK_')
+            self.FakePhi, self.ElectronsFromB, pid_selection='ReversePIDK_')
         self.PhiE_FakeElectron = self.__PhiE__(
-            self.Phi,  self.FakeElectronsFromB, pid_selection='NoPIDe_')
+            self.Phi,  self.FakeElectronsFromB, pid_selection='ReversePIDe_')
 
         self.Kstar = self.__Kstar__(self.Kaons_Kstar, self.Pions_Kstar)
         self.FakePionKstar = self.__Kstar__(
-            self.Kaons_Kstar, self.FakePions_Kstar, pid_selection="NoPIDPi_")
+            self.Kaons_Kstar, self.FakePions_Kstar, pid_selection="ReversePIDPi_")
         self.FakeKaonKstar = self.__Kstar__(
-            self.FakeKaons_Kstar, self.Pions_Kstar, pid_selection="NoPIDK_")
+            self.FakeKaons_Kstar, self.Pions_Kstar, pid_selection="ReversePIDK_")
 
         self.KstarMu = self.__KstarMu__(self.Kstar, self.MuonsFromB_Kstar)
         self.KstarMu_FakeKaon = self.__KstarMu__(
-            self.FakeKaonKstar, self.MuonsFromB_Kstar, pid_selection='NoPIDK_')
+            self.FakeKaonKstar, self.MuonsFromB_Kstar, pid_selection='ReversePIDK_')
         self.KstarMu_FakePion = self.__KstarMu__(
-            self.FakePionKstar, self.MuonsFromB_Kstar, pid_selection='NoPIDpi_')
+            self.FakePionKstar, self.MuonsFromB_Kstar, pid_selection='ReversePIDpi_')
         self.KstarMu_FakeMuon = self.__KstarMu__(
-            self.Kstar, self.FakeMuonsFromB_Kstar, pid_selection='NoPIDmu_')
+            self.Kstar, self.FakeMuonsFromB_Kstar, pid_selection='ReversePIDmu_')
 
         self.KstarE = self.__KstarE__(self.Kstar, self.ElectronsFromB)
         self.KstarE_FakeKaon = self.__KstarE__(
-            self.FakeKaonKstar, self.ElectronsFromB, pid_selection='NoPIDK_')
+            self.FakeKaonKstar, self.ElectronsFromB, pid_selection='ReversePIDK_')
         self.KstarE_FakePion = self.__KstarE__(
-            self.FakePionKstar, self.ElectronsFromB, pid_selection='NoPIDpi_')
+            self.FakePionKstar, self.ElectronsFromB, pid_selection='ReversePIDpi_')
         self.KstarE_FakeElectron = self.__KstarE__(
-            self.Kstar, self.FakeElectronsFromB, pid_selection='NoPIDe_')
+            self.Kstar, self.FakeElectronsFromB, pid_selection='ReversePIDe_')
 
         self.LambdaStar = self.__Lambdastar__(self.Protons, self.Kaons)
         self.FakeProtonLambdaStar = self.__Lambdastar__(
-            self.FakeProtons, self.Kaons, pid_selection="NoPIDp_")
+            self.FakeProtons, self.Kaons, pid_selection="ReversePIDp_")
         self.FakeKaonLambdaStar = self.__Lambdastar__(
-            self.Protons, self.FakeKaons, pid_selection="NoPIDK_")
+            self.Protons, self.FakeKaons, pid_selection="ReversePIDK_")
 
         self.LambdastarMu = self.__LambdastarMu__(
             self.LambdaStar, self.MuonsFromB)
         self.LambdastarMu_FakeKaon = self.__LambdastarMu__(
-            self.FakeKaonLambdaStar, self.MuonsFromB, pid_selection='NoPIDK_')
+            self.FakeKaonLambdaStar, self.MuonsFromB, pid_selection='ReversePIDK_')
         self.LambdastarMu_FakeProton = self.__LambdastarMu__(
-            self.FakeProtonLambdaStar, self.MuonsFromB, pid_selection='NoPIDp_')
+            self.FakeProtonLambdaStar, self.MuonsFromB, pid_selection='ReversePIDp_')
         self.LambdastarMu_FakeMuon = self.__LambdastarMu__(
-            self.LambdaStar, self.FakeMuonsFromB, pid_selection='NoPIDmu_')
+            self.LambdaStar, self.FakeMuonsFromB, pid_selection='ReversePIDmu_')
 
         self.LambdastarE = self.__LambdastarE__(
             self.LambdaStar, self.ElectronsFromB)
         self.LambdastarE_FakeKaon = self.__LambdastarE__(
-            self.FakeKaonLambdaStar, self.ElectronsFromB, pid_selection='NoPIDK_')
+            self.FakeKaonLambdaStar, self.ElectronsFromB, pid_selection='ReversePIDK_')
         self.LambdastarE_FakeProton = self.__LambdastarE__(
-            self.FakeProtonLambdaStar, self.ElectronsFromB, pid_selection='NoPIDp_')
+            self.FakeProtonLambdaStar, self.ElectronsFromB, pid_selection='ReversePIDp_')
         self.LambdastarE_FakeElectron = self.__LambdastarE__(
-            self.LambdaStar, self.FakeElectronsFromB, pid_selection='NoPIDe_')
+            self.LambdaStar, self.FakeElectronsFromB, pid_selection='ReversePIDe_')
 
         # Muon in final state, b->XXtaumu
         DeclaredDaughters = [self.PhiMu, self.PionsFromTau]
         self.Bs_Mu = self.__Bs_Phi__(daughters=DeclaredDaughters, lepton='mu')
 
         DeclaredDaughters = [self.PhiMu, self.FakePionsFromTau]
-        self.Bs_Mu_NoPIDpiFromTau = self.__Bs_Phi__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDpiFromTau_", lepton='mu')
+        self.Bs_Mu_ReversePIDpiFromTau = self.__Bs_Phi__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDpiFromTau_", lepton='mu')
 
         DeclaredDaughters = [self.PhiMu_FakeMuon, self.PionsFromTau]
-        self.Bs_Mu_NoPIDmu = self.__Bs_Phi__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDmuFromb_", lepton='mu')
+        self.Bs_Mu_ReversePIDmu = self.__Bs_Phi__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDmuFromb_", lepton='mu')
 
         DeclaredDaughters = [self.PhiMu_FakeKaon, self.PionsFromTau]
-        self.Bs_Mu_NoPIDK = self.__Bs_Phi__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDK_", lepton='mu')
+        self.Bs_Mu_ReversePIDK = self.__Bs_Phi__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDK_", lepton='mu')
 
         DeclaredDaughters = [self.KstarMu, self.PionsFromTau]
         self.Bd_Mu = self.__B_Kstar__(daughters=DeclaredDaughters, lepton='mu')
 
         DeclaredDaughters = [self.KstarMu, self.FakePionsFromTau]
-        self.Bd_Mu_NoPIDpiFromTau = self.__B_Kstar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDpiFromTau_", lepton='mu')
+        self.Bd_Mu_ReversePIDpiFromTau = self.__B_Kstar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDpiFromTau_", lepton='mu')
 
         DeclaredDaughters = [self.KstarMu_FakeMuon, self.PionsFromTau]
-        self.Bd_Mu_NoPIDmu = self.__B_Kstar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDmuFromb_", lepton='mu')
+        self.Bd_Mu_ReversePIDmu = self.__B_Kstar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDmuFromb_", lepton='mu')
 
         DeclaredDaughters = [self.KstarMu_FakeKaon, self.PionsFromTau]
-        self.Bd_Mu_NoPIDK = self.__B_Kstar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDK_", lepton='mu')
+        self.Bd_Mu_ReversePIDK = self.__B_Kstar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDK_", lepton='mu')
 
         DeclaredDaughters = [self.KstarMu_FakePion, self.PionsFromTau]
-        self.Bd_Mu_NoPIDpifromKstar = self.__B_Kstar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDpi_", lepton='mu')
+        self.Bd_Mu_ReversePIDpifromKstar = self.__B_Kstar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDpi_", lepton='mu')
 
-        self.Bd_Mu_NoPIDpi = Selection("Bd_NoPIDpi_sel_for" + self.name.replace('L', 'mu'), Algorithm=FilterDesktop(Code='ALL'),
-                                       RequiredSelections=[self.Bd_Mu_NoPIDpiFromTau, self.Bd_Mu_NoPIDpifromKstar])
+        self.Bd_Mu_ReversePIDpi = Selection("Bd_ReversePIDpi_sel_for" + self.name.replace('L', 'mu'), Algorithm=FilterDesktop(Code='ALL'),
+                                       RequiredSelections=[self.Bd_Mu_ReversePIDpiFromTau, self.Bd_Mu_ReversePIDpifromKstar])
 
         DeclaredDaughters = [self.LambdastarMu, self.PionsFromTau]
         self.Lb_Mu = self.__Lambdab_Lambdastar__(
             daughters=DeclaredDaughters, lepton='mu')
 
         DeclaredDaughters = [self.LambdastarMu, self.FakePionsFromTau]
-        self.Lb_Mu_NoPIDpiFromTau = self.__Lambdab_Lambdastar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDpiFromTau_", lepton='mu')
+        self.Lb_Mu_ReversePIDpiFromTau = self.__Lambdab_Lambdastar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDpiFromTau_", lepton='mu')
 
         DeclaredDaughters = [self.LambdastarMu_FakeMuon, self.PionsFromTau]
-        self.Lb_Mu_NoPIDmu = self.__Lambdab_Lambdastar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDmuFromb_", lepton='mu')
+        self.Lb_Mu_ReversePIDmu = self.__Lambdab_Lambdastar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDmuFromb_", lepton='mu')
 
         DeclaredDaughters = [self.LambdastarMu_FakeKaon, self.PionsFromTau]
-        self.Lb_Mu_NoPIDK = self.__Lambdab_Lambdastar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDK_", lepton='mu')
+        self.Lb_Mu_ReversePIDK = self.__Lambdab_Lambdastar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDK_", lepton='mu')
 
         DeclaredDaughters = [self.LambdastarMu_FakeProton, self.PionsFromTau]
-        self.Lb_Mu_NoPIDp = self.__Lambdab_Lambdastar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDp_", lepton='mu')
+        self.Lb_Mu_ReversePIDp = self.__Lambdab_Lambdastar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDp_", lepton='mu')
 
         # Electron in final state, b->XXtaue
 
@@ -427,39 +427,39 @@ class B2XLTau1piConf(LineBuilder):
         self.Bs_E = self.__Bs_Phi__(daughters=DeclaredDaughters, lepton='e')
 
         DeclaredDaughters = [self.PhiE, self.FakePionsFromTau]
-        self.Bs_E_NoPIDpiFromTau = self.__Bs_Phi__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDpiFromTau_", lepton='e')
+        self.Bs_E_ReversePIDpiFromTau = self.__Bs_Phi__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDpiFromTau_", lepton='e')
 
         DeclaredDaughters = [self.PhiE_FakeElectron, self.PionsFromTau]
-        self.Bs_E_NoPIDe = self.__Bs_Phi__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDeFromb_", lepton='e')
+        self.Bs_E_ReversePIDe = self.__Bs_Phi__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDeFromb_", lepton='e')
 
         DeclaredDaughters = [self.PhiE_FakeKaon, self.PionsFromTau]
-        self.Bs_E_NoPIDK = self.__Bs_Phi__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDK_", lepton='e')
+        self.Bs_E_ReversePIDK = self.__Bs_Phi__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDK_", lepton='e')
 
 
         DeclaredDaughters = [self.KstarE, self.PionsFromTau]
         self.Bd_E = self.__B_Kstar__(daughters=DeclaredDaughters, lepton='e')
 
         DeclaredDaughters = [self.KstarE, self.FakePionsFromTau]
-        self.Bd_E_NoPIDpiFromTau = self.__B_Kstar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDpiFromTau_", lepton='e')
+        self.Bd_E_ReversePIDpiFromTau = self.__B_Kstar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDpiFromTau_", lepton='e')
 
         DeclaredDaughters = [self.KstarE_FakeElectron, self.PionsFromTau]
-        self.Bd_E_NoPIDe = self.__B_Kstar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDeFromb_", lepton='e')
+        self.Bd_E_ReversePIDe = self.__B_Kstar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDeFromb_", lepton='e')
 
         DeclaredDaughters = [self.KstarE_FakeKaon, self.PionsFromTau]
-        self.Bd_E_NoPIDK = self.__B_Kstar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDK_", lepton='e')
+        self.Bd_E_ReversePIDK = self.__B_Kstar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDK_", lepton='e')
 
         DeclaredDaughters = [self.KstarE_FakePion, self.PionsFromTau]
-        self.Bd_E_NoPIDpifromKstar = self.__B_Kstar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDpi_", lepton='e')
+        self.Bd_E_ReversePIDpifromKstar = self.__B_Kstar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDpi_", lepton='e')
 
-        self.Bd_E_NoPIDpi = Selection("Bd_NoPIDpi_sel_for" + self.name.replace('L', 'e'), Algorithm=FilterDesktop(Code='ALL'),
-                                      RequiredSelections=[self.Bd_E_NoPIDpiFromTau, self.Bd_E_NoPIDpifromKstar])
+        self.Bd_E_ReversePIDpi = Selection("Bd_ReversePIDpi_sel_for" + self.name.replace('L', 'e'), Algorithm=FilterDesktop(Code='ALL'),
+                                      RequiredSelections=[self.Bd_E_ReversePIDpiFromTau, self.Bd_E_ReversePIDpifromKstar])
 
 
         DeclaredDaughters = [self.LambdastarE, self.PionsFromTau]
@@ -467,20 +467,20 @@ class B2XLTau1piConf(LineBuilder):
             daughters=DeclaredDaughters, lepton='e')
 
         DeclaredDaughters = [self.LambdastarE, self.FakePionsFromTau]
-        self.Lb_E_NoPIDpiFromTau = self.__Lambdab_Lambdastar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDpiFromTau_", lepton='e')
+        self.Lb_E_ReversePIDpiFromTau = self.__Lambdab_Lambdastar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDpiFromTau_", lepton='e')
 
         DeclaredDaughters = [self.LambdastarE_FakeElectron, self.PionsFromTau]
-        self.Lb_E_NoPIDe = self.__Lambdab_Lambdastar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDeFromb_", lepton='e')
+        self.Lb_E_ReversePIDe = self.__Lambdab_Lambdastar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDeFromb_", lepton='e')
 
         DeclaredDaughters = [self.LambdastarE_FakeKaon, self.PionsFromTau]
-        self.Lb_E_NoPIDK = self.__Lambdab_Lambdastar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDK_", lepton='e')
+        self.Lb_E_ReversePIDK = self.__Lambdab_Lambdastar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDK_", lepton='e')
 
         DeclaredDaughters = [self.LambdastarE_FakeProton, self.PionsFromTau]
-        self.Lb_E_NoPIDp = self.__Lambdab_Lambdastar__(
-            daughters=DeclaredDaughters, pid_selection="NoPIDp_", lepton='e')
+        self.Lb_E_ReversePIDp = self.__Lambdab_Lambdastar__(
+            daughters=DeclaredDaughters, pid_selection="ReversePIDp_", lepton='e')
 
         self.FilterSPD = {'Code': " ( recSummary(LHCb.RecSummary.nSPDhits,'Raw/Spd/Digits') < %(SpdMult)s )" % config,
                           'Preambulo': ["from LoKiNumbers.decorators import *", "from LoKiCore.basic import LHCb"]}
@@ -493,23 +493,23 @@ class B2XLTau1piConf(LineBuilder):
             FILTER=self.FilterSPD, algos=[self.Bs_Mu], MDSTFlag=False, MaxCandidates=1000)
         self.registerLine(self.Bs2phipimu_line)
 
-        self.Bs2phipimu_NoPIDmu_line = StrippingLine(
-            self.name + "_Bs2Phipimu_NoPIDMuLine", prescale=0.1,
+        self.Bs2phipimu_ReversePIDmu_line = StrippingLine(
+            self.name + "_Bs2Phipimu_ReversePIDMuLine", prescale=0.08,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bs_Mu_NoPIDmu], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bs2phipimu_NoPIDmu_line)
+            FILTER=self.FilterSPD, algos=[self.Bs_Mu_ReversePIDmu], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bs2phipimu_ReversePIDmu_line)
 
-        self.Bs2phipimu_NoPIDK_line = StrippingLine(
-            self.name + "_Bs2Phipimu_NoPIDKLine", prescale=0.1,
+        self.Bs2phipimu_ReversePIDK_line = StrippingLine(
+            self.name + "_Bs2Phipimu_ReversePIDKLine", prescale=0.1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bs_Mu_NoPIDK], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bs2phipimu_NoPIDK_line)
+            FILTER=self.FilterSPD, algos=[self.Bs_Mu_ReversePIDK], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bs2phipimu_ReversePIDK_line)
 
-        self.Bs2phipimu_NoPIDpi_line = StrippingLine(
-            self.name + "_Bs2Phipimu_NoPIDpiLine", prescale=0.1,
+        self.Bs2phipimu_ReversePIDpi_line = StrippingLine(
+            self.name + "_Bs2Phipimu_ReversePIDpiLine", prescale=0.2,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bs_Mu_NoPIDpiFromTau], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bs2phipimu_NoPIDpi_line)
+            FILTER=self.FilterSPD, algos=[self.Bs_Mu_ReversePIDpiFromTau], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bs2phipimu_ReversePIDpi_line)
 
         self.Bd2Kstpimu_line = StrippingLine(
             self.name + "_B2Kstarpimu_Line", prescale=1,
@@ -517,23 +517,23 @@ class B2XLTau1piConf(LineBuilder):
             FILTER=self.FilterSPD, algos=[self.Bd_Mu], MDSTFlag=False, MaxCandidates=1000)
         self.registerLine(self.Bd2Kstpimu_line)
 
-        self.Bd2Kstpimu_NoPIDmu_line = StrippingLine(
-            self.name + "_B2Kstarpimu_NoPIDMuLine", prescale=0.1,
+        self.Bd2Kstpimu_ReversePIDmu_line = StrippingLine(
+            self.name + "_B2Kstarpimu_ReversePIDMuLine", prescale=0.1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bd_Mu_NoPIDmu], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bd2Kstpimu_NoPIDmu_line)
+            FILTER=self.FilterSPD, algos=[self.Bd_Mu_ReversePIDmu], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bd2Kstpimu_ReversePIDmu_line)
 
-        self.Bd2Kstpimu_NoPIDK_line = StrippingLine(
-            self.name + "_B2Kstarpimu_NoPIDKLine", prescale=0.1,
+        self.Bd2Kstpimu_ReversePIDK_line = StrippingLine(
+            self.name + "_B2Kstarpimu_ReversePIDKLine", prescale=0.1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bd_Mu_NoPIDK], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bd2Kstpimu_NoPIDK_line)
+            FILTER=self.FilterSPD, algos=[self.Bd_Mu_ReversePIDK], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bd2Kstpimu_ReversePIDK_line)
 
-        self.Bd2Kstpimu_NoPIDpi_line = StrippingLine(
-            self.name + "_B2Kstarpimu_NoPIDpiLine", prescale=1,
+        self.Bd2Kstpimu_ReversePIDpi_line = StrippingLine(
+            self.name + "_B2Kstarpimu_ReversePIDpiLine", prescale=1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bd_Mu_NoPIDpi], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bd2Kstpimu_NoPIDpi_line)
+            FILTER=self.FilterSPD, algos=[self.Bd_Mu_ReversePIDpi], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bd2Kstpimu_ReversePIDpi_line)
 
         self.Lb2Lstpimu_line = StrippingLine(
             self.name + "_Lb2Lstarpimu_Line", prescale=1,
@@ -542,29 +542,29 @@ class B2XLTau1piConf(LineBuilder):
 
         self.registerLine(self.Lb2Lstpimu_line)
 
-        self.Lb2Lstpimu_NoPIDmu_line = StrippingLine(
-            self.name + "_Lb2Lstarpimu_NoPIDMuLine", prescale=0.1,
+        self.Lb2Lstpimu_ReversePIDmu_line = StrippingLine(
+            self.name + "_Lb2Lstarpimu_ReversePIDMuLine", prescale=0.1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Lb_Mu_NoPIDmu], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Lb2Lstpimu_NoPIDmu_line)
+            FILTER=self.FilterSPD, algos=[self.Lb_Mu_ReversePIDmu], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Lb2Lstpimu_ReversePIDmu_line)
 
-        self.Lb2Lstpimu_NoPIDK_line = StrippingLine(
-            self.name + "_Lb2Lstarpimu_NoPIDKLine", prescale=0.1,
+        self.Lb2Lstpimu_ReversePIDK_line = StrippingLine(
+            self.name + "_Lb2Lstarpimu_ReversePIDKLine", prescale=0.4,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Lb_Mu_NoPIDK], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Lb2Lstpimu_NoPIDK_line)
+            FILTER=self.FilterSPD, algos=[self.Lb_Mu_ReversePIDK], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Lb2Lstpimu_ReversePIDK_line)
 
-        self.Lb2Lstpimu_NoPIDp_line = StrippingLine(
-            self.name + "_Lb2Lstarpimu_NoPIDpLine", prescale=0.1,
+        self.Lb2Lstpimu_ReversePIDp_line = StrippingLine(
+            self.name + "_Lb2Lstarpimu_ReversePIDpLine", prescale=0.1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Lb_Mu_NoPIDp], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Lb2Lstpimu_NoPIDp_line)
+            FILTER=self.FilterSPD, algos=[self.Lb_Mu_ReversePIDp], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Lb2Lstpimu_ReversePIDp_line)
 
-        self.Lb2Lstpimu_NoPIDpi_line = StrippingLine(
-            self.name + "_Lb2Lstarpimu_NoPIDpiLine", prescale=0.1,
+        self.Lb2Lstpimu_ReversePIDpi_line = StrippingLine(
+            self.name + "_Lb2Lstarpimu_ReversePIDpiLine", prescale=0.3,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Lb_Mu_NoPIDpiFromTau], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Lb2Lstpimu_NoPIDpi_line)
+            FILTER=self.FilterSPD, algos=[self.Lb_Mu_ReversePIDpiFromTau], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Lb2Lstpimu_ReversePIDpi_line)
 
         
         # -----------------------------------------------------------------------------------------
@@ -576,23 +576,23 @@ class B2XLTau1piConf(LineBuilder):
             FILTER=self.FilterSPD, algos=[self.Bs_E], MDSTFlag=False, MaxCandidates=1000)
         self.registerLine(self.Bs2phipie_line)
 
-        self.Bs2phipie_NoPIDe_line = StrippingLine(
-            self.name + "_Bs2Phipie_NoPIDeLine", prescale=0.2,
+        self.Bs2phipie_ReversePIDe_line = StrippingLine(
+            self.name + "_Bs2Phipie_ReversePIDeLine", prescale=0.08,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bs_E_NoPIDe], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bs2phipie_NoPIDe_line)
+            FILTER=self.FilterSPD, algos=[self.Bs_E_ReversePIDe], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bs2phipie_ReversePIDe_line)
 
-        self.Bs2phipie_NoPIDK_line = StrippingLine(
-            self.name + "_Bs2Phipie_NoPIDKLine", prescale=0.1,
+        self.Bs2phipie_ReversePIDK_line = StrippingLine(
+            self.name + "_Bs2Phipie_ReversePIDKLine", prescale=0.1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bs_E_NoPIDK], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bs2phipie_NoPIDK_line)
+            FILTER=self.FilterSPD, algos=[self.Bs_E_ReversePIDK], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bs2phipie_ReversePIDK_line)
 
-        self.Bs2phipie_NoPIDpi_line = StrippingLine(
-            self.name + "_Bs2Phipie_NoPIDpiLine", prescale=0.1,
+        self.Bs2phipie_ReversePIDpi_line = StrippingLine(
+            self.name + "_Bs2Phipie_ReversePIDpiLine", prescale=0.1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bs_E_NoPIDpiFromTau], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bs2phipie_NoPIDpi_line)
+            FILTER=self.FilterSPD, algos=[self.Bs_E_ReversePIDpiFromTau], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bs2phipie_ReversePIDpi_line)
 
         self.Bd2Kstpie_line = StrippingLine(
             self.name + "_B2Kstarpie_Line", prescale=1,
@@ -600,23 +600,23 @@ class B2XLTau1piConf(LineBuilder):
             FILTER=self.FilterSPD, algos=[self.Bd_E], MDSTFlag=False, MaxCandidates=1000)
         self.registerLine(self.Bd2Kstpie_line)
 
-        self.Bd2Kstpie_NoPIDe_line = StrippingLine(
-            self.name + "_B2Kstarpie_NoPIDeLine", prescale=0.15,
+        self.Bd2Kstpie_ReversePIDe_line = StrippingLine(
+            self.name + "_B2Kstarpie_ReversePIDeLine", prescale=0.08,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bd_E_NoPIDe], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bd2Kstpie_NoPIDe_line)
+            FILTER=self.FilterSPD, algos=[self.Bd_E_ReversePIDe], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bd2Kstpie_ReversePIDe_line)
 
-        self.Bd2Kstpie_NoPIDK_line = StrippingLine(
-            self.name + "_B2Kstarpie_NoPIDKLine", prescale=0.2,
+        self.Bd2Kstpie_ReversePIDK_line = StrippingLine(
+            self.name + "_B2Kstarpie_ReversePIDKLine", prescale=0.5,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bd_E_NoPIDK], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bd2Kstpie_NoPIDK_line)
+            FILTER=self.FilterSPD, algos=[self.Bd_E_ReversePIDK], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bd2Kstpie_ReversePIDK_line)
 
-        self.Bd2Kstpie_NoPIDpi_line = StrippingLine(
-            self.name + "_B2Kstarpie_NoPIDpiLine", prescale=1,
+        self.Bd2Kstpie_ReversePIDpi_line = StrippingLine(
+            self.name + "_B2Kstarpie_ReversePIDpiLine", prescale=1,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Bd_E_NoPIDpi], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Bd2Kstpie_NoPIDpi_line)
+            FILTER=self.FilterSPD, algos=[self.Bd_E_ReversePIDpi], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Bd2Kstpie_ReversePIDpi_line)
 
         self.Lb2Lstpie_line = StrippingLine(
             self.name + "_Lb2Lstarpie_Line", prescale=1,
@@ -625,29 +625,29 @@ class B2XLTau1piConf(LineBuilder):
 
         self.registerLine(self.Lb2Lstpie_line)
 
-        self.Lb2Lstpie_NoPIDe_line = StrippingLine(
-            self.name + "_Lb2Lstarpie_NoPIDeLine", prescale=0.15,
+        self.Lb2Lstpie_ReversePIDe_line = StrippingLine(
+            self.name + "_Lb2Lstarpie_ReversePIDeLine", prescale=0.08,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Lb_E_NoPIDe], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Lb2Lstpie_NoPIDe_line)
+            FILTER=self.FilterSPD, algos=[self.Lb_E_ReversePIDe], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Lb2Lstpie_ReversePIDe_line)
 
-        self.Lb2Lstpie_NoPIDK_line = StrippingLine(
-            self.name + "_Lb2Lstarpie_NoPIDKLine", prescale=0.2,
+        self.Lb2Lstpie_ReversePIDK_line = StrippingLine(
+            self.name + "_Lb2Lstarpie_ReversePIDKLine", prescale=0.5,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Lb_E_NoPIDK], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Lb2Lstpie_NoPIDK_line)
+            FILTER=self.FilterSPD, algos=[self.Lb_E_ReversePIDK], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Lb2Lstpie_ReversePIDK_line)
 
-        self.Lb2Lstpie_NoPIDp_line = StrippingLine(
-            self.name + "_Lb2Lstarpie_NoPIDpLine", prescale=0.2,
+        self.Lb2Lstpie_ReversePIDp_line = StrippingLine(
+            self.name + "_Lb2Lstarpie_ReversePIDpLine", prescale=0.2,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Lb_E_NoPIDp], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Lb2Lstpie_NoPIDp_line)
+            FILTER=self.FilterSPD, algos=[self.Lb_E_ReversePIDp], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Lb2Lstpie_ReversePIDp_line)
 
-        self.Lb2Lstpie_NoPIDpi_line = StrippingLine(
-            self.name + "_Lb2Lstarpie_NoPIDpiLine", prescale=0.2,
+        self.Lb2Lstpie_ReversePIDpi_line = StrippingLine(
+            self.name + "_Lb2Lstarpie_ReversePIDpiLine", prescale=0.2,
             HLT2=config['HLT2_FILTER'], HLT1=config['HLT1_FILTER'], L0DU=config['L0DU_FILTER'],
-            FILTER=self.FilterSPD, algos=[self.Lb_E_NoPIDpiFromTau], MDSTFlag=False, MaxCandidates=4000)
-        self.registerLine(self.Lb2Lstpie_NoPIDpi_line)
+            FILTER=self.FilterSPD, algos=[self.Lb_E_ReversePIDpiFromTau], MDSTFlag=False, MaxCandidates=4000)
+        self.registerLine(self.Lb2Lstpie_ReversePIDpi_line)
 
     def __Muons__(self, conf, Kstar=False):
         from StandardParticles import StdAllLooseMuons, StdAllNoPIDsMuons
@@ -665,10 +665,10 @@ class B2XLTau1piConf(LineBuilder):
 
     def __FakeMuons__(self, Kstar=False):
         from StandardParticles import StdAllNoPIDsMuons
-        code = self.MuonFromBCutNoPID if not Kstar else self.MuonFromBCutNoPID_Kstar
+        code = self.MuonFromBCutReversePID if not Kstar else self.MuonFromBCutReversePID_Kstar
         _filter = FilterDesktop(Code=code)
         kstar = '' if not Kstar else '_B2Kstar'
-        _sel = Selection("Selection_" + self._name + "StdAllNoPIDsMuons"+kstar, Algorithm=_filter,
+        _sel = Selection("Selection_" + self._name + "StdAllReversePIDsMuons"+kstar, Algorithm=_filter,
                          RequiredSelections=[StdAllNoPIDsMuons])
         return _sel
 
@@ -686,8 +686,8 @@ class B2XLTau1piConf(LineBuilder):
     def __FakeElectrons__(self):
         from StandardParticles import StdAllNoPIDsElectrons
 
-        _filter = FilterDesktop(Code=self.ElectronFromBCutNoPID)
-        _sel = Selection("Selection_" + self._name + "StdAllNoPIDsElectrons",  Algorithm=_filter,
+        _filter = FilterDesktop(Code=self.ElectronFromBCutReversePID)
+        _sel = Selection("Selection_" + self._name + "StdAllReversePIDsElectrons",  Algorithm=_filter,
                          RequiredSelections=[StdAllNoPIDsElectrons])
         return _sel
 
@@ -702,8 +702,8 @@ class B2XLTau1piConf(LineBuilder):
 
     def __FakeProtons__(self):
         from StandardParticles import StdNoPIDsProtons
-        _filter = FilterDesktop(Code=self.ProtonCutNoPID)
-        _sel = Selection("Selection_" + self._name + "_StdAllNoPIDsProtons", Algorithm=_filter,
+        _filter = FilterDesktop(Code=self.ProtonCutReversePID)
+        _sel = Selection("Selection_" + self._name + "_StdAllReversePIDsProtons", Algorithm=_filter,
                          RequiredSelections=[StdNoPIDsProtons])
         return _sel
 
@@ -723,10 +723,10 @@ class B2XLTau1piConf(LineBuilder):
     def __FakeKaons__(self, sel_name="_"):
         from StandardParticles import StdNoPIDsKaons
         if "Kstar" in sel_name:
-            _filter = FilterDesktop(Code=self.KaonCutNoPID_B2Kstar)
+            _filter = FilterDesktop(Code=self.KaonCutReversePID_B2Kstar)
         else:
-            _filter = FilterDesktop(Code=self.KaonCutNoPID)
-        _sel = Selection("Selection_" + self._name + sel_name + "StdAllNoPIDsKaons", Algorithm=_filter,
+            _filter = FilterDesktop(Code=self.KaonCutReversePID)
+        _sel = Selection("Selection_" + self._name + sel_name + "StdAllReversePIDsKaons", Algorithm=_filter,
                          RequiredSelections=[StdNoPIDsKaons])
         return _sel
 
@@ -743,8 +743,8 @@ class B2XLTau1piConf(LineBuilder):
 
     def __FakePions__(self, sel_name="_"):
         from StandardParticles import StdNoPIDsPions
-        _filter = FilterDesktop(Code=self.PionCutNoPID_B2Kstar)
-        _sel = Selection("Selection_" + self.name + sel_name + "StdAllNoPIDsPions", RequiredSelections=[StdNoPIDsPions],
+        _filter = FilterDesktop(Code=self.PionCutReversePID_B2Kstar)
+        _sel = Selection("Selection_" + self.name + sel_name + "StdAllReversePIDsPions", RequiredSelections=[StdNoPIDsPions],
                          Algorithm=_filter)
         return _sel
 
@@ -760,8 +760,8 @@ class B2XLTau1piConf(LineBuilder):
 
     def __FakePionsFromTau__(self):
         from StandardParticles import StdAllNoPIDsPions
-        _filter = FilterDesktop(Code=self.PionFromTauCutNoPID)
-        _sel = Selection("Selection_" + self._name + "StdAllNoPIDsPions", Algorithm=_filter,
+        _filter = FilterDesktop(Code=self.PionFromTauCutReversePID)
+        _sel = Selection("Selection_" + self._name + "StdAllReversePIDsPions", Algorithm=_filter,
                          RequiredSelections=[StdAllNoPIDsPions])
         return _sel
 
@@ -777,7 +777,7 @@ class B2XLTau1piConf(LineBuilder):
         else:
             _phi2kk.CombinationCut = self.PhiCombCut + \
                 " & (AHASCHILD((PIDK < %(KaonPID)s)))" % conf
-            _sel = Selection("Phi_NoPIDK_selection_for" + self.name, Algorithm=_phi2kk,
+            _sel = Selection("Phi_ReversePIDK_selection_for" + self.name, Algorithm=_phi2kk,
                              RequiredSelections=[Kaons, fakekaon])
         return _sel