From d1b9add7790e65dab501d1b0970df514045e25a2 Mon Sep 17 00:00:00 2001
From: Adam Edward Barton <adam.edward.barton@cern.ch>
Date: Wed, 16 Dec 2020 10:16:12 +0000
Subject: [PATCH] Initial migration of BPHY Derivations to master
---
.../BPhysTools/BPhysTools/BPhysBlindingTool.h | 278 +++
.../BPhysTools/BPhysTools/BPhysToolsDict.h | 16 +
.../BPhysTools/BPhysTrackVertexMapTool.h | 196 ++
.../BPhysTools/IBPhysBlindingTool.h | 79 +
.../BPhysTools/IBPhysTrackVertexMapTool.h | 109 +
.../BPhysTools/BPhysTools/SimpleEncrypter.h | 244 ++
.../BPhys/BPhysTools/BPhysTools/selection.xml | 10 +
.../BPhys/BPhysTools/CMakeLists.txt | 84 +
.../BPhysTools/Root/BPhysBlindingTool.cxx | 464 ++++
.../Root/BPhysTrackVertexMapTool.cxx | 664 +++++
.../BPhys/BPhysTools/Root/SimpleEncrypter.cxx | 516 ++++
.../src/components/BPhysTools_entries.cxx | 4 +
.../BPhysTools/util/createBlindingKeys.cxx | 83 +
.../DerivationFrameworkBPhys/CMakeLists.txt | 26 +
.../AugOriginalCounts.h | 91 +
.../BMuonTrackIsoTool.h | 111 +
.../BPhysAddMuonBasedInvMass.h | 304 +++
.../BPhysConversionFinder.h | 76 +
.../BPhysMetadataBase.h | 100 +
.../BPhysPVCascadeTools.h | 159 ++
.../BPhysPVThinningTool.h | 53 +
.../DerivationFrameworkBPhys/BPhysPVTools.h | 108 +
.../BPhysVarBlinder.h | 76 +
.../BPhysVertexTrackBase.h | 303 +++
.../BTrackVertexMapLogger.h | 49 +
.../BVertexClosestTrackTool.h | 149 ++
.../BVertexTrackIsoTool.h | 119 +
.../BmumuThinningTool.h | 441 ++++
.../DerivationFrameworkBPhys/Bmumu_metadata.h | 42 +
.../Bmumu_reco_mumu.h | 73 +
.../DerivationFrameworkBPhys/Cascade3Plus1.h | 99 +
.../DerivationFrameworkBPhys/CascadeTools.h | 87 +
.../DerivationFrameworkBPhys/CfAthAlgTool.h | 86 +
.../DerivationFrameworkBPhys/FourMuonTool.h | 188 ++
.../JpsiPlusDpstCascade.h | 96 +
.../JpsiPlusDs1Cascade.h | 105 +
.../JpsiPlusDsCascade.h | 91 +
.../JpsiPlusV0Cascade.h | 94 +
.../DerivationFrameworkBPhys/LocalVector.h | 72 +
.../MuonExtrapolationTool.h | 59 +
.../DerivationFrameworkBPhys/ReVertex.h | 98 +
.../DerivationFrameworkBPhys/Reco_4mu.h | 63 +
.../DerivationFrameworkBPhys/Reco_V0Finder.h | 63 +
.../DerivationFrameworkBPhys/Reco_Vertex.h | 54 +
.../DerivationFrameworkBPhys/Select_Bmumu.h | 116 +
.../Select_onia2mumu.h | 71 +
.../Thin_vtxDuplicates.h | 37 +
.../DerivationFrameworkBPhys/Thin_vtxTrk.h | 54 +
.../TriggerCountToMetadata.h | 51 +
.../VertexCaloIsolation.h | 89 +
.../VertexPlus1TrackCascade.h | 74 +
.../VertexTrackIsolation.h | 52 +
.../python/BPhysPyHelpers.py | 84 +
.../python/__init__.py | 2 +
.../DerivationFrameworkBPhys/share/BPHY1.py | 274 ++
.../DerivationFrameworkBPhys/share/BPHY10.py | 477 ++++
.../DerivationFrameworkBPhys/share/BPHY11.py | 506 ++++
.../DerivationFrameworkBPhys/share/BPHY12.py | 389 +++
.../DerivationFrameworkBPhys/share/BPHY13.py | 483 ++++
.../DerivationFrameworkBPhys/share/BPHY14.py | 329 +++
.../DerivationFrameworkBPhys/share/BPHY15.py | 855 +++++++
.../DerivationFrameworkBPhys/share/BPHY16.py | 288 +++
.../DerivationFrameworkBPhys/share/BPHY17.py | 316 +++
.../DerivationFrameworkBPhys/share/BPHY18.py | 506 ++++
.../DerivationFrameworkBPhys/share/BPHY19.py | 313 +++
.../DerivationFrameworkBPhys/share/BPHY2.py | 332 +++
.../DerivationFrameworkBPhys/share/BPHY20.py | 775 ++++++
.../DerivationFrameworkBPhys/share/BPHY21.py | 329 +++
.../DerivationFrameworkBPhys/share/BPHY22.py | 22 +
.../DerivationFrameworkBPhys/share/BPHY3.py | 284 +++
.../DerivationFrameworkBPhys/share/BPHY4.py | 155 ++
.../DerivationFrameworkBPhys/share/BPHY5.py | 558 +++++
.../DerivationFrameworkBPhys/share/BPHY6.py | 344 +++
.../DerivationFrameworkBPhys/share/BPHY7.py | 648 +++++
.../DerivationFrameworkBPhys/share/BPHY8.py | 2200 +++++++++++++++++
.../DerivationFrameworkBPhys/share/BPHY9.py | 398 +++
.../SaveExtraMetadataInMerge_jobOFragment.py | 53 +
.../share/configureConversionFinder.py | 69 +
.../share/configureSimpleV0Finder.py | 201 ++
.../share/configureV0Finder.py | 202 ++
.../share/configureVertexing.py | 148 ++
.../src/AugOriginalCounts.cxx | 150 ++
.../src/BMuonTrackIsoTool.cxx | 448 ++++
.../src/BPhysAddMuonBasedInvMass.cxx | 702 ++++++
.../src/BPhysConversionFinder.cxx | 589 +++++
.../src/BPhysMetadataBase.cxx | 270 ++
.../src/BPhysPVCascadeTools.cxx | 475 ++++
.../src/BPhysPVThinningTool.cxx | 134 +
.../src/BPhysPVTools.cxx | 545 ++++
.../src/BPhysVarBlinder.cxxNoCompile | 72 +
.../src/BPhysVertexTrackBase.cxx | 1480 +++++++++++
.../src/BTrackVertexMapLogger.cxx | 104 +
.../src/BVertexClosestTrackTool.cxx | 672 +++++
.../src/BVertexTrackIsoTool.cxx | 511 ++++
.../src/BmumuThinningTool.cxx_NoCompile | 1167 +++++++++
.../src/Bmumu_metadata.cxx | 238 ++
.../src/Bmumu_reco_mumu.cxx | 177 ++
.../src/Cascade3Plus1.cxx | 524 ++++
.../src/CascadeTools.cxx | 608 +++++
.../src/CfAthAlgTool.cxx | 178 ++
.../src/FourMuonTool.cxx | 449 ++++
.../src/JpsiPlusDpstCascade.cxx | 724 ++++++
.../src/JpsiPlusDs1Cascade.cxx | 905 +++++++
.../src/JpsiPlusDsCascade.cxx | 702 ++++++
.../src/JpsiPlusV0Cascade.cxx | 576 +++++
.../src/MuonExtrapolationTool.cxx | 182 ++
.../DerivationFrameworkBPhys/src/ReVertex.cxx | 284 +++
.../DerivationFrameworkBPhys/src/Reco_4mu.cxx | 269 ++
.../src/Reco_V0Finder.cxx | 307 +++
.../src/Reco_Vertex.cxx | 163 ++
.../src/Select_Bmumu.cxx | 563 +++++
.../src/Select_onia2mumu.cxx | 197 ++
.../src/Thin_vtxDuplicates.cxx | 176 ++
.../src/Thin_vtxTrk.cxx | 200 ++
.../src/TriggerCountToMetadata.cxx | 62 +
.../src/VertexCaloIsolation.cxx | 583 +++++
.../src/VertexPlus1TrackCascade.cxx | 215 ++
.../src/VertexTrackIsolation.cxx | 274 ++
.../DerivationFrameworkBPhys_entries.cxx | 74 +
119 files changed, 34315 insertions(+)
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysBlindingTool.h
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysToolsDict.h
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysTrackVertexMapTool.h
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/IBPhysBlindingTool.h
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/IBPhysTrackVertexMapTool.h
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/SimpleEncrypter.h
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/selection.xml
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/CMakeLists.txt
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/Root/BPhysBlindingTool.cxx
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/Root/BPhysTrackVertexMapTool.cxx
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/Root/SimpleEncrypter.cxx
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/src/components/BPhysTools_entries.cxx
create mode 100644 PhysicsAnalysis/BPhys/BPhysTools/util/createBlindingKeys.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/CMakeLists.txt
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/AugOriginalCounts.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BMuonTrackIsoTool.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysAddMuonBasedInvMass.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysConversionFinder.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysMetadataBase.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVCascadeTools.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVThinningTool.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVTools.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysVarBlinder.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysVertexTrackBase.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BTrackVertexMapLogger.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BVertexClosestTrackTool.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BVertexTrackIsoTool.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BmumuThinningTool.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Bmumu_metadata.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Bmumu_reco_mumu.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Cascade3Plus1.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/CascadeTools.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/CfAthAlgTool.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/FourMuonTool.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDpstCascade.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDs1Cascade.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDsCascade.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusV0Cascade.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/LocalVector.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/MuonExtrapolationTool.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/ReVertex.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_4mu.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_V0Finder.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_Vertex.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Select_Bmumu.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Select_onia2mumu.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Thin_vtxDuplicates.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Thin_vtxTrk.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/TriggerCountToMetadata.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexCaloIsolation.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexPlus1TrackCascade.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexTrackIsolation.h
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/python/BPhysPyHelpers.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/python/__init__.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY1.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY10.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY11.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY12.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY13.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY14.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY15.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY16.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY17.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY18.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY19.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY2.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY20.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY21.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY22.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY3.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY4.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY5.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY6.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY7.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY8.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY9.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/SaveExtraMetadataInMerge_jobOFragment.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureConversionFinder.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureSimpleV0Finder.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureV0Finder.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureVertexing.py
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/AugOriginalCounts.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BMuonTrackIsoTool.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysAddMuonBasedInvMass.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysConversionFinder.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysMetadataBase.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVCascadeTools.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVThinningTool.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVTools.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysVarBlinder.cxxNoCompile
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysVertexTrackBase.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BTrackVertexMapLogger.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BVertexClosestTrackTool.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BVertexTrackIsoTool.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BmumuThinningTool.cxx_NoCompile
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Bmumu_metadata.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Bmumu_reco_mumu.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Cascade3Plus1.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/CascadeTools.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/CfAthAlgTool.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/FourMuonTool.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDpstCascade.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDs1Cascade.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDsCascade.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusV0Cascade.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/MuonExtrapolationTool.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/ReVertex.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_4mu.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_V0Finder.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_Vertex.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Select_Bmumu.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Select_onia2mumu.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Thin_vtxDuplicates.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Thin_vtxTrk.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/TriggerCountToMetadata.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexCaloIsolation.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexPlus1TrackCascade.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexTrackIsolation.cxx
create mode 100644 PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/components/DerivationFrameworkBPhys_entries.cxx
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysBlindingTool.h b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysBlindingTool.h
new file mode 100644
index 00000000000..c7aed623cec
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysBlindingTool.h
@@ -0,0 +1,278 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file BPhysBlindingTool.h
+ * @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ *
+ * @brief Dual-use tool for blinding and unblinding certain float values
+ */
+
+// $Id: $
+#ifndef BPHYSTOOLS_BPHYSBLINDINGTOOL_H
+#define BPHYSTOOLS_BPHYSBLINDINGTOOL_H
+
+// Framework includes
+#include "AsgTools/AsgTool.h"
+
+// System include(s):
+#include <memory>
+
+// Local includes
+#include "BPhysTools/IBPhysBlindingTool.h"
+#include "BPhysTools/SimpleEncrypter.h"
+
+
+// EDM includes
+#include "xAODTracking/VertexAuxContainer.h"
+
+namespace xAOD {
+ ///
+ /// @class BPhysBlindingToll
+ /// @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ ///
+ /// Dual-use tool for blinding and unblinding certain float values
+ /// provided as variables in a container.
+ ///
+ /// This tool can be used in two ways:
+ /// 1. As a tool to blind or unblind arbitrary positive float values
+ /// using doBlind(float val) or doUnblind(float val).
+ /// For this mode to work only the corresponding key
+ /// (JO BlindingKey or UnblindingKey) needs to be set.
+ /// 2. As a tool to blind a list of variables (VarToBlindNames)
+ /// for a certain xAOD::VertexContainer's vertices.
+ /// Since this only works for positive float values,
+ /// an the values may be scaled by a factor and an
+ /// offset may be added to the values, specified separately for
+ /// each variable (BlindingFactors, BlindingOffsets).
+ /// In addition a negative sign may be added to the resulting blinded
+ /// value (NegativeSigns) as a convenience.
+ /// If this tool is used for unblinding the same values for
+ /// BlindingFactors, BlindingOffsets and NegativeSigns need to be
+ /// provided.
+ /// Depending on the mode, the BlindingKey or Unblindingkey need
+ /// to be set.
+ ///
+ /// @Note: Key pairs may be produced using the createBlindingKeys
+ /// utility.
+ ///
+ /// Job options:
+ /// - BlindingKey
+ /// Hex string providing the (public) blinding key.
+ /// - UnblindingKey
+ /// Hex string providing the (private) unblinding key.
+ /// - VertexContainerName
+ /// Name of the vertex container to be used
+ /// - BlindingFlag
+ /// Flag to indicate candidates for blinding ("pass_XXXX")
+ /// Blind values for all candidates if empty.
+ /// - VarToBlindNames
+ /// String with list of float variables to blind (delimiter: .)
+ /// - BlindingOffsets
+ /// Offsets applied to values before blinding
+ /// List must have same length as VarToBlindNames or zero.
+ /// - BlindingFactors
+ /// Scale factors applied before blinding
+ /// List must have same length as VarToBlindNames or zero.
+ /// - NegativeSigns
+ /// Flip signs to negative range?
+ /// List must have same length as VarToBlindNames or zero.
+ ///
+ ///
+ class BPhysBlindingTool :
+ public asg::AsgTool, virtual public xAOD::IBPhysBlindingTool {
+
+ /// Declare the correct constructor for Athena
+ ASG_TOOL_CLASS( BPhysBlindingTool, xAOD::IBPhysBlindingTool )
+
+ public:
+ ///
+ /// @brief Regular AsgTool constructor
+ BPhysBlindingTool(const std::string& name = "BPhysBlindingTool");
+ ///
+ /// @brief Method initialising the tool
+ virtual StatusCode initialize() override;
+
+ ///
+ /// @brief Method finalizing the tool
+ virtual StatusCode finalize() override;
+
+ ///
+ /// @brief Simply blind one positive float value
+ ///
+ /// @param[in] val : positive float value to blind.
+ ///
+ /// @returns Blinded positive float value; same value as input on error.
+ virtual float doBlind(const float& val) override;
+
+ ///
+ /// @name Methods to be called by user classes
+ /// @{
+ ///
+ /// @brief Simply unblind one positive float value
+ ///
+ /// @param[in] val : Blinded positive float value.
+ ///
+ /// @returns Unblinded positive float value; same value as input on error.
+ virtual float doUnblind(const float& val) override;
+
+ ///
+ /// @brief Simply blind one (positive) float value with corrections
+ ///
+ /// @param[in] val : float value to blind.
+ /// @param[in] negativeSign : flip sign after blinding
+ /// @param[in] offset : before blinding, shift by offset
+ /// @param[in] factor : before blinding, stretch by factor
+ ///
+ /// @returns Blinded float value; same value as input on error.
+ virtual float doBlind(const float& val,
+ const bool& negativeSign,
+ const float& offset,
+ const float& factor) override;
+
+ ///
+ /// @name Methods to be called by user classes
+ /// @{
+ ///
+ /// @brief Simply unblind one (positive) float value with corrections
+ ///
+ /// @param[in] val : Blinded float value.
+ /// @param[in] negativeSign : flip sign before unblinding
+ /// @param[in] offset : after unblinding, shift by offset
+ /// @param[in] factor : after unblinding, stretch by factor
+ ///
+ /// @returns Unblinded positive float value; same value as input on error.
+ virtual float doUnblind(const float& val,
+ const bool& negativeSign,
+ const float& offset,
+ const float& factor) override;
+
+ ///
+ /// @brief Perform blinding of requested variables
+ virtual StatusCode doBlind() override;
+
+ ///
+ /// @brief Perform unblinding of requested variables
+ virtual StatusCode doUnblind() override;
+
+ protected:
+ ///
+ /// @name Perform blinding or unblinding action
+ ///
+ virtual StatusCode doBlindingAction(bool unblind=false);
+ ///
+ /// @name Utility methods
+ /// @{
+ ///
+ /// @brief Check whether an element is marked as passing a hypothesis.
+ ///
+ virtual bool pass(const SG::AuxElement& em, std::string hypo);
+
+ ///
+ /// @brief Tokenize a string using certain separators
+ ///
+ virtual std::vector<std::string> getTokens(std::string input,
+ std::string seperators);
+ ///
+ /// @brief Convert vector of floats to string
+ ///
+ virtual std::string vecToString(const std::vector<float>& v) const;
+ ///
+ /// @brief Convert vector of bools to string
+ ///
+ virtual std::string vecToString(const std::vector<bool>& v) const;
+ ///
+ /// @name Cache current event.
+ ///
+ virtual StatusCode cacheEvent();
+ /// @}
+
+ protected:
+ ///
+ /// @name Job options
+ /// @{
+ ///
+ /// @brief Vertex container name
+ std::string m_vertexContainerName;
+ ///
+ /// @brief List of variables to blind
+ ///
+ /// (as concatenated string using . as delimiter)
+ std::string m_varToBlindNames;
+ ///
+ /// @brief Flag to indicate candidates for blinding
+ ///
+ /// Left empty: Blind values for all candidates.
+ std::string m_blindingFlag;
+ ///
+ /// @brief Offsets applied to values before blinding
+ ///
+ /// List must have same length as VarToBlindNames or zero.
+ /// Applied before blinding/after unblinding.
+ std::vector<float> m_vOffsets;
+ ///
+ /// @brief Scale factors applied before blinding
+ ///
+ /// List must have same length as VarToBlindNames or zero.
+ /// Applied before blinding/after unblinding.
+ std::vector<float> m_vFactors;
+ ///
+ /// @brief Flip signs to negative range?
+ ///
+ /// List must have same length as VarToBlindNames or zero.
+ /// Applied after blinding/before unblinding.
+ std::vector<bool> m_vNegSigns;
+ ///
+ /// @brief Key for blinding
+ std::string m_blindKey;
+ ///
+ /// @brief Key for unblinding
+ std::string m_unblindKey;
+ /// @}
+
+ ///
+ /// @name Containers
+ /// @{
+ xAOD::VertexContainer* m_vtxContainer; //!
+ xAOD::VertexAuxContainer* m_vtxAuxContainer; //!
+ /// @}
+
+ ///
+ /// @name Event caching
+ /// @{
+ int m_cachedRun; //!
+ int m_cachedEvent; //!
+ /// @}
+
+ ///
+ ///
+ /// @name Counters
+ /// @{
+ long m_eventsForBlindingSeen; //!
+ long m_candidatesForBlindingSeen; //!
+ long m_eventsForUnblindingSeen; //!
+ long m_candidatesForUnblindingSeen; //!
+ long m_eventsBlinded; //!
+ long m_candidatesBlinded; //!
+ long m_eventsUnblinded; //!
+ long m_candidatesUnblinded; //!
+ /// @}
+ private:
+ ///
+ /// @brief Vector of variable names
+ ///
+ std::vector<std::string> m_vVarNames; //!
+
+ ///
+ /// @brief Instance of SimpleEncrypter
+ ///
+ SimpleEncrypter m_senc; //!
+
+ }; // class BPhysBlindingTool
+
+} // namespace xAOD
+
+#endif // BPHYSTOOLS_BPHYSBLINDINGTOOL_H
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysToolsDict.h b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysToolsDict.h
new file mode 100644
index 00000000000..bf760bccff1
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysToolsDict.h
@@ -0,0 +1,16 @@
+// This file's extension implies that it's C, but it's really -*- C++ -*-.
+
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file BPhysTools/BPhysToolsDict.h
+ * @author Wolfgang Walkowiak <wolfgang.walkowiak@cern.ch>
+ * @date Mar 2018
+ * @brief Dictionary header for BPhysTools.
+ */
+
+#include "BPhysTools/BPhysBlindingTool.h"
+#include "BPhysTools/BPhysTrackVertexMapTool.h"
+#include "BPhysTools/SimpleEncrypter.h"
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysTrackVertexMapTool.h b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysTrackVertexMapTool.h
new file mode 100644
index 00000000000..597539c71b9
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/BPhysTrackVertexMapTool.h
@@ -0,0 +1,196 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: $
+#ifndef BPHYSTOOLS_BPHYSTRACKVERTEXMAPTOOL_H
+#define BPHYSTOOLS_BPHYSTRACKVERTEXMAPTOOL_H
+
+// Framework includes
+#include "BPhysTools/IBPhysTrackVertexMapTool.h"
+#include "AsgTools/AsgTool.h"
+
+// System include(s):
+#include <memory>
+
+// EDM includes
+#include "xAODTracking/TrackParticleAuxContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+
+namespace xAOD {
+ ///
+ /// Dual-use tool createing a track-to-vertex map from
+ /// the vertex-to-track information.
+ ///
+ /// Job options provided by this class:
+ /// - VertexContainerName -- name of container for secondary vertices
+ /// - RefPVContainerName -- name of container for refitted PVs
+ /// - PVContainerName -- name of container for primary vertices
+ /// - TrackParticleContainerName -- name of container for TrackParticles
+ /// - DebugTrkToVtxMaxEvents -- Maximum number of events to produce
+ /// detailed log output for the
+ /// track-to-vertex association maps.
+ /// Set to -1 for infinity.
+ /// - DumpPrefix -- Line prefix for log dump lines.
+ /// - HypoName -- Hypothesis name
+ /// (for picking up inv. mass values)
+ /// May be a set of hypo names to be
+ /// tested, delimited by '|'.
+ ///
+ /// @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ ///
+ /// $Revision:$
+ /// $Date: $
+ ///
+ class BPhysTrackVertexMapTool :
+ public asg::AsgTool, virtual public xAOD::IBPhysTrackVertexMapTool {
+
+ /// Declare the correct constructor for Athena
+ ASG_TOOL_CLASS( BPhysTrackVertexMapTool, xAOD::IBPhysTrackVertexMapTool )
+
+ public:
+ /// Regular AsgTool constructor
+ BPhysTrackVertexMapTool(const std::string& name =
+ "BPhysTrackVertexMapTool");
+
+ /// Function initialising the tool
+ virtual StatusCode initialize() override;
+
+ /// Function being excuted for each event
+ virtual StatusCode logEvent() override;
+
+ /// Function finalizing the tool
+ virtual StatusCode finalize() override;
+
+ /// Function indicating whether log counter allows logging of current event
+ virtual bool doLog() const override;
+
+ /// convenience method to wrap output lines by a prefix
+ static std::string wrapLines(std::string lines, std::string prefix);
+
+ protected:
+ /// @name Functions to be called by user classes
+ /// @{
+ /// fill cache for current event
+ virtual StatusCode cacheEvent() override;
+
+ /// obtain primary vertices for a given ID track (may return empty vector)
+ virtual std::vector<const xAOD::Vertex*>
+ pvsForIDTrack(const xAOD::TrackParticle* track) const override;
+
+ /// obtain refitted primary vertices for a given ID track
+ /// (may return empty vector)
+ virtual std::vector<const xAOD::Vertex*>
+ refPVsForIDTrack(const xAOD::TrackParticle* track) const override;
+
+ /// obtain secondary vertices for a given ID track (may return empty vector)
+ virtual std::vector<const xAOD::Vertex*>
+ svsForIDTrack(const xAOD::TrackParticle* track) const override;
+
+ // track-vertex association related
+ virtual std::string idTrackToString(const xAOD::TrackParticle* track,
+ unsigned int indent=0,
+ bool withPV=false,
+ bool withRefPV=false,
+ bool withSV=false) override;
+
+ virtual std::string pvToString(const xAOD::Vertex* vtx,
+ unsigned int indent=0,
+ bool withTracks=false) override;
+
+ virtual std::string refPVToString(const xAOD::Vertex* vtx,
+ unsigned int indent=0,
+ bool withTracks=false) override;
+ virtual std::string svToString(const xAOD::Vertex* vtx,
+ unsigned int indent=0,
+ bool withTracks=false,
+ bool withMasses=false) override;
+ virtual std::string idTracksToString(const xAOD::TrackParticleContainer*
+ tpc,
+ unsigned int indent=0,
+ bool withPV=false,
+ bool withRefPV=false,
+ bool withSV=false) override;
+
+ virtual std::string pvsToString(const xAOD::VertexContainer* pvc,
+ unsigned int indent=0,
+ bool withTracks=false) override;
+ virtual std::string refPVsToString(const xAOD::VertexContainer* rpvc,
+ unsigned int indent=0,
+ bool withTracks=false) override;
+ virtual std::string svsToString(const xAOD::VertexContainer* svc,
+ unsigned int indent=0,
+ bool withTracks=false,
+ bool withMasses=false) override;
+ virtual std::string summaryToString(std::string prefix) override;
+ /// @}
+
+ protected:
+ virtual float getFloat(std::string name, const xAOD::Vertex* b);
+
+ virtual std::vector<std::string> getTokens(std::string input,
+ std::string seperators);
+
+
+ private:
+ // track-vertex association related
+ typedef std::map<const xAOD::TrackParticle*,
+ std::vector<const xAOD::Vertex*> > TrackToVertexMap_t;
+
+ virtual void initTrackVertexMaps(const xAOD::TrackParticleContainer* tpc,
+ const xAOD::VertexContainer* pvc,
+ const xAOD::VertexContainer* rpvc,
+ const xAOD::VertexContainer* svc);
+ virtual void addVertexToTrackVertexMap(TrackToVertexMap_t& map,
+ const xAOD::TrackParticle* track,
+ const xAOD::Vertex* vtx);
+ virtual std::string pvName(const xAOD::Vertex* vtx);
+ virtual std::string refPVName(const xAOD::Vertex* vtx);
+ virtual std::string svName(const xAOD::Vertex* vtx);
+ virtual std::string idTrackName(const xAOD::TrackParticle* vtx);
+
+ protected:
+ // job options
+ std::string m_vertexContainerName;
+ std::string m_refPVContainerName;
+ std::string m_pvContainerName;
+ std::string m_trackParticleContainerName;
+ int m_debugTrkToVtxMaxEvents;
+ std::string m_dumpPrefix;
+ std::string m_hypoName;
+
+ // containers
+ const xAOD::TrackParticleContainer* m_tracks;
+ const xAOD::TrackParticleAuxContainer* m_tracksAux;
+ const xAOD::VertexContainer* m_pvtxContainer;
+ const xAOD::VertexContainer* m_svtxContainer;
+ const xAOD::VertexAuxContainer* m_svtxAuxContainer;
+ const xAOD::VertexContainer* m_refPVContainer;
+ const xAOD::VertexAuxContainer* m_refPVAuxContainer;
+
+ unsigned int m_nEvtsSeen;
+
+ int m_cachedRun;
+ int m_cachedEvent;
+
+ private:
+ // track-vertex association related
+ typedef std::map<const xAOD::Vertex*, std::string> VertexNameMap_t;
+ VertexNameMap_t m_pvNameMap;
+ VertexNameMap_t m_refPVNameMap;
+ VertexNameMap_t m_svNameMap;
+
+ typedef std::map<const xAOD::TrackParticle*, std::string> TrackNameMap_t;
+ TrackNameMap_t m_idTrackNameMap;
+
+ TrackToVertexMap_t m_idTrackToPVMap;
+ TrackToVertexMap_t m_idTrackToRefPVMap;
+ TrackToVertexMap_t m_idTrackToSVMap;
+
+ }; // class BPhysTrackVertexMapTool
+
+} // namespace xAOD
+
+#endif // BPHYSTOOLS_BPHYSTRACKVERTEXMAPTOOL_H
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/IBPhysBlindingTool.h b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/IBPhysBlindingTool.h
new file mode 100644
index 00000000000..8891bb12cd7
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/IBPhysBlindingTool.h
@@ -0,0 +1,79 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file IBPhysBlindingTool.h
+ * @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ *
+ * @brief Interface for dual-use tool for (un-)blinding of float values.
+ */
+
+#ifndef BPHYSTOOLS_IBPHYSBLINDINGTOOL_H
+#define BPHYSTOOLS_IBPHYSBLINDINGTOOL_H
+
+// Framework includes
+#include "AsgTools/IAsgTool.h"
+
+// System include(s):
+#include <string>
+#include <vector>
+
+// EDM includes
+#include "xAODTracking/VertexContainer.h"
+
+namespace xAOD {
+ ///
+ /// Interface for dual-use tool for blinding and unblinding
+ /// certain float values provided as variables in a container.
+ ///
+ /// @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ ///
+ ///
+ class IBPhysBlindingTool : virtual public asg::IAsgTool {
+
+ public:
+ /// Declare the correct interface for Athena
+ ASG_TOOL_INTERFACE( xAOD::IBPhysBlindingTool )
+
+ /// @ brief Function finalizing the tool
+ virtual StatusCode finalize() = 0;
+
+ ///
+ /// @name Methods to be called by user classes
+ /// @{
+ ///
+ /// @brief Simply blind one positive float value
+ virtual float doBlind(const float& val) = 0;
+
+ ///
+ /// @brief Simply unblind one positive float value
+ virtual float doUnblind(const float& val) = 0;
+
+ ///
+ /// @brief Simply blind one (positive) float value with corretions
+ virtual float doBlind(const float& val, const bool& negativeSign,
+ const float& offset, const float& factor) = 0;
+
+ ///
+ /// @brief Simply unblind one (positive) float value with corrections
+ virtual float doUnblind(const float& val, const bool& negativeSign,
+ const float& offset, const float& factor) = 0;
+
+ ///
+ /// @brief Perform blinding of requested variables
+ virtual StatusCode doBlind() = 0;
+
+ ///
+ /// @brief Perform unblinding of requested variables
+ virtual StatusCode doUnblind() = 0;
+
+ /// @}
+
+ }; // class IBPhysBlindingTool
+
+} // namespace xAOD
+
+#endif // BPHYSTOOLS_IBPHYSBLINDINGTOOL_H
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/IBPhysTrackVertexMapTool.h b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/IBPhysTrackVertexMapTool.h
new file mode 100644
index 00000000000..bb0857657df
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/IBPhysTrackVertexMapTool.h
@@ -0,0 +1,109 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: $
+#ifndef BPHYSTOOLS_IBPHYSTRACKVERTEXMAPTOOL_H
+#define BPHYSTOOLS_IBPHYSTRACKVERTEXMAPTOOL_H
+
+// Framework includes
+#include "AsgTools/IAsgTool.h"
+
+// System include(s):
+#include <string>
+#include <memory>
+#include <vector>
+
+// EDM includes
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/VertexContainer.h"
+
+namespace xAOD {
+ ///
+ /// Interface for dual-use tool createing a track-to-vertex map from
+ /// the vertex-to-track information.
+ ///
+ /// @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ ///
+ /// $Revision:$
+ /// $Date: $
+ ///
+ class IBPhysTrackVertexMapTool : virtual public asg::IAsgTool {
+
+ public:
+ /// Declare the correct interface for Athena
+ ASG_TOOL_INTERFACE( xAOD::IBPhysTrackVertexMapTool )
+
+ /// Function being excuted for each event
+ virtual StatusCode logEvent() = 0;
+
+ /// Function finalizing the tool
+ virtual StatusCode finalize() = 0;
+
+ /// Function indicating whether log counter allows logging of current event
+ virtual bool doLog() const = 0;
+
+ public:
+ /// @name Functions to be called by user classes
+ /// @{
+ /// fill cache for current event
+ virtual StatusCode cacheEvent() = 0;
+
+ /// obtain primary vertices for a given ID track (may return empty vector)
+ virtual std::vector<const xAOD::Vertex*>
+ pvsForIDTrack(const xAOD::TrackParticle* track) const = 0;
+
+ /// obtain refitted primary vertices for a given ID track
+ /// (may return empty vector)
+ virtual std::vector<const xAOD::Vertex*>
+ refPVsForIDTrack(const xAOD::TrackParticle* track) const = 0;
+
+ /// obtain secondary vertices for a given ID track (may return empty vector)
+ virtual std::vector<const xAOD::Vertex*>
+ svsForIDTrack(const xAOD::TrackParticle* track) const = 0;
+
+ // track-vertex association related
+ virtual std::string idTrackToString(const xAOD::TrackParticle* track,
+ unsigned int indent=0,
+ bool withPV=false,
+ bool withRefPV=false,
+ bool withSV=false) = 0;
+
+ virtual std::string pvToString(const xAOD::Vertex* vtx,
+ unsigned int indent=0,
+ bool withTracks=false) = 0;
+
+ virtual std::string refPVToString(const xAOD::Vertex* vtx,
+ unsigned int indent=0,
+ bool withTracks=false) = 0;
+ virtual std::string svToString(const xAOD::Vertex* vtx,
+ unsigned int indent=0,
+ bool withTracks=false,
+ bool withMasses=false) = 0;
+ virtual std::string idTracksToString(const xAOD::TrackParticleContainer*
+ tpc,
+ unsigned int indent=0,
+ bool withPV=false,
+ bool withRefPV=false,
+ bool withSV=false) = 0;
+
+ virtual std::string pvsToString(const xAOD::VertexContainer* pvc,
+ unsigned int indent=0,
+ bool withTracks=false) = 0;
+ virtual std::string refPVsToString(const xAOD::VertexContainer* rpvc,
+ unsigned int indent=0,
+ bool withTracks=false) =0;
+ virtual std::string svsToString(const xAOD::VertexContainer* svc,
+ unsigned int indent=0,
+ bool withTracks=false,
+ bool withMasses=false) = 0;
+ virtual std::string summaryToString(std::string prefix) = 0;
+ /// @}
+
+ }; // class IBPhysTrackVertexMapTool
+
+} // namespace xAOD
+
+#endif // BPHYSTOOLS_IBPHYSTRACKVERTEXMAPTOOL_H
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/SimpleEncrypter.h b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/SimpleEncrypter.h
new file mode 100644
index 00000000000..59c351aa638
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/SimpleEncrypter.h
@@ -0,0 +1,244 @@
+// Dear emacs, this is -*- c++ -*-
+
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file SimpleEncrypter.h
+ * @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ *
+ * @brief Provide simple asymmetric encryption for blinding of float values.
+ */
+
+#ifndef BPHYSTOOLS_SIMPLEENCRYPTER_H
+#define BPHYSTOOLS_SIMPLEENCRYPTER_H
+
+// Framework includes
+#include "AsgMessaging/AsgMessaging.h"
+
+// System includes
+#include <string>
+#include <set>
+
+namespace xAOD {
+ ///
+ /// @class SimpleEncrypter
+ /// @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+ ///
+ /// @brief Provide simple asymmetric encryption for blinding of float values.
+ ///
+ /// Provides asymmetric key encryption for blinding of positive float
+ /// values. Internally it uses a simple RSA encryption of bits in
+ /// the floating point numbers.
+ /// This class is used by the BPhysBlindingTool.
+ ///
+ class SimpleEncrypter : public asg::AsgMessaging {
+
+ public:
+ /// @brief Useful typedefs
+ typedef long long int LLI_t;
+ typedef unsigned long long int ULLI_t;
+
+ ///
+ /// @brief Main constructor
+ ///
+ /// @param[in] name of instance
+ ///
+ SimpleEncrypter(const std::string& name = "SimpleEncrypter");
+
+ ///
+ /// @brief Default destructor
+ ///
+ virtual ~SimpleEncrypter();
+
+ ///
+ /// @brief Generate private and public keys
+ ///
+ /// @returns key pair as string: [private key, public key]
+ ///
+ virtual std::pair<std::string, std::string> genKeyPair();
+
+ ///
+ /// @brief Set private key
+ ///
+ /// @param[in] hex string with private key
+ ///
+ virtual void setPrivKey(std::string keystr);
+
+ ///
+ /// @brief Set public key
+ ///
+ /// @param[in] hex string with public key
+ ///
+ virtual void setPubKey(std::string keystr);
+
+ ///
+ /// @brief Get private key
+ ///
+ /// @returns hex string with private key
+ ///
+ virtual std::string getPrivKey() const;
+
+ ///
+ /// @brief Get public key
+ ///
+ /// @returns hex string with public key
+ ///
+ virtual std::string getPubKey() const;
+
+ ///
+ /// @brief Encrypt a positive integer value
+ ///
+ /// @param[in] unsigned integer value to be encrypted
+ ///
+ /// @returns encrypted unsigned integer value
+ ///
+ virtual ULLI_t encrypt(ULLI_t x);
+
+ ///
+ /// @brief Decrypt a positive integer value
+ ///
+ /// @param[in] unsigned integer value to be decrypted
+ ///
+ /// @returns encrypted unsigned integer value
+ ///
+ virtual ULLI_t decrypt(ULLI_t x);
+
+ ///
+ /// @brief Encrypt a positive float value
+ ///
+ /// @param[in] positive float value to be encrypted
+ ///
+ /// @returns encrypted float value
+ ///
+ virtual float encrypt(float x);
+
+ ///
+ /// @brief Decrypt a positive float value
+ ///
+ /// @param[in] positive float value to be decrypted
+ ///
+ /// @returns encrypted float value
+ ///
+ virtual float decrypt(float x);
+
+
+ private:
+ ///
+ /// @name Key generation utilities
+ /// @{
+ ///
+ /// @brief Internally generate numeric representation of key pair
+ ///
+ virtual void genKeyPairInternal();
+ ///
+ /// @brief Find a prime number
+ ///
+ virtual ULLI_t genPrime() const;
+ ///
+ /// @brief Check for being a prime number
+ ///
+ virtual bool isPrime(ULLI_t n) const;
+ ///
+ /// @brief Find greatest common denominator
+ ///
+ virtual ULLI_t greatestCommonDenominator(ULLI_t n1, ULLI_t n2) const;
+ ///
+ /// @brief Find a coprime number
+ ///
+ virtual ULLI_t genCoprime(ULLI_t n) const;
+ ///
+ /// @brief Find decryption exponent
+ ///
+ virtual ULLI_t genDecryptionExponent(ULLI_t phi, ULLI_t e) const;
+ ///
+ /// @}
+ ///
+ /// @name Key conversion utilities
+ /// @{
+ ///
+ /// @brief Convert key to hex string
+ ///
+ virtual std::string keyToString(ULLI_t a, ULLI_t b) const;
+ ///
+ /// @brief Decode hex string to two integers
+ ///
+ virtual std::pair<ULLI_t, ULLI_t> decodeKeyString(std::string str) const;
+ /// @}
+ ///
+ /// @name float <-> int conversion utilities
+ /// @{
+ ///
+ /// @brief Interpret bits of floating point number as integer
+ ///
+ virtual ULLI_t floatBitsToInt(float val) const;
+ ///
+ /// @brief Interpret bits of integer as floating point number
+ ///
+ virtual float intBitsToFloat(ULLI_t val) const;
+ /// @}
+ ///
+ /// @name Internal en-/decryption methods
+ /// @{
+ ///
+ /// @brief Encrypt using format preserving encryption w.r.t. RSA modulus
+ ///
+ ULLI_t encryptFPECycle(ULLI_t a) const;
+ ///
+ /// @brief Decrypt using format preserving encryption w.r.t. RSA modulus
+ ///
+ ULLI_t decryptFPECycle(ULLI_t a) const;
+ ///
+ /// @brief Encrypt integer (internal)
+ ///
+ ULLI_t encryptInternal(ULLI_t x) const;
+ ///
+ /// @brief Decrypt integer (internal)
+ ///
+ ULLI_t decryptInternal(ULLI_t x) const;
+ ///
+ /// @brief Exponentiate a with d observing modulus n
+ ///
+ ULLI_t powerMod(ULLI_t a, ULLI_t d, ULLI_t n) const;
+ ///
+ /// @brief Check setup readiness for encryption
+ ///
+ bool isOkForEnc();
+ ///
+ /// @brief Check setup readiness for decryption
+ ///
+ bool isOkForDec();
+ ///
+ /// @}
+
+ private:
+ ///
+ /// @name Internal static consts
+ ///
+ /// @brief Approximate range for prime numbers to be generated in
+ static const ULLI_t m_MAXRANGE;
+ static const ULLI_t m_MINRANGE;
+ /// @brief maximum number of hex digits for key parts
+ static const unsigned int m_MAXHEXDIGITS;
+
+ ///
+ /// @name Internal member variables
+ ///
+ /// RSA modulus: common part of both keys
+ ULLI_t m_n;
+ /// encryption exponent: public key part II
+ ULLI_t m_e;
+ /// decryption exponent: private key part II
+ ULLI_t m_d;
+
+ /// indicates that keys are set and range checks are ok
+ bool m_isOkForEnc;
+ bool m_isOkForDec;
+
+ }; // class
+
+} // namespace xAOD
+
+#endif // BPHYSTOOLS_SIMPLEENCRYPTER_H
+
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/selection.xml b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/selection.xml
new file mode 100644
index 00000000000..a6539c15eec
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/BPhysTools/selection.xml
@@ -0,0 +1,10 @@
+<!--
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+-->
+
+<lcgdict>
+ <!-- BPhysTools -->
+ <class name="xAOD::BPhysBlindingTool" />
+ <class name="xAOD::BPhysTrackVertexMapTool" />
+ <class name="xAOD::SimpleEncrypter" />
+</lcgdict>
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/CMakeLists.txt b/PhysicsAnalysis/BPhys/BPhysTools/CMakeLists.txt
new file mode 100644
index 00000000000..4229cef3b69
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/CMakeLists.txt
@@ -0,0 +1,84 @@
+#
+# Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+#
+
+# $Id: CMakeLists.txt 805745 2017-05-31 17:23:48Z wwalko $
+#
+# Build configuration for the package.
+#
+#********************************************
+set(extra_dep)
+if( XAOD_STANDALONE )
+ set(extra_dep)
+else()
+ set( extra_dep
+ GaudiKernel
+ Control/AthenaKernel
+ )
+endif()
+#********************************************
+set(extra_libs)
+if( XAOD_STANDALONE )
+ set(extra_libs)
+else()
+ set( extra_libs
+ GaudiKernel
+ AthenaKernel
+ )
+endif()
+#********************************************
+# The name of the package:
+atlas_subdir( BPhysTools )
+
+
+# Used external(s):
+find_package( ROOT COMPONENTS Core Physics Matrix )
+find_package( Boost )
+
+# Build the main library of the package:
+atlas_add_library( BPhysToolsLib
+ BPhysTools/*.h Root/*.cxx src/*.cxx
+ PUBLIC_HEADERS BPhysTools
+ INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+ PRIVATE_INCLUDE_DIRS ${Boost_INCLUDE_DIRS}
+ LINK_LIBRARIES ${ROOT_LIBRARIES}
+ xAODTracking
+ xAODBPhysLib
+ AsgTools
+ ${extra_libs}
+ PRIVATE_LINK_LIBRARIES ${Boost_LIBRARIES}
+ xAODEventInfo
+ )
+
+if(NOT XAOD_STANDALONE)
+atlas_add_component( BPhysTools
+ src/components/*.cxx
+ INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+ PRIVATE_INCLUDE_DIRS ${Boost_INCLUDE_DIRS}
+ LINK_LIBRARIES ${ROOT_LIBRARIES}
+ xAODTracking
+ xAODBPhysLib
+ AsgTools
+ ${extra_libs}
+ BPhysToolsLib
+ PRIVATE_LINK_LIBRARIES ${Boost_LIBRARIES}
+ xAODEventInfo
+ )
+endif()
+
+# Build the dictionary
+atlas_add_dictionary( BPhysToolsDict
+ BPhysTools/BPhysToolsDict.h
+ BPhysTools/selection.xml
+ LINK_LIBRARIES BPhysToolsLib
+ )
+
+
+# Executables in util subdirectory
+file (GLOB util_sources RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+ "${CMAKE_CURRENT_SOURCE_DIR}/util/*.cxx")
+foreach (source ${util_sources})
+ string (REGEX REPLACE "util/(.*).cxx" "\\1" util ${source})
+ atlas_add_executable (${util} ${source} LINK_LIBRARIES BPhysToolsLib)
+endforeach (source ${util_sources})
+
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/Root/BPhysBlindingTool.cxx b/PhysicsAnalysis/BPhys/BPhysTools/Root/BPhysBlindingTool.cxx
new file mode 100644
index 00000000000..269f6699792
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/Root/BPhysBlindingTool.cxx
@@ -0,0 +1,464 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+// system include:
+#include "boost/tokenizer.hpp"
+#include <boost/algorithm/string.hpp>
+#include <set>
+#include <cmath>
+
+// EDM includes:
+#include "xAODEventInfo/EventInfo.h"
+
+// ROOT includes
+#include "TString.h"
+
+// Local include(s):
+#include "BPhysTools/BPhysBlindingTool.h"
+
+namespace xAOD {
+
+ //--------------------------------------------------------------------------
+ // Constructor
+ //--------------------------------------------------------------------------
+ BPhysBlindingTool::BPhysBlindingTool( const std::string& name )
+ : asg::AsgTool( name ),
+ m_vtxContainer(nullptr), m_vtxAuxContainer(nullptr),
+ m_cachedRun(-1), m_cachedEvent(-1),
+ m_eventsForBlindingSeen(0),
+ m_candidatesForBlindingSeen(0),
+ m_eventsForUnblindingSeen(0),
+ m_candidatesForUnblindingSeen(0),
+ m_eventsBlinded(0),
+ m_candidatesBlinded(0),
+ m_eventsUnblinded(0),
+ m_candidatesUnblinded(0) {
+
+#ifdef ASGTOOL_ATHENA
+ declareInterface< IBPhysBlindingTool >( this );
+#endif // ASGTOOL_ATHENA
+
+ // Vertex container
+ declareProperty("VertexContainerName", m_vertexContainerName = "");
+
+ // List of variables to blind
+ // (as concatenated string using . as delimiter)
+ declareProperty("VarToBlindNames", m_varToBlindNames = "");
+
+ // Flag to indicate candidates for blinding
+ // Left empty: Blind values for all candidates.
+ declareProperty("BlindingFlag" , m_blindingFlag = "");
+
+ // Offsets applied to values before blinding
+ // List must have same length as VarToBlindNames or zero.
+ declareProperty("BlindingOffsets", m_vOffsets);
+
+ // Scale factors applied before blinding
+ // List must have same length as VarToBlindNames or zero.
+ declareProperty("BlindingFactors", m_vFactors);
+
+ // Flip signs to negative range?
+ declareProperty("NegativeSigns" , m_vNegSigns);
+
+ // Key for blinding
+ declareProperty("BlindingKey" , m_blindKey = "");
+
+ // Key for unblinding
+ declareProperty("UnblindingKey" , m_unblindKey = "");
+
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysBlindingTool::initialize() {
+
+ // Greet the user:
+ ATH_MSG_DEBUG( "Initializing xAOD::BPhysBlindingTool" );
+
+ // Setup of variables
+ if ( m_vertexContainerName == "" ) {
+ ATH_MSG_INFO("No vertex container name provided.");
+ }
+
+ if ( m_varToBlindNames != "" ) {
+ m_vVarNames = getTokens(m_varToBlindNames, ".,:;|");
+ }
+
+ // Blinding and unblinding keys
+ if ( m_blindKey == "" && m_unblindKey == "" ) {
+ ATH_MSG_ERROR("You must at least set a key for blinding or unblinding!");
+ } else {
+ if ( m_blindKey != "" ) {
+ m_senc.setPubKey(m_blindKey);
+ ATH_MSG_INFO("Setting blinding key.");
+ }
+ if ( m_unblindKey != "" ) {
+ m_senc.setPrivKey(m_unblindKey);
+ ATH_MSG_INFO("Setting unblinding key.");
+ }
+ }
+
+ // make sure offsets vector is of correct length
+ if ( m_vOffsets.size() < m_vVarNames.size() ) {
+ for (uint i=m_vOffsets.size(); i<m_vVarNames.size(); ++i) {
+ m_vOffsets.push_back(0.);
+ }
+ ATH_MSG_INFO("Extending BlindingOffsets list ...");
+ } else if ( m_vOffsets.size() > m_vVarNames.size() ) {
+ ATH_MSG_WARNING("BlindingOffsets list longer than VarToBlindNames.");
+ }
+
+ // make sure scale factors vector is of correct length
+ if ( m_vFactors.size() < m_vVarNames.size() ) {
+ for (uint i=m_vFactors.size(); i<m_vVarNames.size(); ++i) {
+ m_vFactors.push_back(1.);
+ }
+ ATH_MSG_INFO("Extending BlindingOffsets list ...");
+ } else if ( m_vFactors.size() > m_vVarNames.size() ) {
+ ATH_MSG_WARNING("BlindingFactors list longer than VarToBlindNames.");
+ }
+
+ // make sure negative signs vector is of correct length
+ if ( m_vNegSigns.size() < m_vVarNames.size() ) {
+ for (uint i=m_vNegSigns.size(); i<m_vVarNames.size(); ++i) {
+ m_vNegSigns.push_back(1.);
+ }
+ ATH_MSG_INFO("Extending NegativeSigns list ...");
+ } else if ( m_vNegSigns.size() > m_vVarNames.size() ) {
+ ATH_MSG_WARNING("NegativeSigns list longer than VarToBlindNames.");
+ }
+
+ // some info for the job log
+ ATH_MSG_INFO("VertexContainerName : " << m_vertexContainerName);
+ ATH_MSG_INFO("BlindingFlag : " << m_blindingFlag);
+ ATH_MSG_INFO("VarToBlindNames : " << m_varToBlindNames);
+ ATH_MSG_INFO("BlindingOffsets : " << vecToString(m_vOffsets));
+ ATH_MSG_INFO("BlindingFactors : " << vecToString(m_vFactors));
+ ATH_MSG_INFO("NegativeSigns : " << vecToString(m_vNegSigns));
+ ATH_MSG_INFO("BlindingKey : " << m_blindKey);
+ ATH_MSG_INFO("UnblindingKey : " << m_unblindKey);
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysBlindingTool::finalize() {
+
+ ATH_MSG_DEBUG( "Finalizing xAOD::BPhysBlindingTool" );
+
+ ATH_MSG_INFO("Statistics for " << name() << ":");
+ ATH_MSG_INFO(Form("N_eventsForBlindingSeen : %10ld",
+ m_eventsForBlindingSeen));
+ ATH_MSG_INFO(Form("N_eventsBlinded : %10ld",
+ m_eventsBlinded));
+ ATH_MSG_INFO(Form("N_eventsForUnblindingSeen : %10ld",
+ m_eventsForUnblindingSeen));
+ ATH_MSG_INFO(Form("N_eventsUnblinded : %10ld",
+ m_eventsUnblinded));
+ ATH_MSG_INFO(Form("N_candidatesForBlindingSeen : %10ld",
+ m_candidatesForBlindingSeen));
+ ATH_MSG_INFO(Form("N_candidatesBlinded : %10ld",
+ m_candidatesBlinded));
+ ATH_MSG_INFO(Form("N_candidatesForUnblindingSeen : %10ld",
+ m_candidatesForUnblindingSeen));
+ ATH_MSG_INFO(Form("N_candidatesUnblinded : %10ld",
+ m_candidatesUnblinded));
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Simply blind one positive float value
+ //--------------------------------------------------------------------------
+ float BPhysBlindingTool::doBlind(const float& val) {
+
+ return m_senc.encrypt(val);
+ }
+ //--------------------------------------------------------------------------
+ // Simply unblind one positive float value
+ //--------------------------------------------------------------------------
+ float BPhysBlindingTool::doUnblind(const float& val) {
+
+ return m_senc.decrypt(val);
+ }
+ //--------------------------------------------------------------------------
+ // Simply blind one (positive) float value
+ //--------------------------------------------------------------------------
+ float BPhysBlindingTool::doBlind(const float& val,
+ const bool& negativeSign,
+ const float& offset,
+ const float& factor) {
+
+ // adjustment if requested
+ float bval(val);
+ float cval = val*factor + offset;
+ if ( cval > 0. ) {
+ // perform actual blinding
+ bval = m_senc.encrypt(cval);
+ if (negativeSign) bval *= -1.;
+ } else {
+ ATH_MSG_WARNING("Blinding: Corrected value not positive: "
+ << val << Form(" (%a) -> ", val)
+ << cval << Form(" (%a)", cval));
+ } // if cval > 0
+
+ return bval;
+ }
+ //--------------------------------------------------------------------------
+ // Simply unblind one (positive) float value
+ //--------------------------------------------------------------------------
+ float BPhysBlindingTool::doUnblind(const float& val,
+ const bool& negativeSign,
+ const float& offset,
+ const float& factor) {
+
+ float bval(val), cval(val);
+ if (negativeSign) bval *= -1.;
+ // if ( bval > 0. || isnan(bval) ) {
+ if ( bval > 0. || !std::isnormal(bval) ) {
+ // perform actual unblinding
+ cval = m_senc.decrypt(bval);
+ if ( factor != 0. ) {
+ cval = (cval - offset)/factor;
+ } else {
+ ATH_MSG_WARNING("Unblinding: BlindingFactor == 0!: "
+ << val << Form(" (%a)", val));
+ } // if m_vFactors[ivtx] != 0
+ } else {
+ ATH_MSG_WARNING("Unblinding: Corrected value not positive: "
+ << val << Form(" (%a) -> ", val)
+ << bval << Form(" (%a)", bval));
+ } // if bval > 0
+
+ return cval;
+ }
+ //--------------------------------------------------------------------------
+ // Perform blinding of requested variables
+ //--------------------------------------------------------------------------
+ StatusCode BPhysBlindingTool::doBlind() {
+
+ if ( m_blindKey == "" ) {
+ ATH_MSG_WARNING("Can not blind without blinding key!");
+ } else {
+ ATH_CHECK( doBlindingAction(false) );
+ }
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Perform unblinding of requested variables
+ //--------------------------------------------------------------------------
+ StatusCode BPhysBlindingTool::doUnblind() {
+
+ if ( m_unblindKey == "" ) {
+ ATH_MSG_WARNING("Can not unblind without unblinding key!");
+ } else {
+ ATH_CHECK( doBlindingAction(true) );
+ }
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+
+ //--------------------------------------------------------------------------
+ // Protected methods
+ //--------------------------------------------------------------------------
+
+ //--------------------------------------------------------------------------
+ // Perform blinding or unblinding action
+ //--------------------------------------------------------------------------
+ StatusCode BPhysBlindingTool::doBlindingAction(bool unblind) {
+
+ ATH_CHECK(cacheEvent());
+
+ // counters
+ if ( unblind ) {
+ ++m_eventsForUnblindingSeen;
+ } else {
+ ++m_eventsForBlindingSeen;
+ }
+
+ if ( m_vVarNames.size() > 0 ) {
+ long candidatesBlinded(0);
+ long candidatesUnblinded(0);
+ // loop over vertices
+ // int ivtx(0);
+ for (xAOD::VertexContainer::const_iterator
+ vtxItr = m_vtxContainer->begin();
+ vtxItr != m_vtxContainer->end(); ++vtxItr) {
+ // counters
+ if ( unblind ) {
+ ++m_candidatesForUnblindingSeen;
+ } else {
+ ++m_candidatesForBlindingSeen;
+ }
+ const xAOD::Vertex* vtx = *vtxItr;
+ // check whether to apply (un-)blinding to this candidate
+ if ( m_blindingFlag == "" || pass(*vtx, m_blindingFlag) ) {
+ // counters
+ if ( unblind ) {
+ ++candidatesUnblinded;
+ } else {
+ ++candidatesBlinded;
+ }
+ // loop over variable names
+ for (size_t iv=0; iv<m_vVarNames.size(); ++iv) {
+ SG::AuxElement::Decorator<float> floatDec(m_vVarNames[iv]);
+ // check for variable
+ if ( floatDec.isAvailable(*vtx) ) {
+ float val = floatDec(*vtx);
+ if ( unblind ) {
+ // unblinding
+ floatDec(*vtx) = doUnblind(val, m_vNegSigns[iv],
+ m_vOffsets[iv], m_vFactors[iv]);
+ ATH_MSG_DEBUG("Unblind: " << val << Form(" (%a) -> ", val)
+ << floatDec(*vtx)
+ << Form(" (%a)", floatDec(*vtx)));
+ } else {
+ // blinding
+ floatDec(*vtx) = doBlind(val, m_vNegSigns[iv],
+ m_vOffsets[iv], m_vFactors[iv]);
+ ATH_MSG_DEBUG("Blind: " << val << Form(" (%a) -> ", val)
+ << floatDec(*vtx)
+ << Form(" (%a)", floatDec(*vtx)));
+ } // if unblind
+ } else {
+ ATH_MSG_WARNING("Missing variable " << m_vVarNames[iv]);
+ } // if isAvailable
+ } // for m_vVarNames
+ } // if blinding
+ } // for iv
+ // counters
+ if ( unblind ) {
+ m_candidatesUnblinded += candidatesUnblinded;
+ if ( candidatesUnblinded > 0 ) ++m_eventsUnblinded;
+ } else {
+ m_candidatesBlinded += candidatesBlinded;
+ if ( candidatesBlinded > 0 ) ++m_eventsBlinded;
+ }
+ } // if m_vVarNames.size()
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Cache current event.
+ //
+ // Call this once per event.
+ // Repeated calls for the same run/event are not updating the cache again.
+ //--------------------------------------------------------------------------
+ StatusCode BPhysBlindingTool::cacheEvent() {
+
+ ATH_MSG_DEBUG("BPhysBlindingTool::cacheEvent -- begin");
+
+ const xAOD::EventInfo* eventInfo = NULL;
+ ATH_CHECK(evtStore()->retrieve(eventInfo, "EventInfo"));
+
+ if ( m_cachedRun != (int)eventInfo->runNumber() ||
+ m_cachedEvent != (int)eventInfo->eventNumber() ) {
+
+ // note update
+ m_cachedRun = eventInfo->runNumber();
+ m_cachedEvent = eventInfo->eventNumber();
+
+ ATH_MSG_DEBUG("BPhysBlindingTool::cacheEvent: caching now: "
+ << "run " << m_cachedRun << " event " << m_cachedEvent);
+
+ // retrieve vertices container
+ m_vtxContainer = nullptr;
+ m_vtxAuxContainer = nullptr;
+
+ if ( evtStore()->transientContains<xAOD::VertexContainer>(m_vertexContainerName) ) {
+ ATH_MSG_DEBUG("In transient store: " << m_vertexContainerName);
+ ATH_CHECK(evtStore()->retrieve(m_vtxContainer,
+ m_vertexContainerName));
+ ATH_CHECK(evtStore()->retrieve(m_vtxAuxContainer,
+ m_vertexContainerName+"Aux."));
+ } else {
+ ATH_MSG_DEBUG("Not in transient store: " << m_vertexContainerName);
+ const xAOD::VertexContainer* constVtxContainer = nullptr;
+ const xAOD::VertexAuxContainer* constVtxAuxContainer = nullptr;
+ ATH_CHECK(evtStore()->retrieve(constVtxContainer,
+ m_vertexContainerName));
+ ATH_CHECK(evtStore()->retrieve(constVtxAuxContainer,
+ m_vertexContainerName+"Aux."));
+ // create a copy
+ m_vtxContainer = new xAOD::VertexContainer();
+ m_vtxAuxContainer = new xAOD::VertexAuxContainer();
+ m_vtxContainer->setStore(m_vtxAuxContainer);
+ for (const xAOD::Vertex* constVtx : *constVtxContainer) {
+ xAOD::Vertex* vtx = new xAOD::Vertex();
+ m_vtxContainer->push_back(vtx);
+ *vtx = *constVtx;
+ }
+ ATH_CHECK(evtStore()->record(m_vtxContainer,
+ m_vertexContainerName));
+ ATH_CHECK(evtStore()->record(m_vtxAuxContainer,
+ m_vertexContainerName+"Aux."));
+ }
+
+ ATH_MSG_DEBUG("Found vertex collection with key "
+ << m_vertexContainerName);
+
+ } // if new run/event
+
+ ATH_MSG_DEBUG("BPhysBlindingTool::cacheEvent -- end");
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Helper to check whether an element is marked as passing a specific
+ // hypothesis.
+ //--------------------------------------------------------------------------
+ bool BPhysBlindingTool::pass(const SG::AuxElement& em, std::string hypo) {
+
+ if ( !boost::algorithm::starts_with(hypo, "passed_") )
+ hypo = "passed_" + hypo;
+ SG::AuxElement::Accessor<Char_t> flagAcc(hypo);
+ return flagAcc.isAvailable(em) && flagAcc(em) != 0;
+ }
+ //--------------------------------------------------------------------------
+ // Tokenize a string using certain separators
+ //--------------------------------------------------------------------------
+ std::vector<std::string>
+ BPhysBlindingTool::getTokens(std::string input, std::string seperators) {
+
+ std::vector<std::string> tokens;
+ boost::char_separator<char> sep(seperators.c_str());
+ typedef boost::tokenizer<boost::char_separator<char> > Tokenizer_t;
+ Tokenizer_t tokenizer(input, sep);
+ for (auto& token : tokenizer) {
+ tokens.push_back(token);
+ }
+ return tokens;
+ }
+ //--------------------------------------------------------------------------
+ // Format vector of floats as string
+ //--------------------------------------------------------------------------
+ std::string BPhysBlindingTool::vecToString(const std::vector<float>& v)
+ const {
+ std::string str("[");
+ for (unsigned int i=0; i<v.size(); ++i) {
+ str += std::to_string(v[i]);
+ if ( i < v.size()-1 ) str += ",";
+ }
+ str += "]";
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Format vector of bools as string
+ //--------------------------------------------------------------------------
+ std::string BPhysBlindingTool::vecToString(const std::vector<bool>& v)
+ const {
+ std::string str("[");
+ for (unsigned int i=0; i<v.size(); ++i) {
+ str += std::to_string(v[i]);
+ if ( i < v.size()-1 ) str += ",";
+ }
+ str += "]";
+ return str;
+ }
+ //--------------------------------------------------------------------------
+} // namespace xAOD
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/Root/BPhysTrackVertexMapTool.cxx b/PhysicsAnalysis/BPhys/BPhysTools/Root/BPhysTrackVertexMapTool.cxx
new file mode 100644
index 00000000000..c0cf97b32de
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/Root/BPhysTrackVertexMapTool.cxx
@@ -0,0 +1,664 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// $Id: $
+
+// system include:
+#include "boost/format.hpp"
+#include "boost/tokenizer.hpp"
+
+// EDM includes:
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+
+// Local include(s):
+#include "BPhysTools/BPhysTrackVertexMapTool.h"
+
+namespace xAOD {
+
+ //--------------------------------------------------------------------------
+ // Static utility method to prefix every line by a certain string
+ //--------------------------------------------------------------------------
+ std::string BPhysTrackVertexMapTool::wrapLines(std::string lines,
+ std::string prefix) {
+
+ std::string ostr;
+ std::istringstream stream(lines);
+ std::string line;
+ while ( std::getline(stream, line) ) {
+ if ( !ostr.empty() ) ostr += "\n";
+ ostr += prefix + line;
+ }
+ return ostr;
+ }
+ //--------------------------------------------------------------------------
+ // Constructor
+ //--------------------------------------------------------------------------
+ BPhysTrackVertexMapTool::BPhysTrackVertexMapTool( const std::string& name )
+ : asg::AsgTool( name ),
+ m_tracks(NULL), m_tracksAux(NULL), m_pvtxContainer(NULL),
+ m_svtxContainer(NULL), m_svtxAuxContainer(NULL), m_refPVContainer(NULL),
+ m_refPVAuxContainer(NULL),
+ m_nEvtsSeen (0), m_cachedRun(-1), m_cachedEvent(-1) {
+
+#ifdef ASGTOOL_ATHENA
+ declareInterface< IBPhysTrackVertexMapTool >( this );
+#endif // ASGTOOL_ATHENA
+
+ // Necessary containers
+ declareProperty("VertexContainerName", m_vertexContainerName);
+ declareProperty("TrackParticleContainerName",
+ m_trackParticleContainerName="InDetTrackParticles");
+ declareProperty("PVContainerName", m_pvContainerName = "PrimaryVertices");
+ declareProperty("RefPVContainerName", m_refPVContainerName);
+
+ // Maximum number of events to dump maps to log file for
+ declareProperty("DebugTrkToVtxMaxEvents", m_debugTrkToVtxMaxEvents = 0);
+
+ // Prefix for log dump lines
+ declareProperty("DumpPrefix", m_dumpPrefix="TTV> ");
+
+ // Hypothesis name (for mass value pickup)
+ declareProperty("HypoName", m_hypoName="__NONE__");
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysTrackVertexMapTool::initialize() {
+
+ // Greet the user:
+ ATH_MSG_DEBUG( "Initializing xAOD::BPhysTrackVertexMapTool" );
+
+ if ( m_vertexContainerName == "" ) {
+ ATH_MSG_ERROR("No vertex container name provided!");
+ }
+ if ( m_refPVContainerName == "" ) {
+ ATH_MSG_ERROR("No refitted PV container name provided!");
+ }
+ if ( m_trackParticleContainerName == "" ) {
+ ATH_MSG_ERROR("No track particle container name provided!");
+ }
+ if ( m_pvContainerName == "" ) {
+ ATH_MSG_ERROR("No PV container name provided!");
+ }
+ // some info for the job log
+ ATH_MSG_INFO("VertexContainerName : " << m_vertexContainerName);
+ ATH_MSG_INFO("PVContainerName : " << m_pvContainerName);
+ ATH_MSG_INFO("RefPVContainerName : " << m_refPVContainerName);
+ ATH_MSG_INFO("TrackParticleContainerName : "
+ << m_trackParticleContainerName);
+ ATH_MSG_INFO("DebugTrkToVtxMaxEvents : " << m_debugTrkToVtxMaxEvents);
+ ATH_MSG_INFO("DumpPrefix : " << m_dumpPrefix);
+ ATH_MSG_INFO("HypoName : " << m_hypoName);
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysTrackVertexMapTool::finalize() {
+
+ ATH_MSG_DEBUG( "Finalizing xAOD::BPhysTrackVertexMapTool" );
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysTrackVertexMapTool::logEvent() {
+
+ ATH_MSG_DEBUG( "logEvent in xAOD::BPhysTrackVertexMapTool" );
+
+ // read info into maps cache
+ ATH_CHECK(cacheEvent());
+
+ // dump info from maps if requested
+ if ( doLog() ) {
+
+ ATH_MSG_INFO("Track-to-vertex association map:");
+
+ std::cout << summaryToString(m_dumpPrefix) << std::endl;
+
+ } // if requested
+
+ // increment counter
+ m_nEvtsSeen++;
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ bool BPhysTrackVertexMapTool::doLog() const {
+
+ return ( m_debugTrkToVtxMaxEvents < 0 ||
+ m_debugTrkToVtxMaxEvents > (int)m_nEvtsSeen );
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Cache maps for current event.
+ //
+ // Call this once per event.
+ // Repeated calls for the same run/event are not updating the cache again.
+ //
+ //--------------------------------------------------------------------------
+ StatusCode BPhysTrackVertexMapTool::cacheEvent() {
+
+ ATH_MSG_DEBUG("BPhysTrackVertexMapTool::cacheEvent -- begin");
+
+ const xAOD::EventInfo* eventInfo = NULL;
+ ATH_CHECK(evtStore()->retrieve(eventInfo, "EventInfo"));
+
+ if ( m_cachedRun != (int)eventInfo->runNumber() ||
+ m_cachedEvent != (int)eventInfo->eventNumber() ) {
+
+ // note update
+ m_cachedRun = eventInfo->runNumber();
+ m_cachedEvent = eventInfo->eventNumber();
+
+ ATH_MSG_DEBUG("BPhysTrackVertexMapTool::cacheEvent: caching now: "
+ << "run " << m_cachedRun << " event " << m_cachedEvent);
+
+ // retrieve primary vertices container
+ m_pvtxContainer = NULL;
+ ATH_CHECK(evtStore()->retrieve(m_pvtxContainer, m_pvContainerName));
+ ATH_MSG_DEBUG("Found PV collection with key " << m_pvContainerName);
+
+ // retrieve ID track container
+ m_tracks = NULL;
+ m_tracksAux = NULL;
+ ATH_CHECK(evtStore()->retrieve(m_tracks, m_trackParticleContainerName));
+ if (evtStore()->contains<xAOD::
+ TrackParticleAuxContainer>(m_trackParticleContainerName+"Aux.")) {
+ ATH_CHECK(evtStore()->retrieve(m_tracksAux,
+ m_trackParticleContainerName+"Aux."));
+ } else {
+ ATH_MSG_DEBUG("No aux track collection with key "
+ << m_trackParticleContainerName+"Aux.");
+ }
+ ATH_MSG_DEBUG("Found track collection with key "
+ << m_trackParticleContainerName);
+
+ // vertex container and its auxilliary store
+ m_svtxContainer = NULL;
+ m_svtxAuxContainer = NULL;
+ ATH_CHECK(evtStore()->retrieve(m_svtxContainer, m_vertexContainerName));
+ ATH_CHECK(evtStore()->retrieve(m_svtxAuxContainer,
+ m_vertexContainerName+"Aux."));
+ ATH_MSG_DEBUG("Found SV collection with key " << m_vertexContainerName);
+
+ // refitted primary vertex container and its auxilliary store
+ m_refPVContainer = NULL;
+ m_refPVAuxContainer = NULL;
+ ATH_CHECK(evtStore()->retrieve(m_refPVContainer, m_refPVContainerName));
+ ATH_CHECK(evtStore()->retrieve(m_refPVAuxContainer,
+ m_refPVContainerName+"Aux."));
+ ATH_MSG_DEBUG("Found refitted PV collection with key "
+ << m_refPVContainerName);
+
+ // initialize track, PV and refPV maps
+ initTrackVertexMaps(m_tracks, m_pvtxContainer, m_refPVContainer,
+ m_svtxContainer);
+ } // if new run/event
+
+ ATH_MSG_DEBUG("BPhysTrackVertexMapTool::cacheEvent -- end");
+
+ // Return gracefully:
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Retrieve primary vertices for ID track from map.
+ //
+ //--------------------------------------------------------------------------
+ std::vector<const xAOD::Vertex*>
+ BPhysTrackVertexMapTool::pvsForIDTrack(const xAOD::TrackParticle* track)
+ const {
+
+ TrackToVertexMap_t::const_iterator it = m_idTrackToPVMap.find(track);
+
+ if ( it != m_idTrackToPVMap.end() ) {
+ return it->second;
+ } else {
+ std::vector<const xAOD::Vertex*> dummy;
+ return dummy;
+ }
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Retrieve refitted primary vertices for ID track from map.
+ //
+ //--------------------------------------------------------------------------
+ std::vector<const xAOD::Vertex*>
+ BPhysTrackVertexMapTool::refPVsForIDTrack(const xAOD::TrackParticle* track)
+ const {
+
+ TrackToVertexMap_t::const_iterator it = m_idTrackToRefPVMap.find(track);
+
+ if ( it != m_idTrackToRefPVMap.end() ) {
+ return it->second;
+ } else {
+ std::vector<const xAOD::Vertex*> dummy;
+ return dummy;
+ }
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Retrieve secondary vertices for ID track from map.
+ //
+ //--------------------------------------------------------------------------
+ std::vector<const xAOD::Vertex*>
+ BPhysTrackVertexMapTool::svsForIDTrack(const xAOD::TrackParticle* track)
+ const {
+
+ TrackToVertexMap_t::const_iterator it = m_idTrackToSVMap.find(track);
+
+ if ( it != m_idTrackToSVMap.end() ) {
+ return it->second;
+ } else {
+ std::vector<const xAOD::Vertex*> dummy;
+ return dummy;
+ }
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Initialize ID tracks, PV and refPV related maps.
+ //
+ //--------------------------------------------------------------------------
+ void BPhysTrackVertexMapTool
+ ::initTrackVertexMaps(const xAOD::TrackParticleContainer* tpc,
+ const xAOD::VertexContainer* pvc,
+ const xAOD::VertexContainer* rpvc,
+ const xAOD::VertexContainer* svc) {
+
+ // clear previous entries
+ m_pvNameMap.clear();
+ m_refPVNameMap.clear();
+ m_svNameMap.clear();
+ m_idTrackNameMap.clear();
+ m_idTrackToPVMap.clear();
+ m_idTrackToRefPVMap.clear();
+ m_idTrackToSVMap.clear();
+
+ // initialize maps for PVs
+ for (xAOD::VertexContainer::const_iterator vtxItr = pvc->begin();
+ vtxItr != pvc->end(); ++vtxItr) {
+ const xAOD::Vertex* vtx = *vtxItr;
+ pvName(vtx);
+ for (size_t i = 0; i < vtx->nTrackParticles(); ++i) {
+ const xAOD::TrackParticle* track = vtx->trackParticle(i);
+ // m_idTrackToPVMap[track] = vtx;
+ addVertexToTrackVertexMap(m_idTrackToPVMap, track, vtx);
+ }
+ }
+ // initialize maps for refitted PVs
+ for (xAOD::VertexContainer::const_iterator vtxItr = rpvc->begin();
+ vtxItr != rpvc->end(); ++vtxItr) {
+ const xAOD::Vertex* vtx = *vtxItr;
+ refPVName(vtx);
+ for (size_t i = 0; i < vtx->nTrackParticles(); ++i) {
+ const xAOD::TrackParticle* track = vtx->trackParticle(i);
+ // m_idTrackToRefPVMap[track] = vtx;
+ addVertexToTrackVertexMap(m_idTrackToRefPVMap, track, vtx);
+ }
+ }
+
+ // initialize maps for SVs
+ for (xAOD::VertexContainer::const_iterator vtxItr = svc->begin();
+ vtxItr != svc->end(); ++vtxItr) {
+ const xAOD::Vertex* vtx = *vtxItr;
+ svName(vtx);
+ for (size_t i = 0; i < vtx->nTrackParticles(); ++i) {
+ const xAOD::TrackParticle* track = vtx->trackParticle(i);
+ // m_idTrackToSVMap[track] = vtx;
+ addVertexToTrackVertexMap(m_idTrackToSVMap, track, vtx);
+ }
+ }
+ // initialize maps for ID tracks
+ for (xAOD::TrackParticleContainer::const_iterator trkItr = tpc->begin();
+ trkItr != tpc->end(); ++trkItr) {
+ const xAOD::TrackParticle* track = *trkItr;
+ idTrackName(track);
+ }
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Add vertex to track-to-vertex map with vector of vertices.
+ //
+ //--------------------------------------------------------------------------
+ void BPhysTrackVertexMapTool
+ ::addVertexToTrackVertexMap(TrackToVertexMap_t& map,
+ const xAOD::TrackParticle* track,
+ const xAOD::Vertex* vtx) {
+
+ TrackToVertexMap_t::const_iterator it = map.find(track);
+
+ if ( it == map.end() ) {
+ map[track] = std::vector<const xAOD::Vertex*>();
+ }
+ map[track].push_back(vtx);
+ }
+ //--------------------------------------------------------------------------
+ // Lookup name for PV -- add as next if not yet known
+ //--------------------------------------------------------------------------
+ std::string BPhysTrackVertexMapTool::pvName(const xAOD::Vertex* vtx) {
+
+ if ( m_pvNameMap.find(vtx) == m_pvNameMap.end() ) {
+ boost::format f("PV%03d");
+ f % m_pvNameMap.size();
+ m_pvNameMap[vtx] = f.str();
+ }
+ return m_pvNameMap[vtx];
+ }
+ //--------------------------------------------------------------------------
+ // Lookup name for refitted PV -- add as next if not yet known
+ //--------------------------------------------------------------------------
+ std::string BPhysTrackVertexMapTool::refPVName(const xAOD::Vertex* vtx) {
+
+ if ( m_refPVNameMap.find(vtx) == m_refPVNameMap.end() ) {
+ boost::format f("RV%03d");
+ f % m_refPVNameMap.size();
+ m_refPVNameMap[vtx] = f.str();
+ }
+ return m_refPVNameMap[vtx];
+ }
+ //--------------------------------------------------------------------------
+ // Lookup name for SV -- add as next if not yet known
+ //--------------------------------------------------------------------------
+ std::string BPhysTrackVertexMapTool::svName(const xAOD::Vertex* vtx) {
+
+ if ( m_svNameMap.find(vtx) == m_svNameMap.end() ) {
+ boost::format f("SV%03d");
+ f % m_svNameMap.size();
+ m_svNameMap[vtx] = f.str();
+ }
+ return m_svNameMap[vtx];
+ }
+ //--------------------------------------------------------------------------
+ // Lookup name for ID track -- add as next if not yet known
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::idTrackName(const xAOD::TrackParticle* track) {
+
+ if ( m_idTrackNameMap.find(track) == m_idTrackNameMap.end() ) {
+ boost::format f("T%04d");
+ f % m_idTrackNameMap.size();
+ m_idTrackNameMap[track] = f.str();
+ }
+ return m_idTrackNameMap[track];
+ }
+ //--------------------------------------------------------------------------
+ // Print Track information to string -- optionally adding PVs or refPVs
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::idTrackToString(const xAOD::TrackParticle* track,
+ unsigned int indent,
+ bool withPV, bool withRefPV,
+ bool withSV) {
+
+ std::string sind(indent, ' ');
+ boost::format f1("%s %-5s %p (%10.4f, %10.4f, %10.4f) VL %p");
+ f1 % sind % idTrackName(track) % track
+ % track->pt() % track->eta() % track->phi(); //% track->vertex(); REMOVE IN MIGRATION TO MAKER
+ std::string str = f1.str();
+ if ( withPV ) {
+ TrackToVertexMap_t::iterator it = m_idTrackToPVMap.find(track);
+ if ( it != m_idTrackToPVMap.end() ) {
+ for ( auto vtx : it->second ) {
+ str += "\n" + pvToString(vtx, indent+2, false);
+ }
+ } else {
+ boost::format f2("\n%s %s");
+ f2 % sind % "NOPV";
+ str += f2.str();
+
+ }
+ }
+ if ( withRefPV ) {
+ TrackToVertexMap_t::iterator it = m_idTrackToRefPVMap.find(track);
+ if ( it != m_idTrackToRefPVMap.end() ) {
+ for ( auto vtx : it->second ) {
+ str += "\n" + refPVToString(vtx, indent+2, false);
+ }
+ } else {
+ boost::format f2("\n%s %s");
+ f2 % sind % "NORV";
+ str += f2.str();
+ }
+ }
+ if ( withSV ) {
+ TrackToVertexMap_t::iterator it = m_idTrackToSVMap.find(track);
+ if ( it != m_idTrackToSVMap.end() ) {
+ for ( auto vtx : it->second ) {
+ str += "\n" + svToString(vtx, indent+2, false);
+ }
+ } else {
+ boost::format f2("\n%s %s");
+ f2 % sind % "NOSV";
+ str += f2.str();
+ }
+ }
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Print PV information to string -- optionally adding tracks
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::pvToString(const xAOD::Vertex* vtx,
+ unsigned int indent,
+ bool withTracks) {
+
+ std::string sind(indent, ' ');
+ boost::format f1("%s %-5s %p (%10.4f, %10.4f, %10.4f) NT %4d VT %d");
+ f1 % sind % pvName(vtx) % vtx % vtx->x() % vtx->y() % vtx->z()
+ % vtx->nTrackParticles() % vtx->vertexType();
+ std::string str = f1.str();
+ if ( withTracks ) {
+ for (size_t i=0; i < vtx->nTrackParticles(); ++i) {
+ boost::format f2("\n%s %4d %s");
+ f2 % sind % i
+ % idTrackToString(vtx->trackParticle(i), 0, false, false);
+ str += f2.str();
+ } // for
+ }
+
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Print refitted PV information to string -- optionally adding tracks
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::refPVToString(const xAOD::Vertex* vtx,
+ unsigned int indent,
+ bool withTracks) {
+
+ std::string sind(indent, ' ');
+ boost::format f1("%s %-5s %p (%10.4f, %10.4f, %10.4f) NT %4d VT %d");
+ f1 % sind % refPVName(vtx) % vtx % vtx->x() % vtx->y() % vtx->z()
+ % vtx->nTrackParticles() % vtx->vertexType();
+ std::string str = f1.str();
+ if ( withTracks ) {
+ for (size_t i=0; i < vtx->nTrackParticles(); ++i) {
+ boost::format f2("\n%s %4d %s");
+ f2 % sind % i
+ % idTrackToString(vtx->trackParticle(i), 0, false, false);
+ str += f2.str();
+ } // for
+ }
+
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Print SV information to string -- optionally adding tracks
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::svToString(const xAOD::Vertex* vtx,
+ unsigned int indent,
+ bool withTracks,
+ bool withMasses) {
+
+ std::string sind(indent, ' ');
+ boost::format f1("%s %-5s %p (%10.4f, %10.4f, %10.4f) NT %4d VT %d");
+ f1 % sind % svName(vtx) % vtx % vtx->x() % vtx->y() % vtx->z()
+ % vtx->nTrackParticles() % vtx->vertexType();
+ std::string str = f1.str();
+ if ( withMasses && m_hypoName != "__NONE__" ) {
+ // vector of possible hypo names
+ std::vector<std::string> hypoNames = getTokens(m_hypoName, "|;/");
+ for ( auto hypoName : hypoNames ) {
+ BPhysHypoHelper bhh(hypoName, vtx);
+ float bMass = bhh.mass();
+ float bMassErr = bhh.massErr();
+ float bMucMass = getFloat(hypoName+"_MUCALC_mass", vtx);
+ float bMucMassErr = getFloat(hypoName+"_MUCALC_massErr", vtx);
+ if ( bMass > 0. || bMassErr > 0.
+ || bMucMass > 0. || bMucMassErr > 0. ) {
+ boost::format f3("\n%s %-10s : mass : (%15.4f +/- %15.4f) MeV");
+
+ boost::format f4("\n%s %-10s : m(MUCALC): (%15.4f +/- %15.4f) MeV");
+ f3 % sind % hypoName % bMass % bMassErr;
+ f4 % sind % hypoName % bMucMass % bMucMassErr;
+ str += f3.str() + f4.str();
+ } // if one > 0.
+ } // for hypoNames
+ } // if withMasses
+ if ( withTracks ) {
+ for (size_t i=0; i < vtx->nTrackParticles(); ++i) {
+ boost::format f2("\n%s %4d %s");
+ f2 % sind % i
+ % idTrackToString(vtx->trackParticle(i), 0, false, false);
+ str += f2.str();
+ } // for
+ }
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Print track container information to string
+ // -- optionally adding PVs and refitted PVs
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::idTracksToString(const xAOD::TrackParticleContainer*
+ tpc,
+ unsigned int indent,
+ bool withPV,
+ bool withRefPV,
+ bool withSV) {
+
+ std::string str;
+ std::string sind(indent, ' ');
+ str += sind + "ID tracks: (" + std::to_string(tpc->size()) + ")\n";
+ str += sind + std::string(80-indent, '-');
+ // loop over ID tracks
+ for (xAOD::TrackParticleContainer::const_iterator trkItr = tpc->begin();
+ trkItr != tpc->end(); ++trkItr) {
+ const xAOD::TrackParticle* track = *trkItr;
+ str += "\n"
+ + idTrackToString(track, indent+2, withPV, withRefPV, withSV);
+ }
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Print PV container information to string -- optionally adding tracks
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::pvsToString(const xAOD::VertexContainer* pvc,
+ unsigned int indent,
+ bool withTracks) {
+
+ std::string str;
+ std::string sind(indent, ' ');
+ str += sind + "Primary vertices: (" + std::to_string(pvc->size()) + ")\n";
+ str += sind + std::string(80-indent, '-');
+ for (xAOD::VertexContainer::const_iterator vtxItr = pvc->begin();
+ vtxItr != pvc->end(); ++vtxItr) {
+ const xAOD::Vertex* vtx = *vtxItr;
+ str += "\n" + pvToString(vtx, indent+2, withTracks);
+ } // for
+
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Print refitted PV container information to string
+ // -- optionally adding tracks
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::refPVsToString(const xAOD::VertexContainer* rpvc,
+ unsigned int indent,
+ bool withTracks) {
+
+ std::string str;
+ std::string sind(indent, ' ');
+ str += sind + "Refitted primary vertices: (" + std::to_string(rpvc->size()) + ")\n";
+ str += sind + std::string(80-indent, '-');
+ for (xAOD::VertexContainer::const_iterator vtxItr = rpvc->begin();
+ vtxItr != rpvc->end(); ++vtxItr) {
+ const xAOD::Vertex* vtx = *vtxItr;
+ str += "\n" + refPVToString(vtx, indent+2, withTracks);
+ } // for
+
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Print SV container information to string -- optionally adding tracks
+ //--------------------------------------------------------------------------
+ std::string
+ BPhysTrackVertexMapTool::svsToString(const xAOD::VertexContainer* svc,
+ unsigned int indent,
+ bool withTracks,
+ bool withMasses) {
+
+ std::string str;
+ std::string sind(indent, ' ');
+ str += sind + "Secondary vertices: (" + std::to_string(svc->size()) + ")\n";
+ str += sind + std::string(80-indent, '-');
+ for (xAOD::VertexContainer::const_iterator vtxItr = svc->begin();
+ vtxItr != svc->end(); ++vtxItr) {
+ const xAOD::Vertex* vtx = *vtxItr;
+ str += "\n" + svToString(vtx, indent+2, withTracks, withMasses);
+ } // for
+
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Print a summary of all maps to string -- optionally adding a prefix
+ //--------------------------------------------------------------------------
+ std::string BPhysTrackVertexMapTool::summaryToString(std::string prefix) {
+
+ boost::format form("%s\n\nRun: %d Event: %d\n\n");
+ form % name() % m_cachedRun % m_cachedEvent;
+ std::string dstr =
+ wrapLines("\n"+form.str() +
+ pvsToString(m_pvtxContainer, 0, true) + "\n\n" +
+ refPVsToString(m_refPVContainer, 0, true) + "\n\n" +
+ svsToString(m_svtxContainer, 0, true, true) + "\n\n" +
+ idTracksToString(m_tracks, 0, true, true, true) + "\n",
+ prefix);
+
+ return dstr;
+ }
+ //--------------------------------------------------------------------------
+ // Pick up a float from StoreGate.
+ //--------------------------------------------------------------------------
+ float BPhysTrackVertexMapTool::getFloat(std::string name,
+ const xAOD::Vertex* b) {
+
+ float res = -999999.;
+
+ SG::AuxElement::Accessor<float> floatAcc(name);
+ if ( floatAcc.isAvailable(*b) ) res = floatAcc(*b);
+
+ return res;
+ }
+ //--------------------------------------------------------------------------
+ // Tokenize a string using certain separators
+ //--------------------------------------------------------------------------
+ std::vector<std::string> BPhysTrackVertexMapTool
+ ::getTokens(std::string input, std::string seperators) {
+
+ std::vector<std::string> tokens;
+ boost::char_separator<char> sep(seperators.c_str());
+ typedef boost::tokenizer<boost::char_separator<char> > Tokenizer_t;
+ Tokenizer_t tokenizer(input, sep);
+ for (auto& token : tokenizer) {
+ tokens.push_back(token);
+ }
+ return tokens;
+ }
+ //--------------------------------------------------------------------------
+} // namespace xAOD
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/Root/SimpleEncrypter.cxx b/PhysicsAnalysis/BPhys/BPhysTools/Root/SimpleEncrypter.cxx
new file mode 100644
index 00000000000..77cc5475f19
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/Root/SimpleEncrypter.cxx
@@ -0,0 +1,516 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+// system include:
+#include <climits>
+#include <vector>
+#include <algorithm>
+#include <cstdlib>
+#include <ctime>
+#include <cmath>
+
+// ROOT includes
+#include <TString.h>
+
+// Local include(s):
+#include "BPhysTools/SimpleEncrypter.h"
+
+namespace xAOD {
+
+ //--------------------------------------------------------------------------
+ // Private static constants
+ //--------------------------------------------------------------------------
+ const SimpleEncrypter::ULLI_t SimpleEncrypter::m_MAXRANGE =
+ (SimpleEncrypter::ULLI_t)pow(std::numeric_limits<ULLI_t>::max(), 0.25);
+ const SimpleEncrypter::ULLI_t SimpleEncrypter::m_MINRANGE =
+ (SimpleEncrypter::ULLI_t)SimpleEncrypter::m_MAXRANGE/10;
+ const unsigned int SimpleEncrypter::m_MAXHEXDIGITS =
+ (unsigned int)(log(pow(SimpleEncrypter::m_MAXRANGE,2))/log(16.))+3;
+
+ //--------------------------------------------------------------------------
+ // Public methods
+ //--------------------------------------------------------------------------
+
+ //--------------------------------------------------------------------------
+ // Constructor
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::SimpleEncrypter(const std::string& name) :
+ asg::AsgMessaging(name), m_n(0), m_e(0), m_d(0),
+ m_isOkForEnc(false), m_isOkForDec(false) {
+
+ // initialize random number generator
+ srand(static_cast<unsigned>(time(0)));
+ }
+
+ //--------------------------------------------------------------------------
+ // Destructor
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::~SimpleEncrypter() {
+
+ }
+
+ //--------------------------------------------------------------------------
+ // Generation of key pair as pair of hex strings
+ //--------------------------------------------------------------------------
+ std::pair<std::string, std::string> SimpleEncrypter::genKeyPair() {
+
+ // default preset
+ std::pair<std::string, std::string> keys =
+ std::make_pair("__NO_PRIV_KEY__", "__NO_PUB_KEY__");
+
+ // generate keys
+ genKeyPairInternal();
+
+ if ( isOkForEnc() && isOkForDec() ) {
+ keys = std::make_pair(getPrivKey(), getPubKey());
+ }
+ return keys;
+ }
+
+ //--------------------------------------------------------------------------
+ // Set private key
+ //--------------------------------------------------------------------------
+ void SimpleEncrypter::setPrivKey(std::string keystr) {
+
+ std::pair<ULLI_t, ULLI_t> keys = decodeKeyString(keystr);
+
+ if ( m_n > 0 && m_n != keys.first ) {
+ ATH_MSG_WARNING("RSA module already set!");
+ }
+ m_n = keys.first;
+ m_d = keys.second;
+ m_isOkForDec = false;
+ }
+ //--------------------------------------------------------------------------
+ // Set public key
+ //--------------------------------------------------------------------------
+ void SimpleEncrypter::setPubKey(std::string keystr) {
+
+ std::pair<ULLI_t, ULLI_t> keys = decodeKeyString(keystr);
+
+ if ( m_n > 0 && m_n != keys.second ) {
+ ATH_MSG_WARNING("RSA module already set!");
+ }
+ m_e = keys.first;
+ m_n = keys.second;
+ m_isOkForEnc = false;
+ }
+ //--------------------------------------------------------------------------
+ // Get private key
+ //--------------------------------------------------------------------------
+ std::string SimpleEncrypter::getPrivKey() const {
+
+ return keyToString(m_n, m_d);
+ }
+ //--------------------------------------------------------------------------
+ // Get public key
+ //--------------------------------------------------------------------------
+ std::string SimpleEncrypter::getPubKey() const {
+
+ return keyToString(m_e, m_n);
+ }
+ //--------------------------------------------------------------------------
+ // Encrypt unsigned integer value
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::encrypt(ULLI_t a) {
+
+ ULLI_t b = a;
+
+ if ( isOkForEnc() ) {
+ b = encryptFPECycle(a);
+ }
+ return b;
+ }
+ //--------------------------------------------------------------------------
+ // Decrypt unsigned integer value
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::decrypt(ULLI_t a) {
+
+ ULLI_t b = a;
+
+ if ( isOkForDec() ) {
+ b = decryptFPECycle(a);
+ }
+ return b;
+ }
+ //--------------------------------------------------------------------------
+ // Encrypt positive float value
+ //--------------------------------------------------------------------------
+ float SimpleEncrypter::encrypt(float a) {
+
+ float b = a;
+
+ if ( a > 0. ) {
+ if ( isOkForEnc() ) {
+ ULLI_t ia = floatBitsToInt(a);
+ ULLI_t ib = encryptFPECycle(ia);
+ b = intBitsToFloat(ib);
+ }
+ } else {
+ ATH_MSG_WARNING("Encrypt: Float value not positive: "
+ << a << Form(" (%a) !", a));
+ } // if a > 0
+ return b;
+ }
+
+ //--------------------------------------------------------------------------
+ // Decrypt positive float value
+ //--------------------------------------------------------------------------
+ float SimpleEncrypter::decrypt(float a) {
+
+ float b = a;
+
+ // As nan is a valid encrypted value, decrypt it as well.
+ if ( a > 0. || std::isnan(a) ) {
+ if ( isOkForDec() ) {
+ ULLI_t ia = floatBitsToInt(a);
+ ULLI_t ib = decryptFPECycle(ia);
+ b = intBitsToFloat(ib);
+ }
+ } else {
+ ATH_MSG_WARNING("Decrypt: Float value not positive: "
+ << a << Form(" (%a) !", a));
+ } // if a > 0
+ return b;
+ }
+
+ //--------------------------------------------------------------------------
+ // Private methods
+ //--------------------------------------------------------------------------
+
+ //--------------------------------------------------------------------------
+ // Generate numeric representation of the keys
+ //--------------------------------------------------------------------------
+ void SimpleEncrypter::genKeyPairInternal() {
+
+ // Generate prime numbers p != q
+ ULLI_t p(1);
+ ULLI_t q(1);
+ // Euler's phi function
+ ULLI_t phi(1);
+
+ // reset encryption and decryption exponent
+ m_e = 0;
+ m_d = 0;
+ while ( p == q || m_e < 2 || m_e >= phi || m_d < 2
+ || m_e*m_d % phi != 1 ) {
+ double dlog2 = 0.;
+ while ( p == q || dlog2 < 0.1 || dlog2 > 30. ) {
+ p = genPrime();
+ q = genPrime();
+ dlog2 = fabs(log2(p)-log2(q));
+ } // inner while loop
+ phi = (p-1)*(q-1);
+ m_n = p*q;
+ m_e = genCoprime(phi);
+ m_d = genDecryptionExponent(phi, m_e);
+ } // outer while loop
+ m_isOkForDec = false;
+ m_isOkForEnc = false;
+ }
+ //--------------------------------------------------------------------------
+ // Find a prime number
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::genPrime() const {
+
+ ULLI_t t = (m_MINRANGE + rand()) % (m_MAXRANGE-1);
+ do {
+ t++;
+ } while ( !isPrime(t) || t < m_MINRANGE );
+ return t;
+ }
+ //--------------------------------------------------------------------------
+ // Test for being a prime number
+ //--------------------------------------------------------------------------
+ bool SimpleEncrypter::isPrime(ULLI_t n) const {
+
+ bool isPrime = true;
+ if (n != 2) {
+ for (LLI_t i = 2; i < (LLI_t)sqrt(n) + 1; ++i) {
+ if (n % i == 0) {
+ isPrime = false;
+ break;
+ }
+ }
+ }
+ return isPrime;
+ }
+ //--------------------------------------------------------------------------
+ // Greatest common denominator
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t
+ SimpleEncrypter::greatestCommonDenominator(ULLI_t n1, ULLI_t n2) const {
+
+ std::vector<LLI_t> r;
+ LLI_t i = 1;
+ r.push_back(std::max(n1, n2));
+ r.push_back(std::min(n1, n2));
+ while (r[i] != 0) {
+ ++i;
+ r.push_back(r[i-2] % r[i-1]);
+ }
+ return r[i-1];
+ }
+ //--------------------------------------------------------------------------
+ // Find coprime number
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::genCoprime(ULLI_t n) const {
+
+ // make sure coprime is larger than 5th Fermat number (2^16+1 = 65537)
+ ULLI_t i = (65537 + rand()) % (m_MAXRANGE -1);
+ do {
+ ++i;
+ } while (greatestCommonDenominator(n, i) != 1);
+ return i;
+ }
+ //--------------------------------------------------------------------------
+ // Find decryption exponent
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t
+ SimpleEncrypter::genDecryptionExponent(ULLI_t phi, ULLI_t e) const {
+
+ for (ULLI_t i=1; i<m_MAXRANGE; ++i) {
+ if ( ((phi * i + 1) % e) == 0 ) {
+ return (ULLI_t)((phi * i + 1) / e);
+ }
+ }
+ return 0;
+ }
+ //--------------------------------------------------------------------------
+ // Convert key to a hex string
+ //--------------------------------------------------------------------------
+ std::string SimpleEncrypter::keyToString(ULLI_t a, ULLI_t b) const {
+
+ // length of keys w.r.t. hex digits
+ unsigned int ra = (unsigned int)(log(a)/log(16.))+1;
+ unsigned int rb = (unsigned int)(log(b)/log(16.))+1;
+
+ // random numbers for padding
+ unsigned int r1 = rand() & ((1 << 4*(m_MAXHEXDIGITS-ra))-1);
+ unsigned int r2 = rand() & ((1 << 4*(m_MAXHEXDIGITS-rb))-1);
+
+ // format string
+ TString tstr = Form("%02x%02x%02x%0*x%0*llx%0*x%0*llx",
+ m_MAXHEXDIGITS, ra, rb,
+ m_MAXHEXDIGITS-ra, r1, ra, a,
+ m_MAXHEXDIGITS-rb, r2, rb, b);
+
+ return std::string(tstr.Data());
+ }
+ //--------------------------------------------------------------------------
+ // Convert hex string to two integers
+ //--------------------------------------------------------------------------
+ std::pair<SimpleEncrypter::ULLI_t, SimpleEncrypter::ULLI_t>
+ SimpleEncrypter::decodeKeyString(std::string hstr) const {
+
+ std::pair<ULLI_t, ULLI_t> keys(0,0);
+
+ TString str(hstr);
+ if (str.IsHex() && str.Length() > 3) {
+ str.ToLower();
+ unsigned int ndigits = strtoul(TString(str(0,2)).Data(), nullptr, 16);
+ unsigned int ra = strtoul(TString(str(2,2)).Data(), nullptr, 16);
+ unsigned int rb = strtoul(TString(str(4,2)).Data(), nullptr, 16);
+ if ( str.Length() == (int)(2*ndigits + 6) ) {
+ keys.first = strtoll(TString(str(ndigits+6-ra, ra)).Data(),
+ nullptr, 16);
+ keys.second = strtoll(TString(str(2*ndigits+6-rb, rb)).Data(),
+ nullptr, 16);
+ } else {
+ ATH_MSG_ERROR("Private/public key must be a hex string of " <<
+ 2*m_MAXHEXDIGITS+6 << " digits!");
+ } // if Length()
+ } else {
+ ATH_MSG_ERROR("Private/public key must be a hex string of " <<
+ 2*m_MAXHEXDIGITS+6 << " digits!");
+ } // if IsHex() ...
+
+ return keys;
+ }
+ //--------------------------------------------------------------------------
+ // Interpret bits of positive floating point number as integer
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::floatBitsToInt(float val) const {
+
+ ULLI_t res(0);
+
+ if ( val < 0. ) {
+ ATH_MSG_ERROR("Float value needs to be positive!");
+ } else {
+ // convert floating point number to ULLI_t if size fits
+ if ( sizeof(float) <= sizeof(ULLI_t) ) {
+ // check whether a quick conversion is possible
+ if ( sizeof(float) == sizeof(int) ) {
+ int* p = reinterpret_cast<int*>(&val);
+ res = *p;
+ } else {
+ // do a slow conversion
+ char* pval = reinterpret_cast<char*>(&val);
+ // loop over bytes
+ for (unsigned int i=0; i<sizeof(float); ++i) {
+ // loop over bits
+ for (unsigned int j=0; j<CHAR_BIT; ++j) {
+ unsigned int n = i*CHAR_BIT + j;
+ unsigned int bit = (*(pval+i) >> j) & 1;
+ if ( bit > 0 ) res |= 1 << n;
+ } // for bits
+ } // for bytes
+ } // if sizeof
+ } else {
+ ATH_MSG_ERROR("sizeof(float) > sizeof(ULLI_t): "
+ << sizeof(float) << " > " << sizeof(LLI_t));
+ } // if sizeof
+ } // if val < 0.
+
+ return res;
+ }
+ //--------------------------------------------------------------------------
+ // Interpret bits of positive integer as floating point number
+ //--------------------------------------------------------------------------
+ float SimpleEncrypter::intBitsToFloat(ULLI_t val) const {
+
+ float res(0.);
+
+ // number of bits needed
+ unsigned int r = (int)(std::log2(val))+1;
+
+ // convert ULLI_t to floating point number if size fits
+ if ( sizeof(float)*CHAR_BIT >= r ) {
+ // check whether a quick conversion is possible
+ if ( sizeof(float) == sizeof(int) ) {
+ float* p = reinterpret_cast<float*>(&val);
+ res = *p;
+ } else {
+ // do a slow conversion
+ char* pres = reinterpret_cast<char*>(&res);
+ // loop over bytes
+ for (unsigned int i=0; i<sizeof(float); ++i) {
+ // loop over bits
+ for (unsigned int j=0; j<CHAR_BIT; ++j) {
+ unsigned int n = i*CHAR_BIT + j;
+ unsigned int bit = (val >> n) & 1;
+ if ( bit > 0 ) *(pres+i) |= 1 << j;
+ } // for bits
+ } // for bytes
+ } // if sizeof
+ } else {
+ ATH_MSG_WARNING("sizeof(float)*CHAR_BIT < r: "
+ << sizeof(float)*CHAR_BIT << " < " << r);
+ } // if sizeof
+
+ return res;
+ }
+ //--------------------------------------------------------------------------
+ // Encrypt using format preserving encryption w.r.t. RSA modulus
+ // via cycling
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::encryptFPECycle(ULLI_t a) const {
+
+ ULLI_t enc = 0;
+ if ( a > 0 ) {
+ ULLI_t r = (int)(std::log2(m_n));
+ ULLI_t rmask = pow(2,r)-1;
+ ULLI_t c = a & rmask;
+ ULLI_t b = a - c;
+ do {
+ c = encryptInternal(c);
+ } while ( c > rmask );
+ enc = b + c;
+ } // if
+ return enc;
+ }
+ //--------------------------------------------------------------------------
+ // Decrypt using format preserving encryption w.r.t. RSA modulus
+ // via cycling
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::decryptFPECycle(ULLI_t enc) const {
+
+ ULLI_t dec = 0;
+ if ( enc > 0 ) {
+ ULLI_t r = (int)(std::log2(m_n));
+ ULLI_t rmask = pow(2,r)-1;
+ ULLI_t d = enc & rmask;
+ ULLI_t b = enc - d;
+ do {
+ d = decryptInternal(d);
+ } while ( d > rmask );
+ dec = d + b;
+ } // if
+ return dec;
+ }
+ //--------------------------------------------------------------------------
+ // Encrypt integer
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::encryptInternal(ULLI_t x) const {
+
+ return powerMod(x, m_e, m_n);
+ }
+ //--------------------------------------------------------------------------
+ // Decrypt integer
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t SimpleEncrypter::decryptInternal(ULLI_t x) const {
+
+ return powerMod(x, m_d, m_n);
+ }
+ //--------------------------------------------------------------------------
+ // Exponentiate a with d observing modulus n
+ //--------------------------------------------------------------------------
+ SimpleEncrypter::ULLI_t
+ SimpleEncrypter::powerMod(ULLI_t a, ULLI_t d, ULLI_t n) const {
+
+ int bin[sizeof(ULLI_t)*CHAR_BIT];
+ ULLI_t dec[sizeof(ULLI_t)*CHAR_BIT];
+
+ ULLI_t r = (ULLI_t)(std::log2(d))+1;
+ ULLI_t tmp = d;
+ // decompose exponent into binary number (reverse order!)
+ for (ULLI_t i=0; i < r; ++i) {
+ bin[r-i-1] = tmp % 2;
+ tmp = (LLI_t)(tmp/2);
+ } // for i
+
+ // perform the exponentiation taking modulus into account
+ dec[0] = a;
+ for (ULLI_t i=1; i < r; ++i) {
+ ULLI_t d2 = dec[i-1]*dec[i-1] % n;
+ if ( bin[i] > 0 ) d2 *= a;
+ dec[i] = d2 % n;
+ } // for i
+
+ return dec[r-1];
+ }
+ //--------------------------------------------------------------------------
+ // Check setup readiness for encryption
+ //--------------------------------------------------------------------------
+ bool SimpleEncrypter::isOkForEnc() {
+
+ if ( !m_isOkForEnc ) {
+ if ( m_n > 0 && m_e > 1 && m_e < m_n ) {
+ m_isOkForEnc = true;
+ } else {
+ ATH_MSG_ERROR("Setup not OK for encryption: public key set?");
+ }
+ } // if ! m_isOkForEnc
+
+ return m_isOkForEnc;
+ }
+
+ //--------------------------------------------------------------------------
+ // Check setup readiness for decryption
+ //--------------------------------------------------------------------------
+ bool SimpleEncrypter::isOkForDec() {
+
+ if ( !m_isOkForDec ) {
+ if ( m_n > 0 && m_d > 1 && m_d < m_n ) {
+ m_isOkForDec = true;
+ } else {
+ ATH_MSG_ERROR("Setup not OK for decryption: private key set?");
+ }
+ } // if ! m_isOkForDec
+
+ return m_isOkForDec;
+ }
+
+ //--------------------------------------------------------------------------
+} // namespace xAOD
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/src/components/BPhysTools_entries.cxx b/PhysicsAnalysis/BPhys/BPhysTools/src/components/BPhysTools_entries.cxx
new file mode 100644
index 00000000000..2298acdeb10
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/src/components/BPhysTools_entries.cxx
@@ -0,0 +1,4 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
diff --git a/PhysicsAnalysis/BPhys/BPhysTools/util/createBlindingKeys.cxx b/PhysicsAnalysis/BPhys/BPhysTools/util/createBlindingKeys.cxx
new file mode 100644
index 00000000000..3be9cb51430
--- /dev/null
+++ b/PhysicsAnalysis/BPhys/BPhysTools/util/createBlindingKeys.cxx
@@ -0,0 +1,83 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file creteBlindingKeys.cxx
+ * @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ *
+ * @brief Utility to create a set of blinding keys
+ *
+ * @param[in] option: -c : perform a quick encoding/decoding check
+ */
+
+// system includes:
+#include <iostream>
+#include <iomanip>
+#include <set>
+#include <string>
+#include <cstdlib>
+#include <ctime>
+
+// Local include(s):
+#include "BPhysTools/SimpleEncrypter.h"
+
+int main(int argc, char* argv[]) {
+
+ // Enable check (-c flag)
+ bool doCheck(false);
+ int nChecks(1);
+ if ( argc > 1 ) {
+ std::string arg(argv[1]);
+ if ( arg == "-c" ) doCheck = true;
+ }
+ if ( argc > 2 ) {
+ nChecks = atoi(argv[2]);
+ }
+
+ // Helper object
+ xAOD::SimpleEncrypter senc;
+
+ // Create key pair
+ std::pair<std::string, std::string> keys = senc.genKeyPair();
+
+ std::cout << std::endl;
+ std::cout << "Blinding keys generated:" << std::endl;
+ std::cout << " Private key: " << keys.first << std::endl;
+ std::cout << " Public key: " << keys.second << std::endl;
+ std::cout << std::endl;
+
+ // check that encryption works
+ if ( doCheck ) {
+ srand(static_cast<unsigned>(time(0)));
+
+ std::cout << "Encryption test:" << std::endl;
+ int nOK(0);
+ for (int i=0; i<nChecks; ++i) {
+ float val = 10000.*
+ static_cast <float>(rand())/(static_cast <float> (RAND_MAX));
+ // float val = 5267.23;
+ float enc = senc.encrypt(val);
+ float dec = senc.decrypt(enc);
+ if ( dec == val ) ++nOK;
+ if ( i == 0 || dec != val ) {
+ std::cout << " Test # " << i << std::endl;
+ std::cout << " val = " << val << std::endl;
+ std::cout << " enc = " << enc << std::endl;
+ std::cout << " dec = " << dec << std::endl;
+ if ( dec == val ) {
+ std::cout << " => worked!" << std::endl;
+ } else {
+ std::cout << " => FAILED!" << std::endl;
+ }
+ } // if
+ } // for
+ std::cout << std::endl;
+ std::cout << "Summary:" << std::endl;
+ std::cout << " nChecks: " << std::setw(12) << nChecks << std::endl;
+ std::cout << " nOK : " << std::setw(12) << nOK << std::endl;
+ std::cout << " nFailed: " << std::setw(12) << nChecks - nOK << std::endl;
+ } // if
+
+ exit(0);
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/CMakeLists.txt b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/CMakeLists.txt
new file mode 100644
index 00000000000..357dae19e36
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/CMakeLists.txt
@@ -0,0 +1,26 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+################################################################################
+# Package: DerivationFrameworkBPhys
+################################################################################
+
+# Declare the package name:
+atlas_subdir( DerivationFrameworkBPhys )
+find_package( ROOT COMPONENTS Core MathCore )
+
+# Component(s) in the package:
+atlas_add_component( DerivationFrameworkBPhys
+ DerivationFrameworkBPhys/*.h src/*.cxx src/components/*.cxx
+ INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
+ LINK_LIBRARIES xAODMuon AthenaBaseComps JpsiUpsilonToolsLib
+ MuonSelectorToolsLib ${ROOT_LIBRARIES}
+ xAODTracking xAODBPhysLib AthenaKernel RecoToolInterfaces EventPrimitives
+ DerivationFrameworkInterfaces BPhysToolsLib TrackVertexAssociationToolLib
+ xAODBase xAODMetaData AsgTools CaloInterfaceLib TrackToCaloLib
+ xAODEventInfo AthenaPoolUtilities xAODPrimitives TrigDecisionToolLib
+ BeamSpotConditionsData TrkVertexAnalysisUtilsLib ITrackToVertex
+ InDetTrackSelectionToolLib InDetV0FinderLib)
+
+
+# Install files from the package:
+atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8})
+atlas_install_joboptions( share/*.py )
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/AugOriginalCounts.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/AugOriginalCounts.h
new file mode 100644
index 00000000000..47c5b166c79
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/AugOriginalCounts.h
@@ -0,0 +1,91 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file AugOriginalCounts.h
+ *
+ * @brief Augmentation with primary vertex counts (before thinning)
+ */
+
+#ifndef DERIVATIONFRAMEWORKBPHYS_AUGORIGINALCOUNTS_H
+#define DERIVATIONFRAMEWORKBPHYS_AUGORIGINALCOUNTS_H
+
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "StoreGate/WriteDecorHandleKey.h"
+
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODEventInfo/EventInfo.h"
+
+#include <string>
+
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/VertexContainer.h"
+#include <string>
+#include "xAODEventInfo/EventInfo.h"
+#include <StoreGate/WriteDecorHandleKey.h>
+
+namespace DerivationFramework {
+ ///
+ /// @class AugOriginalCounts
+ ///
+ /// @brief Augmentation with primary vertex counts (before thinning)
+ ///
+ /// This tool adds primary vertex counts and track counts
+ /// to the EventInfo container in order to preserve them in
+ /// case the primary vertex or track collections are thinned.
+ ///
+ /// ### Job options
+ /// <table border="0">
+ /// <tr><th align="left">Name</td>
+ /// <th align="left">Description</th></tr>
+ /// <tr><td>TrackContainer</td>
+ /// <td>name of the TrackParticle container to be used</td>
+ /// </tr>
+ /// <tr><td>VertexContainer</td>
+ /// <td>name of the Vertex container to be used</td>
+ /// </tr>
+ /// <tr><td>AddPVCountsByType</td>
+ /// <td>add PV counts by PV type (default: false)</td>
+ /// </td>
+ /// </table>
+ ///
+ class AugOriginalCounts : public AthAlgTool, public IAugmentationTool {
+ public:
+ /// @brief Main constructor
+ AugOriginalCounts(const std::string& t, const std::string& n,
+ const IInterface* p);
+ /// @brief Main method called for each event
+ virtual StatusCode addBranches() const override;
+ virtual StatusCode initialize() override;
+ private:
+ ///
+ /// @name job options
+ /// @{
+ SG::WriteDecorHandleKey<xAOD::EventInfo> m_OrigPVNTracks{this, "DO_NOT_SET1", "", "internal property"};
+ SG::WriteDecorHandleKey<xAOD::EventInfo> m_OrigNTracksKeys{this, "DO_NOT_SET2", "", "internal property"};
+ SG::WriteDecorHandleKey<xAOD::EventInfo> m_OrigNtype0{this, "DO_NOT_SET3", "", "internal property"};
+ SG::WriteDecorHandleKey<xAOD::EventInfo> m_OrigNtype1{this, "DO_NOT_SET4", "", "internal property"};
+ SG::WriteDecorHandleKey<xAOD::EventInfo> m_OrigNtype2{this, "DO_NOT_SET5", "", "internal property"};
+ SG::WriteDecorHandleKey<xAOD::EventInfo> m_OrigNtype3{this, "DO_NOT_SET6", "", "internal property"};
+ SG::WriteDecorHandleKey<xAOD::EventInfo> m_OrigNtypeUnknown{this, "DO_NOT_SET7", "", "internal property"};
+
+ SG::WriteDecorHandleKey<xAOD::VertexContainer> m_OrigSqrtPt2Sum{this, "DO_NOT_SET8", "", "internal property"};
+ SG::WriteDecorHandleKey<xAOD::VertexContainer> m_d_nPVTracks{this, "DO_NOT_SET9", "", "internal property"};
+ SG::ReadHandleKey<xAOD::TrackParticleContainer> m_TrackContainername;
+ SG::ReadHandleKey<xAOD::VertexContainer> m_PVContainername;
+ bool m_addPVCountsByType;
+ bool m_addNTracksToPVs;
+ bool m_addSqrtPt2SumToPVs;
+ /// @}
+ };
+}
+
+#endif // DERIVATIONFRAMEWORKBPHYS_AUGORIGINALCOUNTS_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BMuonTrackIsoTool.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BMuonTrackIsoTool.h
new file mode 100644
index 00000000000..b670df14553
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BMuonTrackIsoTool.h
@@ -0,0 +1,111 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BMuonTrackIsoTool.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Add muon track isolation information for different configurations,
+// different track selections and different PV-to-SV association methods.
+//
+// For an usage example see BPHY8.py .
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_BMuonTrackIsoTool_H
+#define DERIVATIONFRAMEWORK_BMuonTrackIsoTool_H
+
+#include "DerivationFrameworkBPhys/BPhysVertexTrackBase.h"
+#include "xAODMuon/MuonContainer.h"
+#include "boost/multi_array.hpp"
+
+namespace InDet {
+ class IInDetTrackSelectionTool;
+}
+
+namespace DerivationFramework {
+
+ class BMuonTrackIsoTool : virtual public BPhysVertexTrackBase {
+
+ private:
+ typedef BPhysVertexTrackBase super;
+
+ //
+ // internal helper class
+ //
+ protected:
+ class MuIsoItem : public BaseItem {
+
+ public:
+ MuIsoItem(std::string Name="_none_", std::string Bname="muiso",
+ std::string Prefix="");
+ virtual ~MuIsoItem();
+
+ virtual void resetVals();
+ virtual void copyVals(const BaseItem& item);
+ virtual void copyVals(const MuIsoItem& item);
+ virtual void fill(double isoValue=-2., int nTracks=-1,
+ const xAOD::Muon* muon=NULL);
+ virtual std::string muIsoName();
+ virtual std::string nTracksName();
+ virtual std::string muLinkName();
+
+ public:
+ mutable std::vector<float> vIsoValues;
+ mutable std::vector<int> vNTracks;
+ mutable MuonBag vMuons;
+ }; // MuIsoItem
+
+ public:
+ BMuonTrackIsoTool(const std::string& t, const std::string& n,
+ const IInterface* p);
+
+ protected:
+ // Hook methods
+ virtual StatusCode initializeHook();
+ virtual StatusCode finalizeHook();
+
+ virtual StatusCode addBranchesVCSetupHook(size_t ivc) const;
+
+ virtual StatusCode addBranchesSVLoopHook(const xAOD::Vertex* vtx) const;
+
+ virtual StatusCode calcValuesHook(const xAOD::Vertex* vtx,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const;
+ virtual bool fastFillHook(const xAOD::Vertex* vtx,
+ const int ipv) const;
+
+ private:
+ virtual StatusCode saveIsolation(const xAOD::Vertex* vtx) const;
+ virtual void initResults();
+ virtual void setResultsPrefix(std::string prefix) const;
+
+ virtual std::string buildBranchName(unsigned int ic,
+ unsigned int its,
+ unsigned int ipv,
+ unsigned int itt) const;
+
+ private:
+ // job options
+ std::string m_muonContainerName;
+ std::vector<double> m_isoConeSizes;
+ std::vector<double> m_isoTrkImpLogChi2Max;
+ std::vector<int> m_isoDoTrkImpLogChi2Cut;
+
+ // containers
+ mutable const xAOD::MuonContainer* m_muons;
+
+
+ // results array
+ typedef boost::multi_array<MuIsoItem, 4> MuIsoItem4_t;
+ mutable MuIsoItem4_t m_results;
+
+ }; // BMuonTrackIsoTool
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_BMuonTrackIsoTool_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysAddMuonBasedInvMass.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysAddMuonBasedInvMass.h
new file mode 100644
index 00000000000..3b87f752824
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysAddMuonBasedInvMass.h
@@ -0,0 +1,304 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file BPhysAddMuonBasedInvMass.h
+ * @author Wolfgang Walkowiak <wolfgang.walkowiak@cern.ch>
+ *
+ * @brief Augmentation with muon-information based invariant mass.
+ *
+ */
+//
+#ifndef DERIVATIONFRAMEWORK_BPhysAddMuonBasedInvMass_H
+#define DERIVATIONFRAMEWORK_BPhysAddMuonBasedInvMass_H
+
+#include <string>
+#include <vector>
+#include <set>
+#include <map>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "EventPrimitives/EventPrimitives.h"
+#include "ITrackToVertex/ITrackToVertex.h"
+
+namespace DerivationFramework {
+ //
+ // typedefs -- to abbreviate long lines
+ //
+ typedef std::vector<const xAOD::TrackParticle*> TrackBag;
+ typedef std::vector<const xAOD::Muon*> MuonBag;
+
+ ///
+ /// @class BPhysAddMuonBasedInvMass
+ /// @author Wolfgang Walkowiak <wolfgang.walkowiak@cern.ch>
+ ///
+ /// @brief Augment secondary vertices with muon-information-based mass.
+ ///
+ /// Add muon-information based invarient mass to secondary vertices using
+ /// a four vector sum. Optionally, it also calculates the minimum
+ /// chi2 for all muon tracks of the secondary vertex candidate w.r.t.
+ /// any primary vertex matching the selection criteria.
+ ///
+ /// ### Job options provided by this class:
+ /// <table border="0">
+ /// <tr><th align="left">Name</th>
+ /// <th align="left">Description</th>
+ /// </tr>
+ /// <tr><td>BranchPrefix</td>
+ /// <td>assign the prefix of added branches
+ /// (possibly the derivation format's name)</td>
+ /// </tr>
+ /// <tr><td>VertexContainerName</td>
+ /// <td>name of container for vertices</td>
+ /// </tr>
+ /// <tr><td>TrkMasses</td>
+ /// <td>ordered list of track masses
+ /// (Important to keep proper order: J/psi muons go first!)</td>
+ /// </tr>
+ /// <tr><td>TrackToVertexTool</td>
+ /// <td>ToolHandle for track-to-vertex tool</td>
+ /// </tr>
+ /// <tr><td>AdjustToMuonKinematics</td>
+ /// <td>Adjust the primary track particle's kinematics to the one of
+ /// the muon.</td>
+ /// </tr>
+ /// <tr><td valign="top">AddMinChi2ToAnyPVMode</td>
+ /// <td>mode of minLogChi2ToAnyPV calculation: (default: 0)
+ /// <table border="0">
+ /// <tr><th align="left">Value</th>
+ /// <th align="left">Explanation<th></tr>
+ /// <tr><td> 0 </td><td>no such calculation</td></tr>
+ /// <tr><td> 1 </td><td>use all PVs of requested
+ /// type(s)</td></tr>
+ /// <tr><td> 2 </td><td>exclude PVs associated to SVs</td></tr>
+ /// <tr><td> 3 </td><td>replace PVs associated to SVs by
+ /// corresponding refitted PVs</td></tr>
+ /// </table></td>
+ /// </tr>
+ /// <tr><td>PrimaryVertexContainerName</td>
+ /// <td>name of container for primary vertices</td>
+ /// </tr>
+ /// <tr><td>MinNTracksInPV</td>
+ /// <td>minimum number of tracks in PV
+ /// for PV to be considered in calculation
+ /// of minChi2MuToAnyPV variable.</td>
+ /// </tr>
+ /// <tr><td>PVTypesToConsider</td>
+ /// <td>list of primary vertex types to consider
+ /// (default: {1, 3})</td>
+ /// </tr>
+ /// <tr><td>DoVertexType</td>
+ /// <td>PV-to-SV association types to be considered (bitwise variable,
+ /// see xAODBPhys::BPhysHelper)<br>
+ /// Note: only needed for AddMinChi2ToAnyPVMode > 1</td>
+ /// </tr>
+ /// </table>
+ ///
+ /// @note
+ ///
+ /// For a usage example see BPHY8.py .
+ ///
+ class BPhysAddMuonBasedInvMass : virtual public AthAlgTool,
+ virtual public IAugmentationTool {
+
+ public:
+ ///
+ /// @brief Main contructor
+ ///
+ BPhysAddMuonBasedInvMass(const std::string& t, const std::string& n,
+ const IInterface* p);
+
+ /// @brief Initialize augmentation tool.
+ virtual StatusCode initialize();
+ /// @brief Finalize augmentation tool.
+ virtual StatusCode finalize();
+ /// @brief Main method called for each event.
+ virtual StatusCode addBranches() const;
+
+ protected:
+ ///
+ /// @name Internal protected methods
+ /// @{
+ ///
+ /// @brief Calculate muon-information based mass values if available.
+ ///
+ /// @param[in] vtx secondary vertex
+ /// @param[in] trkMasses ordered vector of track mass values
+ /// @param[in] nMuRequested number of muons requested
+ /// @returns muon-information based invariant mass for secondary
+ /// vertex and the corresponding uncertainty
+ ///
+ std::pair<double, double> getMuCalcMass(xAOD::BPhysHelper& vtx,
+ std::vector<double>
+ trkMasses,
+ int nMuRequested) const;
+ ///
+ /// @brief Obtain a set of tracks with muon track information if available
+ ///
+ /// @param[in] vtx secondary vertex
+ /// @returns container of muon tracks, number of muons found
+ ///
+ std::pair<TrackBag, int> getTracksWithMuons(xAOD::BPhysHelper& vtx) const;
+ ///
+ /// @brief Calculate invariant mass and uncertainty from a set of tracks.
+ ///
+ /// Returns invariant mass and mass error given
+ /// a set of tracks, their mass hypotheses and a reference position.
+ /// Each track must have a separate mass hypothesis in
+ /// the vector, and they must be in the same order as the tracks in the
+ /// track vector. Otherwise it will go horribly wrong.
+ ///
+ /// @param[in] trksIn container with tracks to be considered
+ /// @param[in] massHypoTheses vector of mass hypotheses in the same
+ /// order as the tracks
+ /// @param[in] pos position of the vertex
+ /// @returns invariant mass value and uncertainty
+ ///
+ std::pair<double,double>
+ getInvariantMassWithError(TrackBag trksIn,
+ std::vector<double> massHypotheses,
+ const Amg::Vector3D& pos) const;
+ ///
+ /// @brief Determine minimum log chi2 of signal muon tracks w.r.t.
+ // any primary vertex.
+ ///
+ /// Find minimum log chi2 distance of signal muons w.r.t any primary
+ /// vertex of required types and with a minimum number of tracks cut.
+ /// It also depends on the mode w.r.t. the treatment of the associated
+ /// primary vertex and the type of PV-to-SV association.
+ /// Returns this minimum chi2.
+ ///
+ /// @param[in] vtx secondary vertex
+ /// @param[in] pvContainer container of primary vertices
+ /// @parma[in] pvtypes vector of primary vertex types to be considered
+ /// @param[in] minNTracksInPV minimum number of tracks in primary
+ /// vertex for it to be considered
+ /// @param[in] mode mode of operation (possible values: 0, 1, 2 ,3)
+ /// @param[in] pv_type type of PV-to-SV association
+ /// @returns minimum log chi2 = log(d0^2/d0e^+z0^2/z0e^2) w.r.t.
+ /// any primary vertex
+ ///
+ double getMinChi2ToAnyPV(xAOD::BPhysHelper& vtx,
+ const xAOD::VertexContainer* pvContainer,
+ const std::vector<int>& pvtypes,
+ const int minNTracksInPV,
+ const int mode,
+ const xAOD::BPhysHelper::pv_type&
+ pvAssocType) const;
+ ///
+ /// @brief Calculate log chi2 value of a track w.r.t. a position.
+ ///
+ /// Calculate the log chi2 ( = log((d0/d0e)^2+(z0/z0e)^2) contribution
+ /// of a track at the position closest to the given PV.
+ ///
+ /// @param[in] track track considered
+ /// @param[in] pos position considered
+ /// @returns log chi2 value
+ ///
+ double getTrackPVChi2(const xAOD::TrackParticle& track,
+ const Amg::Vector3D& pos) const;
+ ///
+ /// @brief Extract 3x3 momentum covariance matrix from a TrackParticle.
+ ///
+ /// Extract the 3x3 momentum covariance matrix in (x,y,z) notation
+ /// from the (phi, theta, qoverp) notation from a TrackParticle.
+ ///
+ /// @param[in] track TrackParticle considered
+ /// @returns 3x3 momentum covariance matrix
+ ///
+ AmgSymMatrix(3) getMomentumCov(const xAOD::TrackParticle* track) const;
+ ///
+ /// @brief Extract 3x3 momentum covariance matrix from a Perigee.
+ ///
+ /// Extract the 3x3 momentum covariance matrix in (x,y,z) notation
+ /// from the (phi, theta, qoverp) notation from a Perigee.
+ ///
+ /// @param[in] perigee Trk::Perigee considered
+ /// @returns 3x3 momentum covariance matrix
+ ///
+ AmgSymMatrix(3) getMomentumCov(const Trk::Perigee* perigee) const;
+ ///
+ /// @brief Extract 3x3 momentum covariance matrix from a track parameter
+ /// vector and 5x5 covariance matrix.
+ ///
+ /// Extract the 3x3 momentum covariance matrix in (x,y,z) notation
+ /// from the (phi, theta, qoverp) notation from a vector of
+ /// track parameters and the 5x5 error matrix.
+ ///
+ /// @param[in] pars 5-vector of track parameters
+ /// @param[in] cov 5x5 covariance matrix of track parameters
+ /// @returns 3x3 momentum covariance matrix
+ ///
+ AmgSymMatrix(3) getMomentumCov(const AmgVector(5)& pars,
+ const AmgSymMatrix(5)& cov) const;
+ ///
+ /// @brief Find all muons associated to secondary vertex.
+ ///
+ /// Returns a vector of xAOD::Muon objects found
+ /// in this vertex and subsequent decay vertices.
+ /// Recursively calls itself if necessary.
+ ///
+ /// @param[in] vtx secondary vertex
+ /// @returns container of muons found
+ ///
+ MuonBag findAllMuonsInDecay(xAOD::BPhysHelper& vtx) const;
+ ///
+ /// @brief Obtain a set of ID tracks for a set of muons.
+ ///
+ /// @param[in] muons container of muon objects
+ /// @returns container of associated ID tracks
+ ///
+ TrackBag getIdTracksForMuons(MuonBag& muons) const;
+ ///
+ /// @brief Extract TrackParticle for Muon and adjust kinematics.
+ ///
+ /// Extract primary track particle from muon;
+ /// if configured adjust pt, eta and phi of it before returning
+ /// a pointer to it.
+ ///
+ /// @param[in] muon pointer to muon
+ /// @returns TrackParticle pointer
+ ///
+ const xAOD::TrackParticle* adjustTrackParticle(const xAOD::Muon* muon)
+ const;
+ ///
+ /// @brief Initialize PV-to-SV association type vector.
+ ///
+ void initPvAssocTypeVec();
+ ///
+ /// @brief Clear the cache of adjusted TrackParticles.
+ ///
+ void clearAdjTpCache() const;
+ /// @}
+ private:
+ /// @name job options
+ /// @{
+ std::string m_branchPrefix;
+ std::string m_vertexContainerName;
+ std::vector<double> m_trkMasses;
+ ToolHandle<Reco::ITrackToVertex> m_trackToVertexTool;
+ bool m_adjustToMuonKinematics;
+ int m_addMinChi2ToAnyPVMode;
+ std::string m_pvContainerName;
+ int m_minNTracksInPV;
+ std::vector<int> m_pvTypesToConsider;
+ int m_doVertexType;
+ /// @}
+ ///
+ /// map original -> adjusted track particles
+ typedef std::map<const xAOD::TrackParticle*, const xAOD::TrackParticle*>
+ TpMap_t;
+ /// map of adjusted track particles as cache
+ mutable TpMap_t m_adjTpCache;
+
+ /// cache for individual vertex types
+ std::vector<xAOD::BPhysHelper::pv_type> m_pvAssocTypes;
+
+ }; // class
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_BPhysAddMuonBasedInvMass_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysConversionFinder.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysConversionFinder.h
new file mode 100644
index 00000000000..50a42966962
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysConversionFinder.h
@@ -0,0 +1,76 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+///////////////////////////////////////////////////////////////////
+// BPhysConversionFinder.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Author: A. Chisholm <andrew.chisholm@cern.ch>
+#ifndef DERIVATIONFRAMEWORK_BPHYSCONVERSIONFINDER_H
+#define DERIVATIONFRAMEWORK_BPHYSCONVERSIONFINDER_H
+
+#include <string>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+
+#include "InDetConversionFinderTools/VertexPointEstimator.h"
+#include "InDetConversionFinderTools/ConversionPostSelector.h"
+#include "TrkVertexSeedFinderUtils/ITrkDistanceFinder.h"
+
+#include "TLorentzVector.h"
+
+namespace Trk
+{
+ class V0Tools;
+ class IVertexFitter;
+ class TrkVKalVrtFitter;
+}
+
+namespace InDet
+{
+ class VertexPointEstimator;
+ class TrackPairsSelector;
+ class ConversionPostSelector;
+}
+
+namespace DerivationFramework {
+
+class BPhysConversionFinder : public AthAlgTool, public IAugmentationTool {
+
+ public:
+
+ BPhysConversionFinder(const std::string& t, const std::string& n, const IInterface* p);
+
+ StatusCode initialize() override;
+ StatusCode finalize() override;
+
+ virtual StatusCode addBranches() const override;
+
+ private:
+
+ StatusCode doCascadeFit(const xAOD::Vertex * diMuonVertex, const xAOD::Vertex * convVertex, const double diMuonMassConstraint, TLorentzVector & fitMom, float & chiSq) const;
+
+ std::string m_diMuonCollectionToCheck;
+ std::vector<std::string> m_passFlagsToCheck;
+
+ ToolHandle <Trk::V0Tools> m_v0Tools;
+ ToolHandle <Trk::IVertexFitter> m_vertexFitter;
+ ToolHandle <InDet::VertexPointEstimator> m_vertexEstimator;
+ ToolHandle <Trk::ITrkDistanceFinder> m_distanceTool;
+ ToolHandle <InDet::ConversionPostSelector> m_postSelector;
+ ToolHandle <Trk::TrkVKalVrtFitter > m_cascadeFitter;
+
+ std::string m_inputTrackParticleContainerName;
+ std::string m_conversionContainerName;
+
+ float m_maxDistBetweenTracks;
+ float m_maxDeltaCotTheta;
+
+ bool m_requireDeltaM;
+ float m_maxDeltaM;
+
+ };
+}
+
+#endif // DERIVATIONFRAMEWORK_BPhysConversionFinder_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysMetadataBase.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysMetadataBase.h
new file mode 100644
index 00000000000..d4a5ffd9085
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysMetadataBase.h
@@ -0,0 +1,100 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BPhysMetadataBase.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+// - w.w., 2017-01-22: Added use of BPhysMetaDataTool.
+// - w.w., 2019-12-05: Added long and vector<long> types
+//
+// Store JO metadata in the output file.
+//
+// It uses the BPhysMetaDataTool (default) or the IOVDbMetaDataTool to
+// store job option information as metadata in a specific branch whose
+// name needs to prefixed by the deriviation format name.
+// Note: Metadata stored by the IOVDbMetaDataTool is not readable on
+// 'RootCore' level.
+//
+// This is a base class. Inherit from it to add the job options you want
+// to store. For a usage example, see
+// Bmumu_metadata.h / Bmumu_metadata.cxx
+// and
+// BPHY8.py .
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_BPhysMetadataBase_H
+#define DERIVATIONFRAMEWORK_BPhysMetadataBase_H
+
+#include <string>
+#include <map>
+#include <vector>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "GaudiKernel/ToolHandle.h"
+
+namespace DerivationFramework {
+
+ class BPhysMetadataBase : virtual public AthAlgTool,
+ virtual public IAugmentationTool {
+ public:
+ BPhysMetadataBase(const std::string& t, const std::string& n,
+ const IInterface* p);
+
+ virtual StatusCode initialize();
+ virtual StatusCode finalize();
+
+ virtual StatusCode addBranches() const;
+
+ protected:
+ virtual void recordPropertyI(const std::string& name, int val);
+ virtual void recordPropertyL(const std::string& name, long val);
+ virtual void recordPropertyD(const std::string& name, double val);
+ virtual void recordPropertyB(const std::string& name, bool val);
+ virtual void recordPropertyS(const std::string& name, const std::string& val);
+
+ virtual void recordPropertyVI(const std::string& name, const std::vector<int>& val);
+ virtual void recordPropertyVL(const std::string& name, const std::vector<long>& val);
+ virtual void recordPropertyVD(const std::string& name, const std::vector<double>& val);
+ virtual void recordPropertyVB(const std::string& name, const std::vector<bool>& val);
+ virtual void recordPropertyVS(const std::string& name,
+ const std::vector<std::string>& val);
+
+ private:
+ virtual StatusCode saveMetaDataBPhys() const;
+ virtual std::string buildFolderName(const std::string& fname="") const;
+ virtual std::string vecToString(const std::vector<int>& v) const;
+ virtual std::string vecToString(const std::vector<long>& v) const;
+ virtual std::string vecToString(const std::vector<double>& v) const;
+ virtual std::string vecToString(const std::vector<bool>& v) const;
+ virtual std::string vecToString(const std::vector<std::string>& v) const;
+
+ private:
+ /// Object accessing the output metadata store
+ mutable ServiceHandle< StoreGateSvc > m_outputMetaStore;
+
+ // job options
+ std::string m_derivationName;
+ std::string m_mdFolderName;
+ std::string m_prefix;
+
+ // maps for different types of JOs
+ std::map<std::string, int> m_propInt;
+ std::map<std::string, long> m_propLong;
+ std::map<std::string, double> m_propDouble;
+ std::map<std::string, bool> m_propBool;
+ std::map<std::string, std::string> m_propString;
+ std::map<std::string, std::vector<int> > m_propVInt;
+ std::map<std::string, std::vector<long> > m_propVLong;
+ std::map<std::string, std::vector<double> > m_propVDouble;
+ std::map<std::string, std::vector<bool> > m_propVBool;
+ std::map<std::string, std::vector<std::string> > m_propVString;
+ }; // class
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_BPhysMetadataBase_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVCascadeTools.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVCascadeTools.h
new file mode 100644
index 00000000000..c1561102db7
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVCascadeTools.h
@@ -0,0 +1,159 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DERIVATIONFRAMEWORK_PVCASCADETOOLS_H
+#define DERIVATIONFRAMEWORK_PVCASCADETOOLS_H
+
+#include "GaudiKernel/ToolHandle.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include "DerivationFrameworkBPhys/CascadeTools.h"
+#include "EventKernel/PdtPdg.h"
+
+#include <vector>
+// Authors: Adam Barton <abarton@SPAMMENOTTtttcern.ch>
+// Eva Bouhova <bouhova@SPAMMENOTTtttcern.ch>
+
+
+//class CascadeTools;
+namespace Trk {
+ class V0Tools;
+ class VxCascadeInfo;
+}
+
+namespace Analysis{
+ class PrimaryVertexRefitter;
+}
+namespace InDet{
+class BeamSpotData;
+}
+
+namespace HepPDT{
+ class ParticleDataTable;
+}
+
+namespace DerivationFramework {
+
+ class BPhysPVCascadeTools {
+ typedef ElementLink<xAOD::VertexContainer> VertexLink;
+ typedef std::vector<VertexLink> VertexLinkVector;
+ private:
+ const Trk::V0Tools *m_v0Tools;
+ const CascadeTools *m_cascadeTools;
+ const InDet::BeamSpotData *m_beamSpotData;
+
+ /// minimum number of tracks required in PVs considered
+ size_t m_PV_minNTracks;
+
+ public:
+ bool m_copyAllVertices;
+ BPhysPVCascadeTools(const CascadeTools *cascadeTools);
+ BPhysPVCascadeTools(const CascadeTools *cascadeTools,
+ const InDet::BeamSpotData*);
+
+
+ void ProcessVertex(const std::vector<TLorentzVector> &mom, Amg::MatrixX cov, xAOD::BPhysHypoHelper &vtx, xAOD::BPhysHelper::pv_type pvtype, double mass) const;
+
+ static void FillBPhysHelperNULL(xAOD::BPhysHelper &vtx, const xAOD::VertexContainer* PvContainer,
+ xAOD::BPhysHelper::pv_type pvtype);
+
+ ///Fills the BPhysHelper object with the standard parameters
+ void FillBPhysHelper(const std::vector<TLorentzVector> &mom, Amg::MatrixX cov, xAOD::BPhysHelper &vtx, const xAOD::Vertex* refPV,const xAOD::VertexContainer* refPvContainer,
+ xAOD::BPhysHelper::pv_type pvtype, int) const;
+
+ ///Returns the index integer of the vertex with the lowest Z in relation to the given vertex
+ size_t FindLowZIndex(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &Obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks=0) const;
+ ///Returns the index integer of the vertex with the lowest A0 in relation to the given vertex
+ size_t FindLowA0Index(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &Obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks=0) const;
+
+ static size_t FindHighPtIndex(const std::vector<const xAOD::Vertex*> &PVlist);
+
+ template< size_t NTracks> //NTracks = number of tracks in this type of vertex, if this is not known do not use this method
+ static bool VerticesMatchTracks(const xAOD::Vertex* v1, const xAOD::Vertex* v2);
+
+ template< size_t NTracks>
+ static const xAOD::Vertex* FindVertex(const xAOD::VertexContainer* c, const xAOD::Vertex* v);
+
+ /// Static method call with
+ /// DerivationFramework::BPhysDerHelpers::GetGoodPV
+ /// Returns a std::vector containing only PVs of type 1 and 3 - HighPt
+ /// and Pileup, which have at least PV_minNTracks tracks.
+ static std::vector<const xAOD::Vertex*> GetGoodPV(const xAOD::VertexContainer* pvContainer);
+
+ /// Set the minimum number of tracks required for primary vertices to be
+ /// considered for primary vertex association to a secondary vertex.
+ /// Note that this requirement will not be applied for finding
+ /// the vertex with the highest pT sum (FindHighPtIndex()) since
+ /// it would possibly exclude this vertex which has been marked
+ /// earlier in the tool chain.
+ void SetMinNTracksInPV(size_t PV_minNTracks);
+
+ /// Get the current beamspot position either from cache or from
+ /// BeamCondSvc.
+ /// Before processing a new event, make sure to call
+ /// GetBeamSpot();
+ [[nodiscard]] const Amg::Vector3D& GetBeamSpot() const noexcept;
+
+ /// Find the index for the PV with the lowest distance in z of
+ /// the SV's DOCA point w.r.t. the beamline and the PV.
+ size_t FindLowZ0BAIndex(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks=0) const;
+ /// Calculate the distance along z axis between the PV and
+ /// SV's DOCA point w.r.t. the beamline.
+ double DistInZtoDOCA(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &obj,
+ const xAOD::Vertex* vertex) const;
+ /// Point of DOCA w.r.t. the beamline backward extrapolated
+ /// along the B candidate's momentum direction.
+ Amg::Vector3D DocaExtrapToBeamSpot(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &obj) const;
+
+ static void PrepareVertexLinks(Trk::VxCascadeInfo *result, const xAOD::TrackParticleContainer* importedTrackCollection);
+
+ StatusCode FillCandwithRefittedVertices( bool refitPV,
+ const xAOD::VertexContainer* pvContainer, xAOD::VertexContainer* refPvContainer,
+ const Analysis::PrimaryVertexRefitter *pvRefitter, size_t in_PV_max, int DoVertexType,
+ Trk::VxCascadeInfo* casc, int index,
+ double mass, xAOD::BPhysHypoHelper &vtx);
+
+ static std::vector<const xAOD::TrackParticle*> CollectAllChargedTracks(const std::vector<xAOD::Vertex*> &cascadeVertices);
+
+ static void SetVectorInfo(xAOD::BPhysHelper &, const Trk::VxCascadeInfo*);
+ static bool uniqueCollection(const std::vector<const xAOD::TrackParticle*>&);
+ static bool uniqueCollection(const std::vector<const xAOD::TrackParticle*>&, const std::vector<const xAOD::TrackParticle*>&);
+ static bool LinkVertices(SG::AuxElement::Decorator<VertexLinkVector> &decor, const std::vector<const xAOD::Vertex*>& vertices,
+ const xAOD::VertexContainer* vertexContainer, const xAOD::Vertex* vert);
+ static double getParticleMass(const HepPDT::ParticleDataTable* pdt, int pdg);
+ }; // class BPhysPVCascadeTools
+
+} // namespace DerivationFramework
+
+
+//added by ab
+template< size_t NTracks>
+bool DerivationFramework::BPhysPVCascadeTools::VerticesMatchTracks(const xAOD::Vertex* v1, const xAOD::Vertex* v2)
+{
+ if(v1->nTrackParticles() != v2->nTrackParticles()) return false;
+ assert(v1->nTrackParticles() == NTracks);
+ std::array<const xAOD::TrackParticle*, NTracks> a1;
+ std::array<const xAOD::TrackParticle*, NTracks> a2;
+ for(size_t i=0;i<NTracks;i++){
+ a1[i] = v1->trackParticle(i);
+ a2[i] = v2->trackParticle(i);
+ }
+ std::sort(a1.begin(), a1.end());
+ std::sort(a2.begin(), a2.end());
+ return a1 == a2;
+}
+
+template< size_t NTracks>
+const xAOD::Vertex* DerivationFramework::BPhysPVCascadeTools::FindVertex(const xAOD::VertexContainer* c, const xAOD::Vertex* v){
+ for (const xAOD::Vertex* a : *c){
+ if(VerticesMatchTracks<NTracks>(a,v)) return a;
+ }
+ return nullptr;
+}
+#endif // DERIVATIONFRAMEWORK_PVCASCADETOOLS_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVThinningTool.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVThinningTool.h
new file mode 100644
index 00000000000..62d62d55943
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVThinningTool.h
@@ -0,0 +1,53 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// BPhysPVThinningTool.h
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_BPhysPVThinningTool_H
+#define DERIVATIONFRAMEWORK_BPhysPVThinningTool_H 1
+
+#include "xAODTracking/VertexContainer.h"
+// Gaudi & Athena basics
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "StoreGate/ReadHandleKeyArray.h"
+#include "StoreGate/ThinningHandleKey.h"
+// DerivationFramework includes
+#include "DerivationFrameworkInterfaces/IThinningTool.h"
+
+namespace DerivationFramework {
+
+
+ class BPhysPVThinningTool : public AthAlgTool, public IThinningTool {
+
+ public:
+ /** Constructor with parameters */
+ BPhysPVThinningTool( const std::string& t, const std::string& n, const IInterface* p );
+
+ /** Destructor */
+ ~BPhysPVThinningTool();
+
+ // Athena algtool's Hooks
+ virtual StatusCode initialize() override;
+ virtual StatusCode finalize() override;
+
+ /** Check that the current event passes this filter */
+ virtual StatusCode doThinning() const override;
+
+ private:
+ StringProperty m_streamName{ this, "StreamName", "", "Name of the stream being thinned" };
+ SG::ReadHandleKeyArray<xAOD::VertexContainer> m_BPhyCandList;
+ SG::ThinningHandleKey<xAOD::TrackParticleContainer> m_TrackContainerName;
+ SG::ThinningHandleKey<xAOD::VertexContainer> m_PVContainerName;
+ mutable std::atomic<unsigned int> m_ntot;
+ mutable std::atomic<unsigned int> m_npass;
+ mutable std::atomic<unsigned int> m_tracks_kept;
+ bool m_keepTracks;
+ };
+
+}
+
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVTools.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVTools.h
new file mode 100644
index 00000000000..86412eb46d9
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysPVTools.h
@@ -0,0 +1,108 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DERIVATIONFRAMEWORK_PVTOOLS_H
+#define DERIVATIONFRAMEWORK_PVTOOLS_H
+
+#include "GaudiKernel/ToolHandle.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include <vector>
+
+// Author: Adam Barton <abarton@SPAMMENOTTtttcern.ch>
+namespace InDet{
+class BeamSpotData;
+}
+namespace Trk {
+ class V0Tools;
+}
+namespace Analysis{
+ class PrimaryVertexRefitter;
+}
+
+
+namespace DerivationFramework {
+
+ class BPhysPVTools {
+
+ private:
+ const Trk::V0Tools *m_v0Tools;
+ const InDet::BeamSpotData *m_beamSpotData;
+
+ /// minimum number of tracks required in PVs considered
+ size_t m_PV_minNTracks;
+
+ bool m_3dCalc;
+
+ public:
+
+ BPhysPVTools(const Trk::V0Tools *v0Tools);
+ BPhysPVTools(const Trk::V0Tools *v0Tools, const InDet::BeamSpotData*);
+ void SetSave3d(bool v) { m_3dCalc =v; }
+ StatusCode FillCandExistingVertices(xAOD::VertexContainer* vtxContainer, const xAOD::VertexContainer* pvContainer, int DoVertexType);
+
+ static void FillBPhysHelperNULL(xAOD::BPhysHelper &vtx, const xAOD::VertexContainer* PvContainer,
+ xAOD::BPhysHelper::pv_type pvtype, bool do3d = false);
+
+ StatusCode FillCandwithRefittedVertices(xAOD::VertexContainer* vtxContainer, const xAOD::VertexContainer* pvContainer,xAOD::VertexContainer* refPvContainer, const Analysis::PrimaryVertexRefitter* , size_t in_PV_max, int DoVertexType);
+
+ void DecorateWithNULL(xAOD::VertexContainer* vtxContainer,const xAOD::VertexContainer* pvContainer, int DoVertexType) const;
+
+ void DecorateWithDummyVertex(xAOD::VertexContainer* vtxContainer, const xAOD::VertexContainer* pvContainer, const xAOD::Vertex* Dummy, int DoVertexType, bool SetOrignal) const;
+
+ ///Fills the BPhysHelper object with the standard parameters
+ void FillBPhysHelper(xAOD::BPhysHelper &vtx, const xAOD::Vertex* refPV,const xAOD::VertexContainer* refPvContainer,
+ xAOD::BPhysHelper::pv_type pvtype, int) const;
+
+ ///Returns the index integer of the vertex with the lowest Z in relation to the given vertex
+ size_t FindLowZIndex(const xAOD::BPhysHelper &Obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks=0) const;
+ ///Returns the index integer of the vertex with the lowest A0 in relation to the given vertex
+ size_t FindLowA0Index(const xAOD::BPhysHelper &Obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks=0) const;
+
+ static size_t FindHighPtIndex(const std::vector<const xAOD::Vertex*> &PVlist);
+
+ /// Static method call with
+ /// DerivationFramework::BPhysDerHelpers::GetGoodPV
+ /// Returns a std::vector containing only PVs of type 1 and 3 - HighPt
+ /// and Pileup, which have at least PV_minNTracks tracks.
+ static std::vector<const xAOD::Vertex*> GetGoodPV(const xAOD::VertexContainer* pvContainer);
+
+ /// Set the minimum number of tracks required for primary vertices to be
+ /// considered for primary vertex association to a secondary vertex.
+ /// Note that this requirement will not be applied for finding
+ /// the vertex with the highest pT sum (FindHighPtIndex()) since
+ /// it would possibly exclude this vertex which has been marked
+ /// earlier in the tool chain.
+ void SetMinNTracksInPV(size_t PV_minNTracks);
+
+ /// Get the current beamspot position either from cache or from
+ /// BeamCondSvc.
+ /// Before processing a new event, make sure to call
+ /// GetBeamSpot();
+ [[nodiscard]] const Amg::Vector3D& GetBeamSpot() const noexcept;
+
+ /// Find the index for the PV with the lowest distance in z of
+ /// the SV's DOCA point w.r.t. the beamline and the PV.
+ size_t FindLowZ0BAIndex(const xAOD::BPhysHelper &obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks=0) const;
+ /// Calculate the distance along z axis between the PV and
+ /// SV's DOCA point w.r.t. the beamline.
+ double DistInZtoDOCA(const xAOD::BPhysHelper &obj,
+ const xAOD::Vertex* vertex) const;
+ /// Point of DOCA w.r.t. the beamline backward extrapolated
+ /// along the B candidate's momentum direction.
+ Amg::Vector3D DocaExtrapToBeamSpot(const xAOD::BPhysHelper &obj) const;
+
+ static void PrepareVertexLinks(xAOD::Vertex* theResult,
+ const xAOD::TrackParticleContainer* importedTrackCollection);
+ }; // class BPhysPVTools
+
+} // namespace DerivationFramework
+
+
+#endif // DERIVATIONFRAMEWORK_PVTOOLS_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysVarBlinder.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysVarBlinder.h
new file mode 100644
index 00000000000..02e572a4f59
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysVarBlinder.h
@@ -0,0 +1,76 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+///
+/// @file BPhysVarBlinder.h
+/// @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+///
+/// @brief Vertex variable(s) blinding tool
+///
+#ifndef DERIVATIONFRAMEWORK_BPhysVarBlinder_H
+#define DERIVATIONFRAMEWORK_BPhysVarBlinder_H
+
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "DerivationFrameworkBPhys/CfAthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+
+///
+/// forward declarations
+///
+namespace xAOD {
+ class BPhysBlindingTool;
+}
+namespace DerivationFramework {
+
+ ///
+ /// @class BPhysVarBlinder
+ /// @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ ///
+ /// @ brief Vertex variable(s) blinding tool
+ ///
+ /// This is an AthAlgTool wrapper around the BPhysBlindingTool
+ /// from the package BPhysTools.
+ ///
+ /// Job options:
+ /// - BlindingTool : ToolHandle for xAOD::BPhysBlindingTool
+ /// - EnableBlinding : Switch to easily en-/disable this tool
+ ///
+ /// For an example configuration using this tool see BPHY8.py.
+ ///
+ class BPhysVarBlinder : public CfAthAlgTool, public IAugmentationTool {
+
+ public:
+ ///
+ /// @brief Constructor
+ ///
+ BPhysVarBlinder(const std::string& t, const std::string& n,
+ const IInterface* p);
+ ///
+ /// @brief Initialization
+ ///
+ StatusCode initialize();
+ ///
+ /// @brief Finalization
+ ///
+ StatusCode finalize();
+ ///
+ /// @brief Perform blinding per event (if enabled)
+ ///
+ virtual StatusCode addBranches() const;
+
+ private:
+ ///
+ /// @name Job options
+ /// @{
+ ///
+ /// @brief ToolHandle for blinding tool
+ ToolHandle<xAOD::BPhysBlindingTool> m_blindingTool;
+ ///
+ /// @brief Switch for enabling blinding
+ bool m_enableBlinding;
+ /// @}
+
+ };
+}
+#endif // DERIVATIONFRAMEWORK_BPhysVarBlinder_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysVertexTrackBase.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysVertexTrackBase.h
new file mode 100644
index 00000000000..28a8f683152
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BPhysVertexTrackBase.h
@@ -0,0 +1,303 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BPhysVertexTrackBase.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Base class for vertex-track related classes in need of
+// track-to-vertex association handling.
+//
+// For an usage example see BVertexTrackIsoTool and BPHY8.py .
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_BPhysVertexTrackBase_H
+#define DERIVATIONFRAMEWORK_BPhysVertexTrackBase_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "EventPrimitives/EventPrimitives.h"
+#include "ITrackToVertex/ITrackToVertex.h"
+#include "TrackVertexAssociationTool/ITrackVertexAssociationTool.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/TrackParticleAuxContainer.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+
+#include <string>
+#include <vector>
+#include <map>
+
+// forward declarations
+namespace InDet {
+ class IInDetTrackSelectionTool;
+}
+
+class TVector3;
+
+namespace DerivationFramework {
+ //
+ // typedefs -- to abbreviate long lines
+ //
+ typedef std::vector<const xAOD::TrackParticle*> TrackBag;
+ typedef std::vector<const xAOD::Muon*> MuonBag;
+ typedef InDet::IInDetTrackSelectionTool TrkSelTool;
+
+ class BPhysVertexTrackBase : public AthAlgTool,
+ virtual public IAugmentationTool {
+
+ protected:
+ class BaseItem {
+
+ public:
+ BaseItem(std::string Name="_none_", std::string Bname="iso",
+ std::string Prefix="");
+ virtual ~BaseItem();
+
+ virtual void setup(std::string Name, std::string Bname="iso",
+ std::string Prefix="");
+ virtual void setPrefix(std::string Prefix);
+ virtual void resetVals();
+ virtual void copyVals(const BaseItem& item) = 0;
+ virtual std::string buildName(std::string qualifier="",
+ std::string suffix="");
+ virtual std::string toString() const;
+
+ public:
+ std::string name;
+ std::string bname;
+ std::string prefix;
+ };
+
+ protected:
+ class TrackTypeCounter {
+
+ public:
+ TrackTypeCounter(BPhysVertexTrackBase& Parent, std::string Name);
+ virtual ~TrackTypeCounter();
+
+ virtual void addToCounter(uint64_t atype, uint64_t rtype=0,
+ std::string prefix="", std::string suffix="",
+ uint64_t counts=1);
+
+ virtual void addToCounter(std::string name, uint64_t atype=0,
+ uint64_t counts=1);
+
+ virtual std::string countsToString(uint indent=0) const;
+
+ public:
+ std::string name;
+
+ private:
+ typedef std::map<std::string, std::pair<uint64_t, uint64_t> >
+ NameCountMap_t;
+ NameCountMap_t m_cnts;
+ BPhysVertexTrackBase& m_parent;
+ };
+
+ public:
+ //
+ // enumeration for types of tracks to be considered
+ //
+ enum track_type {ASSOCPV, PVTYPE0, PVTYPE1, PVTYPE2, PVTYPE3, NONE,
+ NULLVP,
+ CAPVRFN3U0, CAPVNRN3U0, CAPVRF3DU0, CAPVNR3DU0,
+ CAPVRFN3U1, CAPVNRN3U1, CAPVRF3DU1, CAPVNR3DU1,
+ CAPVRFN3U2, CAPVNRN3U2, CAPVRF3DU2, CAPVNR3DU2,
+ CAPVRFNNU3, CAPVNRNNU3, CAPVRFNNU4, CAPVNRNNU4,
+ CAPVRFNNU5, CAPVNRNNU5, CAPVRFNNU6, CAPVNRNNU6,
+ CAPVRFNNU7, CAPVNRNNU7, CAPVRFNNU8, CAPVNRNNU8,
+ CAPVRFNNU9, CAPVNRNNU9 };
+ static const int n_track_types;
+ static const std::string track_type_str[];
+ static const uint64_t track_type_bit[];
+ private:
+ static uint64_t s_track_type_all_cached;
+
+ public:
+ //
+ // convenience methods
+ //
+ static const std::string tts(track_type type);
+ static uint64_t ttb(track_type type);
+ static uint64_t ttall();
+ static uint64_t ttallMin();
+ static uint64_t rttor(const std::vector<uint64_t> &vtypes);
+ static std::string wrapLines(std::string lines,
+ std::string prefix);
+ static std::string trackToString(const xAOD::TrackParticle* track);
+
+ public:
+ //
+ // public methods called by the framework
+ //
+ BPhysVertexTrackBase(const std::string& t, const std::string& n,
+ const IInterface* p);
+
+ virtual StatusCode initialize();
+ virtual StatusCode finalize();
+ virtual StatusCode addBranches() const;
+
+ protected:
+ //
+ // Hook methods -- need be be overwritten in the concrete class
+ //
+ virtual StatusCode initializeHook();
+ virtual StatusCode finalizeHook();
+ virtual StatusCode addBranchesHook() const;
+ virtual StatusCode addBranchesVCSetupHook(size_t ivc) const;
+ virtual StatusCode addBranchesSVLoopHook(const xAOD::Vertex* vtx) const;
+ virtual StatusCode calcValuesHook(const xAOD::Vertex* vtx,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const;
+ virtual bool fastFillHook(const xAOD::Vertex* vtx,
+ const int ipv) const;
+
+ //
+ // Methods to be called from within addBranchesSVLoopHook()
+ //
+ virtual StatusCode calculateValues(const xAOD::Vertex* vtx) const;
+
+ //
+ // internal methods
+ //
+ // name string for vertex pointer and PV index
+ virtual std::string buildPvAssocCacheName(const xAOD::Vertex* vtx,
+ const int ipv) const;
+
+ virtual void initPvAssocTypeVec();
+ virtual TrackBag findAllTracksInDecay(xAOD::BPhysHelper& vtx) const;
+ virtual void findAllTracksInDecay(xAOD::BPhysHelper& vtx,
+ TrackBag& tracks) const;
+ virtual MuonBag findAllMuonsInDecay(xAOD::BPhysHelper& vtx) const;
+ virtual void findAllMuonsInDecay(xAOD::BPhysHelper& vtx,
+ MuonBag& muons) const;
+ virtual TrackBag findAllMuonIdTracksInDecay(xAOD::BPhysHelper& vtx,
+ MuonBag& muons) const;
+ virtual std::vector<TVector3>
+ findMuonRefTrackMomenta(xAOD::BPhysHelper& vtx, MuonBag& muons) const;
+
+ virtual TrackBag selectTracks(const xAOD::TrackParticleContainer*
+ inpTracks,
+ xAOD::BPhysHelper& cand,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const;
+ virtual TrackBag selectTracks(const xAOD::TrackParticleContainer*
+ inpTracks,
+ const TrackBag& exclTracks,
+ xAOD::BPhysHelper& cand,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const;
+ virtual uint64_t detTrackTypes(const xAOD::TrackParticle* track,
+ const xAOD::Vertex* candPV,
+ const xAOD::Vertex* candRefPV) const;
+ virtual double getTrackCandPVLogChi2(const xAOD::TrackParticle*
+ track,
+ const xAOD::Vertex* vtx,
+ bool doDCAin3D=false,
+ int chi2DefToUse=0) const;
+ virtual std::vector<double> getTrackLogChi2DCA(const xAOD::TrackParticle*
+ track,
+ const xAOD::Vertex* vtx,
+ bool doDCAin3D=false,
+ int chi2DefToUse=0)
+ const;
+ virtual std::string buildBranchBaseName(unsigned int its,
+ unsigned int ipv,
+ unsigned int itt,
+ std::string preSuffix="") const;
+
+ virtual std::pair<const xAOD::Vertex*, double>
+ findMinChi2PV(const xAOD::TrackParticle* track,
+ const xAOD::Vertex* candPV,
+ const xAOD::Vertex* candRefPV,
+ const std::vector<uint64_t>& pvtypes,
+ const int minNTracksInPV,
+ const bool useRefittedPvs,
+ const bool doDCAin3D,
+ const int chi2DefToUse) const;
+
+ virtual const xAOD::Vertex*
+ findAssocPV(const xAOD::TrackParticle* track,
+ const xAOD::Vertex* candPV,
+ const xAOD::Vertex* candRefPV,
+ const std::vector<uint64_t>& pvtypes,
+ const int minNTracksInPV,
+ const bool useRefittedPvs) const;
+
+ protected:
+ // job options
+ std::vector<std::string> m_branchPrefixes;
+ std::string m_branchBaseName;
+ std::string m_branchSuffix;
+ std::vector<std::string> m_vertexContainerNames;
+ std::string m_trackParticleContainerName;
+ ToolHandleArray<TrkSelTool> m_trackSelectionTools;
+
+ ToolHandle<Reco::ITrackToVertex> m_trackToVertexTool;
+
+ ToolHandle<CP::ITrackVertexAssociationTool> m_tvaTool;
+
+ std::string m_pvContainerName;
+ std::vector<std::string> m_refPVContainerNames;
+
+ int m_doVertexType;
+ std::vector<uint64_t> m_useTrackTypes;
+ bool m_incPrecVerticesInDecay;
+ int m_minNTracksInPV;
+ std::vector<uint64_t> m_pvTypesToConsider;
+ int m_debugTrackTypes;
+ std::vector<uint64_t> m_debugTracksInEvents;
+
+ // working point of TVA tool
+ bool m_tvaToolHasWpLoose;
+
+ // containers
+ mutable const xAOD::TrackParticleContainer* m_tracks;
+ mutable const xAOD::TrackParticleAuxContainer* m_tracksAux;
+ mutable const xAOD::VertexContainer* m_pvtxContainer;
+ mutable const xAOD::VertexContainer* m_svtxContainer;
+ mutable const xAOD::VertexAuxContainer* m_svtxAuxContainer;
+ mutable const xAOD::VertexContainer* m_refPVContainer;
+ mutable const xAOD::VertexAuxContainer* m_refPVAuxContainer;
+
+ // cache for individual vertex types
+ std::vector<xAOD::BPhysHelper::pv_type> m_pvAssocTypes;
+
+ mutable unsigned int m_nEvtsSeen;
+
+ // event info
+ mutable const xAOD::EventInfo* m_eventInfo;
+
+ // cache for similar PV-to-SV associations
+ typedef std::map<std::string, int> StringIntMap_t;
+ mutable StringIntMap_t m_pvAssocResMap;
+
+ // track types considered
+ uint64_t m_trackTypesUsed;
+
+ // track type counter map (for debugging)
+ std::unique_ptr<TrackTypeCounter> m_mttc;
+
+ // run and event numbers (see EventIDBase.h for types)
+ mutable unsigned int m_runNumber;
+ mutable uint64_t m_evtNumber;
+
+ // debug tracks in the current event?
+ mutable bool m_debugTracksInThisEvent;
+
+ }; // class
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_BPhysVertexTrackBase_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BTrackVertexMapLogger.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BTrackVertexMapLogger.h
new file mode 100644
index 00000000000..0b20390c590
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BTrackVertexMapLogger.h
@@ -0,0 +1,49 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BTrackVertexMapLogger.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Initiate dumps of track-to-vertex maps to log file which are provided
+// by BPhysTrackVertexMapTool instances.
+//
+// The BPhysTrackVertexMapTool instances need to be configured separately
+// and handed to this tool.
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_BTrackVertexMapLogger_H
+#define DERIVATIONFRAMEWORK_BTrackVertexMapLogger_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "BPhysTools/IBPhysTrackVertexMapTool.h"
+
+namespace DerivationFramework {
+
+ class BTrackVertexMapLogger : virtual public AthAlgTool,
+ virtual public IAugmentationTool {
+ public:
+ BTrackVertexMapLogger(const std::string& t, const std::string& n,
+ const IInterface* p);
+
+ virtual StatusCode initialize();
+ virtual StatusCode finalize();
+
+ virtual StatusCode addBranches() const;
+
+ private:
+ // job options
+ ToolHandleArray<xAOD::IBPhysTrackVertexMapTool> m_ttvmTools;
+ bool m_enable;
+
+ }; // class
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_BTrackVertexMapLogger_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BVertexClosestTrackTool.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BVertexClosestTrackTool.h
new file mode 100644
index 00000000000..2b704516a23
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BVertexClosestTrackTool.h
@@ -0,0 +1,149 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BVertexClosestTrackTool.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Add B vertex closest track information for different configurations,
+// different track selections and different PV-to-SV association methods.
+//
+// For an usage example see BPHY8.py .
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_BVertexClosestTrackTool_H
+#define DERIVATIONFRAMEWORK_BVertexClosestTrackTool_H
+
+#include "DerivationFrameworkBPhys/BPhysVertexTrackBase.h"
+#include "boost/multi_array.hpp"
+
+namespace InDet {
+ class IInDetTrackSelectionTool;
+}
+
+namespace DerivationFramework {
+
+ class BVertexClosestTrackTool : virtual public BPhysVertexTrackBase {
+
+ private:
+ typedef BPhysVertexTrackBase super;
+
+ //
+ // internal helper class
+ //
+ protected:
+ class CtItem : public BaseItem {
+
+ public:
+ CtItem(std::string Name="_none_",
+ std::string Bname = "ctrk",
+ std::string Prefix="",
+ double Dca=-999., double DcaErr=-99.,
+ double Zca=-999., double ZcaErr=-99.,
+ double VtxNDErr2=-99., double TrkNDErr2=-99.,
+ double Phi0Used=-999.,
+ int NTrksChi2=0, xAOD::TrackParticle* CloseTrack=NULL,
+ TrackBag Tracks = {},
+ std::vector<std::vector<double> > Vtap = {},
+ std::vector<unsigned short> Selpat = {});
+
+ virtual ~CtItem();
+
+ virtual void setup(std::string Name="_none_",
+ std::string Bname="ctrk",
+ std::string Prefix="");
+ virtual void setup(std::string Name, std::string Bname,
+ std::string Prefix,
+ double Dca, double DcaErr,
+ double Zca, double ZcaErr,
+ double VtxNDErr2, double TrkNDErr2,
+ double Phi0Used,
+ int NTrksChi2,
+ xAOD::TrackParticle* CloseTrack=NULL,
+ TrackBag Tracks = {},
+ std::vector<std::vector<double> > Vtap = {},
+ std::vector<unsigned short> Selpat = {});
+ virtual void resetVals();
+ virtual void copyVals(const BaseItem& item);
+ virtual void copyVals(const CtItem& item);
+ virtual std::string dcaName();
+ virtual std::string dcaErrName();
+ virtual std::string zcaName();
+ virtual std::string zcaErrName();
+ virtual std::string vtxNDErr2Name();
+ virtual std::string trkNDErr2Name();
+ virtual std::string phi0UsedName();
+ virtual std::string nTrksChi2Name();
+ virtual std::string closeTrackName();
+ virtual std::string toString() const;
+
+ public:
+ mutable double dca;
+ mutable double dcaErr;
+ mutable double zca;
+ mutable double zcaErr;
+ mutable double vtxNDErr2;
+ mutable double trkNDErr2;
+ mutable double phi0Used;
+ mutable int nTrksChi2;
+ const xAOD::TrackParticle* closeTrack;
+ mutable TrackBag tracks;
+ mutable std::vector<std::vector<double> > vtap;
+ mutable std::vector<unsigned short> selpat;
+
+ }; // CtItem
+
+ public:
+ BVertexClosestTrackTool(const std::string& t, const std::string& n,
+ const IInterface* p);
+
+ protected:
+ // Hook methods
+ virtual StatusCode initializeHook();
+ virtual StatusCode finalizeHook();
+
+ virtual StatusCode addBranchesVCSetupHook(size_t ivc) const;
+
+ virtual StatusCode addBranchesSVLoopHook(const xAOD::Vertex* vtx) const;
+
+ virtual StatusCode calcValuesHook(const xAOD::Vertex* vtx,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const;
+ virtual bool fastFillHook(const xAOD::Vertex* vtx,
+ const int ipv) const;
+ private:
+ virtual StatusCode saveClosestTrack(const xAOD::Vertex* vtx) const;
+ virtual void initResults();
+ virtual void setResultsPrefix(std::string prefix) const;
+ virtual StatusCode logCloseTracksDebugInfo() const;
+
+ private:
+ // job options
+
+ std::vector<std::string> m_closeTrackChi2SetName;
+ std::vector<int> m_closeTrackCorrChi2;
+ std::vector<bool> m_minDCAin3D;
+ std::vector<double> m_closeTrackMaxLogChi2;
+ std::vector<double> m_nCloseTrackMaxLogChi2;
+
+ // results array
+ typedef boost::multi_array<CtItem, 4> CtItem4_t;
+ mutable CtItem4_t m_results;
+
+ // last run and event numbers seen
+ mutable unsigned int m_lastRunNumber;
+ mutable uint64_t m_lastEvtNumber;
+
+ // last secondary vertex (candidate) index
+ mutable unsigned int m_svIdx;
+
+ }; // BVertexClosestTrackTool
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_BVertexClosestTrackTool_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BVertexTrackIsoTool.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BVertexTrackIsoTool.h
new file mode 100644
index 00000000000..03e645b8514
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BVertexTrackIsoTool.h
@@ -0,0 +1,119 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BVertexTrackIsoTool.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Add B vertex track isolation information for different configurations,
+// different track selections and different PV-to-SV association methods.
+//
+// For an usage example see BPHY8.py .
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_BVertexTrackIsoTool_H
+#define DERIVATIONFRAMEWORK_BVertexTrackIsoTool_H
+
+#include "DerivationFrameworkBPhys/BPhysVertexTrackBase.h"
+#include "boost/multi_array.hpp"
+
+namespace InDet {
+ class IInDetTrackSelectionTool;
+}
+
+namespace DerivationFramework {
+
+ class BVertexTrackIsoTool : virtual public BPhysVertexTrackBase {
+
+ private:
+ typedef BPhysVertexTrackBase super;
+
+ //
+ // internal helper class
+ //
+ protected:
+ class IsoItem : public BaseItem {
+
+ public:
+ IsoItem(std::string Name="_none_", std::string Bname="iso",
+ std::string Prefix="",
+ double IsoValue=-1., int NTracks=0);
+ virtual ~IsoItem();
+
+ virtual void setup(std::string Name, std::string Bname="iso",
+ std::string Prefix="");
+ virtual void setup(std::string Name, std::string Bname,
+ std::string Prefix,
+ double IsoValue, int NTracks=0);
+ virtual void resetVals();
+ virtual void copyVals(const BaseItem& item);
+ virtual void copyVals(const IsoItem& item);
+ virtual std::string isoName();
+ virtual std::string nTracksName();
+
+ public:
+ mutable double isoValue;
+ mutable int nTracks;
+ }; // IsoItem
+
+ public:
+ BVertexTrackIsoTool(const std::string& t, const std::string& n,
+ const IInterface* p);
+
+ protected:
+ // Hook methods
+ virtual StatusCode initializeHook();
+ virtual StatusCode finalizeHook();
+
+ virtual StatusCode addBranchesVCSetupHook(size_t ivc) const;
+
+ virtual StatusCode addBranchesSVLoopHook(const xAOD::Vertex* vtx) const;
+
+ virtual StatusCode calcValuesHook(const xAOD::Vertex* vtx,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const;
+ virtual bool fastFillHook(const xAOD::Vertex* vtx,
+ const int ipv) const;
+
+ private:
+ virtual StatusCode saveIsolation(const xAOD::Vertex* vtx) const;
+ virtual StatusCode calculateIsolation(const xAOD::Vertex* vtx) const;
+ virtual StatusCode calcIsolation(const IsoItem& iso,
+ const xAOD::Vertex* vtx,
+ const double coneSize,
+ const double logChi2Max,
+ const int doLogChi2,
+ const ToolHandle<TrkSelTool>& tSelTool,
+ const xAOD::BPhysHelper::pv_type
+ pvAssocType,
+ const int trackTypes ) const;
+
+ virtual void initResults();
+ virtual void setResultsPrefix(std::string prefix) const;
+
+ virtual std::string buildBranchName(unsigned int ic,
+ unsigned int its,
+ unsigned int ipv,
+ unsigned int itt) const;
+
+ private:
+ // job options
+ std::vector<double> m_isoConeSizes;
+ std::vector<double> m_isoTrkImpLogChi2Max;
+ std::vector<int> m_isoDoTrkImpLogChi2Cut;
+ bool m_useOptimizedAlgo;
+
+ // results array
+ typedef boost::multi_array<IsoItem, 4> IsoItem4_t;
+ mutable IsoItem4_t m_results;
+
+ }; // BVertexTrackIsoTool
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_BVertexTrackIsoTool_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BmumuThinningTool.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BmumuThinningTool.h
new file mode 100644
index 00000000000..bba64bb5fcb
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/BmumuThinningTool.h
@@ -0,0 +1,441 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//
+/**
+ * @file BmumuThinningTool.h
+ * @author Wolfgang Walkowiak <wolfgang.walkowiak@cern.ch>
+ *
+ * @brief Primary vertex, track and muon thinning for Bmumu analysis.
+ */
+
+#ifndef DERIVATIONFRAMEWORK_BmumuThinningTool_H
+#define DERIVATIONFRAMEWORK_BmumuThinningTool_H
+
+#include "DerivationFrameworkBPhys/CfAthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IThinningTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+
+#include <string>
+
+class IThinningSvc;
+
+namespace SG {
+ class AuxElement;
+}
+
+namespace xAOD {
+ class AuxContainerBase;
+}
+
+namespace DerivationFramework {
+ ///
+ /// @class BmumuThinningTool
+ /// @author Wolfgang Walkowiak <wolfgang.walkowiak@cern.ch>
+ ///
+ /// @brief Primary vertex, track and muon thinning for Bmumu analysis.
+ ///
+ /// This class provides a thinning tool to thin the primary vertex,
+ /// the muon and calibrated muon collections as well as the inner
+ /// detector track selection depending on:
+ /// - the selected secondary vertices
+ /// - the selected PV-to-SV vertex association method
+ /// - additional track sub-collection (e.g. "closest tracks")
+ ///
+ /// This tool is primarily written for the B(s)->mumu analysis
+ /// and used by the BPHY8 derivation.
+ ///
+ /// ### Job options
+ /// <table border="0">
+ /// <tr><th align="left">Name</td>
+ /// <th align="left">Description</th></tr>
+ /// <tr><td valign="top">ThinningService</td>
+ /// <td>Thinning service handle</td></tr>
+ /// <tr><td valign="top">TrackParticleContainerName</td>
+ /// <td>TrackParticle container name
+ /// (default: InDetTrackParticles)</td></tr>
+ /// <tr><td valign="top">VertexContainerNames</td>
+ /// <td>List of secondary vertex container names</td></tr>
+ /// <tr><td valign="top">VertexPassFlags</td>
+ /// <td>List of pass flags for the seconary vertices
+ /// empty list lets all vertices pass.
+ /// List length needs to be identical to length of
+ /// VertexContainerNames list if AlignPassToVertexList
+ /// is True</td></tr>
+ /// <tr><td valign="top">AlignPassToVertexList</td>
+ /// <td>Align VertexPassFlags to VertexContainerNames list?
+ /// This option causes a 1:1 correlation between the two lists,
+ /// i.e. a flag is only applied to the corresponding container
+ /// if this option is set to True. (default: false)</td></tr>
+ /// <tr><td valign="top">PVContainerName</td>
+ /// <td>Primary vertex container name</td></tr>
+ /// <tr><td valign="top">RefPVContainerNames</td>
+ /// <td>Refitted primary vertex container names.
+ /// This list must be of same length and order as the
+ /// m_vtxContNames list.
+ /// (or empty: no thinning of refitted primary
+ /// vertex containers)</td></tr>
+ /// <tr><td valign="top">MuonContainerName</td>
+ /// <td> Name of the used muon container (default: "")</td></tr>
+ /// <tr><td valign="top">CalibMuonContainerName</td>
+ /// <td>Name of the calibrated muons container (default: "")</td></tr>
+ /// <tr><td valign="top">CloseTrackBranchBaseName</td>
+ /// <td>Closest track branch base name</td></tr>
+ /// <tr><td valign="top">CloseTrackBranchPrefixes</td>
+ /// <td>Closest track branch prefixes</td></tr>
+ /// <tr><td valign="top">KeepTracksForSelectedPVs</td>
+ /// <td>Keep tracks for selected (refitted) primary vertices?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">MatchCalibratedMuons</td>
+ /// <td>Match vertex muons with calibrated muons?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">MarkMatchedMuons</td>
+ /// <td>Mark orginal muons for matched calibrated muons as well?
+ /// (only makes sense if MatchCalibratedMuons = True;
+ /// default: false)</td></tr>
+ /// <tr><td valign="top">MarkMatchedCalMuons</td>
+ /// <td>Mark calibrated muons for matched calibrated muons as well?
+ /// (only makes sense if MatchedCalibratedMuons = False;
+ /// default: false)</td></tr>
+ /// <tr><td valign="top">SyncMatchedMuonsBothWays</td>
+ /// <td> Force syncing marked muons both ways?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">AllowFastMuonMaskSync</td>
+ /// <td>Allow fast sync of myon masks?
+ /// (Set to 'False' to force in-depth synchronization
+ /// of muon masks. Default: false)</td></tr>
+ /// <tr><td valign="top">KeepCloseTracks</td>
+ /// <td>Keep tracks for closest tracks? (default: false)</td></tr>
+ /// <tr><td valign="top">KeepTracksForMuons</td>
+ /// <td>Keep tracks for selected muons? (default: false)</td></tr>
+ /// <tr><td valign="top">KeepTracksForCalMuons</td>
+ /// <td>Keep tracks for selected calibrated muons?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">KeepMuonsForTracks</td>
+ /// <td>Keep (original) muons for selected tracks?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">KeepCalMuonsForTracks</td>
+ /// <td>Keep calibrated muons for selected tracks?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">ApplyAndForVertices</td>
+ /// <td>Apply AND for mask matching for vertices?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">ApplyAndForTracks</td>
+ /// <td>Apply AND for mask matching for tracks?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">ApplyAndForMuons</td>
+ /// <td>Apply AND for mask matching for muons?
+ /// (default: false)</td></tr>
+ /// <tr><td valign="top">ThinPVs"</td>
+ /// <td>Thin primary vertex collection? (default: true)</td></tr>
+ /// <tr><td valign="top">ThinRefittedPVs"</td>
+ /// <td>Thin refitted primary vertex collection?
+ /// (default: true)</td></tr>
+ /// <tr><td valign="top">ThinTracks"</td>
+ /// <td>Thin ID track collection?
+ /// (default: true)</td></tr>
+ /// <tr><td valign="top">ThinMuons"</td>
+ /// <td>Thin muon collections?
+ /// (default: true)</td></tr>
+ /// </table>
+ ///
+ class BmumuThinningTool : public CfAthAlgTool, public IThinningTool {
+
+ // useful typedefs
+ typedef xAOD::BPhysHelper::pv_type pv_type;
+ typedef ElementLink<xAOD::TrackParticleContainer> TrackParticleLink;
+
+ public:
+ /// @name pv_type to string map
+ // Note: may later be migrated to xAODBPhys/BPhysHelper
+ static std::map<pv_type, std::string> PvTypeToVarNameMap;
+
+ public:
+ /// @brief Main constructor
+ BmumuThinningTool(const std::string& t, const std::string& n,
+ const IInterface* p);
+ /// @brief Default destructor
+ ~BmumuThinningTool();
+ /// @brief Initialize tool
+ StatusCode initialize();
+ /// @brief Finalize tool
+ StatusCode finalize();
+ /// @brief Main thinning method executed for each event
+ virtual StatusCode doThinning() const;
+
+ protected:
+ ///
+ /// @brief Helper checking for hypothesis passing
+ ///
+ /// Helper to check whether an element is marked as passing a specific
+ /// hypothesis.
+ ///
+ /// @param[in] em auxillary storage element
+ /// @param[in] hypo name of the hypothesis
+ /// @returns true if hypothesis element contains true
+ ///
+ bool pass(const SG::AuxElement& em, std::string hypo) const;
+ ///
+ /// @brief Helper to get a TrackParticle link
+ ///
+ /// @param[in] vtx secondary vertex containing link
+ /// @param[in] name name of the link
+ /// @returns pointer to TrackParticle (NULL if not found)
+ ///
+ const xAOD::TrackParticle* getTrackParticle(const xAOD::Vertex* vtx,
+ std::string name) const;
+
+ template<typename TYPE>
+ StatusCode applyThinMask(SG::ThinningHandle<TYPE> &trkCont,
+ const std::vector<bool>& trkMask,
+ bool doAnd) const;
+
+
+ ///
+ /// @brief Mark muons matched to secondary vertices
+ ///
+ /// @param[in] muCont pointer to MuonContainer
+ /// @param[in,out] muMask vector with mask per muon
+ /// @param[in] vtx secondary vertex
+ /// @param[in] counterName name of counter
+ /// @returns StatusCode
+ ///
+ StatusCode matchMuons(const xAOD::MuonContainer* muCont,
+ std::vector<bool>& muMask,
+ xAOD::BPhysHelper& vtx,
+ std::string counterName) const;
+ ///
+ /// @name Sync-mark methods
+ ///
+ /// @{
+ ///
+ /// @brief Mark original muons for accepted calibrated muons
+ ///
+ /// @param[in] muCont pointer to MuonContainer of
+ /// (original) muons
+ /// @param[in] cmuCont pointer to MuonContainer of
+ /// calibrated muons
+ /// @param[in,out] muMask mask for (original) muons
+ /// @param[in] cmuMask mask for calibrated muons
+ /// @param[in] counterName base name for counters
+ /// @param[in] allowFastSync use fast synchronization method
+ /// @returns StatusCode
+ ///
+ StatusCode markOrigMuons(const xAOD::MuonContainer* muCont,
+ const xAOD::MuonContainer* cmuCont,
+ std::vector<bool>& muMask,
+ std::vector<bool>& cmuMask,
+ std::string counterName,
+ bool allowFastSync=true) const;
+ ///
+ /// @brief Mark calibrated muons for accepted (original) muons
+ ///
+ /// @param[in] muCont pointer to MuonContainer of
+ /// (original) muons
+ /// @param[in] cmuCont pointer to MuonContainer of
+ /// calibrated muons
+ /// @param[in] muMask mask for (original) muons
+ /// @param[in,out] cmuMask mask for calibrated muons
+ /// @param[in] counterName base name for counters
+ /// @param[in] allowFastSync use fast synchronization method
+ /// @returns StatusCode
+ ///
+ StatusCode markCalibMuons(const xAOD::MuonContainer* muCont,
+ const xAOD::MuonContainer* cmuCont,
+ std::vector<bool>& muMask,
+ std::vector<bool>& cmuMask,
+ std::string counterName,
+ bool allowFastSync) const;
+ ///
+ /// @brief Mark ID tracks of selected (original or calibrated) muons
+ ///
+ /// @param[in] trkPartCont pointer to TrackParticle container
+ /// @param[in,out] trkMask mask for tracks
+ /// @param[in] muCont pointer to MuonContainer
+ /// @param[in] muMask mask for muons
+ /// @param[in] counterName base name for counters
+ /// @returns StatusCode
+ ///
+ StatusCode markTrksForSelMuons(const xAOD::TrackParticleContainer*
+ trkPartCont,
+ std::vector<bool>& trkMask,
+ const xAOD::MuonContainer* muCont,
+ std::vector<bool>& muMask,
+ std::string counterName) const;
+ ///
+ /// @brief Mark muons for selected ID tracks
+ ///
+ /// @param[in] trkPartCont pointer to TrackParticle container
+ /// @param[in] trkMask mask for tracks
+ /// @param[in,out] muCont pointer to MuonContainer
+ /// @param[in] muMask mask for muons
+ /// @param[in] counterName base name for counters
+ /// @returns StatusCode
+ ///
+ StatusCode markMuonsForSelTracks(const xAOD::TrackParticleContainer*
+ trkPartCont,
+ std::vector<bool>& trkMask,
+ const xAOD::MuonContainer* muCont,
+ std::vector<bool>& muMask,
+ std::string counterName) const;
+ /// @}
+ ///
+
+ ///
+ /// @brief Obtain all auxillary elements matching a certain pattern.
+ ///
+ /// Helper to filter all names of auxillary elements of an aux container
+ /// according to a certain pattern. The pattern must be a regular
+ /// expression pattern.
+ ///
+ /// @param[in] auxCont pointer to AuxContainer
+ /// @param[in] pattern regular expression pattern to be matched by names
+ /// @returns vector<string> of auxillary element names
+ ///
+ std::vector<std::string>
+ filterAuxElements(const xAOD::AuxContainerBase* auxCont,
+ std::string pattern) const;
+ ///
+ /// @brief Determine aux elements to be looked at -- for (refitted) PVs
+ ///
+ /// @param[in] auxCont pointer to AuxContainer
+ /// @param[out] vLinkNames vector of aux element names selected
+ /// @param[out] vLinkTypes vector of PV-to-SV types corresponding to
+ /// aux element names selected
+ /// @param[in] pattern regular expression pattern to be matched by names
+ ///
+ void selectAuxElements(const xAOD::AuxContainerBase* auxCont,
+ std::vector<std::string>& vLinkNames,
+ std::vector<pv_type>& vLinkTypes,
+ std::string pattern) const;
+ ///
+ /// @brief Determine aux elements to be looked at -- for closest tracks
+ ///
+ /// @param[in] auxCont pointer to AuxContainer
+ /// @param[out] vLinkNames vector of aux element names selected
+ /// @param[in] vPrefixes vector of prefixes to be concatenated with
+ /// pattern for search
+ /// @param[out] vLinkTypes vector of PV-to-SV types corresponding to
+ /// aux element names selected
+ /// @param[in] pattern regular expression pattern to be matched by names
+ ///
+ void selectAuxElements(const xAOD::AuxContainerBase* auxCont,
+ std::vector<std::string>& vLinkNames,
+ std::vector<std::string> vPrefixes,
+ std::vector<pv_type>& vLinkTypes,
+ std::string pattern) const;
+ ///
+ /// @brief Dump a vector<str> to a string
+ ///
+ /// @param[in] vs vector<string> to be dumped
+ /// @param[in] header header string to be prepended
+ /// @param[in] nBlanks number of blanks to prepend each line with
+ ///
+ std::string dumpVS(const std::vector<std::string>& vs,
+ const std::string header="",
+ size_t nBlanks=0) const;
+ ///
+ /// @brief Wrap string at line breaks and print with
+ /// appropriate message level
+ ///
+ /// @param[in] str string to be printed
+ /// @param[in] lvl MSG::Level chosen
+ ///
+ void logWrappedMsg(const std::string& str, const MSG::Level lvl) const;
+ ///
+ /// @brief Check two masks for consistency
+ ///
+ /// This is a method returning debugging information.
+ ///
+ /// @param[in] mask1 first mask vector to be checked
+ /// @param[in] mask2 second mask vector to be checked
+ /// @param[in] name1 name of first mask vector
+ /// @param[in] name2 name of second mask vector
+ /// @param[in] header text to be prepended to output string
+ /// @returns string with debugging information
+ ///
+ std::string checkMaskConsistency(const std::vector<bool>& mask1,
+ const std::vector<bool>& mask2,
+ const std::string name1,
+ const std::string name2,
+ const std::string header="") const;
+
+ private:
+ ///
+ /// @name Job options
+ /// @{
+ ServiceHandle<IThinningSvc> m_thinningSvc;
+ std::string m_trkPartContName;
+ std::vector<std::string> m_vtxContNames;
+ std::vector<std::string> m_vtxPassFlags;
+ std::string m_PVContName;
+ std::vector<std::string> m_refPVContNames;
+ std::string m_muonContName;
+ std::string m_calMuonContName;
+ std::string m_ctBranchBaseName;
+ std::vector<std::string> m_ctBranchPrefixes;
+ bool m_alignPassToVertexList;
+ bool m_keepPVTracks;
+ bool m_matchCalMuons;
+ bool m_markMuons;
+ bool m_markCalMuons;
+ bool m_syncMuonsBothWays;
+ bool m_keepCloseTracks;
+ bool m_keepSelMuonTracks;
+ bool m_keepSelCalMuonTracks;
+ bool m_keepSelTrackMuons;
+ bool m_keepSelTrackCalMuons;
+ bool m_allowFastMuonMaskSync;
+ bool m_thinPVs;
+ bool m_thinRefPVs;
+ bool m_thinTracks;
+ bool m_thinMuons;
+ bool m_vertexAnd;
+ bool m_trackAnd;
+ bool m_muonAnd;
+ /// @}
+
+ ///
+ /// @name internal member variables
+ ///
+ /// process close tracks
+ bool m_doCloseTracks;
+ /// process primary vertices
+ bool m_doPVs;
+ /// process refitted primary vertices
+ bool m_doRefPVs;
+ /// process (original) muons
+ bool m_doMuons;
+ /// process refitted muons
+ bool m_doCalMuons;
+ /// process ID tracks
+ bool m_doTracks;
+ /// @}
+
+ ///
+ /// @name aux element link name caches
+ ///
+ /// @{
+ ///
+ /// caching aux element link names (and pv types)
+ /// for original and refitted PVs
+ ///
+ mutable std::vector<std::vector<std::string> > m_vvOrigPVLinkNames;
+ mutable std::vector<std::vector<pv_type> > m_vvOrigPVLinkTypes;
+ mutable std::vector<std::vector<std::string> > m_vvRefPVLinkNames;
+ mutable std::vector<std::vector<pv_type> > m_vvRefPVLinkTypes;
+
+ ///
+ /// caching aux element link names (and pv types)
+ /// for closest tracks
+ mutable std::vector<std::vector<std::string> > m_vvCtLinkNames;
+ mutable std::vector<std::vector<pv_type> > m_vvCtLinkTypes;
+ /// @}
+
+ };
+
+} // namespace DerivationFramework
+
+#endif // DERIVATIONFRAMEWORK_BmumuThinningTool_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Bmumu_metadata.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Bmumu_metadata.h
new file mode 100644
index 00000000000..4e040a8ad14
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Bmumu_metadata.h
@@ -0,0 +1,42 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file Bmumu_metadata.h
+ * @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch>
+ *
+ * @brief Store JO metadata specific to the Bmumu analysis.
+ */
+
+#ifndef DERIVATIONFRAMEWORK_Bmumu_metadata_H
+#define DERIVATIONFRAMEWORK_Bmumu_metadata_H
+
+#include <string>
+#include <map>
+#include <vector>
+
+#include "DerivationFrameworkBPhys/BPhysMetadataBase.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "GaudiKernel/ToolHandle.h"
+
+namespace DerivationFramework {
+ ///
+ /// @class Bmumu_metadata
+ /// @author Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+ ///
+ /// @brief Store JO metadata specific to the Bmumu analysis.
+ ///
+ /// Store JO metadata specific to the Bmumu analysis in the output file.
+ /// This class inherits from BPhysMetadataBase.
+ ///
+ class Bmumu_metadata : virtual public BPhysMetadataBase {
+ public:
+ /// @brief Main constructor
+ Bmumu_metadata(const std::string& t, const std::string& n,
+ const IInterface* p);
+ }; // class
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_Bmumu_metadata_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Bmumu_reco_mumu.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Bmumu_reco_mumu.h
new file mode 100644
index 00000000000..efe1ab4ee91
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Bmumu_reco_mumu.h
@@ -0,0 +1,73 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// Bmumu_reco_mumu.h
+///////////////////////////////////////////////////////////////////
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Original author (Reco_mumu):
+// Daniel Scheirich <daniel.scheirich@cern.ch>
+//
+// Changes:
+// Basic dimuon reconstruction for the derivation framework.
+// This class inherits from CfAthAlgTool instead of AthAlgTool in order
+// to have access to the CutFlowSvc instance.
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_Bmumu_reco_mumu_H
+#define DERIVATIONFRAMEWORK_Bmumu_reco_mumu_H
+
+#include <string>
+
+#include "DerivationFrameworkBPhys/CfAthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/JpsiFinder.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+
+/** forward declarations
+ */
+namespace Trk {
+ class V0Tools;
+}
+
+/** THE reconstruction tool
+ */
+namespace DerivationFramework {
+
+ class Bmumu_reco_mumu : public CfAthAlgTool, public IAugmentationTool {
+ public:
+ Bmumu_reco_mumu(const std::string& t, const std::string& n,
+ const IInterface* p);
+
+ StatusCode initialize();
+ StatusCode finalize();
+
+ virtual StatusCode addBranches() const;
+
+ private:
+ /** tools
+ */
+ ToolHandle<Trk::V0Tools> m_v0Tools;
+ ToolHandle<Analysis::JpsiFinder> m_jpsiFinder;
+ ToolHandle<Analysis::PrimaryVertexRefitter> m_pvRefitter;
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+
+ /** job options
+ */
+ std::string m_outputVtxContainerName;
+ std::string m_pvContainerName;
+ std::string m_refPVContainerName;
+ bool m_refitPV;
+ int m_PV_max;
+ int m_DoVertexType;
+ size_t m_PV_minNTracks;
+ bool m_do3d;
+ };
+}
+
+#endif // DERIVATIONFRAMEWORK_Bmumu_reco_mumu_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Cascade3Plus1.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Cascade3Plus1.h
new file mode 100644
index 00000000000..7ed5f72f719
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Cascade3Plus1.h
@@ -0,0 +1,99 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef DERIVATIONFRAMEWORKBPHYS_CASCADE3PLUS1_H
+#define DERIVATIONFRAMEWORKBPHYS_CASCADE3PLUS1_H
+//*********************
+// Cascade3Plus1 header file
+//
+// Adam Barton <abarton@cern.ch>
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include <vector>
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "xAODTracking/TrackParticle.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include "InDetConversionFinderTools/VertexPointEstimator.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+
+namespace Trk {
+ class IVertexFitter;
+ class TrkVKalVrtFitter;
+ class VxTrackAtVertex;
+ class ITrackSelectorTool;
+ class VxCascadeInfo;
+ class V0Tools;
+}
+
+
+namespace DerivationFramework {
+ class CascadeTools;
+}
+
+namespace DerivationFramework {
+ static const InterfaceID IID_Cascade3Plus1("Cascade3Plus1", 1, 0);
+class Cascade3Plus1 : virtual public AthAlgTool, public IAugmentationTool
+{
+
+public:
+ static const InterfaceID& interfaceID() { return IID_Cascade3Plus1;}
+ Cascade3Plus1(const std::string& t, const std::string& n, const IInterface* p);
+ virtual ~Cascade3Plus1();
+ virtual StatusCode initialize() override;
+ virtual StatusCode addBranches() const override;
+
+private:
+ static constexpr int s_topoN = 2;
+
+ ToolHandle < Trk::ITrackSelectorTool > m_trkSelector;
+ ToolHandle < Trk::TrkVKalVrtFitter > m_iVertexFitter;
+ ToolHandle < Trk::V0Tools > m_V0Tools;
+ ToolHandle < DerivationFramework::CascadeTools > m_CascadeTools;
+ ToolHandle < Analysis::PrimaryVertexRefitter > m_pvRefitter;
+ ToolHandle < InDet::VertexPointEstimator > m_vertexEstimator;
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+
+ std::unique_ptr<Trk::VxCascadeInfo> CascadeFit(std::array<const xAOD::TrackParticle*, 4> &Track)const;
+
+ std::vector<double> m_trackMasses;
+ std::vector<std::string> m_cascadeOutputsKeys;
+ double m_2trackmassMin = 979.45;
+ double m_2trackmassMax = 1059.45;
+ double m_3trackmassMin = 1800.47;
+ double m_3trackmassMax = 2168.47;
+ double m_4trackmassMin = 5200.0;
+ double m_4trackmassMax = 5450.0;
+ double m_3tracksMass = 1968.47;
+ double m_4tracksMass = 5366.79;
+ double m_2tracksMass = 0;
+
+ double m_4trackmassFinalMin = 0;
+ double m_4trackmassFinalMax = 0;
+ std::string m_hypoName; //!< name of the mass hypothesis. E.g. Jpsi, Upsi, etc. Will be used as a prefix for decorations
+ std::string m_3TrackName;
+ int m_PV_max;
+ int m_DoVertexType;
+ size_t m_PV_minNTracks;
+ std::string m_VxPrimaryCandidateName; //!< Name of primary vertex container
+ std::string m_refPVContainerName;
+ double m_Chi2NDFCut=0.;
+ float m_3TrackChi2NDFCut=0.;
+ double m_tauCut = -999999;
+ bool m_refitPV;
+ bool m_3TrackMassConstraint = false;
+ bool m_2TrackMassConstraint = false;
+ bool m_eliminateBad3Tracksfrom4Track = false;
+ bool m_copyAllVertices = false;
+ std::bitset<4> m_muonTrackBit{0};
+ std::vector<int> m_requireMuonsOnTrack;
+ std::string m_3TrackVertexOutput;
+ std::unique_ptr<xAOD::Vertex> StandardFit(const std::vector<const xAOD::TrackParticle*> &inputTracks, const xAOD::TrackParticleContainer* importedTrackCollection) const;
+ std::vector<double> m_ptCutPerTrack;
+ std::array<double, 3> m_ptCutPerVertex;
+ const std::vector<const xAOD::TrackParticle*>& ApplyAdditionalCuts(const std::vector<const xAOD::TrackParticle*>&,
+ const std::vector<const xAOD::TrackParticle*>&,
+ std::vector<const xAOD::TrackParticle*>&, size_t) const;
+};
+}
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/CascadeTools.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/CascadeTools.h
new file mode 100644
index 00000000000..932b814d3d2
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/CascadeTools.h
@@ -0,0 +1,87 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef DERIVATIONFRAMEWORKBPHYS_CASCADETOOLS_H
+#define DERIVATIONFRAMEWORKBPHYS_CASCADETOOLS_H
+//*********************
+// CascadeTools header file
+//
+// Eva Bouhova <e.bouhova@cern.ch>
+// Adam Barton <abarton@cern.ch>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "CLHEP/Vector/LorentzVector.h"
+#include "xAODTracking/Vertex.h"
+
+
+namespace DerivationFramework {
+
+ static const InterfaceID IID_CascadeTools("CascadeTools", 1, 1);
+
+ class CascadeTools : public AthAlgTool{
+
+ public:
+
+/**
+ * Default constructor due to Athena interface
+ */
+ CascadeTools(const std::string& t, const std::string& n, const IInterface* p);
+
+/**
+ * Virtual destructor
+ */
+ ~CascadeTools();
+
+/**
+ * Standard AlgTool methods
+ */
+ //Nothing done not needed
+ //StatusCode initialize() override;
+ //StatusCode finalize() override;
+
+/**
+ * AlgTool interface methods
+ */
+ static const InterfaceID& interfaceID()
+ {
+ return IID_CascadeTools;
+ }
+
+
+ Amg::Vector3D momentum(const std::vector<TLorentzVector> &particleMom) const;
+ Amg::Vector3D pca(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+
+ double invariantMass(const std::vector<TLorentzVector> &moms, const std::vector<double> &masses) const;
+ double invariantMass(const std::vector<TLorentzVector> &moms) const;
+ double invariantMassError(const std::vector<TLorentzVector> &moms, const Amg::MatrixX& cov, const std::vector<double> &masses) const;
+ double invariantMassError(const std::vector<TLorentzVector> &moms, const Amg::MatrixX& cov) const;
+ double pT(const std::vector<TLorentzVector> &moms) const;
+ double pTError(const std::vector<TLorentzVector> &moms, const Amg::MatrixX& cov) const;
+ double lxy(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double lxyError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double tau(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double tauError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double tau(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV, double M) const;
+ double tauError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV, double M) const;
+ double a0z(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double a0zError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double a0xy(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double a0xyError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double a0(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double a0Error(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double cosTheta(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double cosTheta_xy(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const;
+ double massProbability(double V0Mass, double mass, double massErr) const;
+ double vertexProbability(int ndf, double chi2) const;
+
+ Amg::MatrixX * convertCovMatrix(const xAOD::Vertex * vxCandidate) const;
+ Amg::MatrixX SetFullMatrix(int NTrk, const std::vector<float> & Matrix) const;
+
+ //private:
+
+ }; //end of class definitions
+
+} //end of namespace definitions
+
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/CfAthAlgTool.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/CfAthAlgTool.h
new file mode 100644
index 00000000000..f5280c5ccde
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/CfAthAlgTool.h
@@ -0,0 +1,86 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// CfAthAlgTool.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Wrapper around AthAlgTool to provide easy access to CutFlowSvc
+// and some utility methods for it.
+// Methods for accessing the CutFlowSvc are modelled after
+// AthFilterAlgorithm's implementation.
+//
+// This class inherits from AthAlgTool. It should be inherited from.
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_CfAthAlgTool_H
+#define DERIVATIONFRAMEWORK_CfAthAlgTool_H
+
+#include "GaudiKernel/ToolHandle.h"
+#include "GaudiKernel/ServiceHandle.h"
+#include "AthenaKernel/ICutFlowSvc.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+
+#include <string>
+#include <map>
+
+namespace DerivationFramework {
+
+ class CfAthAlgTool : public AthAlgTool {
+ public:
+ // constructor with parameters
+ CfAthAlgTool(const std::string& t, const std::string& n,
+ const IInterface* p);
+ // destructor
+ virtual ~CfAthAlgTool();
+
+ // return a handle to an ICutFlowSvc instance
+ ServiceHandle<ICutFlowSvc>& cutFlowSvc() const;
+
+ // Initialization method invoked by the framework.
+ virtual StatusCode sysInitialize() override;
+
+ // add event to a named counter -- returns counts after adding
+ virtual bool addEvent(const std::string &name, double weight=1.) const;
+
+ // add to a named counter -- returns counts after adding
+ // if counts > 1 : same weight is added multiple times
+ virtual bool addToCounter(const std::string &name, uint64_t counts=1,
+ double weight=1.) const;
+
+ protected:
+ // add a counter by name -- returns id if it already exists
+ virtual CutIdentifier getCounter(const std::string &name) const;
+
+ // returns counter name by id
+ virtual std::string getCounterNameById(CutIdentifier id) const;
+
+ // returns counter id by name
+ virtual CutIdentifier getCounterIdByName(const std::string &name) const;
+
+ private:
+ // typedef for ServiceHandle<ICutFlowSvc>
+ typedef ServiceHandle<ICutFlowSvc> ICutFlowSvc_t;
+ // handle to the service holding tables of cut-flows for filtering algs.
+ mutable ICutFlowSvc_t m_cutFlowSvc;
+
+ // base name for counters
+ std::string m_ctbasename;
+
+ // map of counter names to counter ids
+ typedef std::map<std::string, CutIdentifier> NameIdMap_t;
+ mutable NameIdMap_t m_mctn;
+
+ // base counter
+ mutable CutIdentifier m_bid;
+ mutable bool m_bidisset;
+
+ }; // class
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_CfAthAlgTool_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/FourMuonTool.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/FourMuonTool.h
new file mode 100644
index 00000000000..88348740f02
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/FourMuonTool.h
@@ -0,0 +1,188 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// ****************************************************************************
+// ----------------------------------------------------------------------------
+// FourMuonTool header file
+//
+// James Catmore <James.Catmore@cern.ch>
+
+// ----------------------------------------------------------------------------
+// ****************************************************************************
+#ifndef BPHY4TOOL_H
+#define BPHY4TOOL_H
+#include "AthenaBaseComps/AthAlgorithm.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "InDetConversionFinderTools/InDetConversionFinderTools.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+#include "xAODMuon/Muon.h"
+#include "xAODMuon/MuonContainer.h"
+
+#include <vector>
+#include <string>
+/////////////////////////////////////////////////////////////////////////////
+
+namespace Trk {
+ class IVertexFitter;
+ // class VxCandidate;
+ // class TrackParticleBase;
+ // class VxTrackAtVertex;
+ // class RecVertex;
+ class TrkV0VertexFitter;
+ class ITrackSelectorTool;
+ class V0Tools;
+ // class ExtendedVxCandidate;
+}
+
+namespace InDet { class VertexPointEstimator; class BeamSpotData;}
+
+namespace DerivationFramework {
+
+ static const InterfaceID IID_FourMuonTool("FourMuonTool", 1, 0);
+
+ // Struct and enum to associate muon pairs with track pairs
+ // and make the program flow more straightforward
+ struct Combination
+ {
+ std::vector<const xAOD::Muon*> muons;
+ std::vector<unsigned int> quadIndices;
+ std::pair<unsigned int, unsigned int> pairIndices;
+
+ std::string combinationCharges() {
+ std::string chargeStr = "";
+ if (muons.at(0)->charge() > 0) {chargeStr += "+";}
+ else {chargeStr += "-";}
+ if (muons.at(1)->charge() > 0) {chargeStr += "+";}
+ else {chargeStr += "-";}
+ if (muons.size()==4) {
+ if (muons.at(2)->charge() > 0) {chargeStr += "+";}
+ else {chargeStr += "-";}
+ if (muons.at(3)->charge() > 0) {chargeStr += "+";}
+ else {chargeStr += "-";}
+ }
+ return chargeStr;
+ }
+
+ std::string combinationIndices() {
+ std::string indexStr = "";
+ std::stringstream ss;
+ if (muons.size()==2) {
+ ss.str(""); ss.clear();
+ ss << pairIndices.first;
+ indexStr+=ss.str();
+ ss.str(""); ss.clear();
+ ss << pairIndices.second;
+ indexStr+=ss.str();
+ }
+ if (muons.size()==4) {
+ for (unsigned int i=0; i<4; ++i) {
+ ss.str(""); ss.clear();
+ ss << quadIndices[i];
+ indexStr+=ss.str();
+ }
+ }
+ return indexStr;
+ }
+
+ const xAOD::TrackParticle* GetMuonTrack(const xAOD::Muon* mu) const{
+ auto& link = mu->inDetTrackParticleLink();
+ return link.isValid() ? *link : nullptr;
+ }
+
+ std::vector<const xAOD::TrackParticle*> trackParticles(std::string specify) {
+ std::vector<const xAOD::TrackParticle*> theTracks;
+ bool oppCh(false);
+ if (muons.at(0)->charge()*muons.at(1)->charge() < 0) oppCh=true;
+ if (specify=="pair1") {
+ theTracks.push_back(GetMuonTrack(muons.at(0)));
+ theTracks.push_back(GetMuonTrack(muons.at(1)));
+ }
+ if (specify=="pair2") {
+ theTracks.push_back(GetMuonTrack(muons.at(2)));
+ theTracks.push_back(GetMuonTrack(muons.at(3)));
+ }
+ if (specify=="DC") {
+ if (oppCh) {
+ theTracks.push_back(GetMuonTrack(muons.at(0)));
+ theTracks.push_back(GetMuonTrack(muons.at(1)));
+ theTracks.push_back(GetMuonTrack(muons.at(2)));
+ theTracks.push_back(GetMuonTrack(muons.at(3)));
+ } else {
+ theTracks.push_back(GetMuonTrack(muons.at(0)));
+ theTracks.push_back(GetMuonTrack(muons.at(2)));
+ theTracks.push_back(GetMuonTrack(muons.at(1)));
+ theTracks.push_back(GetMuonTrack(muons.at(3)));
+ }
+ }
+ if (specify=="AC") {
+ theTracks.push_back(GetMuonTrack(muons.at(0)));
+ theTracks.push_back(GetMuonTrack(muons.at(3)));
+ theTracks.push_back(GetMuonTrack(muons.at(1)));
+ theTracks.push_back(GetMuonTrack(muons.at(2)));
+ }
+ if (specify=="SS") {
+ if (oppCh) {
+ theTracks.push_back(GetMuonTrack(muons.at(0)));
+ theTracks.push_back(GetMuonTrack(muons.at(2)));
+ theTracks.push_back(GetMuonTrack(muons.at(1)));
+ theTracks.push_back(GetMuonTrack(muons.at(3)));
+ } else {
+ theTracks.push_back(GetMuonTrack(muons.at(0)));
+ theTracks.push_back(GetMuonTrack(muons.at(1)));
+ theTracks.push_back(GetMuonTrack(muons.at(2)));
+ theTracks.push_back(GetMuonTrack(muons.at(3)));
+ }
+ }
+ return theTracks;
+ }
+
+ };
+
+ class FourMuonTool: virtual public AthAlgTool
+ {
+ public:
+ FourMuonTool(const std::string& t, const std::string& n, const IInterface* p);
+ ~FourMuonTool();
+ StatusCode initialize();
+
+ static const InterfaceID& interfaceID() { return IID_FourMuonTool;}
+
+ //-------------------------------------------------------------------------------------
+ //Doing Calculation and inline functions
+ StatusCode performSearch(xAOD::VertexContainer*& pairVxContainer, xAOD::VertexAuxContainer*& pairVxAuxContainer,
+ xAOD::VertexContainer*& quadVxContainer, xAOD::VertexAuxContainer*& quadVxAuxContainer, bool &acceptEvent) const;
+ xAOD::Vertex* fit(const std::vector<const xAOD::TrackParticle*>& ,const xAOD::TrackParticleContainer* importedTrackCollection, const Amg::Vector3D &beamSpot) const;
+ static std::vector<std::vector<unsigned int> > getQuadIndices(unsigned int length);
+ static std::vector<std::pair<unsigned int, unsigned int> > getPairIndices(unsigned int length);
+ static std::vector<std::vector<unsigned int> > mFromN(unsigned int m, unsigned int n);
+ static void combinatorics(unsigned int offset,
+ unsigned int k,
+ std::vector<unsigned int> &combination,
+ std::vector<unsigned int> &mainList,
+ std::vector<std::vector<unsigned int> > &allCombinations);
+ static void buildCombinations(const std::vector<const xAOD::Muon*> &muonsIn,
+ std::vector<Combination> &pairs,
+ std::vector<Combination> &quadruplets,
+ unsigned int nSelectedMuons);
+ static bool passesQuadSelection(const std::vector<const xAOD::Muon*> &muonsIn);
+ //-------------------------------------------------------------------------------------
+
+ private:
+ double m_ptCut;
+ double m_etaCut;
+ bool m_useV0Fitter;
+ SG::ReadHandleKey<xAOD::MuonContainer> m_muonCollectionKey;
+ SG::ReadHandleKey<xAOD::TrackParticleContainer> m_TrkParticleCollection;
+ ToolHandle < Trk::IVertexFitter > m_iVertexFitter;
+ ToolHandle < Trk::IVertexFitter > m_iV0VertexFitter;
+ ToolHandle < Trk::V0Tools > m_V0Tools;
+ ToolHandle < Trk::ITrackSelectorTool > m_trkSelector;
+ ToolHandle < InDet::VertexPointEstimator > m_vertexEstimator;
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+ SG::WriteDecorHandleKey<xAOD::MuonContainer> m_muonIndex{this, "muonIndexDec", "Muons.BPHY4MuonIndex"};
+
+ };
+} // end of namespace
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDpstCascade.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDpstCascade.h
new file mode 100644
index 00000000000..7376be66ae1
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDpstCascade.h
@@ -0,0 +1,96 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef JPSIPLUSDPSTCASCADE_H
+#define JPSIPLUSDPSTCASCADE_H
+//*********************
+// JpsiPlusDpstCascade header file
+//
+// Eva Bouhova <e.bouhova@cern.ch>
+// Adam Barton <abarton@cern.ch>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include <vector>
+#include "BeamSpotConditionsData/BeamSpotData.h"
+
+namespace Trk {
+ class IVertexFitter;
+ class TrkVKalVrtFitter;
+ class IVertexCascadeFitter;
+ class VxCascadeInfo;
+ class V0Tools;
+ class ParticleDataTable;
+}
+
+namespace DerivationFramework {
+ class CascadeTools;
+}
+
+namespace DerivationFramework {
+
+ static const InterfaceID IID_JpsiPlusDpstCascade("JpsiPlusDpstCascade", 1, 0);
+
+ class JpsiPlusDpstCascade : virtual public AthAlgTool, public IAugmentationTool
+ {
+ public:
+ static const InterfaceID& interfaceID() { return IID_JpsiPlusDpstCascade;}
+ JpsiPlusDpstCascade(const std::string& t, const std::string& n, const IInterface* p);
+ ~JpsiPlusDpstCascade();
+ virtual StatusCode initialize() override;
+ StatusCode performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer ) const;
+ virtual StatusCode addBranches() const override;
+
+ private:
+ std::string m_vertexContainerKey;
+ std::string m_vertexD0ContainerKey;
+ std::vector<std::string> m_cascadeOutputsKeys;
+
+ std::string m_VxPrimaryCandidateName; //!< Name of primary vertex container
+
+ double m_jpsiMassLower;
+ double m_jpsiMassUpper;
+ double m_jpsipiMassLower;
+ double m_jpsipiMassUpper;
+ double m_D0MassLower;
+ double m_D0MassUpper;
+ double m_DstMassLower;
+ double m_DstMassUpper;
+ double m_MassLower;
+ double m_MassUpper;
+ double m_vtx0MassHypo; // mass hypothesis of vertex 0
+ double m_vtx1MassHypo; // mass hypothesis of vertex 1
+ double m_vtx0Daug1MassHypo; // mass hypothesis of 1st daughter from vertex 0
+ double m_vtx0Daug2MassHypo; // mass hypothesis of 2nd daughter from vertex 0
+ double m_vtx0Daug3MassHypo; // mass hypothesis of 3rd daughter from vertex 0
+ double m_vtx1Daug1MassHypo; // mass hypothesis of 1st daughter from vertex 1
+ double m_vtx1Daug2MassHypo; // mass hypothesis of 2nd daughter from vertex 1
+
+
+ double m_mass_jpsi;
+ int m_Dx_pid;
+ bool m_constrD0;
+ bool m_constrJpsi;
+ double m_chi2cut;
+
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+ ToolHandle < Trk::TrkVKalVrtFitter > m_iVertexFitter;
+ ToolHandle < Analysis::PrimaryVertexRefitter > m_pvRefitter;
+ ToolHandle < Trk::V0Tools > m_V0Tools;
+ ToolHandle < DerivationFramework::CascadeTools > m_CascadeTools;
+
+ bool m_refitPV;
+ std::string m_refPVContainerName;
+ std::string m_hypoName; //!< name of the mass hypothesis. E.g. Jpsi, Upsi, etc. Will be used as a prefix for decorations
+ //This parameter will allow us to optimize the number of PVs under consideration as the probability
+ //of a useful primary vertex drops significantly the higher you go
+ int m_PV_max;
+ int m_DoVertexType;
+ size_t m_PV_minNTracks;
+
+ };
+}
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDs1Cascade.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDs1Cascade.h
new file mode 100644
index 00000000000..d923f5fe4f9
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDs1Cascade.h
@@ -0,0 +1,105 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef JPSIPLUSDS1CASCADE_H
+#define JPSIPLUSDS1CASCADE_H
+//*********************
+// JpsiPlusDs1Cascade header file
+//
+// Eva Bouhova <e.bouhova@cern.ch>
+// Adam Barton <abarton@cern.ch>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "HepPDT/ParticleDataTable.hh"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include <vector>
+#include "BeamSpotConditionsData/BeamSpotData.h"
+
+namespace Trk {
+ class IVertexFitter;
+ class TrkVKalVrtFitter;
+ class IVertexCascadeFitter;
+ class VxCascadeInfo;
+ class V0Tools;
+ class ParticleDataTable;
+}
+
+namespace DerivationFramework {
+ class CascadeTools;
+}
+
+namespace DerivationFramework {
+
+ static const InterfaceID IID_JpsiPlusDs1Cascade("JpsiPlusDs1Cascade", 1, 0);
+
+ class JpsiPlusDs1Cascade : virtual public AthAlgTool, public IAugmentationTool
+ {
+ public:
+ static const InterfaceID& interfaceID() { return IID_JpsiPlusDs1Cascade;}
+ JpsiPlusDs1Cascade(const std::string& t, const std::string& n, const IInterface* p);
+ ~JpsiPlusDs1Cascade();
+ virtual StatusCode initialize() override;
+ StatusCode performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer ) const;
+ virtual StatusCode addBranches() const override;
+
+ private:
+ std::string m_vertexContainerKey;
+ std::string m_vertexD0ContainerKey;
+ std::string m_vertexK0ContainerKey;
+ std::vector<std::string> m_cascadeOutputsKeys;
+
+ std::string m_VxPrimaryCandidateName; //!< Name of primary vertex container
+
+ double m_jpsiMassLower;
+ double m_jpsiMassUpper;
+ double m_jpsipiMassLower;
+ double m_jpsipiMassUpper;
+ double m_D0MassLower;
+ double m_D0MassUpper;
+ double m_K0MassLower;
+ double m_K0MassUpper;
+ double m_DstMassLower;
+ double m_DstMassUpper;
+ double m_MassLower;
+ double m_MassUpper;
+ double m_vtx0MassHypo; // mass hypothesis of vertex 0
+ double m_vtx1MassHypo; // mass hypothesis of vertex 1
+ double m_vtx2MassHypo; // mass hypothesis of vertex 2
+ double m_vtx0Daug1MassHypo; // mass hypothesis of 1st daughter from vertex 0
+ double m_vtx0Daug2MassHypo; // mass hypothesis of 2nd daughter from vertex 0
+ double m_vtx0Daug3MassHypo; // mass hypothesis of 3rd daughter from vertex 0
+ double m_vtx1Daug1MassHypo; // mass hypothesis of 1st daughter from vertex 1
+ double m_vtx1Daug2MassHypo; // mass hypothesis of 2nd daughter from vertex 1
+ double m_vtx2Daug1MassHypo; // mass hypothesis of 1st daughter from vertex 2
+ double m_vtx2Daug2MassHypo; // mass hypothesis of 2nd daughter from vertex 2
+
+ const HepPDT::ParticleDataTable* m_particleDataTable;
+ double m_mass_jpsi;
+ int m_Dx_pid;
+ bool m_constrD0;
+ bool m_constrK0;
+ bool m_constrJpsi;
+ double m_chi2cut;
+
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+ ToolHandle < Trk::TrkVKalVrtFitter > m_iVertexFitter;
+ ToolHandle < Analysis::PrimaryVertexRefitter > m_pvRefitter;
+ ToolHandle < Trk::V0Tools > m_V0Tools;
+ ToolHandle < DerivationFramework::CascadeTools > m_CascadeTools;
+
+ bool m_refitPV;
+ std::string m_refPVContainerName;
+ std::string m_hypoName; //!< name of the mass hypothesis. E.g. Jpsi, Upsi, etc. Will be used as a prefix for decorations
+ //This parameter will allow us to optimize the number of PVs under consideration as the probability
+ //of a useful primary vertex drops significantly the higher you go
+ int m_PV_max;
+ int m_DoVertexType;
+ size_t m_PV_minNTracks;
+
+ double getParticleMass(int particlecode) const;
+ };
+}
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDsCascade.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDsCascade.h
new file mode 100644
index 00000000000..024fe6a7313
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusDsCascade.h
@@ -0,0 +1,91 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef JPSIPLUSDSCASCADE_H
+#define JPSIPLUSDSCASCADE_H
+//*********************
+// JpsiPlusDsCascade header file
+//
+// Eva Bouhova <e.bouhova@cern.ch>
+// Adam Barton <abarton@cern.ch>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include <vector>
+#include "BeamSpotConditionsData/BeamSpotData.h"
+
+namespace Trk {
+ class IVertexFitter;
+ class TrkVKalVrtFitter;
+ class IVertexCascadeFitter;
+ class VxCascadeInfo;
+ class V0Tools;
+ class ParticleDataTable;
+}
+
+namespace DerivationFramework {
+ class CascadeTools;
+}
+
+namespace DerivationFramework {
+
+ static const InterfaceID IID_JpsiPlusDsCascade("JpsiPlusDsCascade", 1, 0);
+
+ class JpsiPlusDsCascade : virtual public AthAlgTool, public IAugmentationTool
+ {
+ public:
+ static const InterfaceID& interfaceID() { return IID_JpsiPlusDsCascade;}
+ JpsiPlusDsCascade(const std::string& t, const std::string& n, const IInterface* p);
+ ~JpsiPlusDsCascade();
+ virtual StatusCode initialize() override;
+ StatusCode performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer ) const;
+ virtual StatusCode addBranches() const override;
+
+ private:
+ std::string m_vertexContainerKey;
+ std::string m_vertexDxContainerKey;
+ std::vector<std::string> m_cascadeOutputsKeys;
+
+ std::string m_VxPrimaryCandidateName; //!< Name of primary vertex container
+
+ double m_jpsiMassLower;
+ double m_jpsiMassUpper;
+ double m_DxMassLower;
+ double m_DxMassUpper;
+ double m_MassLower;
+ double m_MassUpper;
+ double m_vtx0MassHypo; // 1st vertex mass hypothesis
+ double m_vtx1MassHypo; // 2nd vertex mass hypothesis
+ double m_vtx0Daug1MassHypo; // mass hypothesis of 1st daughter from vertex 0
+ double m_vtx0Daug2MassHypo; // mass hypothesis of 2nd daughter from vertex 0
+ double m_vtx1Daug1MassHypo; // mass hypothesis of 1st daughter from vertex 1
+ double m_vtx1Daug2MassHypo; // mass hypothesis of 2nd daughter from vertex 1
+ double m_vtx1Daug3MassHypo; // mass hypothesis of 3rd daughter from vertex 1
+
+ double m_mass_jpsi;
+ int m_Dx_pid;
+ bool m_constrDx;
+ bool m_constrJpsi;
+ double m_chi2cut;
+
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+ ToolHandle < Trk::TrkVKalVrtFitter > m_iVertexFitter;
+ ToolHandle < Analysis::PrimaryVertexRefitter > m_pvRefitter;
+ ToolHandle < Trk::V0Tools > m_V0Tools;
+ ToolHandle < DerivationFramework::CascadeTools > m_CascadeTools;
+
+ bool m_refitPV;
+ std::string m_refPVContainerName;
+ std::string m_hypoName; //!< name of the mass hypothesis. E.g. Jpis, Upsi, etc. Will be used as a prefix for decorations
+ //This parameter will allow us to optimize the number of PVs under consideration as the probability
+ //of a useful primary vertex drops significantly the higher you go
+ int m_PV_max;
+ int m_DoVertexType;
+ size_t m_PV_minNTracks;
+
+ };
+}
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusV0Cascade.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusV0Cascade.h
new file mode 100644
index 00000000000..9720b3d6ca3
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/JpsiPlusV0Cascade.h
@@ -0,0 +1,94 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef JPSIPLUSV0CASCADE_H
+#define JPSIPLUSV0CASCADE_H
+//*********************
+// JpsiPlusV0Cascade header file
+//
+// Eva Bouhova <e.bouhova@cern.ch>
+// Adam Barton <abarton@cern.ch>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include <vector>
+#include "BeamSpotConditionsData/BeamSpotData.h"
+
+
+namespace Trk {
+ class IVertexFitter;
+ class TrkVKalVrtFitter;
+ class IVertexCascadeFitter;
+ class VxCascadeInfo;
+ class V0Tools;
+ class ParticleDataTable;
+}
+
+namespace DerivationFramework {
+ class CascadeTools;
+}
+
+
+namespace DerivationFramework {
+
+ static const InterfaceID IID_JpsiPlusV0Cascade("JpsiPlusV0Cascade", 1, 0);
+
+ class JpsiPlusV0Cascade : virtual public AthAlgTool, public IAugmentationTool
+ {
+
+ std::string m_vertexContainerKey;
+ std::string m_vertexV0ContainerKey;
+ std::vector<std::string> m_cascadeOutputsKeys;
+
+ std::string m_VxPrimaryCandidateName; //!< Name of primary vertex container
+
+ double m_jpsiMassLower;
+ double m_jpsiMassUpper;
+ double m_V0MassLower;
+ double m_V0MassUpper;
+ double m_MassLower;
+ double m_MassUpper;
+
+ double m_mass_muon;
+ double m_mass_pion;
+ double m_mass_proton;
+ double m_mass_lambda;
+ double m_mass_ks;
+ double m_mass_jpsi;
+ double m_mass_b0;
+ double m_mass_lambdaB;
+ int m_v0_pid;
+ bool m_constrV0;
+ bool m_constrJpsi;
+
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+ ToolHandle < Trk::TrkVKalVrtFitter > m_iVertexFitter;
+ ToolHandle < Analysis::PrimaryVertexRefitter > m_pvRefitter;
+ ToolHandle < Trk::V0Tools > m_V0Tools;
+ ToolHandle < DerivationFramework::CascadeTools > m_CascadeTools;
+
+ bool m_refitPV;
+ std::string m_refPVContainerName;
+ std::string m_hypoName; //!< name of the mass hypothesis. E.g. Jpis, Upsi, etc. Will be used as a prefix for decorations
+ //This parameter will allow us to optimize the number of PVs under consideration as the probability
+ //of a useful primary vertex drops significantly the higher you go
+ int m_PV_max;
+ int m_DoVertexType;
+ size_t m_PV_minNTracks;
+
+ public:
+ static const InterfaceID& interfaceID() { return IID_JpsiPlusV0Cascade;}
+ JpsiPlusV0Cascade(const std::string& t, const std::string& n, const IInterface* p);
+ ~JpsiPlusV0Cascade();
+ StatusCode initialize() override;
+ StatusCode performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer ) const;
+ virtual StatusCode addBranches() const override;
+ };
+}
+
+
+#endif
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/LocalVector.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/LocalVector.h
new file mode 100644
index 00000000000..1865c520e35
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/LocalVector.h
@@ -0,0 +1,72 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+#ifndef LOCALVECTOR_H
+#define LOCALVECTOR_H
+
+#include <array>
+#include <algorithm>
+#include <iterator>
+
+template <class A_Type, size_t SIZE>
+class LocalVector
+{
+protected:
+ std::array<A_Type, SIZE> m_memblock;
+ size_t m_x;
+public:
+ LocalVector() : m_x(0) { }
+ size_t size() const noexcept {
+ return m_x;
+ }
+ constexpr size_t max_size() const noexcept {
+ return SIZE;
+ }
+ typename std::array<A_Type, SIZE>::iterator begin() noexcept {
+ return m_memblock.begin();
+ }
+ typename std::array<A_Type, SIZE>::iterator end() noexcept {
+ auto it = m_memblock.begin();
+ std::advance(it, m_x);
+ return it;
+ }
+ typename std::array<A_Type, SIZE>::const_iterator begin() const noexcept {
+ return m_memblock.cbegin();
+ }
+ typename std::array<A_Type, SIZE>::const_iterator end() const noexcept {
+ auto it = m_memblock.cbegin();
+ std::advance(it, m_x);
+ return it;
+ }
+ A_Type& operator[]( size_t pos ) {
+ return m_memblock[pos];
+ }
+ const A_Type& operator[]( size_t pos ) const {
+ return m_memblock[pos];
+ }
+ bool contains(const A_Type& a) const {
+ return std::find(begin(), end(), a) != end();
+ }
+ void push_back(const A_Type& a) {
+ m_memblock[m_x++] = a;
+ }
+ void pop_back() {
+ --m_x;
+ }
+ void clear() noexcept {
+ m_x = 0;
+ }
+ A_Type& back( ) {
+ return m_memblock[m_x-1];
+ }
+ const A_Type& back( ) const {
+ return m_memblock[m_x-1];
+ }
+ A_Type& front( ) {
+ return m_memblock.front();
+ }
+ const A_Type& front( ) const {
+ return m_memblock.front();
+ }
+};
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/MuonExtrapolationTool.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/MuonExtrapolationTool.h
new file mode 100644
index 00000000000..7464e520f10
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/MuonExtrapolationTool.h
@@ -0,0 +1,59 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+ */
+
+//////////////////////////////////////////////////////////////////////////////
+// MuonExtrapolationTool
+//////////////////////////////////////////////////////////////////////////////
+#ifndef MuonExtrapolationTool_H
+#define MuonExtrapolationTool_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODMuon/Muon.h"
+#include "TrkParameters/TrackParameters.h"
+
+namespace Trk {
+ class IExtrapolator;
+}
+
+namespace DerivationFramework {
+ class MuonExtrapolationTool : public AthAlgTool, public IAugmentationTool {
+
+ public:
+ MuonExtrapolationTool(const std::string& t, const std::string& n, const IInterface *p);
+
+ virtual StatusCode initialize();
+ virtual StatusCode addBranches() const;
+
+ ToolHandle<Trk::IExtrapolator> m_extrapolator;
+ private:
+
+ /// run the extrapolation - only available in full athena
+ const Trk::TrackParameters* extrapolateToTriggerPivotPlane(const xAOD::TrackParticle& track) const;
+
+ // Utility method to handle extrapolation and decoration for one TrackParticle.
+ // It looks for the decoration, and, if it is missing, runs track extrapolation, decorating the result
+ // to the particle to avoid repeating the process unnecessarily.
+ // Returns success (true) or failure (false) of the procedure, fills eta and phi coordinates via reference
+ // If the extrapolation fails or the decoration is missing in AthAnalysis, it will *not* change eta and phi
+ // So you can set them to defaults before calling this guy, and they will be preserved in case of failure.
+ // Will not run outside athena, because it requires the extrapolator
+ bool extrapolateAndDecorateTrackParticle(const xAOD::TrackParticle* particle, float & eta, float & phi) const;
+
+ // utility method: Obtains the track particle which we want to extrapolate into the MS.
+ // Works for all kinds of probes.
+ const xAOD::TrackParticle* getPreferredTrackParticle (const xAOD::IParticle* probe) const;
+
+ // these define the surfaces that we extrapolate to.
+ // We approximate the pivot plane in the form of a cylinder surface and two disks
+ double m_endcapPivotPlaneZ;
+ double m_endcapPivotPlaneMinimumRadius;
+ double m_endcapPivotPlaneMaximumRadius;
+ double m_barrelPivotPlaneRadius;
+ double m_barrelPivotPlaneHalfLength;
+ std::string m_muonContainerName;
+ };
+}
+#endif // MuonExtrapolationTool_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/ReVertex.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/ReVertex.h
new file mode 100644
index 00000000000..853f03bcf72
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/ReVertex.h
@@ -0,0 +1,98 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+// ****************************************************************************
+// ----------------------------------------------------------------------------
+// ReVertex header file
+//
+// Konstantin Beloborodov <Konstantin.Beloborodov@cern.ch>
+//
+// ----------------------------------------------------------------------------
+// ****************************************************************************
+
+#ifndef DERIVATIONFRAMEWORK_ReVertex_H
+#define DERIVATIONFRAMEWORK_ReVertex_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "xAODTracking/Vertex.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+/** forward declarations
+ */
+namespace Trk {
+ class IVertexFitter;
+ class TrkV0VertexFitter;
+ class ITrackSelectorTool;
+ class V0Tools;
+ class TrkVKalVrtFitter;
+}
+
+namespace Analysis {
+ class PrimaryVertexRefitter;
+}
+
+namespace InDet { class VertexPointEstimator; }
+
+namespace DerivationFramework {
+
+class ReVertex : public AthAlgTool, public IAugmentationTool {
+public:
+
+ ReVertex(const std::string& t, const std::string& n, const IInterface* p);
+
+ virtual StatusCode initialize() override;
+ //virtual StatusCode finalize() override;
+
+ virtual StatusCode addBranches() const override;
+
+ void fitAndStore(xAOD::VertexContainer* vtxContainer,
+ const xAOD::Vertex* v,
+ const xAOD::VertexContainer *InVtxContainer,
+ const std::vector<const xAOD::TrackParticle*> &inputTracks,
+ const xAOD::TrackParticleContainer* importedTrackCollection,
+ const xAOD::VertexContainer* pvContainer) const;
+ xAOD::Vertex* fit(const std::vector<const xAOD::TrackParticle*> &inputTracks,
+ const xAOD::Vertex* pv) const;
+private:
+ std::vector<int> m_TrackIndices;
+ ToolHandle < InDet::VertexPointEstimator > m_vertexEstimator;
+ ToolHandle < Trk::IVertexFitter > m_iVertexFitter;
+ Trk::TrkVKalVrtFitter* m_VKVFitter;
+ SG::WriteHandleKey<xAOD::VertexContainer> m_OutputContainerName;
+ SG::ReadHandleKey<xAOD::VertexContainer> m_inputContainerName;
+ SG::ReadHandleKey<xAOD::TrackParticleContainer> m_trackContainer;
+ SG::WriteHandleKey<xAOD::VertexContainer> m_refPVContainerName;
+ SG::ReadHandleKey<xAOD::VertexContainer> m_pvContainerName;
+
+
+ std::vector<double> m_trkMasses;
+ std::vector<int> m_indices;
+ double m_massConst;
+ double m_totalMassConst;
+ std::vector<std::string> m_hypoNames;
+
+ ToolHandle<Trk::V0Tools> m_v0Tools;
+ ToolHandle<Analysis::PrimaryVertexRefitter> m_pvRefitter;
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+ int m_PV_max;
+ int m_DoVertexType;
+ size_t m_PV_minNTracks;
+ bool m_do3d;
+ bool m_AddPVData;
+ bool m_refitPV;
+ bool m_doMassConst;
+ bool m_startingpoint0;
+
+ bool m_vertexFittingWithPV;
+
+ double m_BMassUpper;
+ double m_BMassLower;
+ double m_chi2cut; // chi2/Ndof of the final veretx
+ double m_trkDeltaZ; // DeltaZ between the JPsi vertex and hadronic tracks Z0
+
+ bool m_useAdditionalTrack;
+};
+}
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_4mu.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_4mu.h
new file mode 100644
index 00000000000..5b311a975fd
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_4mu.h
@@ -0,0 +1,63 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// Reco_4mu.h
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_Reco_4mu_H
+#define DERIVATIONFRAMEWORK_Reco_4mu_H
+
+#include <string>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/ISkimmingTool.h"
+#include "DerivationFrameworkBPhys/FourMuonTool.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include "xAODBPhys/BPhysHelper.h"
+
+/** forward declarations
+ */
+namespace Trk {
+ class V0Tools;
+}
+
+namespace xAOD {
+ class BPhysHypoHelper;
+}
+
+/** THE reconstruction tool
+ */
+namespace DerivationFramework {
+
+ class Reco_4mu : public AthAlgTool, public ISkimmingTool {
+ public:
+ Reco_4mu(const std::string& t, const std::string& n, const IInterface* p);
+
+ StatusCode initialize();
+ StatusCode finalize();
+
+ virtual bool eventPassesFilter() const;
+
+ private:
+ /** tools
+ */
+ void ProcessVertex(xAOD::BPhysHypoHelper&, xAOD::BPhysHelper::pv_type, std::vector<double> trackMasses) const;
+ ToolHandle<Trk::V0Tools> m_v0Tools;
+ ToolHandle<DerivationFramework::FourMuonTool> m_fourMuonTool;
+ ToolHandle<Analysis::PrimaryVertexRefitter> m_pvRefitter;
+
+ /** job options
+ */
+ std::string m_pairName;
+ std::string m_quadName;
+ std::string m_pvContainerName;
+ std::string m_refPVContainerName;
+ bool m_refitPV;
+ int m_PV_max;
+ int m_DoVertexType;
+ };
+}
+
+#endif // DERIVATIONFRAMEWORK_Reco_4mu_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_V0Finder.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_V0Finder.h
new file mode 100644
index 00000000000..ceb666c2393
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_V0Finder.h
@@ -0,0 +1,63 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+///////////////////////////////////////////////////////////////////
+// Reco_V0Finder.h, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_V0FINDER_H
+#define DERIVATIONFRAMEWORK_V0FINDER_H
+
+#include <string>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "InDetV0Finder/InDetV0FinderTool.h"
+#include "HepPDT/ParticleDataTable.hh"
+
+/** forward declarations
+ */
+namespace Trk
+{
+ class V0Tools;
+ class ParticleDataTable;
+}
+
+namespace DerivationFramework {
+
+ class Reco_V0Finder : public AthAlgTool, public IAugmentationTool {
+ public:
+ Reco_V0Finder(const std::string& t, const std::string& n, const IInterface* p);
+
+ StatusCode initialize() override;
+ StatusCode finalize() override;
+
+ virtual StatusCode addBranches() const override;
+
+ private:
+
+ std::vector<std::string> m_CollectionsToCheck;
+ ToolHandle <InDet::InDetV0FinderTool> m_v0FinderTool;
+ ToolHandle <Trk::V0Tools> m_V0Tools;
+ const HepPDT::ParticleDataTable *m_particleDataTable;
+
+ int m_masses; //!< = 1 if using PDG values, = 2 if user set (1)
+ double m_masspi; //!< pion mass (139.57 MeV)
+ double m_massp; //!< proton mass (938.272 MeV)
+ double m_masse; //!< electron mass (0.510999 MeV)
+ double m_massK0S; //!< Kshort mass (497.672 MeV)
+ double m_massLambda; //!< Lambda mass (1115.68 MeV)
+
+ std::string m_VxPrimaryCandidateName; //!< Name of primary vertex container
+
+ std::string m_v0ContainerName;
+ std::string m_ksContainerName;
+ std::string m_laContainerName;
+ std::string m_lbContainerName;
+
+ };
+}
+
+#endif // DERIVATIONFRAMEWORK_Reco_dimuTrk_H
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_Vertex.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_Vertex.h
new file mode 100644
index 00000000000..57e82e2048e
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Reco_Vertex.h
@@ -0,0 +1,54 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// Reco_Vertex.h
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_Reco_Vertex_H
+#define DERIVATIONFRAMEWORK_Reco_Vertex_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/ICandidateSearch.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+#include "StoreGate/ReadHandleKeyArray.h"
+
+namespace DerivationFramework {
+
+ class Reco_Vertex : public AthAlgTool, public IAugmentationTool {
+ public:
+ Reco_Vertex(const std::string& t, const std::string& n, const IInterface* p);
+
+ virtual StatusCode initialize();
+
+ virtual StatusCode addBranches() const;
+
+ private:
+ /** tools
+ */
+ ToolHandle<Trk::V0Tools> m_v0Tools;
+ ToolHandle<Analysis::ICandidateSearch> m_SearchTool;
+ ToolHandle<Analysis::PrimaryVertexRefitter> m_pvRefitter;
+ SG::ReadCondHandleKey<InDet::BeamSpotData> m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };
+
+ /** job options
+ */
+ SG::WriteHandleKey<xAOD::VertexContainer> m_outputVtxContainerName;
+ SG::ReadHandleKey<xAOD::VertexContainer> m_pvContainerName;
+ SG::WriteHandleKey<xAOD::VertexContainer> m_refPVContainerName;
+ bool m_refitPV;
+ int m_PV_max;
+ int m_DoVertexType;
+ size_t m_PV_minNTracks;
+ bool m_do3d;
+ bool m_checkCollections;
+ SG::ReadHandleKeyArray<xAOD::VertexContainer> m_CollectionsToCheck;
+ };
+}
+
+#endif // DERIVATIONFRAMEWORK_Reco_Vertex_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Select_Bmumu.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Select_Bmumu.h
new file mode 100644
index 00000000000..cf43240a3ac
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Select_Bmumu.h
@@ -0,0 +1,116 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// Select_Bmumu.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Based on Select_onia2mumu.h.
+// Original author: Daniel Scheirich <daniel.scheirich@cern.ch>
+//
+// Select B candidates for the B(s)mumu analysis including for
+// the reference channels used.
+//
+// For an example see BPHY8.py .
+//
+// Job options provided by this class:
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_Select_Bmumu_H
+#define DERIVATIONFRAMEWORK_Select_Bmumu_H
+
+#include <string>
+
+#include "GaudiKernel/ToolHandle.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkBPhys/CfAthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "MuonAnalysisInterfaces/IMuonSelectionTool.h"
+#include "JpsiUpsilonTools/JpsiFinder.h"
+#include "xAODBPhys/BPhysHelper.h"
+
+/** forward declarations
+ */
+namespace Trk {
+ class V0Tools;
+}
+
+namespace xAOD {
+ class BPhysHypoHelper;
+}
+
+namespace SG {
+ class AuxElement;
+}
+
+/** THE candidate selection tool
+ */
+namespace DerivationFramework {
+
+ class Select_Bmumu : public CfAthAlgTool, public IAugmentationTool {
+ public:
+ Select_Bmumu(const std::string& t, const std::string& n, const IInterface* p);
+
+ /** initialization and finalization
+ */
+ StatusCode initialize() override;
+ StatusCode finalize() override;
+
+ /** @brief: augmentation and selection
+ * Retrieved vertices are augmented with usual information.
+ * Selection is performed and each candidate is decorated with the
+ * Char_t flag named "passed_"+name() to indicate whether if the candidate
+ * passed the selection. This flag is then used by the event selection tool
+ * and by the vertex thinning tool.
+ */
+ virtual StatusCode addBranches() const override;
+
+ private:
+ void ProcessVertex(xAOD::BPhysHypoHelper&, xAOD::BPhysHelper::pv_type) const;
+ bool massCuts(float mass) const;
+ bool massInBlindedRegion(float mass) const;
+
+ bool checkAllMuonsTight(const std::vector<const xAOD::Muon*>& muons,
+ int maxMuonsToCheck=-1) const;
+
+ bool pass(const SG::AuxElement& em, std::string hypo) const;
+ bool setPass(const SG::AuxElement& em, std::string hypo, bool passVal) const;
+ bool setPassIfNotAvailable(SG::AuxElement& em, std::string hypo,
+ bool passVal) const;
+ // std::vector<xAOD::Vertex*> getPrecedingVertices(const xAOD::Vertex* vtx);
+
+ /** tools
+ */
+ ToolHandle<Trk::V0Tools> m_v0Tools;
+ ToolHandle<CP::IMuonSelectionTool> m_muSelectionTool;
+
+ /** job options
+ */
+ std::string m_hypoName; //!< name of the mass hypothesis. E.g. Jpis, Upsi, etc. Will be used as a prefix for decorations
+ std::string m_inputVtxContainerName; //!< name of the input container name
+ std::vector<double> m_trkMasses; //!< track mass hypotheses
+ double m_massHypo; //!< vertex mass hypothesis
+ double m_massMax; //!< invariant mass range
+ double m_massMin; //!< invariant mass range
+ double m_chi2Max; //!< max chi2 cut
+ int m_DoVertexType; //!< Allows user to skip certain vertexes - bitwise test 7==all(111)
+ bool m_do3d; //!< add 3d proper time
+ double m_blindMassMin; //!< blinding mass range
+ double m_blindMassMax; //!< blinding mass range
+ bool m_doBlinding; //!< enable blinding range
+ bool m_doCutBlinded; //!< enable cutting blinded vertices
+ bool m_blindOnlyAllMuonsTight; //!< only blind candidates with all tight muons
+ bool m_useMuCalcMass; //!< also check against MUCALC mass
+
+ std::vector<std::string> m_subDecVtxContNames; //!< names of sub-decay vertex containers
+ std::vector<std::string> m_subDecVtxHypoCondNames; //!< hypo names for sub-decays to be considered
+ std::vector<std::string> m_subDecVtxHypoFlagNames; //!< names of hypo flags set on sub-decays if passing
+ };
+}
+
+#endif // DERIVATIONFRAMEWORK_Select_Bmumu_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Select_onia2mumu.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Select_onia2mumu.h
new file mode 100644
index 00000000000..f2157f8b24e
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Select_onia2mumu.h
@@ -0,0 +1,71 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// Select_onia2mumu.h
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_Select_onia2mumu_H
+#define DERIVATIONFRAMEWORK_Select_onia2mumu_H
+
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/JpsiFinder.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include <string>
+
+/** forward declarations
+ */
+namespace Trk {
+ class V0Tools;
+}
+
+namespace xAOD {
+ class BPhysHypoHelper;
+}
+
+/** THE candidate selection tool
+ */
+namespace DerivationFramework {
+
+ class Select_onia2mumu : public AthAlgTool, public IAugmentationTool {
+ public:
+ Select_onia2mumu(const std::string& t, const std::string& n, const IInterface* p);
+
+ /** inirialization and finalization
+ */
+ StatusCode initialize() override;
+
+ /** @brief: augmentation and selection
+ * Retrieved vertices are augmented with usual information.
+ * Selection is performed and each candidate is decorated with the
+ * Char_t flag named "passed_"+name() to indicate whether if the candidate
+ * passed the selection. This flag is then used by the event selection tool
+ * and by the vertex thinning tool.
+ */
+ virtual StatusCode addBranches() const override;
+
+ private:
+ void ProcessVertex(xAOD::BPhysHypoHelper&, xAOD::BPhysHelper::pv_type) const;
+ /** tools
+ */
+ ToolHandle<Trk::V0Tools> m_v0Tools;
+
+ /** job options
+ */
+ std::string m_hypoName; //!< name of the mass hypothesis. E.g. Jpis, Upsi, etc. Will be used as a prefix for decorations
+ SG::ReadHandleKey<xAOD::VertexContainer> m_inputVtxContainerName; //!< name of the input container name
+ std::vector<double> m_trkMasses; //!< track mass hypotheses
+ double m_massHypo; //!< vertex mass hypothesis
+ double m_massMax; //!< invariant mass range
+ double m_massMin; //!< invariant mass range
+ double m_chi2Max; //!< max chi2 cut
+ double m_lxyMin; //!< min lxy cut
+ int m_DoVertexType; //!< Allows user to skip certain vertexes - bitwise test 7==all(111)
+ bool m_do3d;
+ };
+}
+
+#endif // DERIVATIONFRAMEWORK_Select_onia2mumu_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Thin_vtxDuplicates.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Thin_vtxDuplicates.h
new file mode 100644
index 00000000000..77aa7c81386
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Thin_vtxDuplicates.h
@@ -0,0 +1,37 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef DERIVATIONFRAMEWORK_Thin_vtxDuplicates_H
+#define DERIVATIONFRAMEWORK_Thin_vtxDuplicates_H
+
+#include "xAODTracking/VertexContainer.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IThinningTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "StoreGate/ThinningHandleKey.h"
+#include "StoreGate/ReadDecorHandleKeyArray.h"
+class IThinningSvc;
+
+namespace DerivationFramework {
+
+ class Thin_vtxDuplicates : public AthAlgTool, public IThinningTool {
+ public:
+ Thin_vtxDuplicates(const std::string& t, const std::string& n, const IInterface* p);
+ ~Thin_vtxDuplicates();
+ virtual StatusCode initialize();
+ virtual StatusCode finalize();
+ virtual StatusCode doThinning() const;
+
+ private:
+ bool m_noFlags;
+ StringProperty m_streamName{ this, "StreamName", "", "Name of the stream being thinned" };
+ mutable std::atomic<unsigned int> m_nVtxTot, m_nVtxPass;
+
+ SG::ThinningHandleKey< xAOD::VertexContainer > m_vertexContainerNames;
+ SG::ReadDecorHandleKeyArray<xAOD::VertexContainer> m_passFlags;
+ bool m_and;
+ };
+}
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Thin_vtxTrk.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Thin_vtxTrk.h
new file mode 100644
index 00000000000..3222f0ffcfd
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/Thin_vtxTrk.h
@@ -0,0 +1,54 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// Thin_vtxTrk.h
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_Thin_vtxTrk_H
+#define DERIVATIONFRAMEWORK_Thin_vtxTrk_H
+
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/VertexContainer.h"
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IThinningTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "StoreGate/ThinningHandleKey.h"
+#include "StoreGate/HandleKeyArray.h"
+#include "StoreGate/ReadDecorHandleKeyArray.h"
+#include <string>
+
+namespace SG{
+ template <class T>
+ using ThinningHandleKeyArray = HandleKeyArray<ReadHandle<T>, ThinningHandleKey<T>, Gaudi::DataHandle::Reader >;
+}
+
+namespace DerivationFramework {
+
+ class Thin_vtxTrk : public AthAlgTool, public IThinningTool {
+ public:
+ Thin_vtxTrk(const std::string& t, const std::string& n, const IInterface* p);
+ ~Thin_vtxTrk();
+ StatusCode initialize();
+ StatusCode finalize();
+ virtual StatusCode doThinning() const;
+
+ private:
+ StringProperty m_streamName{ this, "StreamName", "", "Name of the stream being thinned" };
+ mutable std::atomic<unsigned int> m_ntot, m_npass;
+ double m_acceptanceR;
+ mutable std::atomic<unsigned int> m_nVtxTot, m_nVtxPass;
+
+ SG::ThinningHandleKey<xAOD::TrackParticleContainer> m_trackParticleContainerName;
+ SG::ThinningHandleKeyArray<xAOD::VertexContainer> m_vertexContainerName;
+ std::vector<std::string> m_passFlags;
+ SG::ReadDecorHandleKeyArray<xAOD::VertexContainer> m_passArray{this, "INTERNALARRAY", {}};
+ bool m_and;
+ bool m_trackAnd;
+ bool m_thinTracks;
+ bool m_noFlags; //To take all entries, regardless of flags
+ };
+}
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/TriggerCountToMetadata.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/TriggerCountToMetadata.h
new file mode 100644
index 00000000000..69290703ebd
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/TriggerCountToMetadata.h
@@ -0,0 +1,51 @@
+/*
+Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+//============================================================================
+//
+// Author : Matteo Bedognetti <matteo.bedognetti@cern.ch.>
+// Changes:
+//
+// Store trigger counts for specific chains in the DAOD's MetaData.
+// This allows it to store information about triggers upon which events are NOT selected during the derivation
+//
+// Job options:
+// - TriggerList -- a vector containing all triggers to store as strings
+// - TrigDecisionTool -- if one wants to pass this a specific TrigDecisionTool
+//
+//============================================================================
+//
+#ifndef DERIVATIONFRAMEWORK_TriggerCountToMetadata_H
+#define DERIVATIONFRAMEWORK_TriggerCountToMetadata_H
+
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "DerivationFrameworkBPhys/CfAthAlgTool.h"
+#include "TrigDecisionTool/TrigDecisionTool.h"
+
+#include <string>
+#include <vector>
+
+namespace Trig{
+ class TrigDecisionTool;
+}
+
+namespace DerivationFramework {
+
+ class TriggerCountToMetadata : virtual public CfAthAlgTool, virtual public IAugmentationTool {
+
+ public:
+ TriggerCountToMetadata(const std::string& t, const std::string& n, const IInterface* p);
+ virtual StatusCode initialize() override;
+ virtual StatusCode addBranches() const override;
+
+ private: //Don't use protected for this one!
+
+ std::vector<std::string> m_triggerList;
+ ToolHandle<Trig::TrigDecisionTool> m_trigDecisionTool;
+ std::string m_folderName;
+
+ }; // class
+} // namespace
+
+#endif // DERIVATIONFRAMEWORK_TriggerCountToMetadata_H
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexCaloIsolation.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexCaloIsolation.h
new file mode 100644
index 00000000000..50e7b4d252d
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexCaloIsolation.h
@@ -0,0 +1,89 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// VertexCaloIsolation.h by Matteo Bedognetti
+///////////////////////////////////////////////////////////////////
+//
+// This code is based on CaloIsolationTool of IsolationTools package
+//
+// Etcone is determined as a topoCluster-isolation value minus Energy Density (ED) correction and minus the energy depositions of the muons
+// Muon's energy deposition is already stored in side the xAOD::Muon objects, but the muon-clusters are used to correct for the fact that they muons may have overlapping clusters
+// The muon-clusters are stored as well in connection with the muons themselves
+//
+// The idea of comparing topoClusters with muon-clusters to decide what part of the muon's deposition is of
+// importance had to be abandoned because topCluster cells are not present in xAOD
+//
+// It enforces the fact that for muons no core-surface is removed for the energy-density correction (thus the corrections are independent from each other)
+//
+// "isReliable" flag reports of each isolation value if all particles crossing the cone have been correctly corrected for.
+// In the case of 2mu+ 1 track it mirrors the fact that the track does not extrapolate into the cone (as tracks have no muon-cluster from which to determine the core-correction)
+//
+#ifndef DERIVATIONFRAMEWORK_VertexCaloIsolation_H
+#define DERIVATIONFRAMEWORK_VertexCaloIsolation_H
+
+#include <string>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+//#include "MuonIdHelpers/MuonIdHelperTool.h"
+//#include "IsolationTool/CaloIsolationTool.h"
+//#include "TrkCaloExtension/CaloExtension.h"
+
+#include "RecoToolInterfaces/IParticleCaloExtensionTool.h"
+#include "RecoToolInterfaces/ICaloTopoClusterIsolationTool.h"
+
+//#include "TrackToCalo/CaloCellCollector.h"
+//#include "CaloInterface/ICaloNoiseTool.h"
+#include "xAODBPhys/BPhysHelper.h"
+//#include "xAODPrimitives/IsolationType.h" //
+
+
+/** THE reconstruction tool
+ */
+namespace DerivationFramework {
+
+ class VertexCaloIsolation : public AthAlgTool, public IAugmentationTool {
+ public:
+ VertexCaloIsolation(const std::string& t, const std::string& n, const IInterface* p);
+
+ StatusCode initialize();
+ StatusCode finalize();
+
+ StatusCode addBranches() const;
+ bool extrapolateTrack(TLorentzVector& extr_tp, const xAOD::IParticle& tp) const;
+ bool extrapolateMuon(TLorentzVector& extr_tp, const xAOD::CaloCluster* cluster) const;
+ xAOD::TrackParticle& makeSlyTrack(xAOD::TrackParticle&, const TLorentzVector& candidate, const xAOD::Vertex* vertex, xAOD::BPhysHelper::pv_type vertexType) const;
+
+
+ private:
+
+ //ToolHandle<xAOD::ICaloCellIsolationTool> m_caloIsoTool;
+ ToolHandle<xAOD::ICaloTopoClusterIsolationTool> m_caloIsoTool;
+ std::string m_trackContainerName;
+ std::string m_vertexContainerName;
+ std::string m_caloClusterContainerName;
+ std::string m_cellContainerName;
+ std::string m_muonContainerName;
+ ToolHandle<Trk::IParticleCaloExtensionTool> m_caloExtTool;
+ std::vector<unsigned int> m_cones; //I cannot use xAOD::Iso::IsolationType as a type here, as it clashes with setProperty()
+ std::vector<std::string> m_passFlags;
+
+
+ // ToolHandle <ICaloNoiseTool> m_caloNoiseTool; //Removed to reduce requirements
+ //Rec::CaloCellCollector m_cellCollector; //Seems to be a plain class, so no need for handles
+
+ /// Number of sigma for calo cell noise cut
+ float m_sigmaCaloNoiseCut;
+
+ int m_vertexType;
+
+
+
+ };
+}
+
+#endif
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexPlus1TrackCascade.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexPlus1TrackCascade.h
new file mode 100644
index 00000000000..416b42c5a07
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexPlus1TrackCascade.h
@@ -0,0 +1,74 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef VERTEXPLUS1TRACKCASCADE_H
+#define VERTEXPLUS1TRACKCASCADE_H
+//*********************
+// VertexPlus1Cascade header file
+//
+// Adam Barton <abarton@cern.ch>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "GaudiKernel/ToolHandle.h"
+#include "xAODMuon/MuonContainer.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/VertexContainer.h"
+#include <vector>
+
+
+namespace Trk {
+ class IVertexFitter;
+ class ITrackSelectorTool;
+ class TrkVKalVrtFitter;
+ class IVertexCascadeFitter;
+ class VxCascadeInfo;
+}
+
+namespace DerivationFramework {
+
+ static const InterfaceID IID_VertexPlus1TrackCascade("VertexPlus1TrackCascade", 1, 0);
+
+ class VertexPlus1TrackCascade : virtual public AthAlgTool
+ {
+
+
+ SG::ReadHandleKey<xAOD::VertexContainer> m_vertexContainerKey;
+ SG::ReadHandleKey<xAOD::TrackParticleContainer> m_TrackPContainerKey;
+ SG::ReadHandleKey<xAOD::MuonContainer> m_MuonsUsedInJpsiKey;
+
+ std::vector<double> m_massHypothesis;
+
+ std::vector<int> m_massConstraintTracksVtx1;
+ std::vector<int> m_massConstraintTracksVtx2;
+ double m_Vtx1MassConstraint;
+ double m_Vtx2MassConstraint;
+
+ double m_trkThresholdPt;
+ double m_trkMaxEta;
+// double m_BThresholdPt;
+// double m_BMassUpper;
+// double m_BMassLower;
+
+ double m_roughMassLower;
+ double m_roughMassUpper;
+ ToolHandle < Trk::TrkVKalVrtFitter > m_iVertexFitter;
+ ToolHandle < Trk::ITrackSelectorTool > m_trkSelector;
+
+ public:
+ static const InterfaceID& interfaceID() { return IID_VertexPlus1TrackCascade;}
+ VertexPlus1TrackCascade(const std::string& t, const std::string& n, const IInterface* p);
+ ~VertexPlus1TrackCascade();
+ StatusCode initialize() override;
+ StatusCode finalize() override;
+ static double getInvariantMass(const std::vector<const xAOD::TrackParticle*> &Tracks, const std::vector<double> &massHypotheses);
+ static bool isContainedIn(const xAOD::TrackParticle* theTrack, const xAOD::MuonContainer* theColl);
+ StatusCode performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer ) const;
+
+ };
+}
+
+
+#endif
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexTrackIsolation.h b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexTrackIsolation.h
new file mode 100644
index 00000000000..603da6cef65
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/DerivationFrameworkBPhys/VertexTrackIsolation.h
@@ -0,0 +1,52 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// VertexTrackIsolation.h,
+///////////////////////////////////////////////////////////////////
+
+#ifndef DERIVATIONFRAMEWORK_VertexTrackIsolation_H
+#define DERIVATIONFRAMEWORK_VertexTrackIsolation_H
+
+#include <string>
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+//#include "MuonIdHelpers/MuonIdHelperTool.h"
+//#include "IsolationTool/TrackIsolationTool.h"
+#include "RecoToolInterfaces/ITrackIsolationTool.h"
+//#include "xAODPrimitives/IsolationType.h"
+#include <vector>
+/** THE reconstruction tool
+ */
+namespace DerivationFramework {
+
+ class VertexTrackIsolation : public AthAlgTool, public IAugmentationTool {
+ public:
+ VertexTrackIsolation(const std::string& t, const std::string& n, const IInterface* p);
+
+ StatusCode initialize();
+ StatusCode finalize();
+
+ virtual StatusCode addBranches() const;
+
+ bool isSame(const xAOD::Vertex* theVtx1, const xAOD::Vertex* theVtx2) const;
+ bool isContainedIn(const xAOD::Vertex* theVtx, const std::vector<const xAOD::Vertex*> &theColl) const;
+
+ private:
+
+ ToolHandle<xAOD::ITrackIsolationTool> m_trackIsoTool;
+ std::string m_trackContainerName;
+ std::string m_vertexContainerName;
+ std::vector<unsigned int> m_cones;
+ std::vector<std::string> m_passFlags;
+ int m_vertexType; //Which type of primary vertices should be used? (7 = 0b111 are all at the moment)
+
+ bool m_doIsoPerTrk;
+ int m_removeDuplicate;
+ };
+}
+
+#endif
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/python/BPhysPyHelpers.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/python/BPhysPyHelpers.py
new file mode 100644
index 00000000000..c30320e4e2f
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/python/BPhysPyHelpers.py
@@ -0,0 +1,84 @@
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+
+#====================================================================
+# BPhysPyHelpers.py
+#
+# Python helper classes for BPHY derivations.
+#
+# authors: W. Walkowiak <wolfgang.walkowiak@cern.ch>, 2016-05-19
+# changed:
+#
+# This file contains a set of Python helper classes for the
+# BPHY derivations.
+#
+# Available helper classes and methods:
+# - BPyWrapper -- wrap configurable to ensure default contents of
+# __slots__ dict are available as attributes
+# Usage example: see BPHY8.py
+# Note: Unfortunately, this doesn't quite work, since the
+# wrapped class is no longer recognized as Configurable
+# - BPhysEnsureAttributes(algtool)
+# -- ensure default contents of __slots__ dict a
+# are available as attributes to the class
+# - BPhysFilterBranches(...)
+# -- create list of isolation or closest track branches
+# to be thinned
+#
+#====================================================================
+
+#--------------------------------------------------------------------
+class BPyWrapper(object):
+ __slots__ = {'wclass' : object}
+
+ def __init__(self, wclass, *args, **kargs):
+ object.__setattr__(self, 'wclass', wclass(*args, **kargs))
+ # the important part: make __slot__ variables attributes
+ for n,v in self.wclass.__slots__.items():
+ if not hasattr(self.wclass, n):
+ setattr(self.wclass, n, v)
+
+ def __getattr__(self, attr):
+ return self.wclass.__getattribute__(attr)
+
+ def __setattr__(self, attr, value):
+ setattr(self.wclass, attr, value)
+
+ def __call__(self, *args, **kwargs):
+ return self.wclass(*args, **kwargs)
+#--------------------------------------------------------------------
+#
+# ensure default contents of __slots__ dict are available as attributes
+#
+def BPhysEnsureAttributes(algtool):
+
+ for n,v in algtool.__slots__.items():
+ if not hasattr(algtool, n):
+ setattr(algtool, n, v)
+ return algtool
+#--------------------------------------------------------------------
+#
+# create list of isolation or closest track branches to be thinned
+# (used by BPHY8)
+#
+def BPhysFilterBranches(name, brPrefixList, brIncludeList, doVertexTypeList,
+ categoryList, trackTypeList, coneOrChi2SetList,
+ forCloseTrack=False):
+ res = ""
+ brIncludes = [tuple(x.split('|',3)) for x in brIncludeList]
+ for bntup in brPrefixList:
+ bn, sep, bnsuf = bntup.partition('+')
+ for i, cstr in enumerate(coneOrChi2SetList):
+ for itt in trackTypeList:
+ ittstr = "T%010d" % itt
+ for itcstr in categoryList:
+ if brIncludes and not (cstr,str(itt),itcstr) in brIncludes:
+ for dvs in doVertexTypeList:
+ if forCloseTrack:
+ fbn = '_'.join(filter(None, [name,bn,ittstr,itcstr,
+ dvs,cstr,bnsuf]))
+ else:
+ fbn = '_'.join(filter(None, [name,bn,cstr,ittstr,
+ itcstr,dvs,bnsuf]))
+ res += ".-"+fbn
+ return res
+#--------------------------------------------------------------------
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/python/__init__.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/python/__init__.py
new file mode 100644
index 00000000000..74583d364ec
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/python/__init__.py
@@ -0,0 +1,2 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY1.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY1.py
new file mode 100644
index 00000000000..6b20ae9dacb
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY1.py
@@ -0,0 +1,274 @@
+#====================================================================
+# BPHY1.py
+# This an example job options script showing how to set up a
+# derivation of the data using the derivation framework.
+# It requires the reductionConf flag BPHY1 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print (isSimulation)
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+#include( "JpsiUpsilonTools/configureServices.py" )
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY1_VertexTools = BPHYVertexTools("BPHY1")
+
+#--------------------------------------------------------------------
+## 2/ Setup the vertex fitter tools (e.g. JpsiFinder, JpsiPlus1Track, etc).
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY1JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY1JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ invMassUpper = 100000.0,
+ invMassLower = 0.0,
+ Chi2Cut = 200.,
+ oppChargesOnly = True,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY1_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY1_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY1_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY1_VertexTools.VtxPointEstimator,
+ useMCPCuts = False )
+
+ToolSvc += BPHY1JpsiFinder
+print (BPHY1JpsiFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY1_Reco_mumu = DerivationFramework__Reco_Vertex(
+ name = "BPHY1_Reco_mumu",
+ VertexSearchTool = BPHY1JpsiFinder,
+ OutputVtxContainerName = "BPHY1OniaCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY1RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 100000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY1_Reco_mumu
+print (BPHY1_Reco_mumu)
+
+#--------------------------------------------------------------------
+## 4/ setup the vertex selection and augmentation tool(s). These tools decorate the vertices with
+## variables that depend on the vertex mass hypothesis, e.g. invariant mass, proper decay time, etc.
+## Property HypothesisName is used as a prefix for these decorations.
+## They also perform tighter selection, flagging the vertecis that passed. The flag is a Char_t branch
+## named "passed_"+HypothesisName. It is used later by the "SelectEvent" and "Thin_vtxTrk" tools
+## to determine which events and candidates should be kept in the output stream.
+## Multiple instances of the Select_* tools can be used on a single input collection as long as they
+## use different "HypothesisName" flags.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY1_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY1_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY1OniaCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 2000.0,
+ MassMax = 3600.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY1_Select_Jpsi2mumu
+print (BPHY1_Select_Jpsi2mumu)
+
+## b/ augment and select Psi(2S)->mumu candidates
+BPHY1_Select_Psi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY1_Select_Psi2mumu",
+ HypothesisName = "Psi",
+ InputVtxContainerName = "BPHY1OniaCandidates",
+ VtxMassHypo = 3686.09,
+ MassMin = 3300.0,
+ MassMax = 4500.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY1_Select_Psi2mumu
+print (BPHY1_Select_Psi2mumu)
+
+# Added by ASC
+## c/ augment and select Upsilon(nS)->mumu candidates
+BPHY1_Select_Upsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY1_Select_Upsi2mumu",
+ HypothesisName = "Upsi",
+ InputVtxContainerName = "BPHY1OniaCandidates",
+ VtxMassHypo = 9460.30,
+ MassMin = 7000.0,
+ MassMax = 12500.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY1_Select_Upsi2mumu
+print (BPHY1_Select_Upsi2mumu)
+
+
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY1Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY1Stream )
+BPHY1Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY1Stream.AcceptAlgs(["BPHY1Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+augStream = MSMgr.GetStream( streamName )
+
+
+
+#--------------------------------------------------------------------
+## 5/ select the event. We only want to keep events that contain certain vertices which passed certain selection.
+## This is specified by the "SelectionExpression" property, which contains the expression in the following format:
+##
+## "ContainerName.passed_HypoName > count"
+##
+## where "ContainerName" is output container form some Reco_* tool, "HypoName" is the hypothesis name setup in some "Select_*"
+## tool and "count" is the number of candidates passing the selection you want to keep.
+
+expression = "count(BPHY1OniaCandidates.passed_Jpsi) > 0 || count(BPHY1OniaCandidates.passed_Psi) > 0 || count(BPHY1OniaCandidates.passed_Upsi) > 0"
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY1_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY1_SelectEvent",
+ expression = expression)
+ToolSvc += BPHY1_SelectEvent
+print (BPHY1_SelectEvent)
+
+#--------------------------------------------------------------------
+## 6/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY1Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY1Thin_vtxTrk",
+ TrackParticleContainerName = "InDetTrackParticles",
+ StreamName = streamName,
+ VertexContainerNames = ["BPHY1OniaCandidates"],
+ PassFlags = ["passed_Jpsi", "passed_Psi", "passed_Upsi"] )
+
+ToolSvc += BPHY1Thin_vtxTrk
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY1MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY1MuonTPThinningTool",
+ MuonKey = "Muons",
+ StreamName = streamName,
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY1MuonTPThinningTool
+
+# Added by ASC
+# Only save truth informtion directly associated with Onia
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY1TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY1TruthThinTool",
+ StreamName = streamName,
+ ParticleSelectionString = "TruthParticles.pdgId == 443 || TruthParticles.pdgId == 100443 || TruthParticles.pdgId == 553 || TruthParticles.pdgId == 100553 || TruthParticles.pdgId == 200553",
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY1TruthThinTool
+print (BPHY1TruthThinTool)
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+## 7/ IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel! If you don't do that, they will not be
+## be executed!
+
+# Added by ASC
+BPHY1ThinningTools = [BPHY1Thin_vtxTrk, BPHY1MuonTPThinningTool]
+if globalflags.DataSource()=='geant4':
+ BPHY1ThinningTools.append(BPHY1TruthThinTool)
+
+# The name of the kernel (BPHY1Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY1Kernel",
+ AugmentationTools = [BPHY1_Reco_mumu, BPHY1_Select_Jpsi2mumu, BPHY1_Select_Psi2mumu, BPHY1_Select_Upsi2mumu],
+ SkimmingTools = [BPHY1_SelectEvent],
+ ThinningTools = BPHY1ThinningTools
+ )
+
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY1SlimmingHelper = SlimmingHelper("BPHY1SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY1SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY1SlimmingHelper.IncludeBPhysTriggerContent = True
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY1RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY1RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+AllVariables += ["Muons"]
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY1_Reco_mumu.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY1_Reco_mumu.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY1_Reco_mumu.OutputVtxContainerName]
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+BPHY1SlimmingHelper.AllVariables = AllVariables
+BPHY1SlimmingHelper.StaticContent = StaticContent
+BPHY1SlimmingHelper.AppendContentToStream(BPHY1Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY10.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY10.py
new file mode 100644
index 00000000000..2f9dcb083a9
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY10.py
@@ -0,0 +1,477 @@
+#====================================================================
+# BPHY10.py
+# Bs>J/psiKK
+# It requires the reductionConf flag BPHY10 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+#include( "JpsiUpsilonTools/configureServices.py" )
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY10_VertexTools = BPHYVertexTools("BPHY10")
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__AugOriginalCounts
+BPHY10_AugOriginalCounts = DerivationFramework__AugOriginalCounts(
+ name = "BPHY10_AugOriginalCounts",
+ VertexContainer = "PrimaryVertices",
+ TrackContainer = "InDetTrackParticles" )
+ToolSvc += BPHY10_AugOriginalCounts
+
+
+#--------------------------------------------------------------------
+## 2/ setup JpsiFinder tool
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY10JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY10JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True,
+ invMassUpper = 4000.0,
+ invMassLower = 2600.0,
+ Chi2Cut = 200.,
+ oppChargesOnly = True,
+ combOnly = True,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY10_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY10_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY10_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY10_VertexTools.VtxPointEstimator,
+ useMCPCuts = False)
+
+ToolSvc += BPHY10JpsiFinder
+print(BPHY10JpsiFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY10JpsiSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY10JpsiSelectAndWrite",
+ VertexSearchTool = BPHY10JpsiFinder,
+ OutputVtxContainerName = "BPHY10JpsiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ # RefPVContainerName = "BPHY10RefJpsiPrimaryVertices",
+ # RefitPV = True,
+ # MaxPVrefit = 10000,
+ DoVertexType = 1)
+
+ToolSvc += BPHY10JpsiSelectAndWrite
+print(BPHY10JpsiSelectAndWrite)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY10_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY10_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY10JpsiCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 2600.0,
+ MassMax = 4000.0,
+ Chi2Max = 200,
+ DoVertexType =1)
+
+
+ToolSvc += BPHY10_Select_Jpsi2mumu
+print(BPHY10_Select_Jpsi2mumu)
+
+
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BdKstVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BdKstVertexFit",
+ Extrapolator = BPHY10_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+
+ToolSvc += BdKstVertexFit
+print(BdKstVertexFit)
+
+## 5/ setup the Jpsi+2 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY10BdJpsiKst = Analysis__JpsiPlus2Tracks(
+ name = "BPHY10BdJpsiKst",
+ OutputLevel = INFO,
+ kaonkaonHypothesis = False,
+ pionpionHypothesis = False,
+ kaonpionHypothesis = True,
+ trkThresholdPt = 500.0,
+ trkMaxEta = 3.0,
+ BThresholdPt = 5000.,
+ BMassLower = 4300.0,
+ BMassUpper = 6300.0,
+ JpsiContainerKey = "BPHY10JpsiCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ #MuonsUsedInJpsi = "Muons", #Don't remove all muons, just those in J/psi candidate (see the following cut)
+ ExcludeCrossJpsiTracks = False, #setting this to False rejects the muons from J/psi candidate
+ TrkVertexFitterTool = BdKstVertexFit,
+ TrackSelectorTool = BPHY10_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY10_VertexTools.VtxPointEstimator,
+ UseMassConstraint = True,
+ #DiTrackMassUpper = 1500.,
+ #DiTrackMassLower = 500.,
+ Chi2Cut = 10.0,
+ DiTrackPt = 500.,
+ TrkQuadrupletMassLower = 3500.0,
+ TrkQuadrupletMassUpper = 6800.0,
+ #FinalDiTrackMassUpper = 1000.,
+ #FinalDiTrackMassLower = 800.,
+ #TrkDeltaZ = 20., #Normally, this cut should not be used since it is lifetime-dependent
+ FinalDiTrackPt = 500.
+ )
+
+ToolSvc += BPHY10BdJpsiKst
+print(BPHY10BdJpsiKst)
+
+
+## 6/ setup the combined augmentation/skimming tool for the BdKst
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY10BdKstSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY10BdKstSelectAndWrite",
+ Jpsi2PlusTrackName = BPHY10BdJpsiKst,
+ OutputVtxContainerName = "BPHY10BdJpsiKstCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY10RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY10BdKstSelectAndWrite
+print(BPHY10BdKstSelectAndWrite)
+
+## b/ augment and select Bd->JpsiKst candidates
+# set mass hypothesis (K pi)
+BPHY10_Select_Bd2JpsiKst = DerivationFramework__Select_onia2mumu(
+ name = "BPHY10_Select_Bd2JpsiKst",
+ HypothesisName = "Bd",
+ InputVtxContainerName = "BPHY10BdJpsiKstCandidates",
+ TrkMasses = [105.658, 105.658, 493.677, 139.570],
+ VtxMassHypo = 5279.6,
+ MassMin = 100.0, #no mass cuts here
+ MassMax = 100000.0, #no mass cuts here
+ Chi2Max = 200)
+
+ToolSvc += BPHY10_Select_Bd2JpsiKst
+print(BPHY10_Select_Bd2JpsiKst)
+
+## c/ augment and select Bdbar->JpsiKstbar candidates
+# set mass hypothesis (pi K)
+BPHY10_Select_Bd2JpsiKstbar = DerivationFramework__Select_onia2mumu(
+ name = "BPHY10_Select_Bd2JpsiKstbar",
+ HypothesisName = "Bdbar",
+ InputVtxContainerName = "BPHY10BdJpsiKstCandidates",
+ TrkMasses = [105.658, 105.658, 139.570, 493.677],
+ VtxMassHypo = 5279.6,
+ MassMin = 100.0, #no mass cuts here
+ MassMax = 100000.0, #no mass cuts here
+ Chi2Max = 200)
+
+ToolSvc += BPHY10_Select_Bd2JpsiKstbar
+print(BPHY10_Select_Bd2JpsiKstbar)
+
+
+## 7/ call the V0Finder if a Jpsi has been found
+doSimpleV0Finder = False
+if doSimpleV0Finder:
+ include("DerivationFrameworkBPhys/configureSimpleV0Finder.py")
+else:
+ include("DerivationFrameworkBPhys/configureV0Finder.py")
+
+BPHY10_V0FinderTools = BPHYV0FinderTools("BPHY10")
+print(BPHY10_V0FinderTools)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_V0Finder
+BPHY10_Reco_V0Finder = DerivationFramework__Reco_V0Finder(
+ name = "BPHY10_Reco_V0Finder",
+ V0FinderTool = BPHY10_V0FinderTools.V0FinderTool,
+ #OutputLevel = DEBUG,
+ V0ContainerName = "BPHY10RecoV0Candidates",
+ KshortContainerName = "BPHY10RecoKshortCandidates",
+ LambdaContainerName = "BPHY10RecoLambdaCandidates",
+ LambdabarContainerName = "BPHY10RecoLambdabarCandidates",
+ CheckVertexContainers = ['BPHY10JpsiCandidates'])
+
+ToolSvc += BPHY10_Reco_V0Finder
+print(BPHY10_Reco_V0Finder)
+
+## 8/ setup the cascade vertexing tool
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+JpsiV0VertexFit = Trk__TrkVKalVrtFitter(
+ name = "JpsiV0VertexFit",
+ #OutputLevel = DEBUG,
+ Extrapolator = BPHY10_VertexTools.InDetExtrapolator,
+ #FirstMeasuredPoint = True,
+ FirstMeasuredPoint = False,
+ CascadeCnstPrecision = 1e-6,
+ MakeExtendedVertex = True)
+
+ToolSvc += JpsiV0VertexFit
+print(JpsiV0VertexFit)
+
+## 9/ setup the Jpsi+V0 finder
+## a/ Bd->JpsiKshort
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__JpsiPlusV0Cascade
+BPHY10JpsiKshort = DerivationFramework__JpsiPlusV0Cascade(
+ name = "BPHY10JpsiKshort",
+ #OutputLevel = DEBUG,
+ HypothesisName = "Bd",
+ TrkVertexFitterTool = JpsiV0VertexFit,
+ V0Hypothesis = 310,
+ JpsiMassLowerCut = 2800.,
+ JpsiMassUpperCut = 4000.,
+ V0MassLowerCut = 400.,
+ V0MassUpperCut = 600.,
+ MassLowerCut = 4300.,
+ MassUpperCut = 6300.,
+ RefitPV = True,
+ RefPVContainerName = "BPHY10RefittedPrimaryVertices",
+ JpsiVertices = "BPHY10JpsiCandidates",
+ CascadeVertexCollections= ["BPHY10JpsiKshortCascadeSV2", "BPHY10JpsiKshortCascadeSV1"],
+ V0Vertices = "BPHY10RecoV0Candidates")
+
+ToolSvc += BPHY10JpsiKshort
+print(BPHY10JpsiKshort)
+
+## b/ Lambda_b->JpsiLambda
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__JpsiPlusV0Cascade
+BPHY10JpsiLambda = DerivationFramework__JpsiPlusV0Cascade(
+ name = "BPHY10JpsiLambda",
+ #OutputLevel = DEBUG,
+ HypothesisName = "Lambda_b",
+ TrkVertexFitterTool = JpsiV0VertexFit,
+ V0Hypothesis = 3122,
+ JpsiMassLowerCut = 2800.,
+ JpsiMassUpperCut = 4000.,
+ V0MassLowerCut = 1050.,
+ V0MassUpperCut = 1250.,
+ MassLowerCut = 4600.,
+ MassUpperCut = 6600.,
+ RefitPV = True,
+ RefPVContainerName = "BPHY10RefittedPrimaryVertices",
+ JpsiVertices = "BPHY10JpsiCandidates",
+ CascadeVertexCollections= ["BPHY10JpsiLambdaCascadeSV2", "BPHY10JpsiLambdaCascadeSV1"],
+ V0Vertices = "BPHY10RecoV0Candidates")
+
+ToolSvc += BPHY10JpsiLambda
+print(BPHY10JpsiLambda)
+
+## c/ Lambda_bbar->JpsiLambdabar
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__JpsiPlusV0Cascade
+BPHY10JpsiLambdabar = DerivationFramework__JpsiPlusV0Cascade(
+ name = "BPHY10JpsiLambdabar",
+ HypothesisName = "Lambda_bbar",
+ #OutputLevel = DEBUG,
+ TrkVertexFitterTool = JpsiV0VertexFit,
+ V0Hypothesis = -3122,
+ JpsiMassLowerCut = 2800.,
+ JpsiMassUpperCut = 4000.,
+ V0MassLowerCut = 1050.,
+ V0MassUpperCut = 1250.,
+ MassLowerCut = 4600.,
+ MassUpperCut = 6600.,
+ RefitPV = True,
+ RefPVContainerName = "BPHY10RefittedPrimaryVertices",
+ JpsiVertices = "BPHY10JpsiCandidates",
+ CascadeVertexCollections= ["BPHY10JpsiLambdabarCascadeSV2", "BPHY10JpsiLambdabarCascadeSV1"],
+ V0Vertices = "BPHY10RecoV0Candidates")
+
+ToolSvc += BPHY10JpsiLambdabar
+print(BPHY10JpsiLambdabar)
+
+CascadeCollections = []
+CascadeCollections += BPHY10JpsiKshort.CascadeVertexCollections
+CascadeCollections += BPHY10JpsiLambda.CascadeVertexCollections
+CascadeCollections += BPHY10JpsiLambdabar.CascadeVertexCollections
+
+
+
+if not isSimulation: #Only Skim Data
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+ BPHY10_SelectBdJpsiKstEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY10_SelectBdJpsiKstEvent",
+ #expression = "(count(BPHY10BdJpsiKstCandidates.passed_Bd > 0) + count(BPHY10BdJpsiKstCandidates.passed_BdBar > 0) + count(BPHY10RecoV0Candidates) + count(RecoKshortContainerName) + count(RecoLambdaContainerName) + count(RecoLambdabarContainerName) ) > 0")
+ expression = "(count(BPHY10BdJpsiKstCandidates.passed_Bd > 0) + count(BPHY10BdJpsiKstCandidates.passed_Bdbar > 0) + count(BPHY10JpsiKshortCascadeSV1.x > -999) + count(BPHY10JpsiLambdaCascadeSV1.x > -999) + count(BPHY10JpsiLambdabarCascadeSV1.x > -999) ) > 0")
+
+ ToolSvc += BPHY10_SelectBdJpsiKstEvent
+ print(BPHY10_SelectBdJpsiKstEvent)
+
+
+
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools
+ #====================================================================
+
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+ BPHY10SkimmingOR = CfgMgr.DerivationFramework__FilterCombinationOR(
+ "BPHY10SkimmingOR",
+ FilterList = [BPHY10_SelectBdJpsiKstEvent],)
+ ToolSvc += BPHY10SkimmingOR
+ print(BPHY10SkimmingOR)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY10_thinningTool_Tracks = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY10_thinningTool_Tracks",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BPHY10BdJpsiKstCandidates","BPHY10JpsiKshortCascadeSV1","BPHY10JpsiKshortCascadeSV2","BPHY10JpsiLambdaCascadeSV1","BPHY10JpsiLambdaCascadeSV2","BPHY10JpsiLambdabarCascadeSV1","BPHY10JpsiLambdabarCascadeSV2"],
+ PassFlags = ["passed_Bd", "passed_Bdbar"] )
+
+ToolSvc += BPHY10_thinningTool_Tracks
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysPVThinningTool
+BPHY10_thinningTool_PV = DerivationFramework__BPhysPVThinningTool(
+ name = "BPHY10_thinningTool_PV",
+ CandidateCollections = ["BPHY10BdJpsiKstCandidates","BPHY10JpsiKshortCascadeSV1","BPHY10JpsiKshortCascadeSV2","BPHY10JpsiLambdaCascadeSV1","BPHY10JpsiLambdaCascadeSV2","BPHY10JpsiLambdabarCascadeSV1","BPHY10JpsiLambdabarCascadeSV2"],
+ KeepPVTracks =True
+ )
+
+ToolSvc += BPHY10_thinningTool_PV
+
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY10MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(
+ name = "BPHY10MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY10MuonTPThinningTool
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+thiningCollection = []
+
+print(thiningCollection)
+
+
+# The name of the kernel (BPHY10Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY10Kernel",
+ AugmentationTools = [BPHY10JpsiSelectAndWrite, BPHY10_Select_Jpsi2mumu,
+ BPHY10BdKstSelectAndWrite, BPHY10_Select_Bd2JpsiKst, BPHY10_Select_Bd2JpsiKstbar,
+ BPHY10_Reco_V0Finder, BPHY10JpsiKshort, BPHY10JpsiLambda, BPHY10JpsiLambdabar,
+ BPHY10_AugOriginalCounts],
+ #Only skim if not MC
+ SkimmingTools = [BPHY10SkimmingOR] if not isSimulation else [],
+ ThinningTools = thiningCollection
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY10Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY10Stream )
+BPHY10Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY10Stream.AcceptAlgs(["BPHY10Kernel"])
+
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+
+BPHY10ThinningSvc = createThinningSvc( svcName="BPHY10ThinningSvc", outStreams=[evtStream] )
+svcMgr += BPHY10ThinningSvc
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY10SlimmingHelper = SlimmingHelper("BPHY10SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY10SlimmingHelper.IncludeMuonTriggerContent = TRUE
+BPHY10SlimmingHelper.IncludeBPhysTriggerContent = TRUE
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY10RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY10RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+AllVariables += ["Muons"]
+
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY10JpsiSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY10JpsiSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY10BdKstSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY10BdKstSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % 'BPHY10RecoV0Candidates']
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % 'BPHY10RecoV0Candidates']
+StaticContent += ["xAOD::VertexContainer#%s" % 'BPHY10RecoKshortCandidates']
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % 'BPHY10RecoKshortCandidates']
+StaticContent += ["xAOD::VertexContainer#%s" % 'BPHY10RecoLambdaCandidates']
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % 'BPHY10RecoLambdaCandidates']
+StaticContent += ["xAOD::VertexContainer#%s" % 'BPHY10RecoLambdabarCandidates']
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % 'BPHY10RecoLambdabarCandidates']
+
+for cascades in CascadeCollections:
+ StaticContent += ["xAOD::VertexContainer#%s" % cascades]
+ StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % cascades]
+
+# Tagging information (in addition to that already requested by usual algorithms)
+AllVariables += ["GSFTrackParticles", "MuonSpectrometerTrackParticles" ]
+
+
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+AllVariables = list(set(AllVariables)) # remove duplicates
+
+BPHY10SlimmingHelper.AllVariables = AllVariables
+BPHY10SlimmingHelper.StaticContent = StaticContent
+BPHY10SlimmingHelper.SmartCollections = []
+
+BPHY10SlimmingHelper.AppendContentToStream(BPHY10Stream)
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY11.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY11.py
new file mode 100644
index 00000000000..a0ea555b5e4
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY11.py
@@ -0,0 +1,506 @@
+#====================================================================
+# BPHY11.py
+# Lambda_b -> J/psi p K
+# It requires the reductionConf flag BPHY11 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+#include( "JpsiUpsilonTools/configureServices.py" )
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY11_VertexTools = BPHYVertexTools("BPHY11")
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__AugOriginalCounts
+BPHY11_AugOriginalCounts = DerivationFramework__AugOriginalCounts(
+ name = "BPHY11_AugOriginalCounts",
+ VertexContainer = "PrimaryVertices",
+ TrackContainer = "InDetTrackParticles"
+)
+
+ToolSvc += BPHY11_AugOriginalCounts
+
+
+#--------------------------------------------------------------------
+## 2/ setup JpsiFinder tool
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY11_JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY11_JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True,
+ invMassUpper = 3600.0,
+ invMassLower = 2600.0,
+ Chi2Cut = 30.0,
+ oppChargesOnly = False,
+ allChargeCombinations = True,
+ combOnly = False,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY11_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY11_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY11_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY11_VertexTools.VtxPointEstimator,
+ useMCPCuts = False
+)
+
+ToolSvc += BPHY11_JpsiFinder
+print(BPHY11_JpsiFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY11_JpsiSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY11_JpsiSelectAndWrite",
+ VertexSearchTool = BPHY11_JpsiFinder,
+ OutputVtxContainerName = "BPHY11_JpsiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ DoVertexType = 1
+)
+
+ToolSvc += BPHY11_JpsiSelectAndWrite
+print(BPHY11_JpsiSelectAndWrite)
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY11_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY11_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY11_JpsiCandidates",
+ VtxMassHypo = 3096.900,
+ MassMin = 2600.0,
+ MassMax = 3600.0,
+ Chi2Max = 30.0,
+ DoVertexType = 1
+)
+
+ToolSvc += BPHY11_Select_Jpsi2mumu
+print(BPHY11_Select_Jpsi2mumu)
+
+
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+LbJpsipKVertexFit = Trk__TrkVKalVrtFitter(
+ name = "LbJpsipKVertexFit",
+ Extrapolator = BPHY11_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = False,
+ MakeExtendedVertex = True,
+ usePassWithTrkErrCnst = True
+)
+
+ToolSvc += LbJpsipKVertexFit
+print(LbJpsipKVertexFit)
+
+
+## 5/ setup the Jpsi+2 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY11_LbJpsipK = Analysis__JpsiPlus2Tracks(
+ name = "BPHY11_LbJpsipK",
+ OutputLevel = INFO,
+ kaonkaonHypothesis = False,
+ pionpionHypothesis = False,
+ kaonpionHypothesis = False,
+ kaonprotonHypothesis = True,
+ oppChargesOnly = False,
+ trkThresholdPt = 1500.0,
+ trkMaxEta = 3.0,
+ BMassUpper = 6500.0,
+ BMassLower = 4000.0,
+# DiTrackMassUpper = 10000.,
+ DiTrackMassLower = 1000.,
+ Chi2Cut = 200.0,
+ TrkQuadrupletMassUpper = 7000.0,
+ TrkQuadrupletMassLower = 4000.0,
+ JpsiContainerKey = "BPHY11_JpsiCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ MuonsUsedInJpsi = "Muons",
+ TrkVertexFitterTool = LbJpsipKVertexFit,
+ TrackSelectorTool = BPHY11_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = True,
+ UseVertexFittingWithPV = True,
+ VertexContainer = "PrimaryVertices"
+)
+
+ToolSvc += BPHY11_LbJpsipK
+print(BPHY11_LbJpsipK)
+
+## 6/ setup the combined augmentation/skimming tool for the Bpm
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY11_LbJpsipKSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY11_LbJpsipKSelectAndWrite",
+ Jpsi2PlusTrackName = BPHY11_LbJpsipK,
+ OutputVtxContainerName = "LbJpsipKCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY11_RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000,
+ DoVertexType = 7
+)
+
+ToolSvc += BPHY11_LbJpsipKSelectAndWrite
+print(BPHY11_LbJpsipKSelectAndWrite)
+
+## b/ augment and select Lb->JpsipK candidates
+BPHY11_Select_Lb2JpsipK = DerivationFramework__Select_onia2mumu(
+ name = "BPHY11_Select_Lb2JpsipK",
+ HypothesisName = "Lb_pK",
+ InputVtxContainerName = "LbJpsipKCandidates",
+ TrkMasses = [105.658, 105.658, 938.272, 493.677],
+ VtxMassHypo = 5619.6,
+ MassMin = 4000.0,
+ MassMax = 6500.0,
+ Chi2Max = 200,
+ LxyMin = 0.3
+)
+
+ToolSvc += BPHY11_Select_Lb2JpsipK
+print(BPHY11_Select_Lb2JpsipK)
+
+
+## b/ augment and select Lb->JpsiKp candidates
+BPHY11_Select_Lb2JpsiKp = DerivationFramework__Select_onia2mumu(
+ name = "BPHY11_Select_Lb2JpsiKp",
+ HypothesisName = "Lb_Kp",
+ InputVtxContainerName = "LbJpsipKCandidates",
+ TrkMasses = [105.658, 105.658, 493.677, 938.272],
+ VtxMassHypo = 5619.6,
+ MassMin = 4000.0,
+ MassMax = 6500.0,
+ Chi2Max = 200.0,
+ LxyMin = 0.3
+)
+
+ToolSvc += BPHY11_Select_Lb2JpsiKp
+print(BPHY11_Select_Lb2JpsiKp)
+
+#-------------------------------------------------------
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__ReVertex
+BPHY11_LbPlusTrk = DerivationFramework__ReVertex(
+ name = "BPHY11_LbPlusTrk",
+ InputVtxContainerName = "LbJpsipKCandidates",
+ HypothesisNames = [ BPHY11_Select_Lb2JpsipK.HypothesisName, BPHY11_Select_Lb2JpsiKp.HypothesisName ],
+ TrackIndices = [ 0, 1, 2, 3 ],
+ UseAdditionalTrack = True,
+ UseMassConstraint = True,
+ UseVertexFittingWithPV = True,
+# VertexMass = 5619.6,
+ SubVertexMass = 3096.900,
+ MassInputParticles = [ 105.658, 105.658, 139.57, 139.57, 139.57 ],
+ SubVertexTrackIndices = [ 1, 2 ],
+ BMassUpper = 10000.0,
+ BMassLower = 4000.0,
+ Chi2Cut = 5.0,
+ TrkVertexFitterTool = LbJpsipKVertexFit,
+ OutputVtxContainerName = "LbJpsipKTrkCandidates"
+)
+
+ToolSvc += BPHY11_LbPlusTrk
+print(BPHY11_LbPlusTrk)
+
+BPHY11_Select_LbPlusTrk = DerivationFramework__Select_onia2mumu(
+ name = "BPHY11_Select_LbPlusTrk",
+ HypothesisName = "LbPlusTrk",
+ InputVtxContainerName = "LbJpsipKTrkCandidates",
+ TrkMasses = BPHY11_LbPlusTrk.MassInputParticles,
+ VtxMassHypo = 5619.6,
+ MassMin = 4000.0,
+ MassMax = 10000.0,
+ Chi2Max = 50.0
+)
+
+ToolSvc += BPHY11_Select_LbPlusTrk
+print(BPHY11_Select_LbPlusTrk)
+
+#-------------------------------------------------------
+
+BPHY11_Lb_pK_ReFit = DerivationFramework__ReVertex(
+ name = "BPHY11_Lb_pK_ReFit",
+ InputVtxContainerName = "LbJpsipKCandidates",
+ HypothesisNames = [ BPHY11_Select_Lb2JpsipK.HypothesisName ],
+ TrackIndices = [ 0, 1, 2, 3 ],
+ UseMassConstraint = True,
+ UseVertexFittingWithPV = True,
+ VertexMass = 5619.6,
+ SubVertexMass = 3096.900,
+ MassInputParticles = [ 105.658, 105.658, 938.272, 493.677 ],
+ SubVertexTrackIndices = [ 1, 2 ],
+ TrkVertexFitterTool = LbJpsipKVertexFit,
+ OutputVtxContainerName = "LbJpsipKCandidatesReFit"
+)
+
+ToolSvc += BPHY11_Lb_pK_ReFit
+print(BPHY11_Lb_pK_ReFit)
+
+BPHY11_Select_Lb_pK_ReFit = DerivationFramework__Select_onia2mumu(
+ name = "BPHY11_Select_Lb_pK_ReFit",
+ HypothesisName = "Lb_pK_ReFit",
+ InputVtxContainerName = "LbJpsipKCandidatesReFit",
+ TrkMasses = BPHY11_Lb_pK_ReFit.MassInputParticles,
+ VtxMassHypo = 5619.6,
+ MassMin = 0.0,
+ MassMax = 1.0e10,
+ Chi2Max = 1.0e10
+)
+
+ToolSvc += BPHY11_Select_Lb_pK_ReFit
+print(BPHY11_Select_Lb_pK_ReFit)
+
+BPHY11_Lb_Kp_ReFit = DerivationFramework__ReVertex(
+ name = "BPHY11_Lb_Kp_ReFit",
+ InputVtxContainerName = "LbJpsipKCandidates",
+ HypothesisNames = [ BPHY11_Select_Lb2JpsiKp.HypothesisName ],
+ TrackIndices = [ 0, 1, 2, 3 ],
+ UseMassConstraint = True,
+ UseVertexFittingWithPV = True,
+ VertexMass = 5619.6,
+ SubVertexMass = 3096.900,
+ MassInputParticles = [ 105.658, 105.658, 493.677, 938.272 ],
+ SubVertexTrackIndices = [ 1, 2 ],
+ TrkVertexFitterTool = LbJpsipKVertexFit,
+ OutputVtxContainerName = "LbJpsiKpCandidatesReFit"
+)
+
+ToolSvc += BPHY11_Lb_Kp_ReFit
+print(BPHY11_Lb_Kp_ReFit)
+
+BPHY11_Select_Lb_Kp_ReFit = DerivationFramework__Select_onia2mumu(
+ name = "BPHY11_Select_Lb_Kp_ReFit",
+ HypothesisName = "Lb_Kp_ReFit",
+ InputVtxContainerName = "LbJpsiKpCandidatesReFit",
+ TrkMasses = BPHY11_Lb_Kp_ReFit.MassInputParticles,
+ VtxMassHypo = 5619.6,
+ MassMin = 0.0,
+ MassMax = 1.0e10,
+ Chi2Max = 1.0e10
+)
+
+ToolSvc += BPHY11_Select_Lb_Kp_ReFit
+print(BPHY11_Select_Lb_Kp_ReFit)
+
+
+
+#from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__SelectEvent
+
+if not isSimulation: #Only Skim Data
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+ BPHY11_SelectLdJpsipKEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY11_SelectLdJpsipKEvent",
+ expression = "count(LbJpsipKCandidates.passed_Lb_pK > 0) > 0"
+ )
+
+ ToolSvc += BPHY11_SelectLdJpsipKEvent
+ print(BPHY11_SelectLdJpsipKEvent)
+
+ BPHY11_SelectLdJpsiKpEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY11_SelectLdJpsiKpEvent",
+ expression = "count(LbJpsipKCandidates.passed_Lb_Kp > 0) > 0"
+ )
+
+ ToolSvc += BPHY11_SelectLdJpsiKpEvent
+ print(BPHY11_SelectLdJpsiKpEvent)
+
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools
+ #====================================================================
+
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+ BPHY11_SkimmingOR = CfgMgr.DerivationFramework__FilterCombinationOR(
+ "BPHY11_SkimmingOR",
+ FilterList = [BPHY11_SelectLdJpsipKEvent,BPHY11_SelectLdJpsiKpEvent],)
+
+ ToolSvc += BPHY11_SkimmingOR
+ print(BPHY11_SkimmingOR)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY11_thinningTool_Tracks = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY11_thinningTool_Tracks",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["LbJpsipKCandidates"],
+ PassFlags = ["passed_Lb_pK","passed_Lb_Kp"]
+)
+
+ToolSvc += BPHY11_thinningTool_Tracks
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysPVThinningTool
+BPHY11_thinningTool_PV = DerivationFramework__BPhysPVThinningTool(
+ name = "BPHY11_thinningTool_PV",
+ CandidateCollections = ["LbJpsipKCandidates"],
+ KeepPVTracks = True
+)
+
+ToolSvc += BPHY11_thinningTool_PV
+
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY11_MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(
+ name = "BPHY11_MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles"
+)
+
+ToolSvc += BPHY11_MuonTPThinningTool
+
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__EgammaTrackParticleThinning
+BPHY11_ElectronTPThinningTool = DerivationFramework__EgammaTrackParticleThinning(
+ name = "BPHY11_ElectronTPThinningTool",
+ SGKey = "Electrons",
+ GSFTrackParticlesKey = "GSFTrackParticles",
+ InDetTrackParticlesKey = "InDetTrackParticles",
+ SelectionString = "",
+ BestMatchOnly = True,
+ ConeSize = 0.3,
+ ApplyAnd = False
+)
+
+ToolSvc+=BPHY11_ElectronTPThinningTool
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+BPHY11_ThiningCollection = [BPHY11_thinningTool_Tracks,
+ BPHY11_thinningTool_PV,
+ BPHY11_MuonTPThinningTool,
+ BPHY11_ElectronTPThinningTool]
+print(BPHY11_ThiningCollection)
+
+
+# The name of the kernel (BPHY11_Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY11_Kernel",
+ AugmentationTools = [BPHY11_JpsiSelectAndWrite, BPHY11_Select_Jpsi2mumu,
+ BPHY11_LbJpsipKSelectAndWrite, BPHY11_Select_Lb2JpsipK, BPHY11_Select_Lb2JpsiKp,
+ BPHY11_LbPlusTrk, BPHY11_Select_LbPlusTrk,
+ BPHY11_Lb_pK_ReFit, BPHY11_Select_Lb_pK_ReFit,
+ BPHY11_Lb_Kp_ReFit, BPHY11_Select_Lb_Kp_ReFit,
+ BPHY11_AugOriginalCounts],
+ #Only skim if not MC
+ SkimmingTools = [BPHY11_SkimmingOR] if not isSimulation else [],
+ ThinningTools = BPHY11_ThiningCollection
+)
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY11Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY11Stream )
+BPHY11Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY11Stream.AcceptAlgs(["BPHY11_Kernel"])
+
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+
+BPHY11_ThinningSvc = createThinningSvc( svcName="BPHY11_ThinningSvc", outStreams=[evtStream] )
+svcMgr += BPHY11_ThinningSvc
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY11_SlimmingHelper = SlimmingHelper("BPHY11_SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY11_SlimmingHelper.IncludeMuonTriggerContent = TRUE
+BPHY11_SlimmingHelper.IncludeBPhysTriggerContent = TRUE
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY11_RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY11_RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+AllVariables += ["Muons"]
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY11_JpsiSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY11_JpsiSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY11_LbJpsipKSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY11_LbJpsipKSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY11_LbPlusTrk.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY11_LbPlusTrk.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY11_Lb_pK_ReFit.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY11_Lb_pK_ReFit.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY11_Lb_Kp_ReFit.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY11_Lb_Kp_ReFit.OutputVtxContainerName]
+
+
+
+# Tagging information (in addition to that already requested by usual algorithms)
+#AllVariables += ["Electrons"]
+AllVariables += ["GSFTrackParticles"]
+tagJetCollections = ['AntiKt4LCTopoJets']
+
+for jet_collection in tagJetCollections:
+ AllVariables += [jet_collection]
+ AllVariables += ["BTagging_%s" % (jet_collection[:-4]) ]
+ AllVariables += ["BTagging_%sJFVtx" % (jet_collection[:-4]) ]
+ AllVariables += ["BTagging_%sSecVtx" % (jet_collection[:-4]) ]
+
+
+
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+ AllVariables += ["AntiKt4TruthJets","egammaTruthParticles"]
+
+BPHY11_SlimmingHelper.AllVariables = AllVariables
+BPHY11_SlimmingHelper.StaticContent = StaticContent
+BPHY11_SlimmingHelper.SmartCollections = ["Electrons" , "Photons"]
+
+BPHY11_SlimmingHelper.AppendContentToStream(BPHY11Stream)
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY12.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY12.py
new file mode 100644
index 00000000000..90f52acbc56
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY12.py
@@ -0,0 +1,389 @@
+#====================================================================
+# BPHY12.py
+# This an example job options script showing how to set up a
+# derivation of the data using the derivation framework.
+# It requires the reductionConf flag BPHY12 in Reco_tf.py
+#====================================================================
+
+#====================================================================
+# FLAGS TO PERSONALIZE THE DERIVATION
+#====================================================================
+
+skimTruth = False
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print('is this simulation? ', isSimulation)
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY12_VertexTools = BPHYVertexTools("BPHY12")
+
+print('********************** VERTEX TOOLS ***********************')
+print(BPHY12_VertexTools)
+print(BPHY12_VertexTools.TrkV0Fitter)
+print('********************** END VERTEX TOOLS ***********************')
+
+#====================================================================
+# TriggerCounting for Kernel1 #Added by Matteo
+#====================================================================
+#List of trigggers to be counted (high Sig-eff*Lumi ones are in)
+triggersToMetadata= [
+"HLT_mu11_mu6_bBmumuxv2",
+"HLT_2mu10_bBmumuxv2",
+"HLT_2mu6_bBmumuxv2_L1LFV-MU6",
+"HLT_mu11_mu6_bBmumux_BpmumuKp",
+"HLT_2mu6_bBmumux_BpmumuKp_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+
+"HLT_mu11_mu6_bDimu",
+"HLT_4mu4_bDimu6000"
+ ]
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__TriggerCountToMetadata
+BPHY12TriggerCountToMetadata = DerivationFramework__TriggerCountToMetadata(name = "BPHY12TriggerCount",
+ TriggerList = triggersToMetadata,
+ FolderName = "BPHY12")
+
+ToolSvc += BPHY12TriggerCountToMetadata
+
+#====================================================================
+# PRESELECTION for Kernel1 #Added by Matteo
+#====================================================================
+## 1/ Setup the skimming based on triggers
+##
+
+triggerList = [
+"HLT_mu11_mu6_bBmumuxv2",
+"HLT_2mu10_bBmumuxv2",
+"HLT_2mu6_bBmumuxv2_L1LFV-MU6",
+"HLT_mu11_mu6_bBmumux_BpmumuKp",
+"HLT_2mu6_bBmumux_BpmumuKp_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+"HLT_mu11_mu6_bDimu",
+"HLT_4mu4_bDimu6000"
+ ]
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__TriggerSkimmingTool
+BPHY12TriggerSkim = DerivationFramework__TriggerSkimmingTool(name = "BPHY12TriggerSkim",
+ TriggerListOR = triggerList,
+ TriggerListAND = [] )
+
+ToolSvc += BPHY12TriggerSkim
+
+#--------------------------------------------------------------------
+## 2/ Setup the vertex fitter tools (e.g. JpsiFinder, JpsiPlus1Track, etc).
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY12DiMuonFinder = Analysis__JpsiFinder(
+ name = "BPHY12DiMuonFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ invMassUpper = 100000.0,
+ invMassLower = 0.0,
+ Chi2Cut = 200.,
+ oppChargesOnly = True,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY12_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY12_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY12_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY12_VertexTools.VtxPointEstimator,
+ useMCPCuts = False )
+
+ToolSvc += BPHY12DiMuonFinder
+print(BPHY12DiMuonFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY12_Reco_DiMuon = DerivationFramework__Reco_Vertex(
+ name = "BPHY12_Reco_DiMuon",
+ VertexSearchTool = BPHY12DiMuonFinder,
+ OutputVtxContainerName = "BPHY12DiMuonCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY12RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 100000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY12_Reco_DiMuon
+print(BPHY12_Reco_DiMuon)
+
+#--------------------------------------------------------------------
+## 4/ setup the vertex selection and augmentation tool(s). These tools decorate the vertices with
+## variables that depend on the vertex mass hypothesis, e.g. invariant mass, proper decay time, etc.
+## Property HypothesisName is used as a prefix for these decorations.
+## They also perform tighter selection, flagging the vertecis that passed. The flag is a Char_t branch
+## named "passed_"+HypothesisName. It is used later by the "SelectEvent" and "Thin_vtxTrk" tools
+## to determine which events and candidates should be kept in the output stream.
+## Multiple instances of the Select_* tools can be used on a single input collection as long as they
+## use different "HypothesisName" flags.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY12_Select_DiMuons = DerivationFramework__Select_onia2mumu(
+ name = "BPHY12_Select_DiMuons",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY12DiMuonCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 1.0,
+ MassMax = 7000.0,
+ Chi2Max = 200.,
+ DoVertexType = 7)
+
+ToolSvc += BPHY12_Select_DiMuons
+print(BPHY12_Select_DiMuons)
+
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BmumuKstVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BmumuKstVertexFit",
+ Extrapolator = BPHY12_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+
+ToolSvc += BmumuKstVertexFit
+print(BmumuKstVertexFit)
+
+## 5/ setup the Jpsi+2 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY12BmumuKstFinder = Analysis__JpsiPlus2Tracks(
+ name = "BPHY12BmumuKstFinder",
+ OutputLevel = INFO, #can also be DEBUG, WARNING, VERBOSE
+ kaonkaonHypothesis = False,
+ pionpionHypothesis = False,
+ kaonpionHypothesis = True,
+ trkThresholdPt = 500.0, #minimum track pT in MeV
+ trkMaxEta = 3.0,
+ BThresholdPt = 1000.,
+ BMassLower = 3000.0, #OI makes no sense below Jpsi mass #same values as BPHY18 (original) - Bs->JpsiKK
+ BMassUpper = 6500.0,
+ JpsiContainerKey = "BPHY12DiMuonCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ #MuonsUsedInJpsi = "Muons", #Don't remove all muons, just those in J/psi candidate (see the following cut)
+ ExcludeCrossJpsiTracks = False, #setting this to False rejects the muons from J/psi candidate
+ TrkVertexFitterTool = BmumuKstVertexFit,
+ TrackSelectorTool = BPHY12_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = False, #Set to True, according to Bs->JpsiKK DAOD
+ DiTrackMassUpper = 1110., #OI was 1500. Can eventually set these to be the K* mass?
+ DiTrackMassLower = 690., #OI was 500
+ Chi2Cut = 15., #THIS IS CHI2/NDOF, checked the code!!!
+ DiTrackPt = 500.,
+ TrkQuadrupletMassLower = 1000.0, #Two electrons + two tracks (one K, one pi)
+ TrkQuadrupletMassUpper = 100000.0, # same as BPHY18, original
+ #FinalDiTrackMassUpper = 1000.,
+ #FinalDiTrackMassLower = 800.,
+ #TrkDeltaZ = 20., #Normally, this cut should not be used since it is lifetime-dependent
+ FinalDiTrackPt = 500.,
+#OI DoElectrons = True,
+ #UseGSFTrackIndices = [0,1]
+ )
+
+ToolSvc += BPHY12BmumuKstFinder
+print(BPHY12BmumuKstFinder)
+## 6/ setup the combined augmentation/skimming tool for the BeeKst
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY12_Reco_BmumuKst = DerivationFramework__Reco_Vertex(
+ name = "BPHY12_Reco_BmumuKst",
+ Jpsi2PlusTrackName = BPHY12BmumuKstFinder,
+ OutputVtxContainerName = "BPHY12BmumuKstCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY12RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY12_Reco_BmumuKst
+print(BPHY12_Reco_BmumuKst)
+
+## b/ augment and select B->eeKst candidates
+# set mass hypothesis (K pi)
+BPHY12_Select_BmumuKst = DerivationFramework__Select_onia2mumu(
+ name = "BPHY12_Select_BmumuKst",
+ HypothesisName = "Bd", #creates output variable pass_Bd
+ InputVtxContainerName = "BPHY12BmumuKstCandidates",
+ TrkMasses = [105.658, 105.658, 493.677, 139.570],
+ VtxMassHypo = 5279.6, #mass of B
+ MassMin = 1.0, #no mass cuts here
+ MassMax = 10000.0, #no mass cuts here
+ Chi2Max = 30.0) #THIS IS CHI2! NOT CHI2/NDOF! Careful!
+
+ToolSvc += BPHY12_Select_BmumuKst
+print(BPHY12_Select_BmumuKst)
+
+#--------------------------------------------------------------------
+## 5/ select the event. We only want to keep events that contain certain vertices which passed certain selection.
+## This is specified by the "SelectionExpression" property, which contains the expression in the following format:
+##
+## "ContainerName.passed_HypoName > count"
+##
+## where "ContainerName" is output container form some Reco_* tool, "HypoName" is the hypothesis name setup in some "Select_*"
+## tool and "count" is the number of candidates passing the selection you want to keep.
+
+if skimTruth or not isSimulation: #Only Skim Data
+ expression = "count(BPHY12BmumuKstCandidates.passed_Bd) > 0"
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+ BPHY12_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY12_SelectEvent",
+ expression = expression)
+ ToolSvc += BPHY12_SelectEvent
+ print(BPHY12_SelectEvent)
+
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools (though it seems we only have one here!)
+ #====================================================================
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+ BPHY12SkimmingOR = CfgMgr.DerivationFramework__FilterCombinationOR(
+ name = "BPHY12SkimmingOR",
+ FilterList = [BPHY12_SelectEvent, BPHY12TriggerSkim]) #OR of all your different filters
+ ToolSvc += BPHY12SkimmingOR
+ print(BPHY12SkimmingOR)
+
+#--------------------------------------------------------------------
+## 6/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY12Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY12Thin_vtxTrk",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BPHY12BmumuKstCandidates"],
+ PassFlags = ["passed_Bd"] )
+
+ToolSvc += BPHY12Thin_vtxTrk
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY12MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY12MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY12MuonTPThinningTool
+
+# Added by ASC
+# Only save truth informtion directly associated with Onia
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY12TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY12TruthThinTool",
+ ParticleSelectionString = "TruthParticles.pdgId == 511 || TruthParticles.pdgId == -511 || TruthParticles.pdgId == 531 || TruthParticles.pdgId == -531",
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY12TruthThinTool
+print(BPHY12TruthThinTool)
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+## 7/ IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel! If you don't do that, they will not be
+## be executed!
+
+# Added by ASC
+BPHY12ThinningTools = [BPHY12Thin_vtxTrk, BPHY12MuonTPThinningTool]
+if globalflags.DataSource()=='geant4':
+ BPHY12ThinningTools.append(BPHY12TruthThinTool)
+
+# The name of the kernel (BPHY12Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY12Kernel",
+ AugmentationTools = [BPHY12_Reco_DiMuon, BPHY12_Select_DiMuons,
+ BPHY12_Reco_BmumuKst, BPHY12_Select_BmumuKst],
+ SkimmingTools = [BPHY12SkimmingOR] if skimTruth or not isSimulation else [],
+ ThinningTools = BPHY12ThinningTools
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY12Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY12Stream )
+BPHY12Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY12Stream.AcceptAlgs(["BPHY12Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+svcMgr += createThinningSvc( svcName="BPHY12ThinningSvc", outStreams=[evtStream] )
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY12SlimmingHelper = SlimmingHelper("BPHY12SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY12SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY12SlimmingHelper.IncludeBPhysTriggerContent = True
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY12RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY12RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+AllVariables += ["Muons"]
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY12_Reco_DiMuon.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY12_Reco_DiMuon.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY12_Reco_DiMuon.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY12_Reco_BmumuKst.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY12_Reco_BmumuKst.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY12_Reco_BmumuKst.OutputVtxContainerName]
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+BPHY12SlimmingHelper.AllVariables = AllVariables
+BPHY12SlimmingHelper.StaticContent = StaticContent
+BPHY12SlimmingHelper.AppendContentToStream(BPHY12Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY13.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY13.py
new file mode 100644
index 00000000000..b0549a61618
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY13.py
@@ -0,0 +1,483 @@
+#====================================================================
+# BPHY13.py (Based on BPHY8, BPHY16, and the old BPHY13)
+# Contact: xin.chen@cern.ch
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY13_VertexTools = BPHYVertexTools("BPHY13")
+
+#--------------------------------------------------------------------
+## 2/ Setup the vertex fitter tools (e.g. JpsiFinder, JpsiPlus1Track, etc).
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY13JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY13JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ trackThresholdPt = 2500.,
+ invMassUpper = 12500.,
+ invMassLower = 2000.,
+ Chi2Cut = 200.,
+ oppChargesOnly = True,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY13_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY13_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY13_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY13_VertexTools.VtxPointEstimator,
+ useMCPCuts = False )
+
+ToolSvc += BPHY13JpsiFinder
+print(BPHY13JpsiFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool if the JpsiFinder mass window is wide enough.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY13_Reco_mumu = DerivationFramework__Reco_Vertex(
+ name = "BPHY13_Reco_mumu",
+ VertexSearchTool = BPHY13JpsiFinder,
+ OutputVtxContainerName = "BPHY13OniaCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+# RefPVContainerName = "BPHY13RefittedPrimaryVertices",
+# RefitPV = True,
+# MaxPVrefit = 10000,
+#https://gitlab.cern.ch/atlas/athena/-/blob/21.2/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVTools.cxx#L259
+# bit pattern: doZ0BA|doZ0|doA0|doPt
+ DoVertexType = 1)
+
+ToolSvc += BPHY13_Reco_mumu
+print(BPHY13_Reco_mumu)
+
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BPHY13VertexFit = Trk__TrkVKalVrtFitter(
+ name = "BPHY13VertexFit",
+ Extrapolator = BPHY13_VertexTools.InDetExtrapolator,
+# FirstMeasuredPoint = True,
+ FirstMeasuredPoint = False,
+ MakeExtendedVertex = True)
+ToolSvc += BPHY13VertexFit
+print(BPHY13VertexFit)
+
+## 5/ setup the Jpsi+2 track finder
+# https://gitlab.cern.ch/atlas/athena/-/blob/21.2/PhysicsAnalysis/JpsiUpsilonTools/src/JpsiPlus2Tracks.cxx
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY13Plus2Tracks = Analysis__JpsiPlus2Tracks(
+ name = "BPHY13Plus2Tracks",
+ # OutputLevel = DEBUG,
+ kaonkaonHypothesis = False,
+ pionpionHypothesis = False,
+ kaonpionHypothesis = False,
+ ManualMassHypo = [ 105.658, 105.658, 105.658, 105.658 ],
+ trkThresholdPt = 1500.,
+ trkMaxEta = 2.5,
+ oppChargesOnly = False,
+ DiTrackMassUpper = 12500.,
+ DiTrackMassLower = 2000.,
+ TrkQuadrupletMassUpper = 25000.,
+ TrkQuadrupletMassLower = 0.,
+ Chi2Cut = 200.,
+ JpsiContainerKey = "BPHY13OniaCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ MuonsUsedInJpsi = "Muons",
+ ExcludeJpsiMuonsOnly = True,
+ RequireNMuonTracks = 1,
+ TrkVertexFitterTool = BPHY13VertexFit,
+ TrackSelectorTool = BPHY13_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = False)
+
+ToolSvc += BPHY13Plus2Tracks
+print(BPHY13Plus2Tracks)
+
+## 6/ setup the combined augmentation/skimming tool
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY13FourTrackSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY13FourTrackSelectAndWrite",
+ Jpsi2PlusTrackName = BPHY13Plus2Tracks,
+ OutputVtxContainerName = "BPHY13FourTrack",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY13RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY13FourTrackSelectAndWrite
+print(BPHY13FourTrackSelectAndWrite)
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+BPHY13_Select_FourTrack = DerivationFramework__Select_onia2mumu(
+ name = "BPHY13_Select_FourTrack",
+ HypothesisName = "FourTracks",
+ InputVtxContainerName = "BPHY13FourTrack",
+ TrkMasses = [105.658, 105.658, 105.658, 105.658],
+ VtxMassHypo = 6900.0, # for decay time
+ MassMin = 0.,
+ MassMax = 25000.,
+ Chi2Max = 200.)
+
+ToolSvc += BPHY13_Select_FourTrack
+print(BPHY13_Select_FourTrack)
+
+
+#====================================================================
+# Isolation
+#====================================================================
+
+#Track isolation for candidates
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__VertexTrackIsolation
+BPHY13TrackIsolationDecorator = DerivationFramework__VertexTrackIsolation(
+ name = "BPHY13TrackIsolationDecorator",
+ OutputLevel = INFO,
+ TrackIsoTool = "xAOD::TrackIsolationTool",
+ TrackContainer = "InDetTrackParticles",
+ InputVertexContainer = "BPHY13FourTrack",
+ PassFlags = ["passed_FourTracks"],
+ DoIsoPerTrk = True,
+ RemoveDuplicate = 2
+)
+
+ToolSvc += BPHY13TrackIsolationDecorator
+print(BPHY13TrackIsolationDecorator)
+
+
+#====================================================================
+# Revertex with mass constraint
+#====================================================================
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__ReVertex
+BPHY13_Revertex_2mu = DerivationFramework__ReVertex(
+ name = "BPHY13_Revertex_2mu",
+ InputVtxContainerName = "BPHY13FourTrack",
+ TrackIndices = [ 0, 1 ],
+ RefitPV = True,
+ RefPVContainerName = "BPHY13RefittedPrimaryVertices", # use existing refitted PVs
+ UseMassConstraint = True,
+ VertexMass = 3096.916,
+ MassInputParticles = [105.658, 105.658],
+ TrkVertexFitterTool = BPHY13VertexFit,
+ OutputVtxContainerName = "BPHY13TwoMuon")
+
+ToolSvc += BPHY13_Revertex_2mu
+print(BPHY13_Revertex_2mu)
+
+BPHY13_Select_TwoMuon = DerivationFramework__Select_onia2mumu(
+ name = "BPHY13_Select_TwoMuon",
+ HypothesisName = "TwoMuons",
+ InputVtxContainerName = "BPHY13TwoMuon",
+ TrkMasses = [105.658, 105.658],
+ VtxMassHypo = 3096.916,
+ MassMin = 2000.,
+ MassMax = 3600.,
+ Chi2Max = 200)
+
+ToolSvc += BPHY13_Select_TwoMuon
+print(BPHY13_Select_TwoMuon)
+
+BPHY13_Revertex_2trk = DerivationFramework__ReVertex(
+ name = "BPHY13_Revertex_2trk",
+ InputVtxContainerName = "BPHY13FourTrack",
+ TrackIndices = [ 2, 3 ],
+ RefitPV = True,
+ RefPVContainerName = "BPHY13RefittedPrimaryVertices", # use existing refitted PVs
+ UseMassConstraint = True,
+ VertexMass = 3096.916,
+ MassInputParticles = [105.658, 105.658],
+ TrkVertexFitterTool = BPHY13VertexFit,
+ OutputVtxContainerName = "BPHY13TwoTrack")
+
+ToolSvc += BPHY13_Revertex_2trk
+print(BPHY13_Revertex_2trk)
+
+BPHY13_Select_TwoTrack = DerivationFramework__Select_onia2mumu(
+ name = "BPHY13_Select_TwoTrack",
+ HypothesisName = "TwoTracks",
+ InputVtxContainerName = "BPHY13TwoTrack",
+ TrkMasses = [105.658, 105.658],
+ VtxMassHypo = 3096.916,
+ MassMin = 2000.,
+ MassMax = 3600.,
+ Chi2Max = 200)
+
+ToolSvc += BPHY13_Select_TwoTrack
+print(BPHY13_Select_TwoTrack)
+
+
+BPHY13_Revertex_2muHi = DerivationFramework__ReVertex(
+ name = "BPHY13_Revertex_2muHi",
+ InputVtxContainerName = "BPHY13FourTrack",
+ TrackIndices = [ 0, 1 ],
+ RefitPV = True,
+ RefPVContainerName = "BPHY13RefittedPrimaryVertices", # use existing refitted PVs
+ UseMassConstraint = True,
+ VertexMass = 9460.30,
+ MassInputParticles = [105.658, 105.658],
+ TrkVertexFitterTool = BPHY13VertexFit,
+ OutputVtxContainerName = "BPHY13TwoMuonHi")
+
+ToolSvc += BPHY13_Revertex_2muHi
+print(BPHY13_Revertex_2muHi)
+
+BPHY13_Select_TwoMuonHi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY13_Select_TwoMuonHi",
+ HypothesisName = "TwoMuonsHi",
+ InputVtxContainerName = "BPHY13TwoMuonHi",
+ TrkMasses = [105.658, 105.658],
+ VtxMassHypo = 9460.30,
+ MassMin = 8500.,
+ MassMax = 11000.,
+ Chi2Max = 200)
+
+ToolSvc += BPHY13_Select_TwoMuonHi
+print(BPHY13_Select_TwoMuonHi)
+
+BPHY13_Revertex_2trkHi = DerivationFramework__ReVertex(
+ name = "BPHY13_Revertex_2trkHi",
+ InputVtxContainerName = "BPHY13FourTrack",
+ TrackIndices = [ 2, 3 ],
+ RefitPV = True,
+ RefPVContainerName = "BPHY13RefittedPrimaryVertices", # use existing refitted PVs
+ UseMassConstraint = True,
+ VertexMass = 9460.30,
+ MassInputParticles = [105.658, 105.658],
+ TrkVertexFitterTool = BPHY13VertexFit,
+ OutputVtxContainerName = "BPHY13TwoTrackHi")
+
+ToolSvc += BPHY13_Revertex_2trkHi
+print(BPHY13_Revertex_2trkHi)
+
+BPHY13_Select_TwoTrackHi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY13_Select_TwoTrackHi",
+ HypothesisName = "TwoTracksHi",
+ InputVtxContainerName = "BPHY13TwoTrackHi",
+ TrkMasses = [105.658, 105.658],
+ VtxMassHypo = 9460.30,
+ MassMin = 8500.,
+ MassMax = 11000.,
+ Chi2Max = 200)
+
+ToolSvc += BPHY13_Select_TwoTrackHi
+print(BPHY13_Select_TwoTrackHi)
+
+
+BPHY13_Revertex_2muMed = DerivationFramework__ReVertex(
+ name = "BPHY13_Revertex_2muMed",
+ InputVtxContainerName = "BPHY13FourTrack",
+ TrackIndices = [ 0, 1 ],
+ RefitPV = True,
+ RefPVContainerName = "BPHY13RefittedPrimaryVertices", # use existing refitted PVs
+ UseMassConstraint = True,
+ VertexMass = 3686.10,
+ MassInputParticles = [105.658, 105.658],
+ TrkVertexFitterTool = BPHY13VertexFit,
+ OutputVtxContainerName = "BPHY13TwoMuonMed")
+
+ToolSvc += BPHY13_Revertex_2muMed
+print(BPHY13_Revertex_2muMed)
+
+BPHY13_Select_TwoMuonMed = DerivationFramework__Select_onia2mumu(
+ name = "BPHY13_Select_TwoMuonMed",
+ HypothesisName = "TwoMuonsMed",
+ InputVtxContainerName = "BPHY13TwoMuonMed",
+ TrkMasses = [105.658, 105.658],
+ VtxMassHypo = 3686.10,
+ MassMin = 3300.0,
+ MassMax = 4500.0,
+ Chi2Max = 200)
+
+ToolSvc += BPHY13_Select_TwoMuonMed
+print(BPHY13_Select_TwoMuonMed)
+
+BPHY13_Revertex_2trkMed = DerivationFramework__ReVertex(
+ name = "BPHY13_Revertex_2trkMed",
+ InputVtxContainerName = "BPHY13FourTrack",
+ TrackIndices = [ 2, 3 ],
+ RefitPV = True,
+ RefPVContainerName = "BPHY13RefittedPrimaryVertices", # use existing refitted PVs
+ UseMassConstraint = True,
+ VertexMass = 3686.10,
+ MassInputParticles = [105.658, 105.658],
+ TrkVertexFitterTool = BPHY13VertexFit,
+ OutputVtxContainerName = "BPHY13TwoTrackMed")
+
+ToolSvc += BPHY13_Revertex_2trkMed
+print(BPHY13_Revertex_2trkMed)
+
+BPHY13_Select_TwoTrackMed = DerivationFramework__Select_onia2mumu(
+ name = "BPHY13_Select_TwoTrackMed",
+ HypothesisName = "TwoTracksMed",
+ InputVtxContainerName = "BPHY13TwoTrackMed",
+ TrkMasses = [105.658, 105.658],
+ VtxMassHypo = 3686.10,
+ MassMin = 3300.,
+ MassMax = 4500.,
+ Chi2Max = 200)
+
+ToolSvc += BPHY13_Select_TwoTrackMed
+print(BPHY13_Select_TwoTrackMed)
+
+#--------------------------------------------------------------------
+## 7/ select the event. We only want to keep events that contain certain vertices which passed certain selection.
+## This is specified by the "SelectionExpression" property, which contains the expression in the following format:
+##
+## "ContainerName.passed_HypoName > count"
+##
+## where "ContainerName" is output container from some Reco_* tool, "HypoName" is the hypothesis name setup in some "Select_*"
+## tool and "count" is the number of candidates passing the selection you want to keep.
+
+#expression = "count(BPHY13FourTrack.passed_FourTracks) > 0"
+expression = "count(BPHY13FourTrack.passed_FourTracks) > 0 && ( count(BPHY13TwoMuon.passed_TwoMuons) + count(BPHY13TwoTrack.passed_TwoTracks) > 1 || count(BPHY13TwoMuonMed.passed_TwoMuonsMed) + count(BPHY13TwoTrackMed.passed_TwoTracksMed) > 1 || count(BPHY13TwoMuon.passed_TwoMuons) + count(BPHY13TwoTrackMed.passed_TwoTracksMed) > 1 || count(BPHY13TwoMuonMed.passed_TwoMuonsMed) + count(BPHY13TwoTrack.passed_TwoTracks) > 1 || count(BPHY13TwoMuonHi.passed_TwoMuonsHi) + count(BPHY13TwoTrackHi.passed_TwoTracksHi) > 0 )"
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY13_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY13_SelectEvent",
+ expression = expression)
+ToolSvc += BPHY13_SelectEvent
+print(BPHY13_SelectEvent)
+
+#--------------------------------------------------------------------
+## 8/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+## 9/ IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel! If you don't do that, they will not be
+## be executed!
+
+
+# The name of the kernel (BPHY13Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY13Kernel",
+ AugmentationTools = [BPHY13_Reco_mumu, BPHY13FourTrackSelectAndWrite, BPHY13_Select_FourTrack, BPHY13TrackIsolationDecorator, BPHY13_Revertex_2mu, BPHY13_Select_TwoMuon, BPHY13_Revertex_2trk, BPHY13_Select_TwoTrack, BPHY13_Revertex_2muHi, BPHY13_Select_TwoMuonHi, BPHY13_Revertex_2trkHi, BPHY13_Select_TwoTrackHi, BPHY13_Revertex_2muMed, BPHY13_Select_TwoMuonMed, BPHY13_Revertex_2trkMed, BPHY13_Select_TwoTrackMed],
+ SkimmingTools = [BPHY13_SelectEvent]
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY13Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY13Stream )
+BPHY13Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY13Stream.AcceptAlgs(["BPHY13Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+svcMgr += createThinningSvc( svcName="BPHY13ThinningSvc", outStreams=[evtStream] )
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY13SlimmingHelper = SlimmingHelper("BPHY13SlimmingHelper")
+BPHY13_AllVariables = []
+BPHY13_StaticContent = []
+
+# Needed for trigger objects
+BPHY13SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY13SlimmingHelper.IncludeBPhysTriggerContent = True
+
+## primary vertices
+BPHY13_AllVariables += ["PrimaryVertices"]
+BPHY13_StaticContent += ["xAOD::VertexContainer#BPHY13RefittedPrimaryVertices"]
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#BPHY13RefittedPrimaryVerticesAux."]
+
+## ID track particles
+BPHY13_AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+BPHY13_AllVariables += ["CombinedMuonTrackParticles"]
+BPHY13_AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+BPHY13_AllVariables += ["Muons"]
+
+
+BPHY13_StaticContent += ["xAOD::VertexContainer#%s" % BPHY13FourTrackSelectAndWrite.OutputVtxContainerName]
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY13FourTrackSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY13FourTrackSelectAndWrite.OutputVtxContainerName]
+
+BPHY13_StaticContent += ["xAOD::VertexContainer#%s" % BPHY13_Revertex_2mu.OutputVtxContainerName]
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY13_Revertex_2mu.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY13_Revertex_2mu.OutputVtxContainerName]
+
+BPHY13_StaticContent += ["xAOD::VertexContainer#%s" % BPHY13_Revertex_2trk.OutputVtxContainerName]
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY13_Revertex_2trk.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY13_Revertex_2trk.OutputVtxContainerName]
+
+BPHY13_StaticContent += ["xAOD::VertexContainer#%s" % BPHY13_Revertex_2muHi.OutputVtxContainerName]
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY13_Revertex_2muHi.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY13_Revertex_2muHi.OutputVtxContainerName]
+
+BPHY13_StaticContent += ["xAOD::VertexContainer#%s" % BPHY13_Revertex_2trkHi.OutputVtxContainerName]
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY13_Revertex_2trkHi.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY13_Revertex_2trkHi.OutputVtxContainerName]
+
+BPHY13_StaticContent += ["xAOD::VertexContainer#%s" % BPHY13_Revertex_2muMed.OutputVtxContainerName]
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY13_Revertex_2muMed.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY13_Revertex_2muMed.OutputVtxContainerName]
+
+BPHY13_StaticContent += ["xAOD::VertexContainer#%s" % BPHY13_Revertex_2trkMed.OutputVtxContainerName]
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY13_Revertex_2trkMed.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY13_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY13_Revertex_2trkMed.OutputVtxContainerName]
+
+
+# Truth information for MC only
+if isSimulation:
+ BPHY13_AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+BPHY13SlimmingHelper.AllVariables = BPHY13_AllVariables
+BPHY13SlimmingHelper.StaticContent = BPHY13_StaticContent
+BPHY13SlimmingHelper.AppendContentToStream(BPHY13Stream)
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY14.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY14.py
new file mode 100644
index 00000000000..411fe0b4a3c
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY14.py
@@ -0,0 +1,329 @@
+#====================================================================
+# BPHY14.py
+# This an example job options script showing how to set up a
+# derivation of the data using the derivation framework.
+# It requires the reductionConf flag BPHY14 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+
+print(isSimulation)
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+#include( "JpsiUpsilonTools/configureServices.py" )
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY14_VertexTools = BPHYVertexTools("BPHY14")
+
+#--------------------------------------------------------------------
+## 2/ Setup the vertex fitter tools (e.g. JpsiFinder, JpsiPlus1Track, etc).
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY14JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY14JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ invMassUpper = 15000.0,
+ invMassLower = 2000.,
+ Chi2Cut = 200.,
+ muonThresholdPt = 2500.,
+ oppChargesOnly = True,
+ atLeastOneComb = False,
+ combOnly = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY14_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY14_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY14_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY14_VertexTools.VtxPointEstimator,
+ useMCPCuts = False )
+
+ToolSvc += BPHY14JpsiFinder
+print(BPHY14JpsiFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY14_Reco_mumu = DerivationFramework__Reco_Vertex(
+ name = "BPHY14_Reco_mumu",
+ VertexSearchTool = BPHY14JpsiFinder,
+ OutputVtxContainerName = "BPHY14OniaCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY14RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 100000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY14_Reco_mumu
+print(BPHY14_Reco_mumu)
+
+#--------------------------------------------------------------------
+## 4/ setup the vertex selection and augmentation tool(s). These tools decorate the vertices with
+## variables that depend on the vertex mass hypothesis, e.g. invariant mass, proper decay time, etc.
+## Property HypothesisName is used as a prefix for these decorations.
+## They also perform tighter selection, flagging the vertecis that passed. The flag is a Char_t branch
+## named "passed_"+HypothesisName. It is used later by the "SelectEvent" and "Thin_vtxTrk" tools
+## to determine which events and candidates should be kept in the output stream.
+## Multiple instances of the Select_* tools can be used on a single input collection as long as they
+## use different "HypothesisName" flags.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY14_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY14_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY14OniaCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 2000.0,
+ MassMax = 3600.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY14_Select_Jpsi2mumu
+print(BPHY14_Select_Jpsi2mumu)
+
+## b/ augment and select Psi(2S)->mumu candidates
+BPHY14_Select_Psi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY14_Select_Psi2mumu",
+ HypothesisName = "Psi",
+ InputVtxContainerName = "BPHY14OniaCandidates",
+ VtxMassHypo = 3686.09,
+ MassMin = 3300.0,
+ MassMax = 4500.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY14_Select_Psi2mumu
+print(BPHY14_Select_Psi2mumu)
+
+# Added by ASC
+## c/ augment and select Upsilon(nS)->mumu candidates
+BPHY14_Select_Upsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY14_Select_Upsi2mumu",
+ HypothesisName = "Upsi",
+ InputVtxContainerName = "BPHY14OniaCandidates",
+ VtxMassHypo = 9460.30,
+ MassMin = 7000.0,
+ MassMax = 12500.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY14_Select_Upsi2mumu
+print(BPHY14_Select_Upsi2mumu)
+
+#--------------------------------------------------------------------
+## 5/ select the event. We only want to keep events that contain certain vertices which passed certain selection.
+## This is specified by the "SelectionExpression" property, which contains the expression in the following format:
+##
+## "ContainerName.passed_HypoName > count"
+##
+## where "ContainerName" is output container form some Reco_* tool, "HypoName" is the hypothesis name setup in some "Select_*"
+## tool and "count" is the number of candidates passing the selection you want to keep.
+
+#====================================================================
+# Photon things
+#====================================================================
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+from DerivationFrameworkInDet.InDetCommon import *
+from DerivationFrameworkMuons.MuonsCommon import *
+from DerivationFrameworkJetEtMiss.JetCommon import *
+from DerivationFrameworkJetEtMiss.METCommon import *
+from DerivationFrameworkEGamma.EGammaCommon import *
+
+#photonRequirements = '(DFCommonPhotons_et >= 5*GeV) && (abs(DFCommonPhotons_eta) < 2.6)'# && (Photons.Loose)'
+photonRequirements = 'DFCommonPhotons_et > 5*GeV'
+
+
+expression = "(count(BPHY14OniaCandidates.passed_Jpsi) > 0 || count(BPHY14OniaCandidates.passed_Psi) > 0 || count(BPHY14OniaCandidates.passed_Upsi) > 0) && count("+photonRequirements+") >0"
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY14_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY14_SelectEvent",
+ expression = expression)
+ToolSvc += BPHY14_SelectEvent
+print(BPHY14_SelectEvent)
+
+#--------------------------------------------------------------------
+## 6/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY14Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY14Thin_vtxTrk",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BPHY14OniaCandidates"],
+ PassFlags = ["passed_Jpsi", "passed_Psi", "passed_Upsi"] )
+
+ToolSvc += BPHY14Thin_vtxTrk
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY14MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY14MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY14MuonTPThinningTool
+
+
+# Tracks associated with Photons
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__EgammaTrackParticleThinning
+BPHY14PhotonTPThinningTool = DerivationFramework__EgammaTrackParticleThinning(name = "BPHY14PhotonTPThinningTool",
+ SGKey = "Photons",
+ GSFTrackParticlesKey = "GSFTrackParticles",
+ InDetTrackParticlesKey = "InDetTrackParticles",
+ SelectionString = photonRequirements,
+ BestMatchOnly = False,
+ ConeSize = 0.6,
+ ApplyAnd = False)
+ToolSvc += BPHY14PhotonTPThinningTool
+
+
+
+
+# Added by ASC
+# Only save truth informtion directly associated with Onia
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY14TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY14TruthThinTool",
+ ParticleSelectionString = "TruthParticles.pdgId == 22 || TruthParticles.pdgId == 443 || TruthParticles.pdgId == 100443 || TruthParticles.pdgId == 553 || TruthParticles.pdgId == 100553 || TruthParticles.pdgId == 200553",
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY14TruthThinTool
+print(BPHY14TruthThinTool)
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+## 7/ IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel! If you don't do that, they will not be
+## be executed!
+
+# Added by ASC
+BPHY14ThinningTools = [BPHY14Thin_vtxTrk, BPHY14MuonTPThinningTool,BPHY14PhotonTPThinningTool]
+if globalflags.DataSource()=='geant4':
+ BPHY14ThinningTools.append(BPHY14TruthThinTool)
+
+# The name of the kernel (BPHY14Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY14Kernel",
+ AugmentationTools = [BPHY14_Reco_mumu, BPHY14_Select_Jpsi2mumu, BPHY14_Select_Psi2mumu, BPHY14_Select_Upsi2mumu],
+ SkimmingTools = [BPHY14_SelectEvent],
+ ThinningTools = BPHY14ThinningTools
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY14Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY14Stream )
+BPHY14Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY14Stream.AcceptAlgs(["BPHY14Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+svcMgr += createThinningSvc( svcName="BPHY14ThinningSvc", outStreams=[evtStream] )
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY14SlimmingHelper = SlimmingHelper("BPHY14SlimmingHelper")
+BPHY14_AllVariables = []
+BPHY14_StaticContent = []
+BPHY14_SmartCollections = []
+BPHY14_ExtraVariables = []
+
+# Needed for trigger objects
+BPHY14SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY14SlimmingHelper.IncludeBPhysTriggerContent = True
+BPHY14SlimmingHelper.IncludeEGammaTriggerContent = True
+
+## primary vertices
+BPHY14_SmartCollections += ["PrimaryVertices"]
+BPHY14_StaticContent += ["xAOD::VertexContainer#BPHY14RefittedPrimaryVertices"]
+BPHY14_StaticContent += ["xAOD::VertexAuxContainer#BPHY14RefittedPrimaryVerticesAux."]
+
+## ID track particles
+BPHY14_SmartCollections += ["InDetTrackParticles"]
+BPHY14_ExtraVariables += ["%s.vx.vy.vz" % "InDetTrackParticles"]
+#BPHY14_AllVariables += ["InDetTrackParticles"]
+
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+BPHY14_AllVariables += ["CombinedMuonTrackParticles"]
+BPHY14_AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+BPHY14_SmartCollections += ["Muons"]
+BPHY14_ExtraVariables += ["%s.etcone30.etcone40" % "Muons"
+ +".momentumBalanceSignificance"
+ +".scatteringCurvatureSignificance"
+ +".scatteringNeighbourSignificance"
+ +".msInnerMatchDOF.msInnerMatchChi2"
+ +".msOuterMatchDOF.msOuterMatchChi2"
+ +".EnergyLoss.ParamEnergyLoss.MeasEnergyLoss"
+ +".ET_Core" ]
+#BPHY14_AllVariables += ["Muons"]
+
+## Jpsi candidates
+BPHY14_StaticContent += ["xAOD::VertexContainer#%s" % BPHY14_Reco_mumu.OutputVtxContainerName]
+BPHY14_StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY14_Reco_mumu.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY14_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY14_Reco_mumu.OutputVtxContainerName]
+
+# Truth information for MC only
+if isSimulation:
+ BPHY14_StaticContent += ["xAOD::TruthParticleContainer#TruthMuons","xAOD::TruthParticleAuxContainer#TruthMuonsAux."]
+ BPHY14_StaticContent += ["xAOD::TruthParticleContainer#TruthPhotons","xAOD::TruthParticleAuxContainer#TruthPhotonsAux."]
+ BPHY14_AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+#Photon Information
+#AllVariables += ["Photons"]
+BPHY14_SmartCollections += ["Photons"] #,"Muons","InDetTrackParticles","PrimaryVertices"]
+from DerivationFrameworkSM.STDMExtraContent import *
+BPHY14_ExtraVariables.extend(ExtraContentPhotons)
+
+
+BPHY14SlimmingHelper.AllVariables = BPHY14_AllVariables
+BPHY14SlimmingHelper.StaticContent = BPHY14_StaticContent
+BPHY14SlimmingHelper.SmartCollections = BPHY14_SmartCollections
+BPHY14SlimmingHelper.ExtraVariables = BPHY14_ExtraVariables
+BPHY14SlimmingHelper.AppendContentToStream(BPHY14Stream)
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY15.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY15.py
new file mode 100644
index 00000000000..be74b9f1394
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY15.py
@@ -0,0 +1,855 @@
+#2018/11/24
+#====================================================================
+# BPHY15.py
+# Bc+>J/psiD_s+, Bc+>J/psiD+, Bc+>J/psiD*+, Bc+>J/psiD_s1+
+# It requires the reductionConf flag BPHY15 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY15_VertexTools = BPHYVertexTools("BPHY15")
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__AugOriginalCounts
+BPHY15_AugOriginalCounts = DerivationFramework__AugOriginalCounts(
+ name = "BPHY15_AugOriginalCounts",
+ VertexContainer = "PrimaryVertices",
+ TrackContainer = "InDetTrackParticles" )
+ToolSvc += BPHY15_AugOriginalCounts
+
+
+#--------------------------------------------------------------------
+# 2/ Select J/psi>mu+mu-
+#--------------------------------------------------------------------
+## a/ setup JpsiFinder tool
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY15JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY15JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True,
+ muonThresholdPt = 2700,
+ invMassUpper = 3400.0,
+ invMassLower = 2800.0,
+ Chi2Cut = 10.,
+ oppChargesOnly = True,
+ allMuons = True,
+ combOnly = False,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY15_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY15_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY15_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY15_VertexTools.VtxPointEstimator,
+ useMCPCuts = False)
+
+ToolSvc += BPHY15JpsiFinder
+print(BPHY15JpsiFinder)
+
+#--------------------------------------------------------------------
+## b/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY15JpsiSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY15JpsiSelectAndWrite",
+ VertexSearchTool = BPHY15JpsiFinder,
+ OutputVtxContainerName = "BPHY15JpsiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ DoVertexType = 1)
+
+ToolSvc += BPHY15JpsiSelectAndWrite
+print(BPHY15JpsiSelectAndWrite)
+
+#--------------------------------------------------------------------
+## c/ augment and select Jpsi->mumu candidates
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+BPHY15_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY15JpsiCandidates",
+ VtxMassHypo = 3096.900,
+ MassMin = 2600.0,
+ MassMax = 3600.0,
+ Chi2Max = 200,
+ LxyMin = 0.1,
+ DoVertexType = 1)
+
+ToolSvc += BPHY15_Select_Jpsi2mumu
+print(BPHY15_Select_Jpsi2mumu)
+
+#--------------------------------------------------------------------
+# 3/ select B_c+->J/psi pi+
+#--------------------------------------------------------------------
+## a/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BcJpsipiVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BcJpsipiVertexFit",
+ Extrapolator = BPHY15_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+
+ToolSvc += BcJpsipiVertexFit
+print(BcJpsipiVertexFit)
+
+#--------------------------------------------------------------------
+## b/ setup the Jpsi+1 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus1Track
+BPHY15BcJpsipi = Analysis__JpsiPlus1Track(
+ name = "BPHY15BcJpsipi",
+ OutputLevel = INFO, #DEBUG,
+ pionHypothesis = True, #False,
+ kaonHypothesis = False,#True,
+ trkThresholdPt = 2700,
+ trkMaxEta = 2.7,
+ BThresholdPt = 100.0,
+ BMassUpper = 6900.0,
+ BMassLower = 5600.0,
+ JpsiContainerKey = "BPHY15JpsiCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ MuonsUsedInJpsi = "Muons",
+ TrkVertexFitterTool = BcJpsipiVertexFit,
+ TrackSelectorTool = BPHY15_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = True,
+ Chi2Cut = 5,
+ TrkTrippletMassUpper = 6900,
+ TrkTrippletMassLower = 5600)
+
+ToolSvc += BPHY15BcJpsipi
+print(BPHY15BcJpsipi)
+
+#--------------------------------------------------------------------
+## c/ setup the combined augmentation/skimming tool for the Bc+>J/psi pi+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY15BcJpsipiSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY15BcJpsipiSelectAndWrite",
+ Jpsi1PlusTrackName = BPHY15BcJpsipi,
+ OutputVtxContainerName = "BPHY15BcJpsipiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY15RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 1000)
+
+ToolSvc += BPHY15BcJpsipiSelectAndWrite
+print(BPHY15BcJpsipiSelectAndWrite)
+
+#--------------------------------------------------------------------
+## d/ augment and select B_c+>Jpsi pi+ candidates
+BPHY15_Select_Bc2Jpsipi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_Bc2Jpsipi",
+ HypothesisName = "Bc",
+ InputVtxContainerName = "BPHY15BcJpsipiCandidates",
+ TrkMasses = [105.658, 105.658, 139.571],
+ VtxMassHypo = 6274.9,
+ MassMin = 5600.0,
+ MassMax = 6900.0,
+ Chi2Max = 200)
+
+ToolSvc += BPHY15_Select_Bc2Jpsipi
+print(BPHY15_Select_Bc2Jpsipi)
+
+#--------------------------------------------------------------------
+# 4/ select J/psi pi+
+#--------------------------------------------------------------------
+## a/ setup the Jpsi+1 track finder
+BPHY15JpsipiFinder = Analysis__JpsiPlus1Track(
+ name = "BPHY15JpsipiFinder",
+ OutputLevel = INFO, #DEBUG,
+ pionHypothesis = True, #False,
+ kaonHypothesis = False,#True,
+ trkThresholdPt = 350.0,
+ trkMaxEta = 2.7,
+ BThresholdPt = 5000.0,
+ BMassUpper = 3600.0,
+ BMassLower = 3200.0,
+ TrkDeltaZ = 20.,
+ TrkQuadrupletPt = 5000,
+ JpsiContainerKey = "BPHY15JpsiCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ MuonsUsedInJpsi = "Muons",
+ TrkVertexFitterTool = BcJpsipiVertexFit,
+ TrackSelectorTool = BPHY15_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = True,
+ Chi2Cut = 5,
+ TrkTrippletMassUpper = 3600,
+ TrkTrippletMassLower = 3200)
+
+ToolSvc += BPHY15JpsipiFinder
+print(BPHY15JpsipiFinder)
+
+#--------------------------------------------------------------------
+## b/ setup the combined augmentation/skimming tool for J/psi pi+
+BPHY15JpsipiSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY15JpsipiSelectAndWrite",
+ Jpsi1PlusTrackName = BPHY15JpsipiFinder,
+ OutputVtxContainerName = "BPHY15JpsipiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ #RefitPV = True,
+ MaxPVrefit = 1000)
+
+ToolSvc += BPHY15JpsipiSelectAndWrite
+print(BPHY15JpsipiSelectAndWrite)
+
+#--------------------------------------------------------------------
+## c/ augment and select Jpsi pi+ candidates for the J/psi D*+ and J/psi D_s1+ modes
+BPHY15_Select_Jpsipi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_Jpsipi",
+ HypothesisName = "Jpsipi",
+ TrkMasses = [105.658, 105.658, 139.571],
+ InputVtxContainerName = "BPHY15JpsipiCandidates",
+ VtxMassHypo = 3396.900,
+ MassMin = 3200.0,
+ MassMax = 3600.0,
+ Chi2Max = 200,
+ LxyMin = 0.1,
+ DoVertexType = 1)
+
+ToolSvc += BPHY15_Select_Jpsipi
+print(BPHY15_Select_Jpsipi)
+
+#--------------------------------------------------------------------
+# 5/ Select K+K-, pi+K- and K+pi-
+#--------------------------------------------------------------------
+## a/ Setup the vertex fitter tools
+BPHY15DiTrkFinder = Analysis__JpsiFinder(
+ name = "BPHY15DiTrkFinder",
+ OutputLevel = INFO,
+ muAndMu = False,
+ muAndTrack = False,
+ TrackAndTrack = True,
+ assumeDiMuons = False, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ trackThresholdPt = 900,
+ invMassUpper = 1900.0,
+ invMassLower = 280.0,
+ Chi2Cut = 10.,
+ oppChargesOnly = True,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY15_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY15_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY15_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY15_VertexTools.VtxPointEstimator,
+ useMCPCuts = False,
+ track1Mass = 139.571, # Not very important, only used to calculate inv. mass cut, leave it loose here
+ track2Mass = 139.571)
+
+ToolSvc += BPHY15DiTrkFinder
+print(BPHY15DiTrkFinder)
+
+#--------------------------------------------------------------------
+## b/ setup the vertex reconstruction "call" tool(s).
+BPHY15DiTrkSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY15DiTrkSelectAndWrite",
+ VertexSearchTool = BPHY15DiTrkFinder,
+ OutputVtxContainerName = "BPHY15DiTrkCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ CheckCollections = True,
+ CheckVertexContainers = ['BPHY15JpsiCandidates'],
+ DoVertexType = 1)
+
+ToolSvc += BPHY15DiTrkSelectAndWrite
+print(BPHY15DiTrkSelectAndWrite)
+
+#--------------------------------------------------------------------
+## c/ augment and select D0 candidates
+BPHY15_Select_D0 = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_D0",
+ HypothesisName = "D0",
+ InputVtxContainerName = "BPHY15DiTrkCandidates",
+ TrkMasses = [139.571, 493.677],
+ VtxMassHypo = 1864.83,
+ MassMin = 1864.83-170,
+ MassMax = 1864.83+170,
+ LxyMin = 0.15,
+ Chi2Max = 200)
+
+ToolSvc += BPHY15_Select_D0
+print(BPHY15_Select_D0)
+
+#--------------------------------------------------------------------
+## d/ augment and select D0bar candidates
+BPHY15_Select_D0b = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_D0b",
+ HypothesisName = "D0b",
+ InputVtxContainerName = "BPHY15DiTrkCandidates",
+ TrkMasses = [493.677, 139.571],
+ VtxMassHypo = 1864.83,
+ MassMin = 1864.83-170,
+ MassMax = 1864.83+170,
+ LxyMin = 0.15,
+ Chi2Max = 200)
+
+ToolSvc += BPHY15_Select_D0b
+print(BPHY15_Select_D0b)
+
+#--------------------------------------------------------------------
+# 6/ select D_s+>K+K-pi+ and D+>K+pi-pi- candidates
+#--------------------------------------------------------------------
+## a/ setup a new vertexing tool (necessary due to use of mass constraint)
+Dh3VertexFit = Trk__TrkVKalVrtFitter(
+ name = "Dh3VertexFit",
+ Extrapolator = BPHY15_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+
+ToolSvc += Dh3VertexFit
+print(Dh3VertexFit)
+
+#--------------------------------------------------------------------
+## b/ setup the Jpsi+1 track finder
+BPHY15Dh3Finder = Analysis__JpsiPlus1Track(
+ name = "BPHY15Dh3Finder",
+ OutputLevel = INFO,
+ pionHypothesis = True,
+ kaonHypothesis = False,
+ trkThresholdPt = 900.0,
+ trkMaxEta = 2.7, # is this value fine?? default would be 102.5
+ BThresholdPt = 2000.0,
+ #BThresholdPt = 3000.0,
+ BMassUpper = 1800.0, # What is this??
+ BMassLower = 500.0,
+ TrkDeltaZ = 20.,
+ TrkTrippletMassUpper = 1800,
+ TrkTrippletMassLower = 500,
+ TrkQuadrupletPt = 2000,
+ #TrkQuadrupletPt = 3000,
+ JpsiContainerKey = "BPHY15DiTrkCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ MuonsUsedInJpsi = "NONE", # ?
+ ExcludeCrossJpsiTracks = False,
+ TrkVertexFitterTool = Dh3VertexFit,
+ TrackSelectorTool = BPHY15_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = False,
+ Chi2Cut = 5) #Cut on chi2/Ndeg_of_freedom
+
+ToolSvc += BPHY15Dh3Finder
+print(BPHY15Dh3Finder)
+
+#--------------------------------------------------------------------
+## c/ setup the combined augmentation/skimming tool for the D(s)+
+BPHY15Dh3SelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY15Dh3SelectAndWrite",
+ OutputLevel = INFO,
+ Jpsi1PlusTrackName = BPHY15Dh3Finder,
+ OutputVtxContainerName = "BPHY15Dh3Candidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ MaxPVrefit = 1000)
+
+ToolSvc += BPHY15Dh3SelectAndWrite
+print(BPHY15Dh3SelectAndWrite)
+
+
+#--------------------------------------------------------------------
+## d/ augment and select D_s+/- candidates
+BPHY15_Select_Ds = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_Ds",
+ HypothesisName = "Ds",
+ TrkMasses = [493.677, 493.677, 139.571],
+ InputVtxContainerName = "BPHY15Dh3Candidates",
+ VtxMassHypo = 1968.28,
+ MassMin = 1968.28-200,
+ MassMax = 1968.28+200,
+ Chi2Max = 200,
+ LxyMin = 0.1,
+ DoVertexType = 1)
+
+ToolSvc += BPHY15_Select_Ds
+print(BPHY15_Select_Ds)
+
+#--------------------------------------------------------------------
+## e/ augment and select D+ candidates
+BPHY15_Select_Dp = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_Dp",
+ HypothesisName = "Dp",
+ TrkMasses = [139.571, 493.677, 139.571],
+ InputVtxContainerName = "BPHY15Dh3Candidates",
+ VtxMassHypo = 1869.59,
+ MassMin = 1869.59-200,
+ MassMax = 1869.59+200,
+ Chi2Max = 200,
+ LxyMin = 0.1,
+ DoVertexType = 1)
+
+ToolSvc += BPHY15_Select_Dp
+print(BPHY15_Select_Dp)
+
+#--------------------------------------------------------------------
+## c/ augment and select D- candidates
+BPHY15_Select_Dm = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_Dm",
+ HypothesisName = "Dm",
+ TrkMasses = [493.677, 139.571, 139.571],
+ InputVtxContainerName = "BPHY15Dh3Candidates",
+ VtxMassHypo = 1869.59,
+ MassMin = 1869.59-200,
+ MassMax = 1869.59+200,
+ Chi2Max = 200,
+ LxyMin = 0.1,
+ DoVertexType = 1)
+
+ToolSvc += BPHY15_Select_Dm
+print(BPHY15_Select_Dm)
+
+
+#--------------------------------------------------------------------
+# 7/ select Bc+>J/psi D_(s)+/-
+#--------------------------------------------------------------------
+## a/ setup the cascade vertexing tool
+BcJpsiDxVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BcJpsiDxVertexFit",
+ Extrapolator = BPHY15_VertexTools.InDetExtrapolator,
+ #FirstMeasuredPoint = True,
+ FirstMeasuredPoint = False,
+ CascadeCnstPrecision = 1e-6,
+ MakeExtendedVertex = True)
+
+ToolSvc += BcJpsiDxVertexFit
+print(BcJpsiDxVertexFit)
+
+#--------------------------------------------------------------------
+## b/ setup the Jpsi Ds finder
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__JpsiPlusDsCascade
+BPHY15JpsiDs = DerivationFramework__JpsiPlusDsCascade(
+ name = "BPHY15JpsiDs",
+ HypothesisName = "Bc",
+ TrkVertexFitterTool = BcJpsiDxVertexFit,
+ DxHypothesis = 431,
+ ApplyDxMassConstraint = True,
+ ApplyJpsiMassConstraint = True,
+ JpsiMassLowerCut = 2600.,
+ JpsiMassUpperCut = 3600.,
+ DxMassLowerCut = 1968.28 - 200.,
+ DxMassUpperCut = 1968.28 + 200.,
+ MassLowerCut = 6274.90 - 600.,
+ MassUpperCut = 6274.90 + 600.,
+ Chi2Cut = 10,
+ RefitPV = True,
+ RefPVContainerName = "BPHY15RefittedPrimaryVertices",
+ JpsiVertices = "BPHY15JpsiCandidates",
+ CascadeVertexCollections = ["BcJpsiDsCascadeSV2", "BcJpsiDsCascadeSV1"],
+ DxVertices = "BPHY15Dh3Candidates")
+
+ToolSvc += BPHY15JpsiDs
+print(BPHY15JpsiDs)
+
+#--------------------------------------------------------------------
+## c/ setup the Jpsi D+ finder
+BPHY15JpsiDp = DerivationFramework__JpsiPlusDsCascade(
+ name = "BPHY15JpsiDp",
+ HypothesisName = "Bc",
+ TrkVertexFitterTool = BcJpsiDxVertexFit,
+ DxHypothesis = 411,
+ ApplyDxMassConstraint = True,
+ ApplyJpsiMassConstraint = True,
+ JpsiMassLowerCut = 2600.,
+ JpsiMassUpperCut = 3600.,
+ DxMassLowerCut = 1869.59 - 180.,
+ DxMassUpperCut = 1869.59 + 180.,
+ MassLowerCut = 6274.90 - 600.,
+ MassUpperCut = 6274.90 + 600.,
+ Chi2Cut = 10,
+ RefitPV = True,
+ RefPVContainerName = "BPHY15RefittedPrimaryVertices",
+ JpsiVertices = "BPHY15JpsiCandidates",
+ CascadeVertexCollections = ["BcJpsiDpCascadeSV2", "BcJpsiDpCascadeSV1"],
+ DxVertices = "BPHY15Dh3Candidates")
+
+ToolSvc += BPHY15JpsiDp
+print(BPHY15JpsiDp)
+
+#--------------------------------------------------------------------
+# 8/ select Bc+>J/psi D*+/-
+#--------------------------------------------------------------------
+## a/ setup the cascade vertexing tool
+BcJpsiDstVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BcJpsiDstVertexFit",
+ Extrapolator = BPHY15_VertexTools.InDetExtrapolator,
+ #FirstMeasuredPoint = True,
+ FirstMeasuredPoint = False,
+ CascadeCnstPrecision = 1e-6,
+ MakeExtendedVertex = True)
+
+ToolSvc += BcJpsiDstVertexFit
+print(BcJpsiDstVertexFit)
+
+#--------------------------------------------------------------------
+## b/ setup Jpsi D*+ finder
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__JpsiPlusDpstCascade
+BPHY15JpsiDpst = DerivationFramework__JpsiPlusDpstCascade(
+ name = "BPHY15JpsiDpst",
+ HypothesisName = "Bc",
+ TrkVertexFitterTool = BcJpsiDstVertexFit,
+ DxHypothesis = 421,
+ ApplyD0MassConstraint = True,
+ ApplyJpsiMassConstraint = True,
+ JpsiMassLowerCut = 2600.,
+ JpsiMassUpperCut = 3600.,
+ JpsipiMassLowerCut = 2600.,
+ JpsipiMassUpperCut = 6800.,
+ D0MassLowerCut = 1864.83 - 200.,
+ D0MassUpperCut = 1864.83 + 200.,
+ DstMassLowerCut = 2010.26 - 300.,
+ DstMassUpperCut = 2010.26 + 300.,
+ MassLowerCut = 5400,
+ MassUpperCut = 6274.90 + 600.,
+ Chi2Cut = 10,
+ RefitPV = True,
+ RefPVContainerName = "BPHY15RefittedPrimaryVertices",
+ JpsipiVertices = "BPHY15JpsipiCandidates",
+ CascadeVertexCollections = ["BcJpsiDpstCascadeSV2", "BcJpsiDpstCascadeSV1"],
+ D0Vertices = "BPHY15DiTrkCandidates")
+
+ToolSvc += BPHY15JpsiDpst
+print(BPHY15JpsiDpst)
+
+
+
+#--------------------------------------------------------------------
+# 9/ select K_S0>pi+pi-
+#--------------------------------------------------------------------
+
+include("DerivationFrameworkBPhys/configureV0Finder.py")
+BPHY15_K0FinderTools = BPHYV0FinderTools("BPHY15")
+print(BPHY15_K0FinderTools)
+
+## a/ Setup the vertex fitter tools
+BPHY15K0Finder = Analysis__JpsiFinder(
+ name = "BPHY15K0Finder",
+ OutputLevel = INFO,
+ muAndMu = False,
+ muAndTrack = False,
+ TrackAndTrack = True,
+ assumeDiMuons = False, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ trackThresholdPt = 400,
+ #trackThresholdPt = 500,
+ invMassUpper = 600.0,
+ invMassLower = 400.0,
+ Chi2Cut = 20,
+ #Chi2Cut = 5.,
+ oppChargesOnly = True,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY15_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = True, # if False a TrkVertexFitterTool will be used
+ #useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY15_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ #TrackSelectorTool = BPHY15_VertexTools.InDetTrackSelectorTool,
+ TrackSelectorTool = BPHY15_K0FinderTools.InDetV0VxTrackSelector,
+ VertexPointEstimator = BPHY15_K0FinderTools.V0VtxPointEstimator,
+ #VertexPointEstimator = BPHY15_VertexTools.VtxPointEstimator,
+ useMCPCuts = False,
+ track1Mass = 139.571, # Not very important, only used to calculate inv. mass cut, leave it loose here
+ track2Mass = 139.571)
+
+ToolSvc += BPHY15K0Finder
+print(BPHY15K0Finder)
+
+#--------------------------------------------------------------------
+## b/ setup the vertex reconstruction "call" tool(s).
+BPHY15K0SelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY15K0SelectAndWrite",
+ VertexSearchTool = BPHY15K0Finder,
+ OutputVtxContainerName = "BPHY15K0Candidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ CheckCollections = True,
+ CheckVertexContainers = ['BPHY15JpsipiCandidates','BPHY15DiTrkCandidates','BcJpsiDpstCascadeSV1'],
+ DoVertexType = 1)
+
+ToolSvc += BPHY15K0SelectAndWrite
+print(BPHY15K0SelectAndWrite)
+
+#--------------------------------------------------------------------
+## c/ augment and select K_S0 candidates
+BPHY15_Select_K0 = DerivationFramework__Select_onia2mumu(
+ name = "BPHY15_Select_K0",
+ HypothesisName = "K0",
+ InputVtxContainerName = "BPHY15K0Candidates",
+ TrkMasses = [139.571, 139.571],
+ VtxMassHypo = 497.672,
+ MassMin = 400,
+ MassMax = 600,
+ LxyMin = 0.2,
+ Chi2Max = 200)
+
+ToolSvc += BPHY15_Select_K0
+print(BPHY15_Select_K0)
+
+#--------------------------------------------------------------------
+# 10/ select Bc+>J/psi D_s1+/-
+#--------------------------------------------------------------------
+## a/ setup the cascade vertexing tool
+BcJpsiDs1VertexFit = Trk__TrkVKalVrtFitter(
+ name = "BcJpsiDs1VertexFit",
+ Extrapolator = BPHY15_VertexTools.InDetExtrapolator,
+ #FirstMeasuredPoint = True,
+ FirstMeasuredPoint = False,
+ CascadeCnstPrecision = 1e-6,
+ MakeExtendedVertex = True)
+
+ToolSvc += BcJpsiDs1VertexFit
+print(BcJpsiDs1VertexFit)
+
+#--------------------------------------------------------------------
+## b/ setup Jpsi D_s1+ finder
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__JpsiPlusDs1Cascade
+BPHY15JpsiDps1 = DerivationFramework__JpsiPlusDs1Cascade(
+ name = "BPHY15JpsiDps1",
+ HypothesisName = "Bc",
+ TrkVertexFitterTool = BcJpsiDs1VertexFit,
+ DxHypothesis = 421,
+ ApplyD0MassConstraint = True,
+ ApplyK0MassConstraint = True,
+ ApplyJpsiMassConstraint = True,
+ JpsiMassLowerCut = 2600.,
+ JpsiMassUpperCut = 3600.,
+ JpsipiMassLowerCut = 2600.,
+ JpsipiMassUpperCut = 6800.,
+ D0MassLowerCut = 1864.83 - 180.,
+ D0MassUpperCut = 1864.83 + 180.,
+ K0MassLowerCut = 400.,
+ K0MassUpperCut = 600.,
+ DstMassLowerCut = 2010.26 - 300.,
+ DstMassUpperCut = 2010.26 + 300.,
+ MassLowerCut = 6274.90 - 600,
+ MassUpperCut = 6274.90 + 600.,
+ Chi2Cut = 10,
+ RefitPV = True,
+ RefPVContainerName = "BPHY15RefittedPrimaryVertices",
+ JpsipiVertices = "BPHY15JpsipiCandidates",
+ CascadeVertexCollections = ["BcJpsiDps1CascadeSV3", "BcJpsiDps1CascadeSV2", "BcJpsiDps1CascadeSV1"],
+ K0Vertices = "BPHY15K0Candidates",
+ D0Vertices = "BPHY15DiTrkCandidates")
+
+ToolSvc += BPHY15JpsiDps1
+print(BPHY15JpsiDps1)
+
+#--------------------------------------------------------------------
+
+CascadeCollections = []
+
+CascadeCollections += BPHY15JpsiDs.CascadeVertexCollections
+CascadeCollections += BPHY15JpsiDp.CascadeVertexCollections
+
+CascadeCollections += BPHY15JpsiDpst.CascadeVertexCollections
+CascadeCollections += BPHY15JpsiDps1.CascadeVertexCollections
+
+#--------------------------------------------------------------------
+
+
+if not isSimulation: #Only Skim Data
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+ BPHY15_SelectBcJpsipiEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY15_SelectBcJpsipiEvent",
+ expression = "( count(BPHY15BcJpsipiCandidates.passed_Bc > 0) + count(BcJpsiDsCascadeSV1.x > -999) + count(BcJpsiDpCascadeSV1.x > -999) + count(BcJpsiDpstCascadeSV1.x > -999) + count(BcJpsiDps1CascadeSV1.x > -999) ) > 0")
+
+ ToolSvc += BPHY15_SelectBcJpsipiEvent
+ print(BPHY15_SelectBcJpsipiEvent)
+
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools
+ #====================================================================
+
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+ BPHY15SkimmingOR = CfgMgr.DerivationFramework__FilterCombinationOR(
+ "BPHY15SkimmingOR",
+ FilterList = [BPHY15_SelectBcJpsipiEvent] )
+ ToolSvc += BPHY15SkimmingOR
+ print(BPHY15SkimmingOR)
+
+#--------------------------------------------------------------------
+##10/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY15_thinningTool_Tracks = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY15_thinningTool_Tracks",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BPHY15BcJpsipiCandidates", "BcJpsiDsCascadeSV1", "BcJpsiDsCascadeSV2", "BcJpsiDpCascadeSV1", "BcJpsiDpCascadeSV2", "BcJpsiDpstCascadeSV1", "BcJpsiDpstCascadeSV2", "BcJpsiDps1CascadeSV1", "BcJpsiDps1CascadeSV2", "BcJpsiDps1CascadeSV3"],
+ PassFlags = ["passed_Bc"])
+
+ToolSvc += BPHY15_thinningTool_Tracks
+print(BPHY15_thinningTool_Tracks)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysPVThinningTool
+BPHY15_thinningTool_PV = DerivationFramework__BPhysPVThinningTool(
+ name = "BPHY15_thinningTool_PV",
+ CandidateCollections = ["BPHY15BcJpsipiCandidates", "BcJpsiDsCascadeSV1", "BcJpsiDsCascadeSV2", "BcJpsiDpCascadeSV1", "BcJpsiDpCascadeSV2", "BcJpsiDpstCascadeSV1", "BcJpsiDpstCascadeSV2", "BcJpsiDps1CascadeSV1", "BcJpsiDps1CascadeSV2", "BcJpsiDps1CascadeSV3"],
+ KeepPVTracks = True)
+
+ToolSvc += BPHY15_thinningTool_PV
+print(BPHY15_thinningTool_PV)
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY15MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(
+ name = "BPHY15MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+
+ToolSvc += BPHY15MuonTPThinningTool
+print(BPHY15MuonTPThinningTool)
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+thiningCollection = []
+
+print(thiningCollection)
+
+# The name of the kernel (BPHY15Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY15Kernel",
+ AugmentationTools = [BPHY15JpsiSelectAndWrite, BPHY15_Select_Jpsi2mumu,
+ BPHY15BcJpsipiSelectAndWrite, BPHY15_Select_Bc2Jpsipi,
+ BPHY15JpsipiSelectAndWrite, BPHY15_Select_Jpsipi,
+ BPHY15DiTrkSelectAndWrite, BPHY15_Select_D0, BPHY15_Select_D0b,
+ BPHY15Dh3SelectAndWrite, BPHY15_Select_Ds, BPHY15_Select_Dp, BPHY15_Select_Dm,
+ BPHY15JpsiDs,
+ BPHY15JpsiDp,
+ BPHY15JpsiDpst,
+ BPHY15K0SelectAndWrite, BPHY15_Select_K0,
+ BPHY15JpsiDps1,
+ BPHY15_AugOriginalCounts],
+ #Only skim if not MC
+ SkimmingTools = [BPHY15SkimmingOR] if not isSimulation else [],
+ ThinningTools = thiningCollection
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY15Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY15Stream )
+BPHY15Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY15Stream.AcceptAlgs(["BPHY15Kernel"])
+
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+
+BPHY15ThinningSvc = createThinningSvc( svcName="BPHY15ThinningSvc", outStreams=[evtStream] )
+svcMgr += BPHY15ThinningSvc
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY15SlimmingHelper = SlimmingHelper("BPHY15SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY15SlimmingHelper.IncludeMuonTriggerContent = TRUE
+BPHY15SlimmingHelper.IncludeBPhysTriggerContent = TRUE
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY15RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY15RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+AllVariables += ["Muons"]
+
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY15JpsiSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY15JpsiSelectAndWrite.OutputVtxContainerName]
+
+## Bc+>J/psi pi+ candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY15BcJpsipiSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY15BcJpsipiSelectAndWrite.OutputVtxContainerName]
+
+## K+K-, Kpi, D0/D0bar candidates
+#StaticContent += ["xAOD::VertexContainer#%s" % BPHY15DiTrkSelectAndWrite.OutputVtxContainerName]
+#StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY15DiTrkSelectAndWrite.OutputVtxContainerName]
+
+## D_(s)+/- candidates
+#StaticContent += ["xAOD::VertexContainer#%s" % BPHY15Dh3SelectAndWrite.OutputVtxContainerName]
+#StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY15Dh3SelectAndWrite.OutputVtxContainerName]
+
+## Jpsi pi+ candidates
+#StaticContent += ["xAOD::VertexContainer#%s" % BPHY15JpsipiSelectAndWrite.OutputVtxContainerName]
+#StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY15JpsipiSelectAndWrite.OutputVtxContainerName]
+
+## K_S0 candidates
+#StaticContent += ["xAOD::VertexContainer#%s" % BPHY15K0SelectAndWrite.OutputVtxContainerName]
+#StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY15K0SelectAndWrite.OutputVtxContainerName]
+
+## Bc+>J/psi D_(s)+/-, J/psi D*+/- and J/psi D_s1+/- candidates
+for cascades in CascadeCollections:
+ StaticContent += ["xAOD::VertexContainer#%s" % cascades]
+ StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % cascades]
+
+# Tagging information (in addition to that already requested by usual algorithms)
+AllVariables += ["GSFTrackParticles", "MuonSpectrometerTrackParticles" ]
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+AllVariables = list(set(AllVariables)) # remove duplicates
+
+BPHY15SlimmingHelper.AllVariables = AllVariables
+BPHY15SlimmingHelper.StaticContent = StaticContent
+BPHY15SlimmingHelper.SmartCollections = []
+
+BPHY15SlimmingHelper.AppendContentToStream(BPHY15Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY16.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY16.py
new file mode 100644
index 00000000000..44d8383d943
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY16.py
@@ -0,0 +1,288 @@
+#====================================================================
+# BPHY16.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY16_VertexTools = BPHYVertexTools("BPHY16")
+
+#--------------------------------------------------------------------
+## 2/ Setup the vertex fitter tools (e.g. JpsiFinder, JpsiPlus1Track, etc).
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY16JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY16JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ invMassUpper = 12000.0,
+ invMassLower = 8000.,
+ Chi2Cut = 20.,
+ oppChargesOnly = True,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY16_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY16_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY16_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY16_VertexTools.VtxPointEstimator,
+ useMCPCuts = False )
+
+ToolSvc += BPHY16JpsiFinder
+print(BPHY16JpsiFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY16_Reco_mumu = DerivationFramework__Reco_Vertex(
+ name = "BPHY16_Reco_mumu",
+ VertexSearchTool = BPHY16JpsiFinder,
+ OutputVtxContainerName = "BPHY16OniaCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY16RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 100000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY16_Reco_mumu
+print(BPHY16_Reco_mumu)
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY16_Select_Upsi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY16_Select_Upsi",
+ HypothesisName = "Upsilon",
+ InputVtxContainerName = "BPHY16OniaCandidates",
+ VtxMassHypo = 9460.30,
+ MassMin = 8000.,
+ MassMax = 12000.,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY16_Select_Upsi
+print(BPHY16_Select_Upsi)
+
+
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BPHY16VertexFit = Trk__TrkVKalVrtFitter(
+ name = "BPHY16VertexFit",
+ Extrapolator = BPHY16_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+ToolSvc += BPHY16VertexFit
+print(BPHY16VertexFit)
+
+## 5/ setup the Jpsi+2 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY16Plus2Tracks = Analysis__JpsiPlus2Tracks(name = "BPHY16Plus2Tracks",
+# OutputLevel = DEBUG,
+kaonkaonHypothesis = False,
+pionpionHypothesis = False,
+kaonpionHypothesis = False,
+ManualMassHypo = [ 105.658, 105.658, 105.658, 105.658 ],
+trkThresholdPt = 0.0,
+trkMaxEta = 3.0,
+BMassUpper = 50000.0,
+BMassLower = 0,
+oppChargesOnly = False,
+#DiTrackMassUpper = 1019.445 + 100.,
+#DiTrackMassLower = 1019.445 - 100.,
+Chi2Cut = 100.0,
+#TrkQuadrupletMassUpper = 60000.0,
+#TrkQuadrupletMassLower = 0.01,
+JpsiContainerKey = "BPHY16OniaCandidates",
+TrackParticleCollection = "InDetTrackParticles",
+MuonsUsedInJpsi = "Muons",
+ExcludeJpsiMuonsOnly = True,
+RequireNMuonTracks = 1,
+TrkVertexFitterTool = BPHY16VertexFit,
+TrackSelectorTool = BPHY16_VertexTools.InDetTrackSelectorTool,
+UseMassConstraint = False)
+
+ToolSvc += BPHY16Plus2Tracks
+print(BPHY16Plus2Tracks)
+
+## 6/ setup the combined augmentation/skimming tool for the Bpm
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY16FourTrackSelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY16FourTrackSelectAndWrite",
+ Jpsi2PlusTrackName = BPHY16Plus2Tracks,
+ OutputVtxContainerName = "BPHY16FourTrack",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY16RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000, DoVertexType = 7)
+ToolSvc += BPHY16FourTrackSelectAndWrite
+print(BPHY16FourTrackSelectAndWrite)
+
+
+BPHY16_Select_FourTrack = DerivationFramework__Select_onia2mumu(
+ name = "BPHY16_Select_FourTracks",
+ HypothesisName = "FourTracks",
+ InputVtxContainerName = "BPHY16FourTrack",
+ TrkMasses = [105.658, 105.658, 105.658, 105.658],
+ VtxMassHypo = 18100.0,
+ MassMin = 0,
+ MassMax = 500000,
+ Chi2Max = BPHY16Plus2Tracks.Chi2Cut)
+
+ToolSvc += BPHY16_Select_FourTrack
+print(BPHY16_Select_FourTrack)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__ReVertex
+BPHY16_Revertex = DerivationFramework__ReVertex(
+ name = "BPHY16_ReVertex",
+ InputVtxContainerName = "BPHY16FourTrack",
+ TrackIndices = [ 2, 3 ],
+ TrkVertexFitterTool = BPHY16VertexFit,
+ OutputVtxContainerName = "BPHY16TwoTrack"
+)
+
+ToolSvc += BPHY16_Revertex
+print(BPHY16_Revertex)
+
+BPHY16_Select_TwoTrack = DerivationFramework__Select_onia2mumu(
+ name = "BPHY16_Select_TwoTracks",
+ HypothesisName = "TwoTracks",
+ InputVtxContainerName = "BPHY16TwoTrack",
+ TrkMasses = [105.658, 105.658],
+ VtxMassHypo = 18100.0,
+ MassMin = 1,
+ MassMax = 500000,
+ Chi2Max = 90)
+
+ToolSvc += BPHY16_Select_TwoTrack
+print(BPHY16_Select_TwoTrack)
+
+expression = "count(BPHY16FourTrack.passed_FourTracks) > 0"
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY16_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY16_SelectEvent",
+ expression = expression)
+ToolSvc += BPHY16_SelectEvent
+print(BPHY16_SelectEvent)
+
+#--------------------------------------------------------------------
+## 6/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+## 7/ IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel! If you don't do that, they will not be
+## be executed!
+
+
+# The name of the kernel (BPHY16Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY16Kernel",
+ AugmentationTools = [BPHY16_Reco_mumu, BPHY16_Select_Upsi, BPHY16FourTrackSelectAndWrite, BPHY16_Select_FourTrack, BPHY16_Revertex, BPHY16_Select_TwoTrack],
+ SkimmingTools = [BPHY16_SelectEvent]
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY16Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY16Stream )
+BPHY16Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY16Stream.AcceptAlgs(["BPHY16Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+svcMgr += createThinningSvc( svcName="BPHY16ThinningSvc", outStreams=[evtStream] )
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY16SlimmingHelper = SlimmingHelper("BPHY16SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY16SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY16SlimmingHelper.IncludeBPhysTriggerContent = True
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY16RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY16RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+AllVariables += ["Muons"]
+
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY16_Reco_mumu.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY16_Reco_mumu.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY16_Reco_mumu.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY16FourTrackSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY16FourTrackSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY16FourTrackSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY16_Revertex.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY16_Revertex.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY16_Revertex.OutputVtxContainerName]
+
+
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+BPHY16SlimmingHelper.AllVariables = AllVariables
+BPHY16SlimmingHelper.StaticContent = StaticContent
+BPHY16SlimmingHelper.AppendContentToStream(BPHY16Stream)
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY17.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY17.py
new file mode 100644
index 00000000000..fcd3b47a2e6
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY17.py
@@ -0,0 +1,316 @@
+#====================================================================
+# BPHY17.py
+# This an example job options script showing how to set up a
+# derivation of the data using the derivation framework.
+# It requires the reductionConf flag BPHY17 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = globalflags.DataSource()=='geant4'
+
+print(isSimulation)
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY17_VertexTools = BPHYVertexTools("BPHY17")
+
+from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetDetailedTrackSelectorTool
+InDetTrackSelectorTool = InDet__InDetDetailedTrackSelectorTool(name = "BPHY17_CascadeTrackSelectorTool",
+ pTMin = 1000.0,
+ IPd0Max = 10000.0,
+ IPz0Max = 10000.0,
+ z0Max = 10000.0,
+ sigIPd0Max = 10000.0,
+ sigIPz0Max = 10000.0,
+ d0significanceMax = -1.,
+ z0significanceMax = -1.,
+ etaMax = 9999.,
+ useTrackSummaryInfo = True,
+ nHitBLayer = 0,
+ nHitPix = 1,
+ nHitBLayerPlusPix = 1,
+ nHitSct = 2,
+ nHitSi = 3,
+ nHitTrt = 0,
+ nHitTrtHighEFractionMax = 10000.0,
+ useSharedHitInfo = False,
+ useTrackQualityInfo = True,
+ fitChi2OnNdfMax = 10000.0,
+ TrtMaxEtaAcceptance = 1.9,
+ TrackSummaryTool = BPHY17_VertexTools.InDetTrackSummaryTool,
+ Extrapolator = BPHY17_VertexTools.InDetExtrapolator
+ )
+
+ToolSvc += InDetTrackSelectorTool
+print(InDetTrackSelectorTool)
+
+#BPHY17_VertexTools.TrkVKalVrtFitter.OutputLevel = DEBUG
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Cascade3Plus1
+BPHY17BsDsPi = DerivationFramework__Cascade3Plus1(
+ name = "BPHY17BsDsPi",
+ TrackMassHyp = [ 493.677, 493.677, 139.57018, 139.57018 ],
+ PTCutPerTrack = [ 0,0,1500, 1500],
+ HypothesisName = "Bs",
+ Track3Name = "Ds",
+ TrackSelectorTool = InDetTrackSelectorTool,
+ TrkVertexFitterTool = BPHY17_VertexTools.TrkVKalVrtFitter,
+ PVContainerName = "PrimaryVertices",
+ RefitPV = True,
+ #OutputLevel = DEBUG,
+ RefPVContainerName = "BPHY17RefittedPrimaryVertices",
+ CascadeVertexCollections= ["BPHY17CascadeVtx1", "BPHY17CascadeVtx2"],
+ ThreeVertexOutputContainer = "BPHY17DsKaonVertexes", EliminateBad3Tracksfrom4Track = True,
+ ThreeTrackChi2NDF = 6,
+ TwoTrackMassMin = 1009.0,
+ TwoTrackMassMax = 1031.0,
+ ThreeTrackMassMin = 1800.47,
+ ThreeTrackMassMax = 2100.0,
+ FourTrackMassMin = 5100.0,
+ FourTrackMassMax = 5600.0,
+ ThreeTracksMass = 1968.47,
+ FourTracksMass = 5366.79,
+ Chi2NDFCut = 10,
+ FourTrackMassFinalMin = 5150.,
+ FourTrackMassFinalMax = 5650.0,
+ ThreeTrackMassConstraint = False,
+ CopyAllVertices = False
+ )
+
+ToolSvc += BPHY17BsDsPi
+print(BPHY17BsDsPi)
+
+###
+BPHY17BsDsPiMuons = DerivationFramework__Cascade3Plus1(
+ name = "BPHY17BsDsPiMuons",
+ TrackMassHyp = [ 105.658374, 105.658374, 139.57018, 139.57018 ],
+ PTCutPerTrack = [ 0,0,1500, 1500],
+ HypothesisName = "Bs",
+ Track3Name = "Ds",
+ TrackSelectorTool = InDetTrackSelectorTool,
+ TrkVertexFitterTool = BPHY17_VertexTools.TrkVKalVrtFitter,
+ PVContainerName = "PrimaryVertices",
+ RefitPV = True,
+ #OutputLevel = DEBUG,
+ RefPVContainerName = "BPHY17RefittedPrimaryVerticesMuons",
+ CascadeVertexCollections= ["BPHY17CascadeMuonVtx1", "BPHY17CascadeMuonVtx2"],
+ ThreeVertexOutputContainer = "BPHY17DsMuonVertexes", EliminateBad3Tracksfrom4Track = True,
+ ThreeTrackChi2NDF = 10,
+ TwoTrackMassMin = 860.0,
+ TwoTrackMassMax = 1180.0,
+ ThreeTrackMassMin = 1800.47,
+ ThreeTrackMassMax = 2100.0,
+ FourTrackMassMin = 5100.0,
+ FourTrackMassMax = 5550.0,
+ ThreeTracksMass = 1968.47,
+ FourTracksMass = 5366.79,
+ Chi2NDFCut = 10,
+ FourTrackMassFinalMin = 5150.,
+ FourTrackMassFinalMax = 5500.0,
+ ThreeTrackMassConstraint = False,
+ UseMuonsForTracks = [0, 1],
+ CopyAllVertices = False
+ )
+
+ToolSvc += BPHY17BsDsPiMuons
+print(BPHY17BsDsPiMuons)
+
+###
+BPHY17BsDsMuSemiLepMuons = DerivationFramework__Cascade3Plus1(
+ name = "BPHY17BsDsMuSemiLepMuons",
+ TrackMassHyp = [ 105.658374, 105.658374, 139.57018, 105.658374 ],
+ PTCutPerTrack = [ 0,0,1500, 0],
+ HypothesisName = "Bs",
+ Track3Name = "Ds",
+ TrackSelectorTool = InDetTrackSelectorTool,
+ TrkVertexFitterTool = BPHY17_VertexTools.TrkVKalVrtFitter,
+ PVContainerName = "PrimaryVertices",
+ RefitPV = True,
+ #OutputLevel = DEBUG,
+ RefPVContainerName = "BPHY17RefittedPrimaryVerticesMuonsSemiLep",
+ CascadeVertexCollections= ["BPHY17CascadeMuonSemiLepVtx1", "BPHY17CascadeMuonSemiLepVtx2"],
+ ThreeVertexOutputContainer = "BPHY17DsMuonSemiLepVertexes", EliminateBad3Tracksfrom4Track = True,
+ ThreeTrackChi2NDF = 10,
+ TwoTrackMassMin = 860.0,
+ TwoTrackMassMax = 1180.0,
+ ThreeTrackMassMin = 1800.47,
+ ThreeTrackMassMax = 2100.0,
+ FourTrackMassMin = 0.,
+ FourTrackMassMax = 999999.0,
+ ThreeTracksMass = 1968.47,
+ FourTracksMass = 5366.79,
+ Chi2NDFCut = 10,
+ FourTrackMassFinalMin = 0,
+ FourTrackMassFinalMax = 999999.0,
+ ThreeTrackMassConstraint = False,
+ UseMuonsForTracks = [0, 1, 3],
+ CopyAllVertices = False
+ )
+
+ToolSvc += BPHY17BsDsMuSemiLepMuons
+print(BPHY17BsDsMuSemiLepMuons)
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+BPHY17_Select_DsPhiKK = DerivationFramework__Select_onia2mumu(
+ name = "BPHY17_Select_DsPhiKK",
+ HypothesisName = "DsPhiKK",
+ InputVtxContainerName = BPHY17BsDsPi.ThreeVertexOutputContainer,
+ TrkMasses = [493.677, 493.677, 139.57018],
+ VtxMassHypo = 1968.47,
+ MassMin = 1000.0,
+ MassMax = 3000.0, Do3d = False, DoVertexType = 1,
+ Chi2Max = 200)
+
+ToolSvc += BPHY17_Select_DsPhiKK
+print(BPHY17_Select_DsPhiKK)
+
+BPHY17_Select_DsPhiMM = DerivationFramework__Select_onia2mumu(
+ name = "BPHY17_Select_DsPhiMM",
+ HypothesisName = "DsPhiMM",
+ InputVtxContainerName = BPHY17BsDsPiMuons.ThreeVertexOutputContainer,
+ TrkMasses = [105.658374, 105.658374, 139.57018],
+ VtxMassHypo = 1968.47,
+ MassMin = 1000.0,
+ MassMax = 3000.0, Do3d = False, DoVertexType = 1,
+ Chi2Max = 200)
+
+ToolSvc += BPHY17_Select_DsPhiMM
+print(BPHY17_Select_DsPhiMM)
+
+
+BPHY17_Select_DsPhiMMSemi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY17_Select_DsPhiMMSemi",
+ HypothesisName = "DsPhiMMSemiLep",
+ InputVtxContainerName = BPHY17BsDsMuSemiLepMuons.ThreeVertexOutputContainer,
+ TrkMasses = [105.658374, 105.658374, 139.57018],
+ VtxMassHypo = 1968.47,
+ MassMin = 1000.0,
+ MassMax = 3000.0, Do3d = False, DoVertexType = 1,
+ Chi2Max = 200)
+
+ToolSvc += BPHY17_Select_DsPhiMMSemi
+print(BPHY17_Select_DsPhiMMSemi)
+
+###
+
+#--------------------------------------------------------------------
+## 5/ select the event. We only want to keep events that contain certain vertices which passed certain selection.
+## This is specified by the "SelectionExpression" property, which contains the expression in the following format:
+##
+## "ContainerName.passed_HypoName > count"
+##
+## where "ContainerName" is output container form some Reco_* tool, "HypoName" is the hypothesis name setup in some "Select_*"
+## tool and "count" is the number of candidates passing the selection you want to keep.
+
+expression = "count(%s.x > -999) > 0" % BPHY17BsDsPi.CascadeVertexCollections[0]
+expression += " || count(%s.x > -999) > 0" % BPHY17BsDsPiMuons.CascadeVertexCollections[0]
+expression += " || count(%s.x > -999) > 0" % BPHY17BsDsPi.ThreeVertexOutputContainer
+expression += " || count(%s.x > -999) > 0" % BPHY17BsDsPiMuons.ThreeVertexOutputContainer
+expression += " || count(%s.x > -999) > 0" % BPHY17BsDsMuSemiLepMuons.CascadeVertexCollections[0]
+expression += " || count(%s.x > -999) > 0" % BPHY17BsDsMuSemiLepMuons.ThreeVertexOutputContainer
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY17_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY17_SelectEvent",
+ expression = expression)
+ToolSvc += BPHY17_SelectEvent
+print(BPHY17_SelectEvent)
+
+MyVertexCollections = BPHY17BsDsPi.CascadeVertexCollections + BPHY17BsDsPiMuons.CascadeVertexCollections + BPHY17BsDsMuSemiLepMuons.CascadeVertexCollections + \
+ [ BPHY17BsDsPi.ThreeVertexOutputContainer, BPHY17BsDsPiMuons.ThreeVertexOutputContainer, BPHY17BsDsMuSemiLepMuons.ThreeVertexOutputContainer ]
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY17_thinningTool_Tracks = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY17_thinningTool_Tracks",
+ TrackParticleContainerName = "InDetTrackParticles",
+ IgnoreFlags = True,
+ VertexContainerNames = MyVertexCollections,
+ PassFlags = ["passed_DsPhiMM", "passed_DsPhiKK"] )
+
+ToolSvc += BPHY17_thinningTool_Tracks
+
+
+# Only save truth informtion directly associated with Onia
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY17TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY17TruthThinTool",
+ ParticleSelectionString = "TruthParticles.pdgId == 511 || TruthParticles.pdgId == -511 || TruthParticles.pdgId == 531 || TruthParticles.pdgId == -531",
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY17TruthThinTool
+print(BPHY17TruthThinTool)
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+## 7/ IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel! If you don't do that, they will not be
+## be executed!
+
+# Added by ASC
+BPHY17ThinningTools = [BPHY17_thinningTool_Tracks]
+if globalflags.DataSource()=='geant4':
+ BPHY17ThinningTools.append(BPHY17TruthThinTool)
+
+# The name of the kernel (BPHY17Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY17Kernel",
+ AugmentationTools = [BPHY17BsDsPi, BPHY17BsDsPiMuons, BPHY17BsDsMuSemiLepMuons, BPHY17_Select_DsPhiKK, BPHY17_Select_DsPhiMM, BPHY17_Select_DsPhiMMSemi],
+ SkimmingTools = [BPHY17_SelectEvent],
+ ThinningTools = BPHY17ThinningTools,
+# OutputLevel = DEBUG
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY17Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY17Stream )
+BPHY17Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY17Stream.AcceptAlgs(["BPHY17Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+svcMgr += createThinningSvc( svcName="BPHY17ThinningSvc", outStreams=[evtStream] )
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY17SlimmingHelper = SlimmingHelper("BPHY17SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY17SlimmingHelper.IncludeBPhysTriggerContent = False
+BPHY17SlimmingHelper.IncludeMuonTriggerContent = False
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+
+for f in MyVertexCollections + [BPHY17BsDsPi.RefPVContainerName, BPHY17BsDsPiMuons.RefPVContainerName + BPHY17BsDsMuSemiLepMuons.RefPVContainerName ]:
+ StaticContent += ["xAOD::VertexContainer#%s" % f]
+ StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % f]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+AllVariables += ["Muons"]
+
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices"]
+
+BPHY17SlimmingHelper.AllVariables = AllVariables
+BPHY17SlimmingHelper.StaticContent = StaticContent
+BPHY17SlimmingHelper.AppendContentToStream(BPHY17Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY18.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY18.py
new file mode 100644
index 00000000000..fdabaaacdfb
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY18.py
@@ -0,0 +1,506 @@
+#====================================================================
+# BPHY18.py
+# B0 -> K*ee
+# It requires the reductionConf flag BPHY18 in Reco_tf.py
+#====================================================================
+
+
+#====================================================================
+# FLAGS TO PERSONALIZE THE DERIVATION
+#====================================================================
+
+onlyAugmentations = False
+thinTruth = False
+skimTruth = False
+
+
+# Set up common services and job object.
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+from DerivationFrameworkMuons.MuonsCommon import *
+from DerivationFrameworkJetEtMiss.JetCommon import *
+from DerivationFrameworkEGamma.EGammaCommon import *
+from DerivationFrameworkEGamma.ElectronsCPContent import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY18_VertexTools = BPHYVertexTools("BPHY18")
+
+
+print('********************** VERTEX TOOLS ***********************')
+print(BPHY18_VertexTools)
+print(BPHY18_VertexTools.TrkV0Fitter)
+print('********************** END VERTEX TOOLS ***********************')
+
+#====================================================================
+# TriggerCounting for Kernel1 #Added by Matteo
+#====================================================================
+#List of trigggers to be counted (high Sig-eff*Lumi ones are in)
+triggersToMetadata = [
+"HLT_2e5_lhvloose_nod0_bBeexM6000t", #37,143,877 inb
+"HLT_e5_lhvloose_nod0_bBeexM6000t", #37,143,877
+"HLT_e5_lhvloose_nod0_bBeexM6000t_2mu4_nomucomb_L1BPH-0DR3-EM7J15_2MU4", #37,312,506
+"HLT_e5_lhvloose_nod0_bBeexM6000t_mu6_nomucomb_L1BPH-0DR3-EM7J15_MU6", #27,041,892
+"HLT_e5_lhvloose_nod0_bBeexM6000_mu6_nomucomb_L1BPH-0DR3-EM7J15_MU6", #149,100
+"HLT_e9_lhloose_bBeexM2700_2mu4_nomucomb_L1BPH-0DR3-EM7J15_2MU4", #2,681,764
+"HLT_e9_lhloose_bBeexM2700_mu6_nomucomb_L1BPH-0DR3-EM7J15_MU6", #1,979,362
+"HLT_e9_lhloose_bBeexM6000_2mu4_nomucomb_L1BPH-0DR3-EM7J15_2MU4", #3,359,105
+"HLT_e9_lhloose_bBeexM6000_mu6_nomucomb_L1BPH-0DR3-EM7J15_MU6", #2,426,663
+"HLT_e9_lhloose_e5_lhloose_bBeexM2700_2mu4_nomucomb_L1BPH-0M9-EM7-EM5_2MU4", #2,950,935
+"HLT_e9_lhloose_e5_lhloose_bBeexM2700_mu6_nomucomb_L1BPH-0M9-EM7-EM5_MU6", #2,928,030
+"HLT_e9_lhloose_e5_lhloose_bBeexM6000_2mu4_nomucomb_L1BPH-0M9-EM7-EM5_2MU4", #3,647,507
+"HLT_e9_lhloose_e5_lhloose_bBeexM6000_mu6_nomucomb_L1BPH-0M9-EM7-EM5_MU6", #3,605,371
+"HLT_e9_lhvloose_nod0_e5_lhvloose_nod0_bBeexM6000t_2mu4_nomucomb_L1BPH-0M9-EM7-EM5_2MU4", #40,169,436
+"HLT_e9_lhvloose_nod0_e5_lhvloose_nod0_bBeexM6000t_mu6_nomucomb_L1BPH-0M9-EM7-EM5_MU6", #37,312,506
+"HLT_e9_lhvloose_nod0_e5_lhvloose_nod0_bBeexM6000_mu6_nomucomb_L1BPH-0M9-EM7-EM5_MU6", #677,340
+
+'HLT_3mu4_bDimu2700', 'HLT_3mu6_bDimu', 'HLT_mu6_2mu4_bDimu2700','HLT_mu11_mu6_bJpsimumu', 'HLT_3mu4_bJpsi', 'HLT_mu11_mu6_bDimu', 'HLT_2mu6_bBmumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6','HLT_2mu6_bJpsimumu_L1BPH-2M9-2MU6_BPH-2DR15-2MU6', 'HLT_2mu10_bBmumuxv2', 'HLT_mu6_mu4_bDimu', 'HLT_2mu6_bBmumuxv2_L1LFV-MU6', 'HLT_mu11_mu6_bJpsimumu_Lxy0', 'HLT_mu11_mu6_bDimu2700', 'HLT_mu11_mu6_bBmumux_BpmumuKp', 'HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4', 'HLT_mu11_mu6_bBmumuxv2', 'HLT_mu6_2mu4_bJpsi', 'HLT_2mu6_bBmumux_BpmumuKp_L1BPH-2M9-2MU6_BPH-2DR15-2MU6', 'HLT_2mu6_bJpsimumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6', 'HLT_3mu6_bJpsi', 'HLT_mu11_mu6_bBmumu']
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__TriggerCountToMetadata
+BPHY18TriggerCountToMetadata = DerivationFramework__TriggerCountToMetadata(name = "BPHY18TriggerCount",
+ TriggerList = triggersToMetadata,
+ FolderName = "BPHY18")
+
+ToolSvc += BPHY18TriggerCountToMetadata
+
+#====================================================================
+# PRESELECTION for Kernel1 #Added by Matteo
+#====================================================================
+## 1/ Setup the skimming based on triggers
+##
+
+triggerList = ["HLT_e5_lhvloose_nod0_bBeexM6000t_2mu4_nomucomb_L1BPH-0DR3-EM7J15_2MU4", #37,312,506
+"HLT_e5_lhvloose_nod0_bBeexM6000t_mu6_nomucomb_L1BPH-0DR3-EM7J15_MU6", #27,041,892
+"HLT_e5_lhvloose_nod0_bBeexM6000_mu6_nomucomb_L1BPH-0DR3-EM7J15_MU6", #149,100
+"HLT_e9_lhloose_bBeexM2700_2mu4_nomucomb_L1BPH-0DR3-EM7J15_2MU4", #2,681,764
+"HLT_e9_lhloose_bBeexM2700_mu6_nomucomb_L1BPH-0DR3-EM7J15_MU6", #1,979,362
+"HLT_e9_lhloose_bBeexM6000_2mu4_nomucomb_L1BPH-0DR3-EM7J15_2MU4", #3,359,105
+"HLT_e9_lhloose_bBeexM6000_mu6_nomucomb_L1BPH-0DR3-EM7J15_MU6", #2,426,663
+"HLT_e9_lhloose_e5_lhloose_bBeexM2700_2mu4_nomucomb_L1BPH-0M9-EM7-EM5_2MU4", #2,950,935
+"HLT_e9_lhloose_e5_lhloose_bBeexM2700_mu6_nomucomb_L1BPH-0M9-EM7-EM5_MU6", #2,928,030
+"HLT_e9_lhloose_e5_lhloose_bBeexM6000_2mu4_nomucomb_L1BPH-0M9-EM7-EM5_2MU4", #3,647,507
+"HLT_e9_lhloose_e5_lhloose_bBeexM6000_mu6_nomucomb_L1BPH-0M9-EM7-EM5_MU6", #3,605,371
+"HLT_e9_lhvloose_nod0_e5_lhvloose_nod0_bBeexM6000t_2mu4_nomucomb_L1BPH-0M9-EM7-EM5_2MU4", #40,169,436
+"HLT_e9_lhvloose_nod0_e5_lhvloose_nod0_bBeexM6000t_mu6_nomucomb_L1BPH-0M9-EM7-EM5_MU6", #37,312,506
+"HLT_e9_lhvloose_nod0_e5_lhvloose_nod0_bBeexM6000_mu6_nomucomb_L1BPH-0M9-EM7-EM5_MU6", #677,340
+"HLT_2e5_lhvloose_nod0_bBeexM6000t", #37,143,877 inb
+"HLT_e5_lhvloose_nod0_bBeexM6000t" #37,143,877
+] # Seeded + Unseeded BeeX triggers
+
+triggerList_unseeded = ["HLT_2e5_lhvloose_nod0_bBeexM6000t", #37,143,877 inb
+"HLT_e5_lhvloose_nod0_bBeexM6000t" #37,143,877
+]
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__TriggerSkimmingTool
+BPHY18TriggerSkim = DerivationFramework__TriggerSkimmingTool(name = "BPHY18TriggerSkim",
+ TriggerListOR = triggerList,
+ TriggerListORHLTOnly = triggerList_unseeded )
+
+ToolSvc += BPHY18TriggerSkim
+print(BPHY18TriggerSkim)
+
+#do not know what this does, but let's leave it for now, until we see if it's useful or not!
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__AugOriginalCounts
+BPHY18_AugOriginalCounts = DerivationFramework__AugOriginalCounts(name = "BPHY18_AugOriginalCounts",
+ VertexContainer = "PrimaryVertices",
+ TrackContainer = "InDetTrackParticles" )
+ToolSvc += BPHY18_AugOriginalCounts
+
+#lhvloose_nod0
+from ElectronPhotonSelectorTools.ElectronPhotonSelectorToolsConf import AsgElectronLikelihoodTool
+ElectronLHSelectorLHvloose_nod0 = AsgElectronLikelihoodTool("ElectronLHSelectorLHvloosenod0",
+ConfigFile="ElectronPhotonSelectorTools/offline/mc16_20190328_nod0/ElectronLikelihoodVeryLooseOfflineConfig2017_Smooth_nod0.conf")
+ElectronLHSelectorLHvloose_nod0.primaryVertexContainer = "PrimaryVertices"
+ToolSvc += ElectronLHSelectorLHvloose_nod0
+print(ElectronLHSelectorLHvloose_nod0)
+
+# decorate electrons with the output of LH vloose nod0
+ElectronPassLHvloosenod0 = DerivationFramework__EGSelectionToolWrapper(name = "ElectronPassLHvloosenod0",
+ EGammaSelectionTool = ElectronLHSelectorLHvloose_nod0,
+ EGammaFudgeMCTool = "",
+ CutType = "",
+ StoreGateEntryName = "DFCommonElectronsLHVeryLoosenod0",
+ ContainerName = "Electrons")
+ToolSvc += ElectronPassLHvloosenod0
+print(ElectronPassLHvloosenod0)
+
+#--------------------------------------------------------------------
+## 2/ setup JpsiFinder tool
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder_ee
+BPHY18DiElectronFinder = Analysis__JpsiFinder_ee(
+ name = "BPHY18DiElectronFinder",
+ OutputLevel = INFO,
+ elAndEl = True,
+ elAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiElectrons = True,
+ elThresholdPt = 4000.0,
+ invMassUpper = 7000.0,
+ invMassLower = 1.0,
+ Chi2Cut = 30.,
+ oppChargesOnly = False,
+ allChargeCombinations = True,
+ useElectronTrackMeasurement = True,
+ electronCollectionKey = "Electrons",
+ TrackParticleCollection = "GSFTrackParticles",
+ useEgammaCuts = True,
+ V0VertexFitterTool = BPHY18_VertexTools.TrkV0Fitter,
+ useV0Fitter = False,
+ TrkVertexFitterTool = BPHY18_VertexTools.TrkVKalVrtFitter,
+ TrackSelectorTool = BPHY18_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY18_VertexTools.VtxPointEstimator,
+ ElectronSelection = "d0_or_nod0"
+ )
+
+ToolSvc += BPHY18DiElectronFinder
+print(BPHY18DiElectronFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s).
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY18DiElectronSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY18DiElectronSelectAndWrite",
+ VertexSearchTool = BPHY18DiElectronFinder,
+ OutputVtxContainerName = "BPHY18DiElectronCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ DoVertexType = 7
+ )
+
+ToolSvc += BPHY18DiElectronSelectAndWrite
+print(BPHY18DiElectronSelectAndWrite)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+BPHY18_Select_DiElectrons = DerivationFramework__Select_onia2mumu(
+ name = "BPHY18_Select_DiElectrons",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY18DiElectronCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 1.0,
+ MassMax = 7000.0,
+ Chi2Max = 30,
+ DoVertexType = 7
+ )
+
+ToolSvc += BPHY18_Select_DiElectrons
+print(BPHY18_Select_DiElectrons)
+
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BeeKstVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BeeKstVertexFit",
+ Extrapolator = BPHY18_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True
+ )
+
+ToolSvc += BeeKstVertexFit
+print(BeeKstVertexFit)
+
+## 5/ setup the Jpsi+2 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY18BeeKst = Analysis__JpsiPlus2Tracks(
+ name = "BPHY18BeeKstFinder",
+ OutputLevel = INFO,
+ kaonkaonHypothesis = False,
+ pionpionHypothesis = False,
+ kaonpionHypothesis = True,
+ oppChargesOnly = False,
+ SameChargesOnly = False,
+ trkThresholdPt = 500.0,
+ trkMaxEta = 3.0,
+ BThresholdPt = 1000.,
+ BMassLower = 3000.0,
+ BMassUpper = 6500.0,
+ JpsiContainerKey = "BPHY18DiElectronCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ ExcludeCrossJpsiTracks = False,
+ TrkVertexFitterTool = BeeKstVertexFit,
+ TrackSelectorTool = BPHY18_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = False,
+ DiTrackMassUpper = 1110.,
+ DiTrackMassLower = 690.,
+ Chi2Cut = 15.0,
+ DiTrackPt = 500.,
+ TrkQuadrupletMassLower = 1000.0,
+ TrkQuadrupletMassUpper = 10000.0,
+ FinalDiTrackPt = 500.,
+ UseGSFTrackIndices = [0,1]
+ )
+
+ToolSvc += BPHY18BeeKst
+print(BPHY18BeeKst)
+
+## 6/ setup the combined augmentation/skimming tool for the BeeKst
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY18BeeKstSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY18BeeKstSelectAndWrite",
+ Jpsi2PlusTrackName = BPHY18BeeKst,
+ OutputVtxContainerName = "BeeKstCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY18RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000,
+ DoVertexType = 7
+ )
+
+ToolSvc += BPHY18BeeKstSelectAndWrite
+print(BPHY18BeeKstSelectAndWrite)
+
+## b/ augment and select B->eeKst candidates
+BPHY18_Select_BeeKst = DerivationFramework__Select_onia2mumu(
+ name = "BPHY18_Select_BeeKst",
+ HypothesisName = "Bd",
+ InputVtxContainerName = "BeeKstCandidates",
+ TrkMasses = [0.511, 0.511, 493.677, 139.570],
+ VtxMassHypo = 5279.6,
+ MassMin = 1.0,
+ MassMax = 10000.0,
+ Chi2Max = 30.0
+ )
+
+ToolSvc += BPHY18_Select_BeeKst
+print(BPHY18_Select_BeeKst)
+
+## c/ augment and select Bdbar->eeKstbar candidates
+BPHY18_Select_BeeKstbar = DerivationFramework__Select_onia2mumu(
+ name = "BPHY18_Select_Bd2JpsiKstbar",
+ HypothesisName = "Bdbar",
+ InputVtxContainerName = "BeeKstCandidates",
+ TrkMasses = [0.511, 0.511, 139.570, 493.677],
+ VtxMassHypo = 5279.6,
+ MassMin = 1.0,
+ MassMax = 10000.0,
+ Chi2Max = 30.0
+ )
+
+ToolSvc += BPHY18_Select_BeeKstbar
+print(BPHY18_Select_BeeKstbar)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__ReVertex
+BPHY18_diMeson_revertex = DerivationFramework__ReVertex(
+ name = "BPHY18_diMeson_revertex",
+ InputVtxContainerName = "BeeKstCandidates",
+ TrackIndices = [ 2, 3 ],
+ TrkVertexFitterTool = BeeKstVertexFit,
+ OutputVtxContainerName = "BPHY18DiMeson"
+ )
+
+ToolSvc += BPHY18_diMeson_revertex
+print(BPHY18_diMeson_revertex)
+
+BPHY18_Select_Kpi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY18_Select_Kpi",
+ HypothesisName = "Kpi",
+ InputVtxContainerName = "BPHY18DiMeson",
+ TrkMasses = [ 493.677, 139.570 ],
+ VtxMassHypo = 891.66,
+ MassMin = 1.0,
+ MassMax = 100000.0,
+ Chi2Max = 100.0
+ )
+
+ToolSvc += BPHY18_Select_Kpi
+print(BPHY18_Select_Kpi)
+
+BPHY18_Select_piK = DerivationFramework__Select_onia2mumu(
+ name = "BPHY18_Select_piK",
+ HypothesisName = "piK",
+ InputVtxContainerName = "BPHY18DiMeson",
+ TrkMasses = [ 139.570, 493.677 ],
+ VtxMassHypo = 891.66,
+ MassMin = 1.0,
+ MassMax = 100000.0,
+ Chi2Max = 100.0
+ )
+
+ToolSvc += BPHY18_Select_piK
+print(BPHY18_Select_piK)
+
+if True:
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+ BPHY18_SelectBeeKstEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY18_SelectBeeKstEvent",
+ expression = "(count(BeeKstCandidates.passed_Bd > 0) + count(BeeKstCandidates.passed_Bdbar > 0)) > 0")
+ ToolSvc += BPHY18_SelectBeeKstEvent
+ print(BPHY18_SelectBeeKstEvent)
+
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools
+ #====================================================================
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationAND
+ BPHY18SkimmingAND = CfgMgr.DerivationFramework__FilterCombinationAND(
+ "BPHY18SkimmingAND",
+ FilterList = [BPHY18_SelectBeeKstEvent, BPHY18TriggerSkim])
+ ToolSvc += BPHY18SkimmingAND
+ print(BPHY18SkimmingAND)
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY18_thinningTool_Tracks = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY18_thinningTool_Tracks",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BeeKstCandidates"],
+ PassFlags = ["passed_Bd", "passed_Bdbar"] )
+
+BPHY18_thinningTool_GSFTracks = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY18_thinningTool_GSFTracks",
+ TrackParticleContainerName = "GSFTrackParticles",
+ VertexContainerNames = ["BeeKstCandidates"],
+ PassFlags = ["passed_Bd", "passed_Bdbar"] )
+
+ToolSvc += BPHY18_thinningTool_Tracks
+ToolSvc += BPHY18_thinningTool_GSFTracks
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysPVThinningTool
+BPHY18_thinningTool_PV = DerivationFramework__BPhysPVThinningTool(
+ name = "BPHY18_thinningTool_PV",
+ CandidateCollections = ["BeeKstCandidates"],
+ KeepPVTracks = True
+ )
+
+ToolSvc += BPHY18_thinningTool_PV
+
+## b) thinning out tracks that are not attached to muons.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY18MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(
+ name = "BPHY18MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY18MuonTPThinningTool
+
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__EgammaTrackParticleThinning
+BPHY18EgammaTPThinningTool = DerivationFramework__EgammaTrackParticleThinning(
+ name = "BPHY18EgammaTPThinningTool",
+ SGKey = "Electrons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY18EgammaTPThinningTool
+
+# Only save truth informtion directly associated with: mu Ds+ D+ D*+ Ds*+ D0 D*0 B+ B*+ B0 B*0
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY18TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY18TruthThinTool",
+ ParticleSelectionString = "abs(TruthParticles.pdgId) == 11 || abs(TruthParticles.pdgId) == 13 || abs(TruthParticles.pdgId) == 10311 || abs(TruthParticles.pdgId) == 521 || abs(TruthParticles.pdgId) == 523 || TruthParticles.pdgId == 511 || TruthParticles.pdgId == 513",
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY18TruthThinTool
+
+# Only save truth neutrino and b/c quarks information
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY18TruthThinNoChainTool = DerivationFramework__GenericTruthThinning(name = "BPHY18TruthThinNoChainTool",
+ ParticleSelectionString = "abs(TruthParticles.pdgId) == 5 || abs(TruthParticles.pdgId) == 12 || abs(TruthParticles.pdgId) == 14",
+ PreserveDescendants = False,
+ PreserveAncestors = False)
+ToolSvc += BPHY18TruthThinNoChainTool
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+thinningCollection = [ BPHY18_thinningTool_Tracks, BPHY18_thinningTool_GSFTracks,
+ BPHY18_thinningTool_PV, #BPHY18_thinningTool_PV_GSF,
+ BPHY18EgammaTPThinningTool, BPHY18MuonTPThinningTool
+ ]
+
+#if we're doing truth, add these [BPHY18TruthThinTool,BPHY18TruthThinNoChainTool]
+if isSimulation:
+ thinningCollection += [BPHY18TruthThinTool,BPHY18TruthThinNoChainTool]
+
+print(thinningCollection)
+
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY18Kernel",
+
+ AugmentationTools = [ ElectronPassLHvloosenod0,BPHY18DiElectronSelectAndWrite,
+ BPHY18_Select_DiElectrons,
+ BPHY18BeeKstSelectAndWrite, BPHY18_Select_BeeKst, BPHY18_Select_BeeKstbar,
+ BPHY18_diMeson_revertex, BPHY18_Select_Kpi, BPHY18_Select_piK ],
+
+ #Only skim if not MC
+ SkimmingTools = [BPHY18SkimmingAND],
+ ThinningTools = thinningCollection
+ )
+
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY18Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY18Stream )
+BPHY18Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY18Stream.AcceptAlgs(["BPHY18Kernel"])
+
+# Special lines for thinning
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+
+BPHY18ThinningSvc = createThinningSvc( svcName="BPHY18ThinningSvc", outStreams=[evtStream] )
+svcMgr += BPHY18ThinningSvc
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY18SlimmingHelper = SlimmingHelper("BPHY18SlimmingHelper")
+AllVariables = []
+StaticContent = []
+ExtraVariables = []
+BPHY18SlimmingHelper.SmartCollections = ["Electrons", "Muons", "InDetTrackParticles" ]
+
+# Needed for trigger objects
+BPHY18SlimmingHelper.IncludeMuonTriggerContent = False
+BPHY18SlimmingHelper.IncludeBPhysTriggerContent = False
+BPHY18SlimmingHelper.IncludeEGammaTriggerContent = True
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY18RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY18RefittedPrimaryVerticesAux."]
+
+ExtraVariables += ["Muons.etaLayer1Hits.etaLayer2Hits.etaLayer3Hits.etaLayer4Hits.phiLayer1Hits.phiLayer2Hits.phiLayer3Hits.phiLayer4Hits",
+ "Muons.numberOfTriggerEtaLayers.numberOfPhiLayers",
+ "InDetTrackParticles.numberOfTRTHits.numberOfTRTHighThresholdHits.vx.vy.vz",
+ "PrimaryVertices.chiSquared.covariance", "Electrons.deltaEta1.DFCommonElectronsLHVeryLoosenod0","egammaClusters.calE.calEta.calPhi.e_sampl.eta_sampl.etaCalo.phiCalo.ETACALOFRAME.PHICALOFRAME","HLT_xAOD__ElectronContainer_egamma_ElectronsAuxDyn.charge"]
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY18DiElectronSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY18DiElectronSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY18BeeKstSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY18BeeKstSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY18_diMeson_revertex.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY18_diMeson_revertex.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY18_diMeson_revertex.OutputVtxContainerName]
+
+AllVariables += [ "GSFTrackParticles"]
+
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices", "ElectronTruthParticles"]
+
+AllVariables = list(set(AllVariables)) # remove duplicates
+
+BPHY18SlimmingHelper.AllVariables = AllVariables
+BPHY18SlimmingHelper.ExtraVariables = ExtraVariables
+
+BPHY18SlimmingHelper.StaticContent = StaticContent
+
+from DerivationFrameworkEGamma.ElectronsCPDetailedContent import *
+BPHY18SlimmingHelper.ExtraVariables += ElectronsCPDetailedContent
+BPHY18SlimmingHelper.ExtraVariables += GSFTracksCPDetailedContent
+
+BPHY18SlimmingHelper.AppendContentToStream(BPHY18Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY19.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY19.py
new file mode 100644
index 00000000000..a8679449c86
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY19.py
@@ -0,0 +1,313 @@
+#
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+#
+#====================================================================
+# BPHY19.py
+# Derivation for dimuon + photon conversion (chi_c/b)
+# Contact: A. Chisholm <andrew.chisholm@cern.ch>
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+#--------------------------------------------------------------------
+# Setup the JpsiFinder vertex fitter tools
+#--------------------------------------------------------------------
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY19_VertexTools = BPHYVertexTools("BPHY19")
+
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY19JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY19JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ invMassUpper = 100000.0,
+ invMassLower = 0.0,
+ Chi2Cut = 200.,
+ oppChargesOnly = True,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY19_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY19_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY19_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY19_VertexTools.VtxPointEstimator,
+ useMCPCuts = False )
+
+ToolSvc += BPHY19JpsiFinder
+print(BPHY19JpsiFinder)
+
+#--------------------------------------------------------------------
+# Setup the vertex reconstruction tools
+#--------------------------------------------------------------------
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+
+BPHY19_Reco_mumu = DerivationFramework__Reco_Vertex(
+ name = "BPHY19_Reco_mumu",
+ VertexSearchTool = BPHY19JpsiFinder,
+ OutputVtxContainerName = "BPHY19OniaCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY19RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 100000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY19_Reco_mumu
+print(BPHY19_Reco_mumu)
+
+#--------------------------------------------------------------------
+# Setup the vertex selection and augmentation tools
+#--------------------------------------------------------------------
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+# psi(nS)->mu+mu- candidates
+BPHY19_Select_Psi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY19_Select_Psi2mumu",
+ HypothesisName = "Psi",
+ InputVtxContainerName = "BPHY19OniaCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 2000.0,
+ MassMax = 4500.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY19_Select_Psi2mumu
+print(BPHY19_Select_Psi2mumu)
+
+# Y(nS)->mu+mu- candidates
+BPHY19_Select_Upsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY19_Select_Upsi2mumu",
+ HypothesisName = "Upsi",
+ InputVtxContainerName = "BPHY19OniaCandidates",
+ VtxMassHypo = 9460.30,
+ MassMin = 8000.0,
+ MassMax = 12000.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY19_Select_Upsi2mumu
+print(BPHY19_Select_Upsi2mumu)
+
+
+#--------------------------------------------------------------------
+# Configure the conversion finder
+#--------------------------------------------------------------------
+
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BPHY19_CascadeVertexFitter = Trk__TrkVKalVrtFitter(
+ name = "BPHY19_CascadeVertexFit",
+ Extrapolator = BPHY19_VertexTools.InDetExtrapolator,
+ #FirstMeasuredPoint = True,
+ FirstMeasuredPoint = False,
+ CascadeCnstPrecision = 1e-6,
+ MakeExtendedVertex = True)
+
+ToolSvc += BPHY19_CascadeVertexFitter
+print(BPHY19_CascadeVertexFitter)
+
+include("DerivationFrameworkBPhys/configureConversionFinder.py")
+BPHY19_ConvTools = BPHYConversionFinderTools("BPHY19")
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysConversionFinder
+BPHY19_ConversionFinder = DerivationFramework__BPhysConversionFinder(
+ name = "BPHY19_ConversionFinder",
+ VertexFitterTool = BPHY19_ConvTools.InDetSecVxFitterTool,
+ VertexEstimator = BPHY19_ConvTools.InDetSecVtxPointEstimator,
+ DistanceTool = BPHY19_ConvTools.InDetSecVxTrkDistanceFinder,
+ ConversionPostSelector = BPHY19_ConvTools.InDetSecVtxPostSelector,
+ CascadeFitter = BPHY19_CascadeVertexFitter,
+ InputTrackParticleContainerName = "InDetTrackParticles",
+ ConversionContainerName = "BPhysConversionCandidates",
+ DiMuonVertexContainer = "BPHY19OniaCandidates",
+ PassFlagsToCheck = ["passed_Psi","passed_Upsi"],
+ RequireDeltaM = True, # Only save conversion if it's a chi_c,b candidate (passes "MaxDeltaM" cut w.r.t. any di-muon candidate)
+ MaxDeltaM = 2000.0)
+
+ToolSvc += BPHY19_ConversionFinder
+print(BPHY19_ConversionFinder)
+
+#--------------------------------------------------------------------
+# Select the events to save
+#--------------------------------------------------------------------
+
+# Require at least one conversion AND one di-muon
+BPHY19_expression = "count(BPhysConversionCandidates.passed) > 0 && (count(BPHY19OniaCandidates.passed_Psi) > 0 || count(BPHY19OniaCandidates.passed_Upsi) > 0)"
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY19_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY19_SelectEvent",
+ expression = BPHY19_expression)
+ToolSvc += BPHY19_SelectEvent
+print(BPHY19_SelectEvent)
+
+#--------------------------------------------------------------------
+# Thin Collections
+#--------------------------------------------------------------------
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+
+# Keep tracks from di-muon vertices
+BPHY19Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY19Thin_vtxTrk",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BPHY19OniaCandidates"],
+ PassFlags = ["passed_Psi", "passed_Upsi"] )
+
+ToolSvc += BPHY19Thin_vtxTrk
+
+# Keep tracks from conversions
+BPHY19Thin_ConvTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY19Thin_ConvTrk",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BPhysConversionCandidates"],
+ PassFlags = ["passed"] )
+
+ToolSvc += BPHY19Thin_ConvTrk
+
+# Keep tracks from all muons
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY19MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY19MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+
+ToolSvc += BPHY19MuonTPThinningTool
+
+#--------------------------------------------------------------------
+# Truth Particle Thinning
+#--------------------------------------------------------------------
+
+BPHY19_TruthIDString = ""
+BPHY19_TruthIDString += "TruthParticles.pdgId == 443" #J/psi
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 100443" #psi(2S)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 10441" #chi_c0(1P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 20443" #chi_c1(1P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 445" #chi_c2(1P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 553" #Y(1S)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 100553" #Y(2S)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 200553" #Y(3S)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 10551" #chi_b0(1P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 110551" #chi_b0(2P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 210551" #chi_b0(3P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 20553" #chi_b1(1P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 120553" #chi_b1(2P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 220553" #chi_b1(3P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 555" #chi_b2(1P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 100555" #chi_b2(2P)
+BPHY19_TruthIDString += " || "
+BPHY19_TruthIDString += "TruthParticles.pdgId == 200555" #chi_b2(3P)
+
+print("PDG IDs to save:")
+print(BPHY19_TruthIDString)
+
+# Only save truth informtion directly associated with Onia
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY19TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY19TruthThinTool",
+ ParticleSelectionString = BPHY19_TruthIDString,
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY19TruthThinTool
+print(BPHY19TruthThinTool)
+
+#--------------------------------------------------------------------
+# Create the derivation kernel
+#--------------------------------------------------------------------
+
+BPHY19ThinningTools = [BPHY19Thin_vtxTrk, BPHY19MuonTPThinningTool, BPHY19Thin_ConvTrk]
+if isSimulation:
+ BPHY19ThinningTools.append(BPHY19TruthThinTool)
+
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY19Kernel",
+ AugmentationTools = [BPHY19_Reco_mumu, BPHY19_Select_Psi2mumu, BPHY19_Select_Upsi2mumu,BPHY19_ConversionFinder],
+ SkimmingTools = [BPHY19_SelectEvent],
+ ThinningTools = BPHY19ThinningTools
+ )
+
+#--------------------------------------------------------------------
+# Create the stream
+#--------------------------------------------------------------------
+
+streamName = derivationFlags.WriteDAOD_BPHY19Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY19Stream )
+BPHY19Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY19Stream.AcceptAlgs(["BPHY19Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+svcMgr += createThinningSvc( svcName="BPHY19ThinningSvc", outStreams=[evtStream] )
+
+#--------------------------------------------------------------------
+# Generic Collection Slimming
+#--------------------------------------------------------------------
+
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY19SlimmingHelper = SlimmingHelper("BPHY19SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Trigger informtion
+BPHY19SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY19SlimmingHelper.IncludeBPhysTriggerContent = True
+
+## Primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY19RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY19RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## Muon container
+AllVariables += ["Muons"]
+
+## Di-muon candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY19_Reco_mumu.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY19_Reco_mumu.OutputVtxContainerName]
+
+# Conversions
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY19_ConversionFinder.ConversionContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY19_ConversionFinder.ConversionContainerName]
+
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+BPHY19SlimmingHelper.AllVariables = AllVariables
+BPHY19SlimmingHelper.StaticContent = StaticContent
+BPHY19SlimmingHelper.AppendContentToStream(BPHY19Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY2.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY2.py
new file mode 100644
index 00000000000..ea9966593f4
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY2.py
@@ -0,0 +1,332 @@
+#====================================================================
+# BPHY2.py
+# BPHY2 repurposed for students analysis of Bs->Upsilon phi Analysis
+# It requires the reductionConf flag BPHY2 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY2_VertexTools = BPHYVertexTools("BPHY2")
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__AugOriginalCounts
+BPHY2_AugOriginalCounts = DerivationFramework__AugOriginalCounts(
+ name = "BPHY2_AugOriginalCounts",
+ VertexContainer = "PrimaryVertices",
+ TrackContainer = "InDetTrackParticles" )
+ToolSvc += BPHY2_AugOriginalCounts
+
+
+#--------------------------------------------------------------------
+## 2/ setup JpsiFinder tool
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY2JpsiFinder = Analysis__JpsiFinder(name = "BPHY2JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True,
+ invMassUpper = 4700.0,
+ invMassLower = 2600.0,
+ Chi2Cut = 15.,
+ oppChargesOnly = True,
+ combOnly = True,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY2_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY2_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY2_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY2_VertexTools.VtxPointEstimator,
+ useMCPCuts = False)
+ToolSvc += BPHY2JpsiFinder
+print(BPHY2JpsiFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY2JpsiSelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY2JpsiSelectAndWrite",
+ VertexSearchTool = BPHY2JpsiFinder,
+ OutputVtxContainerName = "BPHY2JpsiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ DoVertexType =1)
+ToolSvc += BPHY2JpsiSelectAndWrite
+print(BPHY2JpsiSelectAndWrite)
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+
+
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BPHY2BsKKVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BPHY2BsKKVertexFit",
+ Extrapolator = BPHY2_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+ToolSvc += BPHY2BsKKVertexFit
+print(BPHY2BsKKVertexFit)
+
+
+
+## 5/ setup the Jpsi+2 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY2BsJpsiKK = Analysis__JpsiPlus2Tracks(name = "BPHY2BsJpsiKK",
+ OutputLevel = INFO,
+kaonkaonHypothesis = True,
+pionpionHypothesis = False,
+kaonpionHypothesis = False,
+trkThresholdPt = 800.0,
+trkMaxEta = 3.0,
+BMassUpper = 5800.0,
+BMassLower = 5000.0,
+DiTrackMassUpper = 1019.445 + 100.,
+DiTrackMassLower = 1019.445 - 100.,
+Chi2Cut = 8.0,
+TrkQuadrupletMassUpper = 6000.0,
+TrkQuadrupletMassLower = 4800.0,
+JpsiContainerKey = "BPHY2JpsiCandidates",
+TrackParticleCollection = "InDetTrackParticles",
+MuonsUsedInJpsi = "Muons",
+TrkVertexFitterTool = BPHY2BsKKVertexFit,
+TrackSelectorTool = BPHY2_VertexTools.InDetTrackSelectorTool,
+UseMassConstraint = False)
+
+ToolSvc += BPHY2BsJpsiKK
+print(BPHY2BsJpsiKK)
+
+
+
+
+## 6/ setup the combined augmentation/skimming tool for the Bpm
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY2BsKKSelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY2BsKKSelectAndWrite",
+ VertexSearchTool = BPHY2BsJpsiKK,
+ OutputVtxContainerName = "BPHY2BsJpsiKKCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY2RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000, DoVertexType = 7)
+ToolSvc += BPHY2BsKKSelectAndWrite
+print(BPHY2BsKKSelectAndWrite)
+
+
+## b/ augment and select Psi(2S)->mumu candidates
+BPHY2_Select_Psi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY2_Select_Psi2mumu",
+ HypothesisName = "Psi",
+ InputVtxContainerName = "BPHY2JpsiCandidates",
+ VtxMassHypo = 3686.09,
+ MassMin = 3300.0,
+ MassMax = 4500.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY2_Select_Psi2mumu
+print(BPHY2_Select_Psi2mumu)
+
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY2_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY2_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY2JpsiCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 2000.0,
+ MassMax = 3600.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+
+ToolSvc += BPHY2_Select_Jpsi2mumu
+print(BPHY2_Select_Jpsi2mumu)
+
+## b/ augment and select Bs->JpsiKK candidates
+BPHY2_Select_Bs2JpsiKK = DerivationFramework__Select_onia2mumu(
+ name = "BPHY2_Select_Bs2JpsiKK",
+ HypothesisName = "Bs",
+ InputVtxContainerName = "BPHY2BsJpsiKKCandidates",
+ TrkMasses = [105.658, 105.658, 493.677, 493.677],
+ VtxMassHypo = 5366.3,
+ MassMin = 5000.0,
+ MassMax = 5800.0,
+ Chi2Max = 200)
+
+ToolSvc += BPHY2_Select_Bs2JpsiKK
+print(BPHY2_Select_Bs2JpsiKK)
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY2Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY2Stream )
+BPHY2Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY2Stream.AcceptAlgs(["BPHY2Kernel"])
+
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+augStream = MSMgr.GetStream( streamName )
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY2_thinningTool_Tracks = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY2_thinningTool_Tracks",
+ TrackParticleContainerName = "InDetTrackParticles",
+ StreamName = streamName,
+ VertexContainerNames = ["BPHY2BsJpsiKKCandidates", "BPHY2JpsiCandidates"],
+ PassFlags = ["passed_Bs", "passed_Psi", "passed_Jpsi"] )
+
+ToolSvc += BPHY2_thinningTool_Tracks
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysPVThinningTool
+BPHY2_thinningTool_PV = DerivationFramework__BPhysPVThinningTool(
+ name = "BPHY2_thinningTool_PV",
+ CandidateCollections = ["BPHY2BsJpsiKKCandidates"],
+ StreamName = streamName,
+ KeepPVTracks =True)
+
+ToolSvc += BPHY2_thinningTool_PV
+
+if not isSimulation: #Only Skim Data
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+
+ BPHY2_SelectBsJpsiKKEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY2_SelectBsJpsiKKEvent",
+ expression = "count(BPHY2BsJpsiKKCandidates.passed_Bs > 0) > 0")
+ ToolSvc += BPHY2_SelectBsJpsiKKEvent
+ print(BPHY2_SelectBsJpsiKKEvent)
+
+
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools
+ #====================================================================
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+ BPHY2SkimmingOR = CfgMgr.DerivationFramework__FilterCombinationOR("BPHY2SkimmingOR",
+ FilterList = [BPHY2_SelectBsJpsiKKEvent ])#, BPHY2_SelectBplJpsiKplEventBc
+ PassFlags = ["passed_Bs"]
+ ToolSvc += BPHY2SkimmingOR
+ print(BPHY2SkimmingOR)
+
+
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY2MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY2MuonTPThinningTool",
+ MuonKey = "Muons",
+ StreamName = streamName,
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY2MuonTPThinningTool
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+thiningCollection = [BPHY2_thinningTool_Tracks, BPHY2_thinningTool_PV, BPHY2MuonTPThinningTool]
+print(thiningCollection)
+
+BPHY2Seq = CfgMgr.AthSequencer("BPHY2Sequence")
+DerivationFrameworkJob += BPHY2Seq
+
+# The name of the kernel (BPHY2Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+BPHY2Seq += CfgMgr.DerivationFramework__DerivationKernel("BPHY2Kernel",
+ AugmentationTools = [ BPHY2JpsiSelectAndWrite,
+ BPHY2BsKKSelectAndWrite,
+ BPHY2_Select_Psi2mumu,
+ BPHY2_Select_Jpsi2mumu, BPHY2_Select_Bs2JpsiKK,
+ BPHY2_AugOriginalCounts],
+ #Only skim if not MC
+ SkimmingTools = [BPHY2SkimmingOR] if not isSimulation else [],
+ ThinningTools = thiningCollection
+
+ )
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY2SlimmingHelper = SlimmingHelper("BPHY2SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY2SlimmingHelper.IncludeMuonTriggerContent = TRUE
+BPHY2SlimmingHelper.IncludeBPhysTriggerContent = TRUE
+SmartVar = []
+## primary vertices
+SmartVar += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY2RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY2RefittedPrimaryVerticesAux."]
+
+
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+
+
+## muon container
+SmartVar += ["Muons"]
+
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY2JpsiSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY2JpsiSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY2BsKKSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY2BsKKSelectAndWrite.OutputVtxContainerName]
+
+
+# Tagging information (in addition to that already requested by usual algorithms)
+AllVariables += ["MuonSpectrometerTrackParticles" ]
+
+
+
+
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles" ]
+
+
+AllVariables = list(set(AllVariables)) # remove duplicates
+
+BPHY2SlimmingHelper.AllVariables = AllVariables
+BPHY2SlimmingHelper.StaticContent = StaticContent
+BPHY2SlimmingHelper.SmartCollections = SmartVar
+
+BPHY2SlimmingHelper.AppendContentToStream(BPHY2Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY20.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY20.py
new file mode 100644
index 00000000000..1e8f6f8fd31
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY20.py
@@ -0,0 +1,775 @@
+#====================================================================
+#
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+#
+# BPHY20.py
+#
+# R_Jpsi analysis (currently muon channel only)
+#
+#====================================================================
+from AthenaCommon.AppMgr import ServiceMgr as svcMgr
+if not hasattr(svcMgr, 'ItemListSvc'): svcMgr += CfgMgr.ItemListSvc()
+svcMgr.ItemListSvc.OutputLevel = DEBUG
+
+#====================================================================
+# FLAGS TO PERSONALIZE THE DERIVATION
+#====================================================================
+
+onlyAugmentations = False # Set to True to deactivate thinning and skimming, and only keep augmentations (to generate a sample with full xAOD plus all the extra)
+thinTruth = True
+addMuExtrapolationForTrigger = True
+
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+
+from DerivationFrameworkJetEtMiss.JetCommon import *
+from DerivationFrameworkJetEtMiss.METCommon import *
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY20Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY20Stream )
+
+BPHY20Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY20Stream.AcceptAlgs(["BPHY20Kernel"])
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY20_VertexTools = BPHYVertexTools("BPHY20")
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__AugOriginalCounts
+BPHY20_AugOriginalCounts = DerivationFramework__AugOriginalCounts(
+ name = "BPHY20_AugOriginalCounts",
+ VertexContainer = "PrimaryVertices",
+ TrackContainer = "InDetTrackParticles" )
+ToolSvc += BPHY20_AugOriginalCounts
+
+#====================================================================
+# TriggerCounting for Kernel1 (from BPHY7)
+#====================================================================
+#List of trigggers to be counted (high Sig-eff*Lumi ones are in)
+triggersToMetadata= [
+### 2018
+"HLT_mu11_mu6_bJpsimumu",
+"HLT_2mu10_bJpsimumu",
+"HLT_mu6_2mu4_bJpsi",
+"HLT_3mu4_bJpsi",
+"HLT_mu11_mu6_bJpsimumu_Lxy0",
+"HLT_3mu6_bJpsi",
+"HLT_mu11_mu6_bJpsimumu_L1LFV-MU11",
+"HLT_2mu6_bJpsimumu_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+"HLT_mu11_mu6_bJpsimumu_Lxy0_L1LFV-MU11",
+"HLT_2mu6_bJpsimumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+"HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_2mu4_bJpsimumu_Lxy0_L1BPH-2M9-2MU4_BPH-0DR15-2MU4",
+"HLT_mu6_mu4_bJpsimumu_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_mu10_bJpsi_TrkPEB",
+"HLT_mu6_bJpsi_TrkPEB",
+"HLT_2mu6_bJpsimumu",
+"HLT_mu6_mu2noL1_msonly_bJpsimumu_noid_PEB",
+
+### 2017
+#HLT_2mu10_bJpsimumu
+"HLT_2mu10_bJpsimumu_noL2",
+"HLT_2mu6_bJpsimumu",
+#HLT_2mu6_bJpsimumu_L1BPH-2M9-2MU6_BPH-2DR15-2MU6
+"HLT_2mu6_bJpsimumu_Lxy0",
+#HLT_2mu6_bJpsimumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6
+#HLT_3mu4_bJpsi
+#HLT_3mu6_bJpsi
+#HLT_mu10_bJpsi_TrkPEB
+"HLT_mu10_mu6_bJpsimumu",
+"HLT_mu10_mu6_bJpsimumu_Lxy0",
+#HLT_mu11_mu6_bJpsimumu
+#HLT_mu11_mu6_bJpsimumu_Lxy0
+"HLT_mu14_bJpsi_Trkloose",
+"HLT_mu14_bJpsi_TrkPEB",
+"HLT_mu20_2mu2noL1_JpsimumuFS",
+"HLT_mu20_2mu4_JpsimumuL2",
+"HLT_mu20_bJpsi_Trkloose",
+"HLT_mu20_bJpsi_TrkPEB",
+#HLT_mu6_bJpsi_TrkPEB
+#HLT_mu6_mu4_bJpsimumu_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4
+#HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4
+
+### 2016
+#HLT_2mu10_bJpsimumu
+"HLT_2mu10_bJpsimumu_delayed",
+"HLT_2mu10_bJpsimumu_noL2",
+"HLT_2mu4_bJpsimumu_delayed_L1BPH-2M8-2MU4",
+"HLT_2mu4_bJpsimumu_L1BPH-2M8-2MU4",
+"HLT_2mu4_bJpsimumu_Lxy0_delayed_L1BPH-2M8-2MU4",
+"HLT_2mu6_bJpsimumu",
+"HLT_2mu6_bJpsimumu_delayed",
+"HLT_2mu6_bJpsimumu_delayed_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+#HLT_2mu6_bJpsimumu_L1BPH-2M9-2MU6_BPH-2DR15-2MU6
+"HLT_2mu6_bJpsimumu_Lxy0",
+"HLT_2mu6_bJpsimumu_Lxy0_delayed",
+"HLT_2mu6_bJpsimumu_Lxy0_delayed_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+#HLT_2mu6_bJpsimumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6
+#HLT_3mu4_bJpsi
+"HLT_3mu4_bJpsi_delayed",
+#HLT_3mu6_bJpsi
+"HLT_mu10_mu6_bJpsimumu",
+"HLT_mu10_mu6_bJpsimumu_delayed",
+"HLT_mu10_mu6_bJpsimumu_Lxy0",
+"HLT_mu10_mu6_bJpsimumu_Lxy0_delayed",
+"HLT_mu18_bJpsi_Trkloose",
+"HLT_mu20_2mu0noL1_JpsimumuFS",
+"HLT_mu20_2mu4_JpsimumuL2",
+#HLT_mu6_2mu4_bJpsi
+"HLT_mu6_2mu4_bJpsi_delayed",
+"HLT_mu6_mu4_bJpsimumu",
+"HLT_mu6_mu4_bJpsimumu_delayed",
+"HLT_mu6_mu4_bJpsimumu_delayed_L1BPH-2M8-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_mu6_mu4_bJpsimumu_delayed_L1MU6MU4-BO",
+"HLT_mu6_mu4_bJpsimumu_L12MU4-B",
+"HLT_mu6_mu4_bJpsimumu_L1BPH-2M8-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_mu6_mu4_bJpsimumu_L1MU6MU4-BO",
+"HLT_mu6_mu4_bJpsimumu_Lxy0",
+"HLT_mu6_mu4_bJpsimumu_Lxy0_delayed",
+"HLT_mu6_mu4_bJpsimumu_Lxy0_delayed_L1BPH-2M8-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M8-MU6MU4_BPH-0DR15-MU6MU4",
+
+### 2015
+#HLT_2mu10_bJpsimumu
+#HLT_2mu10_bJpsimumu_noL2
+"HLT_2mu10_l2msonly_bJpsimumu_noL2",
+"HLT_2mu4_bJpsimumu",
+"HLT_2mu4_bJpsimumu_noL2",
+"HLT_2mu4_l2msonly_bJpsimumu_noL2",
+#HLT_2mu6_bJpsimumu
+"HLT_2mu6_bJpsimumu_noL2",
+"HLT_2mu6_l2msonly_bJpsimumu_noL2",
+#HLT_3mu4_bJpsi
+#HLT_3mu6_bJpsi
+"HLT_mu10_mu10_l2msonly_bJpsimumu_noL2",
+"HLT_mu18_2mu0noL1_JpsimumuFS",
+"HLT_mu18_2mu4_JpsimumuL2",
+#HLT_mu18_bJpsi_Trkloose
+#HLT_mu20_2mu0noL1_JpsimumuFS
+#HLT_mu20_2mu4_JpsimumuL2
+"HLT_mu4_mu4_l2msonly_bJpsimumu_noL2",
+"HLT_mu6_l2msonly_mu4_bJpsimumu_noL2",
+"HLT_mu6_l2msonly_mu4_l2msonly_bJpsimumu_noL2",
+#HLT_mu6_mu4_bJpsimumu
+"HLT_mu6_mu4_bJpsimumu_noL2",
+"HLT_mu6_mu4_l2msonly_bJpsimumu_noL2",
+"HLT_mu6_mu6_l2msonly_bJpsimumu_noL2",
+
+"HLT_mu4","HLT_mu6","HLT_mu10","HLT_mu14","HLT_mu18","HLT_mu24" #5%
+
+ ]
+
+triggersToMetadata_filter = list( set(triggersToMetadata) )
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__TriggerCountToMetadata
+BPHY20TriggerCountToMetadata = DerivationFramework__TriggerCountToMetadata(name = "BPHY20TriggerCount",
+ TriggerList = triggersToMetadata_filter,
+ FolderName = "BPHY20")
+
+ToolSvc += BPHY20TriggerCountToMetadata
+
+#====================================================================
+# PRESELECTION for Kernel1 #Added by Matteo
+#====================================================================
+## 1/ Setup the skimming based on triggers
+##
+
+triggerList = [
+## 2018
+"HLT_mu11_mu6_bJpsimumu",
+"HLT_2mu10_bJpsimumu",
+"HLT_mu6_2mu4_bJpsi",
+"HLT_3mu4_bJpsi",
+"HLT_mu11_mu6_bJpsimumu_Lxy0",
+"HLT_3mu6_bJpsi",
+"HLT_mu11_mu6_bJpsimumu_L1LFV-MU11",
+"HLT_2mu6_bJpsimumu_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+"HLT_mu11_mu6_bJpsimumu_Lxy0_L1LFV-MU11",
+"HLT_2mu6_bJpsimumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+"HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_2mu4_bJpsimumu_Lxy0_L1BPH-2M9-2MU4_BPH-0DR15-2MU4",
+"HLT_mu6_mu4_bJpsimumu_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_mu10_bJpsi_TrkPEB",
+"HLT_mu6_bJpsi_TrkPEB",
+"HLT_2mu6_bJpsimumu",
+"HLT_mu6_mu2noL1_msonly_bJpsimumu_noid_PEB",
+
+
+"HLT_mu22_mu8noL1_TagandProbe",
+
+### 2017
+#HLT_2mu10_bJpsimumu
+"HLT_2mu10_bJpsimumu_noL2",
+"HLT_2mu6_bJpsimumu",
+#HLT_2mu6_bJpsimumu_L1BPH-2M9-2MU6_BPH-2DR15-2MU6
+"HLT_2mu6_bJpsimumu_Lxy0",
+#HLT_2mu6_bJpsimumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6
+#HLT_3mu4_bJpsi
+#HLT_3mu6_bJpsi
+#HLT_mu10_bJpsi_TrkPEB
+"HLT_mu10_mu6_bJpsimumu",
+"HLT_mu10_mu6_bJpsimumu_Lxy0",
+#HLT_mu11_mu6_bJpsimumu
+#HLT_mu11_mu6_bJpsimumu_Lxy0
+"HLT_mu14_bJpsi_Trkloose",
+"HLT_mu14_bJpsi_TrkPEB",
+"HLT_mu20_2mu2noL1_JpsimumuFS",
+"HLT_mu20_2mu4_JpsimumuL2",
+"HLT_mu20_bJpsi_Trkloose",
+"HLT_mu20_bJpsi_TrkPEB",
+#HLT_mu6_bJpsi_TrkPEB
+#HLT_mu6_mu4_bJpsimumu_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4
+#HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M9-MU6MU4_BPH-0DR15-MU6MU4
+
+### 2016
+#HLT_2mu10_bJpsimumu
+"HLT_2mu10_bJpsimumu_delayed",
+"HLT_2mu10_bJpsimumu_noL2",
+"HLT_2mu4_bJpsimumu_delayed_L1BPH-2M8-2MU4",
+"HLT_2mu4_bJpsimumu_L1BPH-2M8-2MU4",
+"HLT_2mu4_bJpsimumu_Lxy0_delayed_L1BPH-2M8-2MU4",
+"HLT_2mu6_bJpsimumu",
+"HLT_2mu6_bJpsimumu_delayed",
+"HLT_2mu6_bJpsimumu_delayed_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+#HLT_2mu6_bJpsimumu_L1BPH-2M9-2MU6_BPH-2DR15-2MU6
+"HLT_2mu6_bJpsimumu_Lxy0",
+"HLT_2mu6_bJpsimumu_Lxy0_delayed",
+"HLT_2mu6_bJpsimumu_Lxy0_delayed_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+#HLT_2mu6_bJpsimumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6
+#HLT_3mu4_bJpsi
+"HLT_3mu4_bJpsi_delayed",
+#HLT_3mu6_bJpsi
+"HLT_mu10_mu6_bJpsimumu",
+"HLT_mu10_mu6_bJpsimumu_delayed",
+"HLT_mu10_mu6_bJpsimumu_Lxy0",
+"HLT_mu10_mu6_bJpsimumu_Lxy0_delayed",
+"HLT_mu18_bJpsi_Trkloose",
+"HLT_mu20_2mu0noL1_JpsimumuFS",
+"HLT_mu20_2mu4_JpsimumuL2",
+#HLT_mu6_2mu4_bJpsi
+"HLT_mu6_2mu4_bJpsi_delayed",
+"HLT_mu6_mu4_bJpsimumu",
+"HLT_mu6_mu4_bJpsimumu_delayed",
+"HLT_mu6_mu4_bJpsimumu_delayed_L1BPH-2M8-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_mu6_mu4_bJpsimumu_delayed_L1MU6MU4-BO",
+"HLT_mu6_mu4_bJpsimumu_L12MU4-B",
+"HLT_mu6_mu4_bJpsimumu_L1BPH-2M8-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_mu6_mu4_bJpsimumu_L1MU6MU4-BO",
+"HLT_mu6_mu4_bJpsimumu_Lxy0",
+"HLT_mu6_mu4_bJpsimumu_Lxy0_delayed",
+"HLT_mu6_mu4_bJpsimumu_Lxy0_delayed_L1BPH-2M8-MU6MU4_BPH-0DR15-MU6MU4",
+"HLT_mu6_mu4_bJpsimumu_Lxy0_L1BPH-2M8-MU6MU4_BPH-0DR15-MU6MU4",
+
+### 2015
+#HLT_2mu10_bJpsimumu
+#HLT_2mu10_bJpsimumu_noL2
+"HLT_2mu10_l2msonly_bJpsimumu_noL2",
+"HLT_2mu4_bJpsimumu",
+"HLT_2mu4_bJpsimumu_noL2",
+"HLT_2mu4_l2msonly_bJpsimumu_noL2",
+#HLT_2mu6_bJpsimumu
+"HLT_2mu6_bJpsimumu_noL2",
+"HLT_2mu6_l2msonly_bJpsimumu_noL2",
+#HLT_3mu4_bJpsi
+#HLT_3mu6_bJpsi
+"HLT_mu10_mu10_l2msonly_bJpsimumu_noL2",
+"HLT_mu18_2mu0noL1_JpsimumuFS",
+"HLT_mu18_2mu4_JpsimumuL2",
+#HLT_mu18_bJpsi_Trkloose
+#HLT_mu20_2mu0noL1_JpsimumuFS
+#HLT_mu20_2mu4_JpsimumuL2
+"HLT_mu4_mu4_l2msonly_bJpsimumu_noL2",
+"HLT_mu6_l2msonly_mu4_bJpsimumu_noL2",
+"HLT_mu6_l2msonly_mu4_l2msonly_bJpsimumu_noL2",
+#HLT_mu6_mu4_bJpsimumu
+"HLT_mu6_mu4_bJpsimumu_noL2",
+"HLT_mu6_mu4_l2msonly_bJpsimumu_noL2",
+"HLT_mu6_mu6_l2msonly_bJpsimumu_noL2" ,
+
+
+
+"HLT_mu4","HLT_mu6","HLT_mu10","HLT_mu14","HLT_mu18","HLT_mu24", #5%
+
+
+"HLT_.*mu11_mu6.*", # Recent triggers
+"HLT_.*mu.*imedium.*", # Trigger with looser isolation selection
+"HLT_.*mu.*iloose.*",
+"HLT_.*mu6.*2mu4.*",
+"HLT_.*2mu.*",
+"HLT_.*mu11.*2mu4noL1.*",
+"HLT_.*2mu14_nomucomb.*",
+"HLT_.*bTau.*", # Our tau triggers
+"HLT_.*bDimu2700.*",
+"HLT_.*bPhi.*"
+ ]
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__TriggerSkimmingTool
+BPHY20TriggerSkim = DerivationFramework__TriggerSkimmingTool(name = "BPHY20TriggerSkim",
+ TriggerListOR = triggerList,
+ TriggerListAND = [] )
+
+ToolSvc += BPHY20TriggerSkim
+
+#--------------------------------------------------------------------
+# 2/ Select J/psi>mu+mu-
+#--------------------------------------------------------------------
+## a/ setup JpsiFinder tool
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY20JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY20JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True,
+ muonThresholdPt = 1000,
+ invMassUpper = 4500.0,
+ invMassLower = 2000.0,
+ Chi2Cut = 20.,
+ oppChargesOnly = True,
+# allChargeCombinations = True,
+ combOnly = False,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY20_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY20_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY20_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY20_VertexTools.VtxPointEstimator,
+ useMCPCuts = False)
+
+ToolSvc += BPHY20JpsiFinder
+print(BPHY20JpsiFinder)
+
+#--------------------------------------------------------------------
+## b/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY20JpsiSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY20JpsiSelectAndWrite",
+ VertexSearchTool = BPHY20JpsiFinder,
+ OutputVtxContainerName = "BPHY20JpsiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ DoVertexType = 1)
+
+ToolSvc += BPHY20JpsiSelectAndWrite
+print(BPHY20JpsiSelectAndWrite)
+
+#--------------------------------------------------------------------
+## c/ augment and select Jpsi->mumu candidates
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+BPHY20_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY20_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY20JpsiCandidates",
+ VtxMassHypo = 3096.900,
+ MassMin = 2000.0,
+ MassMax = 4500.0,
+ Chi2Max = 20,
+ DoVertexType = 1)
+
+ToolSvc += BPHY20_Select_Jpsi2mumu
+print(BPHY20_Select_Jpsi2mumu)
+
+#--------------------------------------------------------------------
+# 3/ select B_c+->J/psi mu
+#--------------------------------------------------------------------
+## a/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BcJpsiMuVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BcJpsiMuVertexFit",
+ Extrapolator = BPHY20_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+
+ToolSvc += BcJpsiMuVertexFit
+print(BcJpsiMuVertexFit)
+
+#--------------------------------------------------------------------
+## b/ setup the Jpsi+1 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus1Track
+BPHY20BcJpsiMu = Analysis__JpsiPlus1Track(
+ name = "BPHY20BcJpsiMu",
+ OutputLevel = INFO, #DEBUG,
+ pionHypothesis = True, #False,
+ kaonHypothesis = False,#True,
+ trkThresholdPt = 1000,
+ trkMaxEta = 3.0,
+ BThresholdPt = 1000.0,
+ BMassUpper = 6900.0,
+ BMassLower = 2000.0,
+ JpsiContainerKey = "BPHY20JpsiCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ MuonsUsedInJpsi = "Muons",
+ ExcludeCrossJpsiTracks = False,
+ TrkVertexFitterTool = BcJpsiMuVertexFit,
+ TrackSelectorTool = BPHY20_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = True,
+ RequireNMuonTracks = 1,
+ Chi2Cut = 1000, #5
+ TrkTrippletMassUpper = 6900,
+ TrkTrippletMassLower = 2000.0)
+
+ToolSvc += BPHY20BcJpsiMu
+print(BPHY20BcJpsiMu)
+
+#--------------------------------------------------------------------
+## c/ setup the combined augmentation/skimming tool for the Bc+>J/psi mu
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY20BcJpsiMuSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY20BcJpsiMuSelectAndWrite",
+ OutputLevel = INFO,
+ VertexSearchTool = BPHY20BcJpsiMu,
+ OutputVtxContainerName = "BPHY20BcJpsiMuCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY20RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 1000)
+
+ToolSvc += BPHY20BcJpsiMuSelectAndWrite
+print(BPHY20BcJpsiMuSelectAndWrite)
+
+#--------------------------------------------------------------------
+## c/ augment and select B_c+>Jpsi mu candidates
+BPHY20_Select_Bc2JpsiMu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY20_Select_Bc2JpsiMu",
+ HypothesisName = "Bc",
+ InputVtxContainerName = "BPHY20BcJpsiMuCandidates",
+ TrkMasses = [105.658, 105.658, 105.658],
+ VtxMassHypo = 6274.9,
+ MassMin = 2000.0,
+ MassMax = 6900.0,
+ Chi2Max = 1000)
+
+ToolSvc += BPHY20_Select_Bc2JpsiMu
+print(BPHY20_Select_Bc2JpsiMu)
+
+
+
+#====================================================================
+# Isolation
+#====================================================================
+
+
+#Track isolation for candidates
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__VertexTrackIsolation
+BPHY20TrackIsolationDecorator = DerivationFramework__VertexTrackIsolation(
+ name = "BPHY20TrackIsolationDecorator",
+ OutputLevel = INFO,
+ TrackIsoTool = "xAOD::TrackIsolationTool",
+ TrackContainer = "InDetTrackParticles",
+ InputVertexContainer = "BPHY20BcJpsiMuCandidates",
+ PassFlags = ["passed_Bc"] )
+
+ToolSvc += BPHY20TrackIsolationDecorator
+
+#CaloIsolationTool explicitly declared to avoid pointless warnings (it works!!!)
+from IsolationTool.IsolationToolConf import xAOD__CaloIsolationTool
+BPHY20CaloIsolationTool = xAOD__CaloIsolationTool(
+ name = "BPHY20CaloIsolationTool",
+ OutputLevel = WARNING,
+ saveOnlyRequestedCorrections = True,
+ IsoLeakCorrectionTool = "" ) #Workaround for a bug in older versions
+
+ToolSvc += BPHY20CaloIsolationTool
+
+#Calo isolation for candidates
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__VertexCaloIsolation
+BPHY20CaloIsolationDecorator = DerivationFramework__VertexCaloIsolation(
+ name = "BPHY20CaloIsolationDecorator",
+ OutputLevel = INFO,
+ CaloIsoTool = BPHY20CaloIsolationTool, #"xAOD::CaloIsolationTool",
+ TrackContainer = "InDetTrackParticles",
+ InputVertexContainer = "BPHY20BcJpsiMuCandidates",
+ CaloClusterContainer = "CaloCalTopoClusters",
+ ParticleCaloExtensionTool = "Trk::ParticleCaloExtensionTool/ParticleCaloExtensionTool",
+ PassFlags = ["passed_Bc"] )
+
+ToolSvc += BPHY20CaloIsolationDecorator
+
+
+
+#====================================================================
+# Skimming tool to select only events with the correct vertices
+#====================================================================
+
+#--------------------------------------------------------------------
+## 9/ select the event. We only want to keep events that contain certain three-mu vertices which passed certain selection.
+## Exactly like in the preselection, where only 2mu vertices are treated.
+
+#
+#expression = "count(BPHY20JpsiCandidates.x > -999.0)+count(BPHY20BcJpsiMuCandidates.x > -999.0)+ count(BPHY20BcJpsiMuCandidates.passed_Bc) >0 "
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY20_SelectBcJpsiMuEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY20_SelectBcJpsiMuEvent",
+ expression = "count(BPHY20BcJpsiMuCandidates.passed_Bc) >= 1 ")
+
+ToolSvc += BPHY20_SelectBcJpsiMuEvent
+print(BPHY20_SelectBcJpsiMuEvent)
+
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools
+ #====================================================================
+
+# from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+# BPHY20SkimmingOR = CfgMgr.DerivationFramework__FilterCombinationOR(
+# "BPHY20SkimmingOR",
+# FilterList = [BPHY20_SelectBcJpsiMuEvent] )
+# ToolSvc += BPHY20SkimmingOR
+# print BPHY20SkimmingOR
+
+
+#====================================================================
+# Add Extrapolation of muons to trigger layers
+#====================================================================
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__MuonExtrapolationTool
+BPHY20_Extrap_Tool = DerivationFramework__MuonExtrapolationTool( name = "BPHY20_ExtrapolationTool", OutputLevel = INFO )
+
+ToolSvc += BPHY20_Extrap_Tool
+
+
+
+
+
+#====================================================================
+# Thinning Helper and various thinning tools
+#====================================================================
+
+#--------------------------------------------------------------------
+## 10/ Setup the thinning helper, only tool able to perform thinning of trigger navigation information
+
+from DerivationFrameworkCore.ThinningHelper import ThinningHelper
+BPHY20ThinningHelper = ThinningHelper( "BPHY20ThinningHelper" )
+BPHY20ThinningHelper.TriggerChains = 'HLT_.*mu.*' #triggerList # . = any character; * = 0 or more times; + = 1 or more times; ? 0 or 1 times "Regular_Expression"
+BPHY20ThinningHelper.AppendToStream( BPHY20Stream )
+
+
+#--------------------------------------------------------------------
+## 11/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which haven't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## 12/ Cleans up, removing duplicate vertices. An issue caused by the logic of Jpsi+1 track in the case of 3-muon candidates
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxDuplicates
+BPHY20Thin_vtxDuplicates = DerivationFramework__Thin_vtxDuplicates(name = "BPHY20Thin_vtxDuplicates",
+ VertexContainerName = "BPHY20BcJpsiMuCandidates",
+ PassFlags = ["passed_Bc"])
+
+ToolSvc += BPHY20Thin_vtxDuplicates
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY20Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY20Thin_vtxTrk",
+ OutputLevel = INFO,
+ TrackParticleContainerName = "InDetTrackParticles",
+ AcceptanceRadius = 1.,
+ VertexContainerNames = ["BPHY20BcJpsiMuCandidates"],
+ PassFlags = ["passed_Bc"],
+ ApplyAnd = True ) # "and" requirement for Vertices
+
+ToolSvc += BPHY20Thin_vtxTrk
+
+
+## 13/ thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY20MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY20MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY20MuonTPThinningTool
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysPVThinningTool
+BPHY20_thinningTool_PV = DerivationFramework__BPhysPVThinningTool(name = "BPHY20_thinningTool_PV",
+ CandidateCollections = ["BPHY20BcJpsiMuCandidates"],
+ KeepPVTracks =True)
+
+ToolSvc += BPHY20_thinningTool_PV
+
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__TauTrackParticleThinning
+BPHY20TauTPThinningTool = DerivationFramework__TauTrackParticleThinning(name = "BPHY20TauTPThinningTool",
+ TauKey = "TauJets",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY20TauTPThinningTool
+
+# Only save truth informtion directly associated with: mu Ds+ D+ D*+ Ds*+ D0 D*0 B+ B*+ B0 B*0
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY20TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY20TruthThinTool",
+ ParticleSelectionString = "abs(TruthParticles.pdgId) == 13 || abs(TruthParticles.pdgId) == 15 || abs(TruthParticles.pdgId) == 541 || abs(TruthParticles.pdgId) == 431 || abs(TruthParticles.pdgId) == 411 || abs(TruthParticles.pdgId) == 413 || abs(TruthParticles.pdgId) == 433 || TruthParticles.pdgId == 421 || TruthParticles.pdgId == 423 || abs(TruthParticles.pdgId) == 521 || abs(TruthParticles.pdgId) == 523 || TruthParticles.pdgId == 511 || TruthParticles.pdgId == 513",
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY20TruthThinTool
+
+# Only save truth neutrino and b/c quarks information
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY20TruthThinNoChainTool = DerivationFramework__GenericTruthThinning(name = "BPHY20TruthThinNoChainTool",
+ ParticleSelectionString = "abs(TruthParticles.pdgId) == 4 || abs(TruthParticles.pdgId) == 5 || abs(TruthParticles.pdgId) == 12 || abs(TruthParticles.pdgId) == 14 || abs(TruthParticles.pdgId) == 16",
+ PreserveDescendants = False,
+ PreserveAncestors = False)
+ToolSvc += BPHY20TruthThinNoChainTool
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+BPHY20ThinningTools = [ BPHY20MuonTPThinningTool, BPHY20Thin_vtxDuplicates,
+ BPHY20Thin_vtxTrk, BPHY20_thinningTool_PV,
+ BPHY20TauTPThinningTool]
+
+BPHY20SkimmingTools = [BPHY20_SelectBcJpsiMuEvent]
+
+BPHY20AugmentationTools = [BPHY20JpsiSelectAndWrite, BPHY20_Select_Jpsi2mumu,
+ BPHY20BcJpsiMuSelectAndWrite, BPHY20_Select_Bc2JpsiMu,
+ BPHY20_AugOriginalCounts,
+ BPHY20TrackIsolationDecorator, BPHY20CaloIsolationDecorator]
+
+if addMuExtrapolationForTrigger:
+ BPHY20AugmentationTools.append(BPHY20_Extrap_Tool)
+
+Kernel1Tools = [BPHY20TriggerSkim]
+
+if isSimulation:
+ #BPHY20AugmentationTools.append(DFCommonTauTruthMatchingWrapper)
+ if thinTruth:
+ BPHY20ThinningTools.append(BPHY20TruthThinTool)
+ BPHY20ThinningTools.append(BPHY20TruthThinNoChainTool)
+
+#The sequence object. Is in principle just a wrapper which allows to run two kernels in sequence
+BPHY20_Sequence = CfgMgr.AthSequencer("BPHY20_Sequence")
+from DerivationFrameworkFlavourTag.FlavourTagCommon import FlavorTagInit
+FlavorTagInit(JetCollections=['AntiKt4EMPFlowJets'], Sequencer=BPHY20_Sequence)
+
+#onlyAugmentations implementation
+if onlyAugmentations:
+ Kernel1Tools = []
+ BPHY20SkimmingTools = []
+ BPHY20ThinningTools = []
+
+# Kernel n1 PRESELECTION
+# The name of the kernel (BPHY20Kernel1 in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+BPHY20_Sequence += CfgMgr.DerivationFramework__DerivationKernel("BPHY20Kernel_trigPresel",
+ AugmentationTools = [BPHY20TriggerCountToMetadata] ,
+ SkimmingTools = Kernel1Tools)
+# Kernel n2 deep Derivation
+# The name of the kernel (BPHY20Kernel2 in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+BPHY20_Sequence += CfgMgr.DerivationFramework__DerivationKernel("BPHY20Kernel",
+ AugmentationTools = BPHY20AugmentationTools,
+ SkimmingTools = BPHY20SkimmingTools,
+ ThinningTools = BPHY20ThinningTools)
+
+#Vital, replaces the adding of kernels directly
+DerivationFrameworkJob += BPHY20_Sequence
+
+#====================================================================
+# Slimming
+#====================================================================
+
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY20SlimmingHelper = SlimmingHelper("BPHY20SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+
+
+SmartCollections = [
+ "Photons",
+ "TauJets",
+ "AntiKt4EMTopoJets_BTagging201810",
+ "BTagging_AntiKt4EMTopo_201810",
+ "PrimaryVertices",
+ "Muons",
+ "InDetTrackParticles",
+ "MET_Reference_AntiKt4EMTopo"
+ ]
+
+
+AllVariables = ["METAssoc_AntiKt4EMTopo",
+ "MET_Core_AntiKt4EMTopo",
+ "MET_Truth",
+ "MET_Track",
+ "MET_LocHadTopo"]
+
+AllVariables += ["Kt4EMTopoOriginEventShape",
+ "Kt4EMTopoEventShape"]
+
+AllVariables += ["CombinedMuonTrackParticles",
+ "ExtrapolatedMuonTrackParticles",
+ "MuonSpectrometerTrackParticles"]
+
+
+ExtraVariables = ["Photons.pt.eta.phi.m",
+ "Electrons.pt.eta.phi.m","TauJets.pt.eta.phi.m.IsTruthMatched.truthJetLink.truthParticleLink",
+ "AntiKt4EMTopoJets_BTagging201810.JetPileupScaleMomentum_pt.JetPileupScaleMomentum_eta.JetPileupScaleMomentum_phi.JetPileupScaleMomentum_m",
+ "AntiKt4EMTopoJets_BTagging201810.JvtJvfcorr.HECFrac.LArQuality.HECQuality.NegativeE.AverageLArQF",
+ "AntiKt4EMTopoJets_BTagging201810.JetEtaJESScaleMomentum_pt.JetEtaJESScaleMomentum_eta.JetEtaJESScaleMomentum_phi.JetEtaJESScaleMomentum_m"]
+
+ExtraVariables += ["Muons.etaLayer1Hits.etaLayer2Hits.etaLayer3Hits.etaLayer4Hits.phiLayer1Hits.phiLayer2Hits.phiLayer3Hits.phiLayer4Hits",
+ "Muons.numberOfTriggerEtaLayers.numberOfPhiLayers",
+ "CombinedMuonTrackParticles.numberOfTRTHits.numberOfTRTHighThresholdHits",
+ "InDetTrackParticles.numberOfTRTHits.numberOfTRTHighThresholdHits.vx.vy.vz",
+ "PrimaryVertices.chiSquared.covariance"]
+
+
+StaticContent = ["xAOD::VertexContainer#BPHY20RefittedPrimaryVertices",
+ "xAOD::VertexAuxContainer#BPHY20RefittedPrimaryVerticesAux."]
+
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY20JpsiSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY20JpsiSelectAndWrite.OutputVtxContainerName]
+
+## Bc+>J/psi Mu+ candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY20BcJpsiMuSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY20BcJpsiMuSelectAndWrite.OutputVtxContainerName]
+
+
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles", "METMap_Truth"]
+ SmartCollections += ["AntiKt4TruthJets"]
+
+# Needed for trigger objects
+BPHY20SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY20SlimmingHelper.IncludeBPhysTriggerContent = True
+
+# Pass all lists to the SlimmingHelper
+BPHY20SlimmingHelper.ExtraVariables = ExtraVariables
+BPHY20SlimmingHelper.AllVariables = AllVariables
+BPHY20SlimmingHelper.StaticContent = StaticContent
+BPHY20SlimmingHelper.SmartCollections = SmartCollections
+BPHY20SlimmingHelper.AppendContentToStream(BPHY20Stream)
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY21.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY21.py
new file mode 100644
index 00000000000..def21d405a7
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY21.py
@@ -0,0 +1,329 @@
+#2019/11/18
+#====================================================================
+# BPHY21.py
+# W -> (J/psi + D_s)
+# It requires the reductionConf flag BPHY21 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY21_VertexTools = BPHYVertexTools("BPHY21")
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__AugOriginalCounts
+BPHY21_AugOriginalCounts = DerivationFramework__AugOriginalCounts(
+ name = "BPHY21_AugOriginalCounts",
+ VertexContainer = "PrimaryVertices",
+ TrackContainer = "InDetTrackParticles" )
+ToolSvc += BPHY21_AugOriginalCounts
+
+#====================================================================
+# TriggerCounting for Kernel1
+#====================================================================
+#List of trigggers to be counted
+BPHY21_triggersToMetadata= [
+ "HLT_2mu10",
+ "HLT_2mu10_nomucomb",
+ "HLT_2mu14",
+ "HLT_2mu14_nomucomb",
+ "HLT_mu18_mu8noL1",
+ "HLT_mu18_nomucomb_mu8noL1",
+ "HLT_mu20_mu8noL1",
+ "HLT_mu20_nomucomb_mu8noL1",
+ "HLT_mu22_mu8noL1",
+ "HLT_mu22_nomucomb_mu8noL1",
+ "HLT_mu20_mu8noL1",
+ "HLT_mu24_mu8noL1",
+ "HLT_mu10_mu6_bJpsimumu",
+ "HLT_mu22_mu8noL1_calotag_0eta010_L1MU1"
+ ]
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__TriggerCountToMetadata
+BPHY21_TriggerCountToMetadata = DerivationFramework__TriggerCountToMetadata(name = "BPHY21_TriggerCount",
+ TriggerList = BPHY21_triggersToMetadata,
+ FolderName = "BPHY21")
+
+ToolSvc += BPHY21_TriggerCountToMetadata
+
+#====================================================================
+
+
+#====================================================================
+#====================================================================
+## 1/ Setup the skimming based on triggers
+##
+
+BPHY21_triggerList = [
+ "HLT_2mu10",
+ "HLT_2mu10_nomucomb",
+ "HLT_2mu14",
+ "HLT_2mu14_nomucomb",
+ "HLT_mu18_mu8noL1",
+ "HLT_mu18_nomucomb_mu8noL1",
+ "HLT_mu20_mu8noL1",
+ "HLT_mu20_nomucomb_mu8noL1",
+ "HLT_mu22_mu8noL1",
+ "HLT_mu22_nomucomb_mu8noL1",
+ "HLT_mu20_mu8noL1",
+ "HLT_mu24_mu8noL1",
+ "HLT_mu10_mu6_bJpsimumu",
+ "HLT_mu22_mu8noL1_calotag_0eta010_L1MU1"
+ ]
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__TriggerSkimmingTool
+BPHY21_TriggerSkim = DerivationFramework__TriggerSkimmingTool(name = "BPHY21_TriggerSkim",
+ TriggerListOR = BPHY21_triggerList)
+
+ToolSvc += BPHY21_TriggerSkim
+
+
+#--------------------------------------------------------------------
+# 2/ Select J/psi>mu+mu-
+#--------------------------------------------------------------------
+## a/ setup JpsiFinder tool
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY21_JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY21_JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True,
+ muonThresholdPt = 2700,
+ invMassUpper = 3400.0,
+ invMassLower = 2800.0,
+ Chi2Cut = 10.,
+ oppChargesOnly = True,
+ combOnly = True,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY21_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY21_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY21_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY21_VertexTools.VtxPointEstimator,
+ useMCPCuts = False)
+
+ToolSvc += BPHY21_JpsiFinder
+print(BPHY21_JpsiFinder)
+
+#--------------------------------------------------------------------
+## b/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY21_JpsiSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY21_JpsiSelectAndWrite",
+ VertexSearchTool = BPHY21_JpsiFinder,
+ OutputVtxContainerName = "BPHY21_JpsiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ DoVertexType = 1)
+
+ToolSvc += BPHY21_JpsiSelectAndWrite
+print(BPHY21_JpsiSelectAndWrite)
+
+#--------------------------------------------------------------------
+## c/ augment and select Jpsi->mumu candidates
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+BPHY21_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY21_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY21_JpsiCandidates",
+ VtxMassHypo = 3096.900,
+ MassMin = 2600.0,
+ MassMax = 3600.0,
+ Chi2Max = 200,
+ LxyMin = 0.1,
+ DoVertexType = 1)
+
+ToolSvc += BPHY21_Select_Jpsi2mumu
+print(BPHY21_Select_Jpsi2mumu)
+
+
+#--------------------------------------------------------------------
+
+BPHY21_CascadeCollections = []
+
+
+#--------------------------------------------------------------------
+
+
+if not isSimulation: #Only Skim Data
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+ BPHY21_SelectJpsiEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY21_SelectJpsiEvent",
+ expression = "count(BPHY21_JpsiCandidates.passed_Jpsi) > 0")
+
+ ToolSvc += BPHY21_SelectJpsiEvent
+ print(BPHY21_SelectJpsiEvent)
+
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools
+ #====================================================================
+
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+ BPHY21_SkimmingOR = CfgMgr.DerivationFramework__FilterCombinationOR(
+ "BPHY21_SkimmingOR",
+ FilterList = [ BPHY21_TriggerSkim, BPHY21_SelectJpsiEvent] )
+ ToolSvc += BPHY21_SkimmingOR
+ print(BPHY21_SkimmingOR)
+
+#--------------------------------------------------------------------
+##10/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY21_thinningTool_Tracks = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY21_thinningTool_Tracks",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BPHY21_JpsiCandidates"],
+ PassFlags = ["passed_Jpsi"])
+
+ToolSvc += BPHY21_thinningTool_Tracks
+print(BPHY21_thinningTool_Tracks)
+'''
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysPVThinningTool
+BPHY21_thinningTool_PV = DerivationFramework__BPhysPVThinningTool(
+ name = "BPHY21_thinningTool_PV",
+ CandidateCollections = ["BPHY21_JpsiCandidates"],
+ KeepPVTracks = True)
+
+ToolSvc += BPHY21_thinningTool_PV
+print BPHY21_thinningTool_PV
+'''
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY21_MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(
+ name = "BPHY21_MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+
+ToolSvc += BPHY21_MuonTPThinningTool
+print(BPHY21_MuonTPThinningTool)
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+BPHY21_thiningCollection = []
+
+print(BPHY21_thiningCollection)
+
+# The name of the kernel (BPHY21_Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY21_Kernel",
+ AugmentationTools = [BPHY21_JpsiSelectAndWrite, BPHY21_Select_Jpsi2mumu,
+
+ BPHY21_AugOriginalCounts],
+ #Only skim if not MC
+ SkimmingTools = [BPHY21_SkimmingOR] if not isSimulation else [],
+ ThinningTools = BPHY21_thiningCollection
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+BPHY21_streamName = derivationFlags.WriteDAOD_BPHY21Stream.StreamName
+BPHY21_fileName = buildFileName( derivationFlags.WriteDAOD_BPHY21Stream )
+BPHY21_Stream = MSMgr.NewPoolRootStream( BPHY21_streamName, BPHY21_fileName )
+BPHY21_Stream.AcceptAlgs(["BPHY21_Kernel"])
+
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+BPHY21_augStream = MSMgr.GetStream( BPHY21_streamName )
+BPHY21_evtStream = BPHY21_augStream.GetEventStream()
+
+BPHY21_ThinningSvc = createThinningSvc( svcName="BPHY21_ThinningSvc", outStreams=[BPHY21_evtStream] )
+svcMgr += BPHY21_ThinningSvc
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY21_SlimmingHelper = SlimmingHelper("BPHY21_SlimmingHelper")
+BPHY21_AllVariables = []
+BPHY21_StaticContent = []
+
+# Needed for trigger objects
+BPHY21_SlimmingHelper.IncludeMuonTriggerContent = TRUE
+BPHY21_SlimmingHelper.IncludeBPhysTriggerContent = TRUE
+
+## primary vertices
+BPHY21_AllVariables += ["PrimaryVertices"]
+BPHY21_StaticContent += ["xAOD::VertexContainer#BPHY21_RefittedPrimaryVertices"]
+BPHY21_StaticContent += ["xAOD::VertexAuxContainer#BPHY21_RefittedPrimaryVerticesAux."]
+
+## ID track particles
+BPHY21_AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+BPHY21_AllVariables += ["CombinedMuonTrackParticles"]
+BPHY21_AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+BPHY21_AllVariables += ["Muons"]
+
+
+## Jpsi candidates
+BPHY21_StaticContent += ["xAOD::VertexContainer#%s" % BPHY21_JpsiSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY21_StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY21_JpsiSelectAndWrite.OutputVtxContainerName]
+
+
+# Tagging information (in addition to that already requested by usual algorithms)
+#AllVariables += ["GSFTrackParticles", "MuonSpectrometerTrackParticles" ]
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ BPHY21_AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+
+BPHY21_AllVariables = list(set(BPHY21_AllVariables)) # remove duplicates
+
+BPHY21_SlimmingHelper.AllVariables = BPHY21_AllVariables
+BPHY21_SlimmingHelper.StaticContent = BPHY21_StaticContent
+BPHY21_SlimmingHelper.SmartCollections = []
+
+BPHY21_SlimmingHelper.AppendContentToStream(BPHY21_Stream)
+
+#====================================================================
+# END OF BPHY21.py
+#====================================================================
\ No newline at end of file
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY22.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY22.py
new file mode 100644
index 00000000000..791a4f5b028
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY22.py
@@ -0,0 +1,22 @@
+#====================================================================
+# BPHY22.py
+# This an example job options script showing how to set up a
+# derivation of the data using the derivation framework.
+# It requires the reductionConf flag BPHY12 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+# This is a dummy file thus just printing something
+
+print("")
+print("BPHY22 dummy file ... doing nothing.")
+print("")
+print("Please make sure that all local variables in this python")
+print("script are prefixed by BPHY22_ in order to avoid collisions")
+print("in case this derivation format is run in a train with others.")
+print("Please ensure that it is python3 compatible e.g. by using")
+print("print() instead of just print withouth parentheses.")
+print("")
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY3.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY3.py
new file mode 100644
index 00000000000..20f69848280
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY3.py
@@ -0,0 +1,284 @@
+#====================================================================
+# BPHY3.py
+# This an example job options script showing how to set up a
+# derivation of the data using the derivation framework.
+# It requires the reductionConf flag BPHY3 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+#include( "JpsiUpsilonTools/configureServices.py" )
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY3_VertexTools = BPHYVertexTools("BPHY3")
+
+#--------------------------------------------------------------------
+## 2/ Setup the vertex fitter tools (e.g. JpsiFinder, JpsiPlus1Track, etc).
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY3JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY3JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = False,
+ muAndTrack = False,
+ TrackAndTrack = True,
+ assumeDiMuons = False, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ invMassUpper = 10000.0,
+ invMassLower = 0.0,
+ Chi2Cut = 100.,
+ oppChargesOnly = True,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY3_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY3_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY3_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY3_VertexTools.VtxPointEstimator,
+ useMCPCuts = False,
+ track1Mass = 139.57, # Not very important, only used to calculate inv. mass cut, leave it loose here
+ track2Mass = 139.57)
+
+ToolSvc += BPHY3JpsiFinder
+print(BPHY3JpsiFinder)
+
+#--------------------------------------------------------------------
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY3_Reco_diTrk = DerivationFramework__Reco_Vertex(
+ name = "BPHY3_Reco_diTrk",
+ VertexSearchTool = BPHY3JpsiFinder,
+ OutputVtxContainerName = "BPHY3VertexCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY3RefittedPrimaryVertices")
+
+ToolSvc += BPHY3_Reco_diTrk
+print(BPHY3_Reco_diTrk)
+#--------------------------------------------------------------------
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+#--------------------------------------------------------------------
+## a/ augment and select X->pi+pi- candidates
+BPHY3_Select_PiPi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY3_Select_PiPi",
+ HypothesisName = "PiPi",
+ InputVtxContainerName = "BPHY3VertexCandidates",
+ TrkMasses = [139.57,139.57],
+ VtxMassHypo = 497.614,
+ MassMin = 300.0,
+ MassMax = 700.0,
+ Chi2Max = 20)
+
+ToolSvc += BPHY3_Select_PiPi
+print(BPHY3_Select_PiPi)
+#--------------------------------------------------------------------
+
+#--------------------------------------------------------------------
+## a/ augment and select X->piK candidates
+BPHY3_Select_PiK = DerivationFramework__Select_onia2mumu(
+ name = "BPHY3_Select_PiK",
+ HypothesisName = "PiK",
+ InputVtxContainerName = "BPHY3VertexCandidates",
+ TrkMasses = [139.57,493.677],
+ VtxMassHypo = 892.,
+ MassMin = 0.0,
+ MassMax = 3500.0,
+ Chi2Max = 10)
+
+ToolSvc += BPHY3_Select_PiK
+print(BPHY3_Select_PiK)
+#--------------------------------------------------------------------
+
+#--------------------------------------------------------------------
+## a/ augment and select X->KPi candidates
+BPHY3_Select_KPi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY3_Select_KPi",
+ HypothesisName = "KPi",
+ InputVtxContainerName = "BPHY3VertexCandidates",
+ TrkMasses = [493.677,139.57],
+ VtxMassHypo = 892.,
+ MassMin = 0.0,
+ MassMax = 3500.0,
+ Chi2Max = 10)
+
+ToolSvc += BPHY3_Select_KPi
+print(BPHY3_Select_KPi)
+#--------------------------------------------------------------------
+
+
+#--------------------------------------------------------------------
+## a/ augment and select X->K+K- candidates
+BPHY3_Select_KK = DerivationFramework__Select_onia2mumu(
+ name = "BPHY3_Select_KK",
+ HypothesisName = "KK",
+ InputVtxContainerName = "BPHY3VertexCandidates",
+ TrkMasses = [493.677,493.677],
+ VtxMassHypo = 1019.461,
+ MassMin = 0.0,
+ MassMax = 1100.0,
+ Chi2Max = 20)
+
+ToolSvc += BPHY3_Select_KK
+print(BPHY3_Select_KK)
+#--------------------------------------------------------------------
+
+#--------------------------------------------------------------------
+## a/ augment and select X->ppbar candidates
+BPHY3_Select_PP = DerivationFramework__Select_onia2mumu(
+ name = "BPHY3_Select_PP",
+ HypothesisName = "PP",
+ InputVtxContainerName = "BPHY3VertexCandidates",
+ TrkMasses = [938.272,938.272],
+ VtxMassHypo = 3096.916,
+ MassMin = 2800.0,
+ MassMax = 3600.0,
+ Chi2Max = 1)
+
+ToolSvc += BPHY3_Select_PP
+print(BPHY3_Select_PP)
+#--------------------------------------------------------------------
+
+
+#--------------------------------------------------------------------
+## 5/ select the event. We only want to keep events that contain certain vertices which passed certain selection.
+## This is specified by the "SelectionExpression" property, which contains the expression in the following format:
+##
+## "ContainerName.passed_HypoName > count"
+##
+## where "ContainerName" is output container form some Reco_* tool, "HypoName" is the hypothesis name setup in some "Select_*"
+## tool and "count" is the number of candidates passing the selection you want to keep.
+
+expression = "count(BPHY3VertexCandidates.passed_PiPi) > 0 || count(BPHY3VertexCandidates.passed_KPi) > 0 || count(BPHY3VertexCandidates.passed_PiK) > 0 || count(BPHY3VertexCandidates.passed_KK) > 0 || count(BPHY3VertexCandidates.passed_PP) > 0"
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY3_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY3_SelectEvent",
+ expression = expression)
+ToolSvc += BPHY3_SelectEvent
+print(BPHY3_SelectEvent)
+
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY3Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY3Stream )
+BPHY3Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY3Stream.AcceptAlgs(["BPHY3Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+
+
+
+
+#--------------------------------------------------------------------
+## 6/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY3Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY3Thin_vtxTrk",
+ TrackParticleContainerName = "InDetTrackParticles",
+ VertexContainerNames = ["BPHY3VertexCandidates"],
+ StreamName = streamName,
+ PassFlags = ["passed_PiPi","passed_KPi","passed_PiK","passed_KK","passed_PP"])
+
+ToolSvc += BPHY3Thin_vtxTrk
+
+
+
+# Added by ASC
+# Only save truth informtion directly associated with Onia
+#from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+#BPHY1TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY1TruthThinTool",
+# ParticleSelectionString = "TruthParticles.pdgId == 443 || TruthParticles.pdgId == 100443",
+# PreserveDescendants = True,
+# PreserveAncestors = True)
+#ToolSvc += BPHY1TruthThinTool
+#print BPHY1TruthThinTool
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+## 7/ IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel! If you don't do that, they will not be
+## be executed!
+
+# Added by ASC
+BPHY3ThinningTools = [BPHY3Thin_vtxTrk]
+#if globalflags.DataSource()=='geant4':
+# BPHY3ThinningTools.append(BPHY3TruthThinTool)
+
+# The name of the kernel (BPHY1Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY3Kernel",
+ AugmentationTools = [BPHY3_Reco_diTrk,BPHY3_Select_PiPi,BPHY3_Select_KPi,BPHY3_Select_PiK,BPHY3_Select_KK,BPHY3_Select_PP],
+ SkimmingTools = [BPHY3_SelectEvent],
+ ThinningTools = BPHY3ThinningTools
+
+ )
+
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY3SlimmingHelper = SlimmingHelper("BPHY3SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+#BPHY3SlimmingHelper.IncludeMuonTriggerContent = True
+#BPHY3SlimmingHelper.IncludeBPhysTriggerContent = True
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+#StaticContent += ["xAOD::VertexContainer#BPHY3RefittedPrimaryVertices"]
+#StaticContent += ["xAOD::VertexAuxContainer#BPHY3RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## Vertex candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY3_Reco_diTrk.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY3_Reco_diTrk.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY3_Reco_diTrk.OutputVtxContainerName]
+
+# Added by ASC
+# Truth information for MC only
+#if isSimulation:
+# AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+BPHY3SlimmingHelper.AllVariables = AllVariables
+BPHY3SlimmingHelper.StaticContent = StaticContent
+BPHY3SlimmingHelper.AppendContentToStream(BPHY3Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY4.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY4.py
new file mode 100644
index 00000000000..9a973b28e4d
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY4.py
@@ -0,0 +1,155 @@
+#====================================================================
+# BPHY4.py
+#====================================================================
+#ServiceMgr.MessageSvc.debugLimit=100000000
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY4_VertexTools = BPHYVertexTools("BPHY4")
+
+#--------------------------------------------------------------------
+## 2/ Setup the vertex fitter tools
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__FourMuonTool
+BPHY4FourMuonTool = DerivationFramework__FourMuonTool(
+ name = "BPHY4FourMuonTool",
+ OutputLevel = INFO,
+ ptCut = 2500.0,
+ etaCut = 2.5,
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY4_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY4_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY4_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY4_VertexTools.VtxPointEstimator)
+
+ToolSvc += BPHY4FourMuonTool
+print(BPHY4FourMuonTool)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s).
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_4mu
+BPHY4_Reco_4mu = DerivationFramework__Reco_4mu(
+ name = "BPHY4_Reco_4mu",
+ OutputLevel = INFO,
+ FourMuonTool = BPHY4FourMuonTool,
+ PairContainerName = "BPHY4Pairs",
+ QuadrupletContainerName = "BPHY4Quads",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY4RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 100000,
+ DoVertexType = 7)
+
+ToolSvc += BPHY4_Reco_4mu
+print(BPHY4_Reco_4mu)
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY4Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY4Stream )
+BPHY4Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY4Stream.AcceptAlgs(["BPHY4Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+
+augStream = MSMgr.GetStream( streamName )
+
+
+#--------------------------------------------------------------------
+## thinning out tracks that are not attached to muons/electrons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY4MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY4MuonTPThinningTool",
+ MuonKey = "Muons",
+ StreamName = streamName,
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY4MuonTPThinningTool
+BPHY4ThinningTools = [BPHY4MuonTPThinningTool]
+
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__EgammaTrackParticleThinning
+BPHY4ElectronTPThinningTool = DerivationFramework__EgammaTrackParticleThinning(name = "BPHY4ElectronTPThinningTool",
+ SGKey = "Electrons",
+ GSFTrackParticlesKey = "GSFTrackParticles",
+ StreamName = streamName,
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY4ElectronTPThinningTool
+BPHY4ThinningTools += [BPHY4ElectronTPThinningTool]
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+# The name of the kernel (BPHY4Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY4Kernel",
+ SkimmingTools = [BPHY4_Reco_4mu],
+ ThinningTools = BPHY4ThinningTools
+ )
+
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY4SlimmingHelper = SlimmingHelper("BPHY4SlimmingHelper")
+BPHY4AllVariables = []
+BPHY4SmartVariables = []
+BPHY4StaticContent = []
+
+# Needed for trigger objects
+BPHY4SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY4SlimmingHelper.IncludeBPhysTriggerContent = True
+
+## primary vertices
+BPHY4AllVariables += ["PrimaryVertices"]
+BPHY4StaticContent += ["xAOD::VertexContainer#BPHY4RefittedPrimaryVertices"]
+BPHY4StaticContent += ["xAOD::VertexAuxContainer#BPHY4RefittedPrimaryVerticesAux."]
+
+## ID track particles
+BPHY4AllVariables += ["InDetTrackParticles"]
+BPHY4SmartVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+BPHY4AllVariables += ["CombinedMuonTrackParticles"]
+BPHY4AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+BPHY4AllVariables += ["Muons"]
+BPHY4SmartVariables += ["Muons"]
+
+## Electron container
+BPHY4SmartVariables += ["Electrons"]
+
+## Pair/quad candidates
+BPHY4StaticContent += ["xAOD::VertexContainer#%s" % BPHY4_Reco_4mu.PairContainerName]
+BPHY4StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY4_Reco_4mu.PairContainerName]
+BPHY4StaticContent += ["xAOD::VertexContainer#%s" % BPHY4_Reco_4mu.QuadrupletContainerName]
+BPHY4StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY4_Reco_4mu.QuadrupletContainerName]
+
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+BPHY4StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY4_Reco_4mu.PairContainerName]
+BPHY4StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY4_Reco_4mu.QuadrupletContainerName]
+
+BPHY4SlimmingHelper.AllVariables = BPHY4AllVariables
+BPHY4SlimmingHelper.StaticContent = BPHY4StaticContent
+BPHY4SlimmingHelper.SmartCollections = BPHY4SmartVariables
+BPHY4SlimmingHelper.AppendContentToStream(BPHY4Stream)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY5.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY5.py
new file mode 100644
index 00000000000..0b041d9fc3e
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY5.py
@@ -0,0 +1,558 @@
+#====================================================================
+# BPHY5.py
+# Bs>J/psiKK
+# It requires the reductionConf flag BPHY5 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print( isSimulation )
+
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+#include( "JpsiUpsilonTools/configureServices.py" )
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY5_VertexTools = BPHYVertexTools("BPHY5")
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__AugOriginalCounts
+BPHY5_AugOriginalCounts = DerivationFramework__AugOriginalCounts(
+ name = "BPHY5_AugOriginalCounts",
+ VertexContainer = "PrimaryVertices",
+ TrackContainer = "InDetTrackParticles" )
+ToolSvc += BPHY5_AugOriginalCounts
+
+
+#--------------------------------------------------------------------
+## 2/ setup JpsiFinder tool
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY5JpsiFinder = Analysis__JpsiFinder(name = "BPHY5JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True,
+ invMassUpper = 3600.0,
+ invMassLower = 2600.0,
+ Chi2Cut = 30.,
+ oppChargesOnly = True,
+ combOnly = True,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY5_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY5_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY5_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY5_VertexTools.VtxPointEstimator,
+ useMCPCuts = False)
+ToolSvc += BPHY5JpsiFinder
+print (BPHY5JpsiFinder)
+
+#--------------------------------------------------------------------
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY5JpsiSelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY5JpsiSelectAndWrite",
+ VertexSearchTool = BPHY5JpsiFinder,
+ OutputVtxContainerName = "BPHY5JpsiCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED",
+ DoVertexType =1)
+ToolSvc += BPHY5JpsiSelectAndWrite
+print (BPHY5JpsiSelectAndWrite)
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY5_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY5_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY5JpsiCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 2000.0,
+ MassMax = 3600.0,
+ Chi2Max = 200, Do3d = False,
+ DoVertexType =1)
+
+
+ToolSvc += BPHY5_Select_Jpsi2mumu
+print (BPHY5_Select_Jpsi2mumu)
+
+
+
+
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BsKKVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BsKKVertexFit",
+ Extrapolator = BPHY5_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = False,
+ MakeExtendedVertex = True)
+ToolSvc += BsKKVertexFit
+print (BsKKVertexFit)
+
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BplKplVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BplKplVertexFit",
+ Extrapolator = BPHY5_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = False,
+ MakeExtendedVertex = True)
+ToolSvc += BplKplVertexFit
+print (BplKplVertexFit)
+
+#Add the B to pi pi Jpsi X final states
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BpipiXVertexFit = Trk__TrkVKalVrtFitter(
+ name = "BpipiXVertexFit",
+ Extrapolator = BPHY5_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = False,
+ MakeExtendedVertex = True)
+ToolSvc += BpipiXVertexFit
+print (BpipiXVertexFit)
+
+## 5/ setup the Jpsi+2 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY5BsJpsiKK = Analysis__JpsiPlus2Tracks(name = "BPHY5BsJpsiKK",
+ OutputLevel = INFO,
+kaonkaonHypothesis = True,
+pionpionHypothesis = False,
+kaonpionHypothesis = False,
+trkThresholdPt = 800.0,
+trkMaxEta = 3.0,
+BMassUpper = 5800.0,
+BMassLower = 5000.0,
+#DiTrackMassUpper = 1019.445 + 100.,
+#DiTrackMassLower = 1019.445 - 100.,
+Chi2Cut = 15.0,
+TrkQuadrupletMassUpper = 6000.0,
+TrkQuadrupletMassLower = 4800.0,
+JpsiContainerKey = "BPHY5JpsiCandidates",
+TrackParticleCollection = "InDetTrackParticles",
+MuonsUsedInJpsi = "Muons",
+TrkVertexFitterTool = BsKKVertexFit,
+TrackSelectorTool = BPHY5_VertexTools.InDetTrackSelectorTool,
+UseMassConstraint = True)
+
+ToolSvc += BPHY5BsJpsiKK
+print (BPHY5BsJpsiKK)
+
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY5BdJpsiKst = Analysis__JpsiPlus2Tracks(
+ name = "BPHY5BdJpsiKst",
+ OutputLevel = INFO,
+ kaonkaonHypothesis = False,
+ pionpionHypothesis = False,
+ kaonpionHypothesis = True,
+ trkThresholdPt = 800.0,
+ trkMaxEta = 3.0,
+ BThresholdPt = 5000.,
+ BMassLower = 4300.0,
+ BMassUpper = 6300.0,
+ JpsiContainerKey = "BPHY5JpsiCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ #MuonsUsedInJpsi = "Muons", #Don't remove all muons, just those in J/psi candidate (see the following cut)
+ ExcludeCrossJpsiTracks = False, #setting this to False rejects the muons from J/psi candidate
+ TrkVertexFitterTool = BsKKVertexFit,
+ TrackSelectorTool = BPHY5_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY5_VertexTools.VtxPointEstimator,
+ UseMassConstraint = True,
+ Chi2Cut = 15.0,
+ TrkQuadrupletMassLower = 3500.0,
+ TrkQuadrupletMassUpper = 6800.0,
+ )
+
+ToolSvc += BPHY5BdJpsiKst
+print (BPHY5BdJpsiKst)
+
+
+## 5a/ setup the Jpsi+1 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus1Track
+BPHY5BplJpsiKpl = Analysis__JpsiPlus1Track(name = "BPHY5BplJpsiKpl",
+OutputLevel = INFO,#DEBUG,
+pionHypothesis = True,
+kaonHypothesis = True,
+trkThresholdPt = 750.0,
+trkMaxEta = 3.0,
+BThresholdPt = 4000.0,
+BMassUpper = 7000.0,
+BMassLower = 4500.0,
+Chi2Cut = 15.0,
+TrkTrippletMassUpper = 8000,
+TrkTrippletMassLower = 4000,
+JpsiContainerKey = "BPHY5JpsiCandidates",
+TrackParticleCollection = "InDetTrackParticles",
+MuonsUsedInJpsi = "Muons",
+TrkVertexFitterTool = BplKplVertexFit,
+TrackSelectorTool = BPHY5_VertexTools.InDetTrackSelectorTool,
+UseMassConstraint = True,
+ExcludeCrossJpsiTracks = False,
+ExcludeJpsiMuonsOnly = True)
+
+ToolSvc += BPHY5BplJpsiKpl
+print (BPHY5BplJpsiKpl)
+
+## 5b/ setup the Jpsi+pi+pi+X track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus2Tracks
+BPHY5BJpsipipiX = Analysis__JpsiPlus2Tracks(name = "BPHY5BJpsipipiX",
+ OutputLevel = INFO,
+kaonkaonHypothesis = False,
+pionpionHypothesis = True,
+kaonpionHypothesis = False,
+trkThresholdPt = 800.0,
+trkMaxEta = 3.0,
+BMassUpper = 5800.0,
+BMassLower = 3400.0,
+#DiTrackMassUpper = 1019.445 + 100.,
+#DiTrackMassLower = 1019.445 - 100.,
+Chi2Cut = 15.0,
+TrkQuadrupletMassUpper = 5800.0,
+TrkQuadrupletMassLower = 3400.0,
+JpsiContainerKey = "BPHY5JpsiCandidates",
+TrackParticleCollection = "InDetTrackParticles",
+MuonsUsedInJpsi = "Muons",
+TrkVertexFitterTool = BpipiXVertexFit,
+TrackSelectorTool = BPHY5_VertexTools.InDetTrackSelectorTool,
+UseMassConstraint = True,
+ExcludeCrossJpsiTracks = False,
+ExcludeJpsiMuonsOnly = True)
+
+ToolSvc += BPHY5BJpsipipiX
+print (BPHY5BJpsipipiX)
+
+## 6/ setup the combined augmentation/skimming tool for the Bpm
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY5BsKKSelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY5BsKKSelectAndWrite",
+ VertexSearchTool = BPHY5BsJpsiKK,
+ OutputVtxContainerName = "BPHY5BsJpsiKKCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY5RefittedPrimaryVertices",
+ RefitPV = True, Do3d = False,
+ MaxPVrefit = 10000, DoVertexType = 7)
+ToolSvc += BPHY5BsKKSelectAndWrite
+print (BPHY5BsKKSelectAndWrite)
+
+BPHY5BplKplSelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY5BplKplSelectAndWrite",
+ VertexSearchTool = BPHY5BplJpsiKpl,
+ OutputVtxContainerName = "BPHY5BpmJpsiKpmCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY5RefBplJpsiKplPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000 )
+ToolSvc += BPHY5BplKplSelectAndWrite
+print (BPHY5BplKplSelectAndWrite)
+
+BPHY5BpipiXSelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY5BpipiXSelectAndWrite",
+ VertexSearchTool = BPHY5BJpsipipiX,
+ OutputVtxContainerName = "BPHY5BJpsipipiXCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY5RefittedBPipiPrimaryVertices",
+ RefitPV = True, Do3d = False,
+ MaxPVrefit = 10000, DoVertexType = 7)
+ToolSvc += BPHY5BpipiXSelectAndWrite
+print (BPHY5BpipiXSelectAndWrite)
+
+BPHY5BdKstSelectAndWrite = DerivationFramework__Reco_Vertex(
+ name = "BPHY5BdKstSelectAndWrite",
+ VertexSearchTool = BPHY5BdJpsiKst,
+ OutputVtxContainerName = "BPHY5BdJpsiKstCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY5RefittedKstPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 10000,
+ DoVertexType = 7)
+ToolSvc += BPHY5BdKstSelectAndWrite
+print (BPHY5BdKstSelectAndWrite)
+## b/ augment and select Bd->JpsiKst candidates
+# set mass hypothesis (K pi)
+BPHY5_Select_Bd2JpsiKst = DerivationFramework__Select_onia2mumu(
+ name = "BPHY5_Select_Bd2JpsiKst",
+ HypothesisName = "Bd",
+ InputVtxContainerName = "BPHY5BdJpsiKstCandidates",
+ TrkMasses = [105.658, 105.658, 493.677, 139.570],
+ VtxMassHypo = 5279.6,
+ MassMin = 100.0, #no mass cuts here
+ MassMax = 100000.0, #no mass cuts here
+ Chi2Max = 200)
+
+ToolSvc += BPHY5_Select_Bd2JpsiKst
+print (BPHY5_Select_Bd2JpsiKst)
+
+## c/ augment and select Bdbar->JpsiKstbar candidates
+# set mass hypothesis (pi K)
+BPHY5_Select_Bd2JpsiKstbar = DerivationFramework__Select_onia2mumu(
+ name = "BPHY5_Select_Bd2JpsiKstbar",
+ HypothesisName = "Bdbar",
+ InputVtxContainerName = "BPHY5BdJpsiKstCandidates",
+ TrkMasses = [105.658, 105.658, 139.570, 493.677],
+ VtxMassHypo = 5279.6,
+ MassMin = 100.0, #no mass cuts here
+ MassMax = 100000.0, #no mass cuts here
+ Chi2Max = 200)
+
+ToolSvc += BPHY5_Select_Bd2JpsiKstbar
+print (BPHY5_Select_Bd2JpsiKstbar)
+
+
+## b/ augment and select Bs->JpsiKK candidates
+BPHY5_Select_Bs2JpsiKK = DerivationFramework__Select_onia2mumu(
+ name = "BPHY5_Select_Bs2JpsiKK",
+ HypothesisName = "Bs",
+ InputVtxContainerName = "BPHY5BsJpsiKKCandidates",
+ TrkMasses = [105.658, 105.658, 493.677, 493.677],
+ VtxMassHypo = 5366.3,
+ MassMin = 5000.0,
+ MassMax = 5800.0, Do3d = False,
+ Chi2Max = 200)
+
+ToolSvc += BPHY5_Select_Bs2JpsiKK
+print (BPHY5_Select_Bs2JpsiKK)
+
+BPHY5_Select_Bpl2JpsiKpl = DerivationFramework__Select_onia2mumu(
+ name = "BPHY5_Select_Bpl2JpsiKpl",
+ HypothesisName = "Bplus",
+ InputVtxContainerName = "BPHY5BpmJpsiKpmCandidates",
+ TrkMasses = [105.658, 105.658, 493.677],
+ VtxMassHypo = 5279.26,
+ MassMin = 5279.26 - 500, Do3d = False,
+ MassMax = 5279.26 + 500,
+ Chi2Max = 200 )
+
+ToolSvc += BPHY5_Select_Bpl2JpsiKpl
+print (BPHY5_Select_Bpl2JpsiKpl)
+
+BPHY5_Select_Bpl2JpsiPi = DerivationFramework__Select_onia2mumu(
+ name = "BPHY5_Select_Bpl2JpsiPi",
+ HypothesisName = "Bc",
+ InputVtxContainerName = "BPHY5BpmJpsiKpmCandidates",
+ TrkMasses = [105.658, 105.658, 139.570],
+ VtxMassHypo = 6275.1, Do3d = False,
+ MassMin = 6275.1 - 500,
+ MassMax = 6275.1 + 500,
+ Chi2Max = 200 )
+
+ToolSvc += BPHY5_Select_Bpl2JpsiPi
+print (BPHY5_Select_Bpl2JpsiPi)
+
+BPHY5_Select_B2JpsipipiX = DerivationFramework__Select_onia2mumu(
+ name = "BPHY5_Select_B2JpsipipiX",
+ HypothesisName = "pipiJpsi",
+ InputVtxContainerName = "BPHY5BJpsipipiXCandidates",
+ TrkMasses = [105.658, 105.658, 139.570, 139.570],
+ VtxMassHypo = 4260,
+ MassMin = 3400.0,
+ MassMax = 5800.0, Do3d = False,
+ Chi2Max = 200)
+
+ToolSvc += BPHY5_Select_B2JpsipipiX
+print (BPHY5_Select_B2JpsipipiX)
+
+#expression = "count(BPHY5BpmJpsiKpmCandidates.passed_Bplus) > 0"
+#from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+#BPHY5_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY5_SelectEvent",
+# expression = expression)
+#ToolSvc += BPHY5_SelectEvent
+#print BPHY5_SelectEvent
+
+
+#from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__SelectEvent
+
+if not isSimulation: #Only Skim Data
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+ BPHY5_SelectBsJpsiKKEvent = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY5_SelectBsJpsiKKEvent",
+ expression = "count(BPHY5BsJpsiKKCandidates.passed_Bs > 0) > 0")
+
+ ToolSvc += BPHY5_SelectBsJpsiKKEvent
+ print (BPHY5_SelectBsJpsiKKEvent)
+
+ BPHY5_SelectBplJpsiKplEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY5_SelectBplJpsiKplEvent",
+ expression = "count(BPHY5BpmJpsiKpmCandidates.passed_Bplus>0) > 0")
+ ToolSvc += BPHY5_SelectBplJpsiKplEvent
+ print (BPHY5_SelectBplJpsiKplEvent)
+
+ BPHY5_SelectBplJpsiKplEventBc = DerivationFramework__xAODStringSkimmingTool(name = "BPHY5_SelectBplJpsiKplEventBc",
+ expression = "count(BPHY5BpmJpsiKpmCandidates.passed_Bc>0) > 0")
+ ToolSvc += BPHY5_SelectBplJpsiKplEventBc
+ print (BPHY5_SelectBplJpsiKplEventBc)
+
+ BPHY5_SelectBdKstarEventBd = DerivationFramework__xAODStringSkimmingTool(name = "BPHY5_SelectBdKstarEventBd",
+ expression = "count(BPHY5BdJpsiKstCandidates.passed_Bd>0) > 0")
+ ToolSvc += BPHY5_SelectBdKstarEventBd
+ print (BPHY5_SelectBdKstarEventBd)
+
+ BPHY5_SelectBdKstarEventBdBar = DerivationFramework__xAODStringSkimmingTool(name = "BPHY5_SelectBdKstarEventBdbar",
+ expression = "count(BPHY5BdJpsiKstCandidates.passed_Bdbar>0) > 0")
+ ToolSvc += BPHY5_SelectBdKstarEventBdBar
+ print (BPHY5_SelectBdKstarEventBdBar)
+ #====================================================================
+ # Make event selection based on an OR of the input skimming tools
+ #====================================================================
+ from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+ BPHY5SkimmingOR = CfgMgr.DerivationFramework__FilterCombinationOR("BPHY5SkimmingOR",
+ FilterList = [BPHY5_SelectBsJpsiKKEvent, BPHY5_SelectBplJpsiKplEvent, BPHY5_SelectBplJpsiKplEventBc,
+ BPHY5_SelectBdKstarEventBd, BPHY5_SelectBdKstarEventBdBar])
+ ToolSvc += BPHY5SkimmingOR
+ print (BPHY5SkimmingOR)
+
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+thiningCollection = []
+print (thiningCollection)
+
+import DerivationFrameworkJetEtMiss.JetCommon
+bphy5Seq = CfgMgr.AthSequencer("BPHY5Sequence")
+DerivationFrameworkJob += bphy5Seq
+
+# The name of the kernel (BPHY5Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+bphy5Seq += CfgMgr.DerivationFramework__DerivationKernel("BPHY5Kernel",
+ AugmentationTools = [BPHY5JpsiSelectAndWrite, BPHY5_Select_Jpsi2mumu,
+ BPHY5BsKKSelectAndWrite, BPHY5_Select_Bs2JpsiKK,
+ BPHY5BplKplSelectAndWrite, BPHY5BpipiXSelectAndWrite, BPHY5_Select_Bpl2JpsiKpl, BPHY5_Select_Bpl2JpsiPi, BPHY5_Select_B2JpsipipiX,
+ BPHY5BdKstSelectAndWrite, BPHY5_Select_Bd2JpsiKst, BPHY5_Select_Bd2JpsiKstbar,
+ BPHY5_AugOriginalCounts],
+ #Only skim if not MC
+ SkimmingTools = [BPHY5SkimmingOR] if not isSimulation else [],
+ ThinningTools = thiningCollection
+
+ )
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY5Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY5Stream )
+BPHY5Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY5Stream.AcceptAlgs(["BPHY5Kernel"])
+
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+#from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+
+#BPHY5ThinningSvc = createThinningSvc( svcName="BPHY5ThinningSvc", outStreams=[evtStream] )
+#svcMgr += BPHY5ThinningSvc
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY5SlimmingHelper = SlimmingHelper("BPHY5SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY5SlimmingHelper.IncludeMuonTriggerContent = TRUE
+BPHY5SlimmingHelper.IncludeBPhysTriggerContent = TRUE
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY5RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY5RefittedPrimaryVerticesAux."]
+StaticContent += ["xAOD::VertexContainer#BPHY5RefBplJpsiKplPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY5RefBplJpsiKplPrimaryVerticesAux."]
+StaticContent += ["xAOD::VertexContainer#BPHY5RefittedBPipiPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY5RefittedBPipiPrimaryVerticesAux."]
+StaticContent += ["xAOD::VertexContainer#BPHY5RefittedKstPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY5RefittedKstPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+
+## muon container
+AllVariables += ["Muons"]
+
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY5JpsiSelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY5JpsiSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY5BsKKSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY5BsKKSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY5BplKplSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY5BplKplSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY5BpipiXSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY5BpipiXSelectAndWrite.OutputVtxContainerName]
+
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY5BdKstSelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY5BdKstSelectAndWrite.OutputVtxContainerName]
+
+# Tagging information (in addition to that already requested by usual algorithms)
+#AllVariables += ["Electrons"]
+AllVariables += ["GSFTrackParticles", "Electrons" , "Photons", "MuonSpectrometerTrackParticles" ]
+tagJetCollections = ['AntiKt4LCTopoJets', 'AntiKt4EMTopoJets', 'AntiKt4PV0TrackJets']
+
+AllVariables += [ "Kt4LCTopoOriginEventShape", "Kt4EMTopoOriginEventShape" ]
+SmartVar = ["Photons" ] #[ tagJetCollections ]
+
+
+
+
+for jet_collection in tagJetCollections:
+ AllVariables += [jet_collection]
+ AllVariables += ["BTagging_%s" % (jet_collection[:-4]) ]
+ AllVariables += ["BTagging_%sJFVtx" % (jet_collection[:-4]) ]
+ AllVariables += ["BTagging_%sSecVtx" % (jet_collection[:-4]) ]
+
+#addStandardJets("AntiKt", 0.4, "PV0Track", 2000, mods="track_ungroomed", algseq=bphy5Seq, outputGroup="BPHY5")
+
+
+# Added by ASC
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles", "egammaTruthParticles" ]
+ AllVariables += ["AntiKt4TruthJets", "AntiKt4TruthWZJets" ]
+# addStandardJets("AntiKt", 0.4, "Truth", 5000, mods="truth_ungroomed", algseq=bphy5Seq, outputGroup="BPHY5")
+# addStandardJets("AntiKt", 0.4, "TruthWZ", 5000, mods="truth_ungroomed", algseq=bphy5Seq, outputGroup="BPHY5")
+ tagJetCollections += [ "AntiKt4TruthJets", "AntiKt4TruthWZJets" ]
+
+from DerivationFrameworkJetEtMiss.ExtendedJetCommon import replaceAODReducedJets
+replaceAODReducedJets(tagJetCollections, bphy5Seq , "BPHY5" )
+
+
+AllVariables = list(set(AllVariables)) # remove duplicates
+
+BPHY5SlimmingHelper.AllVariables = AllVariables
+BPHY5SlimmingHelper.StaticContent = StaticContent
+BPHY5SlimmingHelper.SmartCollections = SmartVar
+
+BPHY5SlimmingHelper.AppendContentToStream(BPHY5Stream)
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY6.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY6.py
new file mode 100644
index 00000000000..23b5bb5095d
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY6.py
@@ -0,0 +1,344 @@
+#====================================================================
+# BPHY6.py
+# This an example job options script showing how to set up a
+# derivation of the data using the derivation framework.
+# It requires the reductionConf flag BPHY6 in Reco_tf.py
+#====================================================================
+
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+print(isSimulation)
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+## 1/ setup vertexing tools and services
+#include( "JpsiUpsilonTools/configureServices.py" )
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY6_VertexTools = BPHYVertexTools("BPHY6")
+
+
+# General Variables
+dimuon_chi2_max = 50.
+dimuon_mass_min = 100.
+dimuon_mass_max = 150e3
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__MuonExtrapolationTool
+BPHY6_Extrap_Tool = DerivationFramework__MuonExtrapolationTool(
+ name = "BPHY6_ExtrapolationTool",
+ OutputLevel = INFO )
+ToolSvc += BPHY6_Extrap_Tool
+
+
+
+#--------------------------------------------------------------------
+## 2/ Setup the vertex fitter tools (e.g. JpsiFinder, JpsiPlus1Track, etc).
+## These are general tools independent of DerivationFramework that do the
+## actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY6JpsiFinder = Analysis__JpsiFinder(
+ name = "BPHY6JpsiFinder",
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ invMassUpper = dimuon_mass_max,
+ invMassLower = dimuon_mass_min,
+ Chi2Cut = dimuon_chi2_max,
+ oppChargesOnly = True,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY6_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY6_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY6_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY6_VertexTools.VtxPointEstimator,
+ useMCPCuts = False )
+
+ToolSvc += BPHY6JpsiFinder
+print(BPHY6JpsiFinder)
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+
+
+
+BPHY6_Reco_mumu = DerivationFramework__Reco_Vertex(
+ name = "BPHY6_Reco_mumu",
+ VertexSearchTool = BPHY6JpsiFinder,
+ OutputVtxContainerName = "BPHY6OniaCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY6RefittedPrimaryVertices")
+
+ToolSvc += BPHY6_Reco_mumu
+print(BPHY6_Reco_mumu)
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY6_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY6_Select_Jpsi2mumu",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY6OniaCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = 2700.0,
+ MassMax = 3500.0,
+ Chi2Max = 20)
+
+ToolSvc += BPHY6_Select_Jpsi2mumu
+print(BPHY6_Select_Jpsi2mumu)
+
+
+## b/ augment and select Psi(2S)->mumu candidates
+BPHY6_Select_Psi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY6_Select_Psi2mumu",
+ HypothesisName = "Psi",
+ InputVtxContainerName = "BPHY6OniaCandidates",
+ VtxMassHypo = 3686.09,
+ MassMin = 3200.0,
+ MassMax = 4200.0,
+ Chi2Max = 20)
+
+ToolSvc += BPHY6_Select_Psi2mumu
+print(BPHY6_Select_Psi2mumu)
+
+# Added by ASC
+## c/ augment and select Upsilon(nS)->mumu candidates
+BPHY6_Select_Upsi2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY6_Select_Upsi2mumu",
+ HypothesisName = "Upsi",
+ InputVtxContainerName = "BPHY6OniaCandidates",
+ VtxMassHypo = 9460.30,
+ MassMin = 8000.0,
+ MassMax = 12000.0,
+ Chi2Max = 20)
+
+ToolSvc += BPHY6_Select_Upsi2mumu
+print(BPHY6_Select_Upsi2mumu)
+
+BPHY6_Select_Bmumu2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY6_Select_Bmumu2mumu",
+ HypothesisName = "Bmumu",
+ InputVtxContainerName = "BPHY6OniaCandidates",
+ VtxMassHypo = 5366.77,
+ MassMin = 4200.0,
+ MassMax = 8000.0,
+ Chi2Max = 20)
+
+ToolSvc += BPHY6_Select_Bmumu2mumu
+print(BPHY6_Select_Bmumu2mumu)
+
+BPHY6_Select_Zmumu2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY6_Select_Zmumu2mumu",
+ HypothesisName = "Zmumu",
+ InputVtxContainerName = "BPHY6OniaCandidates",
+ VtxMassHypo = 91187.6,
+ MassMin = 60000.0,
+ MassMax = 120000.0,
+ Chi2Max = 20)
+
+ToolSvc += BPHY6_Select_Zmumu2mumu
+print(BPHY6_Select_Zmumu2mumu)
+
+BPHY6_Select_Onia2mumu = DerivationFramework__Select_onia2mumu(
+ name = "BPHY6_Select_Onia2mumu",
+ HypothesisName = "Onia",
+ InputVtxContainerName = "BPHY6OniaCandidates",
+ VtxMassHypo = 3096.916,
+ MassMin = dimuon_mass_min,
+ MassMax = dimuon_mass_max,
+ Chi2Max = 20)
+
+ToolSvc += BPHY6_Select_Onia2mumu
+print(BPHY6_Select_Onia2mumu)
+
+
+
+trigger_list = [r'HLT_\d?mu\d+']
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__TriggerSkimmingTool
+BPHY6TrigSkimmingTool = DerivationFramework__TriggerSkimmingTool( name = "BPHY6TrigSkimmingTool",
+ TriggerListOR = trigger_list )
+ToolSvc += BPHY6TrigSkimmingTool
+
+
+
+expression = "count(BPHY6OniaCandidates.passed_Onia) > 0 "
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY6_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY6_SelectEvent",
+ expression = expression)
+ToolSvc += BPHY6_SelectEvent
+print(BPHY6_SelectEvent)
+
+#--------------------------------------------------------------------
+## 6/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which hasn't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY6Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY6Stream )
+BPHY6Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY6Stream.AcceptAlgs(["BPHY6Kernel"])
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+augStream = MSMgr.GetStream( streamName )
+evtStream = augStream.GetEventStream()
+
+
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY6Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY6Thin_vtxTrk",
+ TrackParticleContainerName = "InDetTrackParticles",
+ StreamName = streamName,
+ VertexContainerNames = ["BPHY6OniaCandidates"],
+ PassFlags = ["passed_Onia"], )
+
+ToolSvc += BPHY6Thin_vtxTrk
+
+
+## b) thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY6MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY6MuonTPThinningTool",
+ MuonKey = "Muons",
+ StreamName = streamName,
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY6MuonTPThinningTool
+
+# Added by ASC
+# Only save truth informtion directly associated with Onia
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY6TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY6TruthThinTool",
+ ParticleSelectionString = "TruthParticles.pdgId == 443 || TruthParticles.pdgId == 100443 || TruthParticles.pdgId == 553 || TruthParticles.pdgId == 100553 || TruthParticles.pdgId == 200553 || TruthParticles.pdgId == 23 || TruthParticles.pdgId == 531 || TruthParticles.pdgId == 511 || TruthParticles.pdgId == 521 || TruthParticles.pdgId == 541",
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY6TruthThinTool
+print(BPHY6TruthThinTool)
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+## 7/ IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel! If you don't do that, they will not be
+## be executed!
+
+# Added by ASC
+BPHY6ThinningTools = [BPHY6Thin_vtxTrk, BPHY6MuonTPThinningTool]
+if globalflags.DataSource()=='geant4':
+ BPHY6ThinningTools.append(BPHY6TruthThinTool)
+
+
+# Build a tool to apply the OR combination of the String expression skimming tool, and the Trigger Skimming Tool
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__FilterCombinationOR
+SkimmingORTool = CfgMgr.DerivationFramework__FilterCombinationOR("BPHY6SkimmingOR",
+ FilterList = [BPHY6_SelectEvent,BPHY6TrigSkimmingTool],)
+ToolSvc += SkimmingORTool
+print(SkimmingORTool)
+
+# The name of the kernel (BPHY6Kernel in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY6Kernel",
+ AugmentationTools = [BPHY6_Reco_mumu,
+ BPHY6_Select_Jpsi2mumu, BPHY6_Select_Psi2mumu, BPHY6_Select_Upsi2mumu,BPHY6_Select_Bmumu2mumu,
+ BPHY6_Select_Zmumu2mumu,BPHY6_Select_Onia2mumu, BPHY6_Extrap_Tool],
+ SkimmingTools = [SkimmingORTool],
+ # ThinningTools = [BPHY6Thin_vtxTrk, BPHY6MuonTPThinningTool]
+ ThinningTools = BPHY6ThinningTools
+
+ )
+
+
+
+
+#====================================================================
+# Slimming
+#====================================================================
+
+# Added by ASC
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY6SlimmingHelper = SlimmingHelper("BPHY6SlimmingHelper")
+AllVariables = []
+StaticContent = []
+
+# Needed for trigger objects
+BPHY6SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY6SlimmingHelper.IncludeBPhysTriggerContent = True
+
+AllVariables += ["LVL1MuonRoIs"]
+
+## primary vertices
+AllVariables += ["PrimaryVertices"]
+StaticContent += ["xAOD::VertexContainer#BPHY6RefittedPrimaryVertices"]
+StaticContent += ["xAOD::VertexAuxContainer#BPHY6RefittedPrimaryVerticesAux."]
+
+## ID track particles
+AllVariables += ["InDetTrackParticles"]
+
+AllVariables += ["HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_EFID"]
+AllVariables += ["HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_IDTrig"]
+AllVariables += ["HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_FTF"]
+AllVariables += ["HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_FTF"]
+AllVariables += ["HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_IDTrig"]
+
+
+
+## combined / extrapolated muon track particles
+## (note: for tagged muons there is no extra TrackParticle collection since the ID tracks
+## are store in InDetTrackParticles collection)
+AllVariables += ["CombinedMuonTrackParticles"]
+AllVariables += ["ExtrapolatedMuonTrackParticles"]
+AllVariables += ["MuonSpectrometerTrackParticles"]
+
+## muon container
+AllVariables += ["Muons"]
+AllVariables += ["HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo"]
+AllVariables += ["HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfo"]
+AllVariables += ["HLT_xAOD__MuonContainer_MuonEFInfo"]
+
+
+AllVariables += ["HLT_xAOD__TrigBphysContainer_L2BMuMuXFex" ]
+AllVariables += ["HLT_xAOD__TrigBphysContainer_EFBMuMuXFex" ]
+AllVariables += ["HLT_xAOD__TrigBphysContainer_L2BMuMuFex" ]
+AllVariables += ["HLT_xAOD__TrigBphysContainer_EFBMuMuFex" ]
+AllVariables += ["HLT_xAOD__TrigBphysContainer_L2TrackMass" ]
+AllVariables += ["HLT_xAOD__TrigBphysContainer_EFTrackMass" ]
+AllVariables += ["HLT_xAOD__TrigBphysContainer_L2MultiMuFex"]
+AllVariables += ["HLT_xAOD__TrigBphysContainer_EFMultiMuFex"]
+
+
+## Jpsi candidates
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY6_Reco_mumu.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY6_Reco_mumu.OutputVtxContainerName]
+
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles"]
+
+BPHY6SlimmingHelper.AllVariables = AllVariables
+BPHY6SlimmingHelper.StaticContent = StaticContent
+BPHY6SlimmingHelper.AppendContentToStream(BPHY6Stream)
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY7.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY7.py
new file mode 100644
index 00000000000..b53b1a403bc
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY7.py
@@ -0,0 +1,648 @@
+#====================================================================
+# BPHY7.py
+#
+# https://twiki.cern.ch/twiki/bin/view/AtlasProtected/LfvBphy7
+#====================================================================
+
+
+#====================================================================
+# FLAGS TO PERSONALIZE THE DERIVATION
+#====================================================================
+
+onlyAugmentations = False # Set to True to deactivate thinning and skimming, and only keep augmentations (to generate a sample with full xAOD plus all the extra)
+thinTruth = True
+addMuExtrapolationForTrigger = True
+
+
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+isSimulation = False
+if globalflags.DataSource()=='geant4':
+ isSimulation = True
+
+from DerivationFrameworkJetEtMiss.JetCommon import *
+from DerivationFrameworkJetEtMiss.METCommon import *
+
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY7Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY7Stream )
+
+BPHY7Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY7Stream.AcceptAlgs(["BPHY7Kernel2"])
+
+## 0/ setup vertexing tools and services
+#include( "JpsiUpsilonTools/configureServices.py" )
+
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY7_VertexTools = BPHYVertexTools("BPHY7")
+
+
+#====================================================================
+# TriggerCounting for Kernel1 #Added by Matteo
+#====================================================================
+#List of trigggers to be counted (high Sig-eff*Lumi ones are in)
+triggersToMetadata= ["HLT_2mu10",
+ "HLT_2mu10_bJpsimumu",
+ "HLT_2mu10_bJpsimumu_delayed",
+ "HLT_2mu10_l2msonly",
+ "HLT_2mu10_nomucomb",
+ "HLT_2mu14",
+ "HLT_2mu14_nomucomb",
+ "HLT_2mu4",
+ "HLT_2mu4_bBmumuxv2",
+ "HLT_2mu4_bDimu_noinvm_novtx_ss",
+ "HLT_2mu6",
+ "HLT_2mu6_10invm30_pt2_z10",
+ "HLT_2mu6_bBmumu",
+ "HLT_2mu6_bBmumux_Taumumux",
+ "HLT_2mu6_bBmumuxv2",
+ "HLT_2mu6_bBmumuxv2_delayed",
+ "HLT_2mu6_bDimu_noinvm_novtx_ss",
+ "HLT_2mu6_bJpsimumu",
+ "HLT_2mu6_bJpsimumu_delayed",
+ "HLT_2mu6_bJpsimumu_Lxy0_delayed",
+ "HLT_2mu6_nomucomb_bPhi",
+ "HLT_2mu6_nomucomb_mu4_nomucomb_bTau_L12MU6_3MU4",
+ "HLT_3mu4",
+ "HLT_3mu4_bDimu",
+ "HLT_3mu4_bDimu2700",
+ "HLT_3mu4_bTau",
+ "HLT_3mu4_l2msonly",
+ "HLT_3mu4_nomucomb_bTau",
+ "HLT_3mu4_nomucomb_delayed",
+ "HLT_3mu6",
+ "HLT_3mu6_bTau",
+ "HLT_3mu6_msonly",
+ "HLT_mu10_mu6_bBmumux_BcmumuDsloose_delayed",
+ "HLT_mu10_mu6_bBmumux_Taumumux",
+ "HLT_mu10_mu6_bBmumux_Taumumux_noL2",
+ "HLT_mu10_mu6_bBmumuxv2",
+ "HLT_mu10_mu6_bBmumuxv2_delayed",
+ "HLT_mu10_mu6_bJpsimumu",
+ "HLT_mu10_mu6_bJpsimumu_Lxy0",
+ "HLT_mu10_mu6_bJpsimumu_Lxy0_delayed",
+ "HLT_mu10_mu6_bUpsimumu",
+ "HLT_mu11_mu6_bBmumu",
+ "HLT_mu11_mu6_bBmumux_BpmumuKp",
+ "HLT_mu11_mu6_bBmumuxv2",
+ "HLT_mu11_mu6_bDimu",
+ "HLT_mu11_mu6_bDimu2700",
+ "HLT_mu11_mu6_bDimu2700_Lxy0",
+ "HLT_mu11_mu6_bDimu_Lxy0",
+ "HLT_mu11_mu6_bJpsimumu",
+ "HLT_mu11_mu6_bJpsimumu_Lxy0",
+ "HLT_mu11_mu6_bPhi",
+ "HLT_mu11_mu6_bTau",
+ "HLT_mu11_mu6_bUpsimumu",
+ "HLT_mu11_mu6noL1_bPhi_L1MU11_2MU6",
+ "HLT_mu10_mu6_bDimu",
+ "HLT_2mu6_bBmumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+ "HLT_2mu6_bJpsimumu_Lxy0_L1BPH-2M9-2MU6_BPH-2DR15-2MU6",
+ "HLT_2mu10_bDimu",
+ "HLT_mu11_2mu4noL1_nscan03_L1MU11_2MU6",
+ "HLT_mu11_L1MU10_2mu4noL1_nscan03_L1MU10_2MU6",
+ "HLT_mu11_nomucomb_2mu4noL1_nscan03_L1MU11_2MU6",
+ "HLT_mu11_nomucomb_2mu4noL1_nscan03_L1MU11_2MU6_bTau",
+ "HLT_mu11_nomucomb_mu6noL1_nscan03_L1MU11_2MU6",
+ "HLT_mu11_nomucomb_mu6noL1_nscan03_L1MU11_2MU6_bTau",
+ "HLT_mu11_nomucomb_mu6noL1_nscan03_L1MU11_2MU6_bTau_delayed",
+ "HLT_mu18_2mu4noL1",
+ "HLT_mu18_mu8noL1",
+ "HLT_mu20_2mu4noL1",
+ "HLT_mu20_l2idonly_mu6noL1_nscan03",
+ "HLT_mu20_l2idonly_mu6noL1_nscan03_bTau",
+ "HLT_mu20_msonly_mu6noL1_msonly_nscan05",
+ "HLT_mu20_mu8noL1",
+ "HLT_mu20_nomucomb_mu6noL1_nscan03",
+ "HLT_mu20_nomucomb_mu6noL1_nscan03_bTau",
+ "HLT_mu22_2mu4noL1",
+ "HLT_mu22_mu8noL1",
+ "HLT_mu24_2mu4noL1",
+ "HLT_mu24_imedium",
+ "HLT_mu24_mu8noL1",
+ "HLT_mu26_ivarmedium",
+ "HLT_mu26i",
+ "HLT_mu50",
+ "HLT_mu6_2mu4",
+ "HLT_mu6_2mu4_bJpsi_delayed",
+ "HLT_mu6_2mu4_bTau_noL2",
+ "HLT_mu6_l2msonly_2mu4_l2msonly_L1MU6_3MU4",
+ "HLT_mu6_mu4_bBmumuxv2",
+ "HLT_mu6_mu4_bBmumuxv2_delayed",
+ "HLT_mu6_mu4_bDimu_noinvm_novtx_ss",
+ "HLT_mu6_nomucomb_2mu4_nomucomb_bTau_L1MU6_3MU4",
+ "HLT_mu6_nomucomb_2mu4_nomucomb_delayed_L1MU6_3MU4",
+ "HLT_mu20_mu6noL1_bTau",
+ "HLT_2mu6_mu4_bTau_L12MU6_3MU4",
+ "HLT_mu6_2mu4_bTau_L1MU6_3MU4",
+ "HLT_mu11_2mu4noL1_bTau_L1MU11_2MU6",
+ "HLT_mu11_mu6noL1_bTau_L1MU11_2MU6",
+ "HLT_3mu4_bPhi",
+ "HLT_mu11_mu6_bPhi",
+ "HLT_mu11_nomucomb_mu6_nomucomb_bPhi",
+ "HLT_mu11_nomucomb_mu6noL1_nscan03_L1MU11_2MU6_bPhi",
+ "HLT_mu6_2mu4_bTau_L1MU6_3MU4",
+ "HLT_mu20_mu6btrk_bTauTight",
+ "HLT_mu20_2mu2btrk_bTauTight",
+ "HLT_mu11_2mu2btrk_bTauTight_L1MU11_2MU6",
+ "HLT_3mu4_bPhi",
+ "HLT_mu11_mu6_bPhi",
+ "HLT_mu11_mu6noL1_bPhi_L1MU11_2MU6",
+ "HLT_mu11_mu6_bPhi_L1LFV-MU11",
+ "HLT_2mu6_bPhi_L1LFV-MU6" ]
+
+
+
+
+triggersToMetadata_filter = list( set(triggersToMetadata) )
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__TriggerCountToMetadata
+BPHY7TriggerCountToMetadata = DerivationFramework__TriggerCountToMetadata(name = "BPHY7TriggerCount",
+ TriggerList = triggersToMetadata_filter,
+ FolderName = "BPHY7")
+
+ToolSvc += BPHY7TriggerCountToMetadata
+
+#====================================================================
+# PRESELECTION for Kernel1 #Added by Matteo
+#====================================================================
+## 1/ Setup the skimming based on triggers
+##
+
+triggerList = [ "HLT_2mu10",
+ "HLT_2mu10_l2msonly",
+ "HLT_2mu10_nomucomb",
+ "HLT_2mu14",
+ "HLT_mu50",
+ "HLT_2mu14_l2msonly",
+ "HLT_2mu14_nomucomb",
+ "HLT_2mu6_l2msonly_mu4_l2msonly_L12MU6_3MU4",
+ "HLT_2mu6_nomucomb_mu4_nomucomb_L12MU6_3MU4",
+ "HLT_mu6_2mu4",
+ "HLT_mu6_l2msonly_2mu4_l2msonly_L1MU6_3MU4",
+ "HLT_mu6_nomucomb_2mu4_nomucomb_L1MU6_3MU4",
+ "HLT_3mu6",
+ "HLT_3mu6_msonly",
+ "HLT_3mu6_nomucomb",
+ "HLT_mu4","HLT_mu6","HLT_mu10","HLT_mu18",
+ "HLT_mu14",
+ "HLT_mu24",
+ "HLT_mu24_L1MU15",
+ "HLT_2mu4",
+ "HLT_2mu6",
+ "HLT_mu20_L1MU15",
+ "HLT_mu18_2mu4noL1",
+ "HLT_mu18_nomucomb_2mu4noL1",
+ "HLT_mu20_2mu4noL1",
+ "HLT_mu20_l2idonly_2mu4noL1",
+ "HLT_mu20_nomucomb_2mu4noL1",
+ "HLT_mu18_mu8noL1",
+ "HLT_mu18_nomucomb_mu8noL1",
+ "HLT_mu20_mu8noL1",
+ "HLT_mu20_l2idonly_2mu4noL1",
+ "HLT_mu20_nomucomb_mu8noL1",
+ "HLT_mu22_mu8noL1",
+ "HLT_mu22_l2idonly_2mu4noL1",
+ "HLT_mu22_nomucomb_mu8noL1",
+ "HLT_mu22_2mu4noL1",
+ "HLT_mu22_nomucomb_2mu4noL1",
+ "HLT_mu20_2mu4noL1", "HLT_mu20_mu8noL1",
+ "HLT_mu14_tau25_medium1_tracktwo",
+ "HLT_mu14_tau35_medium1_tracktwo",
+ "HLT_mu14_tau25_medium1_tracktwo_xe50",
+ "HLT_mu14_tau35_medium1_tracktwo_L1TAU20",
+ "HLT_mu24_mu8noL1",
+ "HLT_mu6_nomucomb_2mu4_nomucomb_delayed_L1MU6_3MU4",
+ "HLT_2mu6_bBmumuxv2_delayed",
+ "HLT_2mu4_bDimu_noinvm_novtx_ss",
+ "HLT_2mu6_bDimu_noinvm_novtx_ss",
+ "HLT_mu24_2mu4noL1",
+ "HLT_mu10_mu6_bUpsimumu",
+ "HLT_mu10_mu6_bBmumuxv2",
+ "HLT_mu10_mu6_bJpsimumu",
+ "HLT_mu6_mu4_bBmumuxv2_delayed",
+ "HLT_2mu6_10invm30_pt2_z10",
+ "HLT_2mu6_nomucomb_bPhi",
+ "HLT_mu6_mu4_bDimu_noinvm_novtx_ss",
+ "HLT_mu11_mu6_bDimu2700",
+ "HLT_2mu6_bBmumux_Taumumux",
+ "HLT_mu10_mu6_bBmumux_Taumumux",
+ "HLT_mu10_mu6_bBmumux_Taumumux_noL2",
+ "HLT_.*mu11_mu6.*", # Recent triggers
+ "HLT_.*3mu4.*",
+ "HLT_.*mu.*imedium.*", # Trigger with looser isolation selection
+ "HLT_.*mu.*iloose.*",
+ "HLT_.*mu6.*2mu4.*",
+ "HLT_.*mu11.*2mu4noL1.*",
+ "HLT_.*2mu14_nomucomb.*",
+ "HLT_.*bTau.*", # Our tau triggers
+ "HLT_.*bDimu2700.*",
+ "HLT_.*bPhi.*",
+ "HLT_.*bBmumuxv2.*",
+ "HLT_.*nscan.*" ] # Narrow scan triggers
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__TriggerSkimmingTool
+BPHY7TriggerSkim = DerivationFramework__TriggerSkimmingTool(name = "BPHY7TriggerSkim",
+ TriggerListOR = triggerList,
+ TriggerListAND = [] )
+
+ToolSvc += BPHY7TriggerSkim
+
+
+#====================================================================
+# 2mu vertex for Kernel2 #Added by Matteo
+#====================================================================
+
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY7DiMuon_Finder = Analysis__JpsiFinder(name = "BPHY7DiMuon_Finder",
+ # OutputLevel = DEBUG,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True,
+ invMassUpper = 2900.0, # Cut just below the J/psi
+ invMassLower = 0.0,
+ Chi2Cut = 110., #CHANGED! Was 200
+ oppChargesOnly = False,
+ allChargeCombinations = True,
+ combOnly = False,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = "Muons",
+ TrackParticleCollection = "InDetTrackParticles",
+ V0VertexFitterTool = BPHY7_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY7_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY7_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY7_VertexTools.VtxPointEstimator,
+ useMCPCuts = False)
+ToolSvc += BPHY7DiMuon_Finder
+
+#--------------------------------------------------------------------
+##Comment from BPHY2...
+## 3/ setup the vertex reconstruction "call" tool(s). They are part of the derivation framework.
+## These Augmentation tools add output vertex collection(s) into the StoreGate and add basic
+## decorations which do not depend on the vertex mass hypothesis (e.g. lxy, ptError, etc).
+## There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+## Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY7DiMuon_SelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY7DiMuon_SelectAndWrite",
+ VertexSearchTool = BPHY7DiMuon_Finder,
+ OutputVtxContainerName = "BPHY7TwoMuCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "SHOULDNOTBEUSED_DiMuonRefittedPV")
+ToolSvc += BPHY7DiMuon_SelectAndWrite
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+## a/ augment and select Jpsi->mumu candidates
+BPHY7DiMuon_Decorator = DerivationFramework__Select_onia2mumu(name = "BPHY7DiMuon_Decorator",
+ HypothesisName = "Jpsi",
+ InputVtxContainerName = "BPHY7TwoMuCandidates",
+ VtxMassHypo = 1230, # used to determine time-of-flight and thus lifetime (deviations and sigmas are also added to the vertex)
+ MassMin = 0.0,
+ MassMax = 2900.0,
+ Chi2Max = 200,
+ DoVertexType =1) # 1 = Pt, 2 = A0, 4 = Z0
+
+ToolSvc += BPHY7DiMuon_Decorator
+#====================================================================
+# 3mu/2mu+trk vertex for Kernel2 #Added by Matteo
+#====================================================================
+## 4/ setup a new vertexing tool (necessary due to use of mass constraint)
+from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+BpmVertexFit = Trk__TrkVKalVrtFitter(name = "BpmVertexFit",
+ Extrapolator = BPHY7_VertexTools.InDetExtrapolator,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+ToolSvc += BpmVertexFit
+
+## 5/ setup the Jpsi+1 track finder
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiPlus1Track
+BPHY7ThreeMuon_Finder = Analysis__JpsiPlus1Track(name = "BPHY7ThreeMuon_Finder",
+ OutputLevel = INFO,
+ pionHypothesis = True,
+ kaonHypothesis = False,
+ trkThresholdPt = 1000.0,
+ #trkMaxEta = 2.5, # is this value fine?? default would be 102.5
+ BThresholdPt = 1000.0,
+ BMassUpper = 5000.0, # What is this??
+ BMassLower = 0.0,
+ JpsiContainerKey = "BPHY7TwoMuCandidates",
+ TrackParticleCollection = "InDetTrackParticles",
+ MuonsUsedInJpsi = "NONE", #cannnot allow, would kill 3muons
+ ExcludeCrossJpsiTracks = False,
+ TrkVertexFitterTool = BpmVertexFit,
+ TrackSelectorTool = BPHY7_VertexTools.InDetTrackSelectorTool,
+ UseMassConstraint = False,
+ Chi2Cut = 150) #Cut on chi2/Ndeg_of_freedom, so is very loose
+
+
+ToolSvc += BPHY7ThreeMuon_Finder
+
+## 6/ setup the combined augmentation/skimming tool for the Bpm
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY7ThreeMuon_SelectAndWrite = DerivationFramework__Reco_Vertex(name = "BPHY7ThreeMuon_SelectAndWrite",
+ OutputLevel = INFO,
+ VertexSearchTool = BPHY7ThreeMuon_Finder,
+ OutputVtxContainerName = "BPHY7Tau3MuCandidates",
+ PVContainerName = "PrimaryVertices",
+ RefPVContainerName = "BPHY7RefittedPrimaryVertices",
+ RefitPV = True,
+ MaxPVrefit = 1000)
+ToolSvc += BPHY7ThreeMuon_SelectAndWrite
+
+## b/ augment and select Bplus->JpsiKplus candidates
+BPHY7ThreeMuon_Decorator = DerivationFramework__Select_onia2mumu(
+ name = "BPHY7ThreeMuon_Decorator",
+ OutputLevel = INFO,
+ HypothesisName = "Tau3MuLoose",
+ InputVtxContainerName = "BPHY7Tau3MuCandidates",
+ TrkMasses = [105.658, 105.658, 105.658],
+ VtxMassHypo = 1777.,
+ MassMin = 0.0,
+ MassMax = 5000., # If the two selections start differing one might have to check that the tools below still run on the right vertices
+ Chi2Max = 100.)
+
+ToolSvc += BPHY7ThreeMuon_Decorator
+
+## b/ augment and select Bplus->JpsiKplus candidates
+BPHY7ThreeMuon_Decorator2 = DerivationFramework__Select_onia2mumu(
+ name = "BPHY7ThreeMuon_Decorator2",
+ OutputLevel = INFO,
+ HypothesisName = "Ds2MuPi",
+ InputVtxContainerName = "BPHY7Tau3MuCandidates",
+ TrkMasses = [105.658, 105.658, 139.57],
+ VtxMassHypo = 1968.3,
+ MassMin = 0.0,
+ MassMax = 5000., # If the two selections start differing one might have to check that the tools below still run on the right vertices
+ Chi2Max = 100.)
+
+ToolSvc += BPHY7ThreeMuon_Decorator2
+
+#Track isolation for candidates
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__VertexTrackIsolation
+BPHY7TrackIsolationDecorator = DerivationFramework__VertexTrackIsolation(
+ name = "BPHY7TrackIsolationDecorator",
+ OutputLevel = INFO,
+ TrackIsoTool = "xAOD::TrackIsolationTool",
+ TrackContainer = "InDetTrackParticles",
+ InputVertexContainer = "BPHY7Tau3MuCandidates",
+ PassFlags = ["passed_Tau3MuLoose", "passed_Ds2MuPi"] )
+
+ToolSvc += BPHY7TrackIsolationDecorator
+
+#CaloIsolationTool explicitly declared to avoid pointless warnings (it works!!!)
+from IsolationTool.IsolationToolConf import xAOD__CaloIsolationTool
+BPHY7CaloIsolationTool = xAOD__CaloIsolationTool(
+ name = "BPHY7CaloIsolationTool",
+ OutputLevel = WARNING,
+ saveOnlyRequestedCorrections = True,
+ IsoLeakCorrectionTool = "" ) #Workaround for a bug in older versions
+
+ToolSvc += BPHY7CaloIsolationTool
+
+#Calo isolation for candidates
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__VertexCaloIsolation
+BPHY7CaloIsolationDecorator = DerivationFramework__VertexCaloIsolation(
+ name = "BPHY7CaloIsolationDecorator",
+ OutputLevel = INFO,
+ CaloIsoTool = BPHY7CaloIsolationTool, #"xAOD::CaloIsolationTool",
+ TrackContainer = "InDetTrackParticles",
+ InputVertexContainer = "BPHY7Tau3MuCandidates",
+ CaloClusterContainer = "CaloCalTopoClusters",
+ ParticleCaloExtensionTool = "Trk::ParticleCaloExtensionTool/ParticleCaloExtensionTool",
+ PassFlags = ["passed_Tau3MuLoose", "passed_Ds2MuPi"] )
+
+ToolSvc += BPHY7CaloIsolationDecorator
+
+#====================================================================
+# Skimming tool to select only events with the correct vertices
+#====================================================================
+
+#--------------------------------------------------------------------
+## 9/ select the event. We only want to keep events that contain certain three-mu vertices which passed certain selection.
+## Exactly like in the preselection, where only 2mu vertices are treated.
+
+expression = "count(BPHY7Tau3MuCandidates.passed_Tau3MuLoose) > 0 || count(BPHY7Tau3MuCandidates.passed_Ds2MuPi) > 0"
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY7_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = "BPHY7_SelectEvent",
+ OutputLevel = INFO,
+ expression = expression)
+
+ToolSvc += BPHY7_SelectEvent
+print(BPHY7_SelectEvent)
+
+#====================================================================
+# Add Extrapolation of muons to trigger layers
+#====================================================================
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__MuonExtrapolationTool
+BPHY7_Extrap_Tool = DerivationFramework__MuonExtrapolationTool( name = "BPHY7_ExtrapolationTool", OutputLevel = INFO )
+
+ToolSvc += BPHY7_Extrap_Tool
+
+
+#====================================================================
+# Thinning Helper and various thinning tools
+#====================================================================
+
+#--------------------------------------------------------------------
+## 10/ Setup the thinning helper, only tool able to perform thinning of trigger navigation information
+
+from DerivationFrameworkCore.ThinningHelper import ThinningHelper
+BPHY7ThinningHelper = ThinningHelper( "BPHY7ThinningHelper" )
+BPHY7ThinningHelper.TriggerChains = 'HLT_.*mu.*' #triggerList # . = any character; * = 0 or more times; + = 1 or more times; ? 0 or 1 times "Regular_Expression"
+BPHY7ThinningHelper.AppendToStream( BPHY7Stream )
+
+
+#--------------------------------------------------------------------
+## 11/ track and vertex thinning. We want to remove all reconstructed secondary vertices
+## which haven't passed any of the selections defined by (Select_*) tools.
+## We also want to keep only tracks which are associates with either muons or any of the
+## vertices that passed the selection. Multiple thinning tools can perform the
+## selection. The final thinning decision is based OR of all the decisions (by default,
+## although it can be changed by the JO).
+
+## 12/ Cleans up, removing duplicate vertices. An issue caused by the logic of Jpsi+1 track in the case of 3-muon candidates
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxDuplicates
+BPHY7Thin_vtxDuplicates = DerivationFramework__Thin_vtxDuplicates(name = "BPHY7Thin_vtxDuplicates",
+ OutputLevel = INFO,
+ VertexContainerName = "BPHY7Tau3MuCandidates",
+ PassFlags = ["passed_Tau3MuLoose", "passed_Ds2MuPi"])
+
+ToolSvc += BPHY7Thin_vtxDuplicates
+
+## a) thining out vertices that didn't pass any selection and idetifying tracks associated with
+## selected vertices. The "VertexContainerNames" is a list of the vertex containers, and "PassFlags"
+## contains all pass flags for Select_* tools that must be satisfied. The vertex is kept is it
+## satisfy any of the listed selections.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY7Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = "BPHY7Thin_vtxTrk",
+ OutputLevel = INFO,
+ TrackParticleContainerName = "InDetTrackParticles",
+ AcceptanceRadius = 1.,
+ VertexContainerNames = ["BPHY7Tau3MuCandidates"],
+ PassFlags = ["passed_Tau3MuLoose", "passed_Ds2MuPi"],
+ ApplyAnd = True ) # "and" requirement for Vertices
+
+ToolSvc += BPHY7Thin_vtxTrk
+
+
+## 13/ thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+## between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY7MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = "BPHY7MuonTPThinningTool",
+ MuonKey = "Muons",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY7MuonTPThinningTool
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__BPhysPVThinningTool
+BPHY7_thinningTool_PV = DerivationFramework__BPhysPVThinningTool(name = "BPHY7_thinningTool_PV",
+ CandidateCollections = ["BPHY7Tau3MuCandidates"],
+ KeepPVTracks =True)
+
+ToolSvc += BPHY7_thinningTool_PV
+
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__TauTrackParticleThinning
+BPHY7TauTPThinningTool = DerivationFramework__TauTrackParticleThinning(name = "BPHY7TauTPThinningTool",
+ TauKey = "TauJets",
+ InDetTrackParticlesKey = "InDetTrackParticles")
+ToolSvc += BPHY7TauTPThinningTool
+
+# Only save truth informtion directly associated with: mu Ds+ D+ D*+ Ds*+ D0 D*0 B+ B*+ B0 B*0
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY7TruthThinTool = DerivationFramework__GenericTruthThinning(name = "BPHY7TruthThinTool",
+ ParticleSelectionString = "abs(TruthParticles.pdgId) == 13 || abs(TruthParticles.pdgId) == 431 || abs(TruthParticles.pdgId) == 411 || abs(TruthParticles.pdgId) == 413 || abs(TruthParticles.pdgId) == 433 || TruthParticles.pdgId == 421 || TruthParticles.pdgId == 423 || abs(TruthParticles.pdgId) == 521 || abs(TruthParticles.pdgId) == 523 || TruthParticles.pdgId == 511 || TruthParticles.pdgId == 513",
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY7TruthThinTool
+
+# Only save truth neutrino and b/c quarks information
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY7TruthThinNoChainTool = DerivationFramework__GenericTruthThinning(name = "BPHY7TruthThinNoChainTool",
+ ParticleSelectionString = "abs(TruthParticles.pdgId) == 4 || abs(TruthParticles.pdgId) == 5 || abs(TruthParticles.pdgId) == 12 || abs(TruthParticles.pdgId) == 14 || abs(TruthParticles.pdgId) == 16",
+ PreserveDescendants = False,
+ PreserveAncestors = False)
+ToolSvc += BPHY7TruthThinNoChainTool
+
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+
+BPHY7ThinningTools = [ BPHY7MuonTPThinningTool, BPHY7Thin_vtxDuplicates, BPHY7Thin_vtxTrk, BPHY7_thinningTool_PV, BPHY7TauTPThinningTool]
+
+BPHY7SkimmingTools = [BPHY7_SelectEvent]
+
+BPHY7AugmentationTools = [BPHY7DiMuon_SelectAndWrite, BPHY7DiMuon_Decorator, BPHY7ThreeMuon_SelectAndWrite, BPHY7ThreeMuon_Decorator, BPHY7ThreeMuon_Decorator2, BPHY7TrackIsolationDecorator, BPHY7CaloIsolationDecorator]
+
+if addMuExtrapolationForTrigger:
+ BPHY7AugmentationTools.append(BPHY7_Extrap_Tool)
+
+Kernel1Tools = [BPHY7TriggerSkim]
+
+if isSimulation:
+ #BPHY7AugmentationTools.append(DFCommonTauTruthMatchingWrapper)
+ if thinTruth:
+ BPHY7ThinningTools.append(BPHY7TruthThinTool)
+ BPHY7ThinningTools.append(BPHY7TruthThinNoChainTool)
+
+#The sequence object. Is in principle just a wrapper which allows to run two kernels in sequence
+BPHY7_Sequence = CfgMgr.AthSequencer("BPHY7_Sequence")
+from DerivationFrameworkFlavourTag.FlavourTagCommon import FlavorTagInit
+FlavorTagInit(JetCollections=['AntiKt4EMPFlowJets'], Sequencer=BPHY7_Sequence)
+
+
+#onlyAugmentations implementation
+if onlyAugmentations:
+ Kernel1Tools = []
+ BPHY7SkimmingTools = []
+ BPHY7ThinningTools = []
+
+# Kernel n1 PRESELECTION
+# The name of the kernel (BPHY7Kernel1 in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+BPHY7_Sequence += CfgMgr.DerivationFramework__DerivationKernel("BPHY7Kernel1",
+ AugmentationTools = [BPHY7TriggerCountToMetadata] ,
+ SkimmingTools = Kernel1Tools)
+# Kernel n2 deep Derivation
+# The name of the kernel (BPHY7Kernel2 in this case) must be unique to this derivation
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+BPHY7_Sequence += CfgMgr.DerivationFramework__DerivationKernel("BPHY7Kernel2",
+ AugmentationTools = BPHY7AugmentationTools,
+ SkimmingTools = BPHY7SkimmingTools,
+ ThinningTools = BPHY7ThinningTools)
+
+#Vital, replaces the adding of kernels directly
+DerivationFrameworkJob += BPHY7_Sequence
+
+#====================================================================
+# Slimming
+#====================================================================
+
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY7SlimmingHelper = SlimmingHelper("BPHY7SlimmingHelper")
+
+
+SmartCollections = ["Electrons", "Photons", "TauJets", "AntiKt4EMTopoJets_BTagging201810", "BTagging_AntiKt4EMTopo_201810", "PrimaryVertices", "Muons", "InDetTrackParticles", "MET_Reference_AntiKt4EMTopo"]
+
+
+AllVariables = ["METAssoc_AntiKt4EMTopo",
+ "MET_Core_AntiKt4EMTopo",
+ "MET_Truth",
+ "MET_Track",
+ "MET_LocHadTopo"]
+
+AllVariables += ["Kt4EMTopoOriginEventShape",
+ "Kt4EMTopoEventShape"]
+
+AllVariables += ["CombinedMuonTrackParticles",
+ "ExtrapolatedMuonTrackParticles",
+ "MuonSpectrometerTrackParticles"]
+
+
+ExtraVariables = ["Photons.pt.eta.phi.m",
+ "Electrons.pt.eta.phi.m","TauJets.pt.eta.phi.m.IsTruthMatched.truthJetLink.truthParticleLink",
+ "AntiKt4EMTopoJets_BTagging201810.JetPileupScaleMomentum_pt.JetPileupScaleMomentum_eta.JetPileupScaleMomentum_phi.JetPileupScaleMomentum_m",
+ "AntiKt4EMTopoJets_BTagging201810.JvtJvfcorr.HECFrac.LArQuality.HECQuality.NegativeE.AverageLArQF",
+ "AntiKt4EMTopoJets_BTagging201810.JetEtaJESScaleMomentum_pt.JetEtaJESScaleMomentum_eta.JetEtaJESScaleMomentum_phi.JetEtaJESScaleMomentum_m"]
+
+ExtraVariables += ["Muons.etaLayer1Hits.etaLayer2Hits.etaLayer3Hits.etaLayer4Hits.phiLayer1Hits.phiLayer2Hits.phiLayer3Hits.phiLayer4Hits",
+ "Muons.numberOfTriggerEtaLayers.numberOfPhiLayers",
+ "CombinedMuonTrackParticles.numberOfTRTHits.numberOfTRTHighThresholdHits",
+ "InDetTrackParticles.numberOfTRTHits.numberOfTRTHighThresholdHits.vx.vy.vz",
+ "PrimaryVertices.chiSquared.covariance"]
+
+
+StaticContent = ["xAOD::VertexContainer#BPHY7RefittedPrimaryVertices",
+ "xAOD::VertexAuxContainer#BPHY7RefittedPrimaryVerticesAux."]
+
+# ThreeBody candidates (vertices)
+StaticContent += ["xAOD::VertexContainer#%s" % BPHY7ThreeMuon_SelectAndWrite.OutputVtxContainerName]
+StaticContent += ["xAOD::VertexAuxContainer#%sAux." % BPHY7ThreeMuon_SelectAndWrite.OutputVtxContainerName]
+## we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+StaticContent += ["xAOD::VertexAuxContainer#%sAux.-vxTrackAtVertex" % BPHY7ThreeMuon_SelectAndWrite.OutputVtxContainerName]
+
+# Truth information for MC only
+if isSimulation:
+ AllVariables += ["TruthEvents","TruthParticles","TruthVertices","MuonTruthParticles", "METMap_Truth"]
+ SmartCollections += ["AntiKt4TruthJets"]
+
+# Needed for trigger objects
+BPHY7SlimmingHelper.IncludeMuonTriggerContent = True
+BPHY7SlimmingHelper.IncludeBPhysTriggerContent = True
+
+# Pass all lists to the SlimmingHelper
+BPHY7SlimmingHelper.ExtraVariables = ExtraVariables
+BPHY7SlimmingHelper.AllVariables = AllVariables
+BPHY7SlimmingHelper.StaticContent = StaticContent
+BPHY7SlimmingHelper.SmartCollections = SmartCollections
+BPHY7SlimmingHelper.AppendContentToStream(BPHY7Stream)
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY8.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY8.py
new file mode 100644
index 00000000000..5e3de69ae0d
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY8.py
@@ -0,0 +1,2200 @@
+#====================================================================
+#
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+#
+# @file BPHY8.py
+#
+# @author W. Walkowiak, <wolfgang.walkowiak@cern.ch>
+#
+# Based on example derivation formats.
+# It requires the reductionConf flag BPHY8 in Reco_tf.py
+#
+# Produces DxAODs for the B(s)->mu+mu- analysis including the reference
+# channels B+->J/psiK+ and Bs->J/psiPhi:
+# * For data vertex containers for all three channels are produced
+# in parallel.
+# * For signal or reference channel MC the appropriate configuration
+# is set according to the dataset number (DSN). The list associating
+# known dataset numbers to decay channels (below) needs to be adjusted
+# in case there are new MC samples with new numbers.
+#
+#====================================================================
+# Set up common services and job object.
+# This should appear in ALL derivation job options
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+
+# for debugging output
+from pprint import pprint
+from egammaRec.Factories import getPropertyValue
+
+# more debug messages
+## svcMgr.MessageSvc.debugLimit = 5000000
+## svcMgr.MessageSvc.debugLimit = 5000
+
+# Set up Bmumu configuration (metadata) tracking tool.
+# This tool imports our defaults from Bmumu_metadata.cxx.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__Bmumu_metadata
+BPHY8_MetaDataTool = DerivationFramework__Bmumu_metadata(
+ name = "BPHY8_metadata",
+ DerivationName = "BPHY8",
+ OutputLevel = WARNING,
+ # verbosity of python script (0 - 10)
+ verbose = 10
+)
+# local shorthand and ensure default contents of __slots__ dict are
+# available as attributes
+from DerivationFrameworkBPhys.BPhysPyHelpers import BPhysEnsureAttributes
+BPHY8cf = BPhysEnsureAttributes(BPHY8_MetaDataTool)
+
+# add it to the ToolSvc chain
+ToolSvc += BPHY8_MetaDataTool
+
+print(BPHY8_MetaDataTool)
+pprint(BPHY8_MetaDataTool.properties())
+
+# data or simulation?
+if globalflags.DataSource() == 'geant4':
+ BPHY8cf.isSimulation = True
+
+# project tag
+BPHY8cf.projectTag = rec.projectName()
+
+# trigger stream name
+from RecExConfig.InputFilePeeker import inputFileSummary
+if inputFileSummary is not None:
+ BPHY8cf.triggerStream = inputFileSummary['tag_info']['triggerStreamOfFile']
+
+# release 21 or newer?
+from PyJobTransforms.trfUtils import releaseIsOlderThan
+BPHY8cf.isRelease21 = not releaseIsOlderThan(21,0)
+
+# MC campaigns by MC run number
+BPHY8MCcampaigns = {284500 : 'mc16a',
+ 300000 : 'mc16d',
+ 310000 : 'mc16e'}
+
+# run number and MC campaign by MC run number
+from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
+import PyUtils.AthFile as BPHY8_af
+BPHY8_f = BPHY8_af.fopen(athenaCommonFlags.PoolAODInput()[0])
+BPHY8cf.mcCampaign = 'unknown'
+if len(BPHY8_f.run_numbers) > 0:
+ BPHY8cf.runNumber = int(BPHY8_f.run_numbers[0])
+ if BPHY8cf.isSimulation and BPHY8cf.runNumber in BPHY8MCcampaigns:
+ BPHY8cf.mcCampaign = BPHY8MCcampaigns[BPHY8cf.runNumber]
+
+print("BPHY8: isSimulation = %s" % BPHY8cf.isSimulation)
+print("BPHY8: project tag = %s" % BPHY8cf.projectTag)
+print("BPHY8: MC campaign = %s" % BPHY8cf.mcCampaign)
+print("BPHY8: DerivationFrameworkHasTruth = %s" % \
+ DerivationFrameworkHasTruth)
+print("BPHY8: release 21 or up: %s" % BPHY8cf.isRelease21)
+
+#====================================================================
+# MC dataset categories (lists of dataset numbers)
+#====================================================================
+BPHY8cf.mcBsmumu = [300203,300306,300307,300308,300402,300426,300430,300446,300447]
+BPHY8cf.mcBplusJpsiKplus = [300203,300306,300307,300308,300997,300999,300404,300405,300406,300437]
+BPHY8cf.mcBsJpsiPhi = [300203,300306,300307,300308,300401,300438,300448,300449]
+BPHY8cf.mcBplusJpsiPiplus = [300406,300437]
+BPHY8cf.mcBhh = [300431,300432,300433,300434]
+BPHY8cf.mcNoTrigger = [300446,300447,300448,300449]
+
+#====================================================================
+# Data datasets to receive special treatment
+#====================================================================
+# Remember our special runs used during validation
+## BPHY8cf.specDataRuns = [302393,339849,358096]
+BPHY8cf.specDataRuns = []
+#
+# for testing only
+## BPHY8cf.specDataRuns += [337491]
+
+#====================================================================
+# MC datasets to receive special treatment
+#====================================================================
+# Remember our special MC datasets used during validation
+## BPHY8cf.specMcChannels = [300307,300404,300405,300426,300430,300438]
+BPHY8cf.specMcChannels = []
+#
+#====================================================================
+# Defaults for BPHY8 configuration
+#====================================================================
+#
+# Blind search setup
+#
+# Enable?
+BPHY8cf.doBmumuBlinding = True
+# Cut blinded values/vertices?
+BPHY8cf.doCutBlinded = False
+## BPHY8cf.doCutBlinded = True
+# Blind only candidates where all muons are of quality tight
+BPHY8cf.blindOnlyAllMuonsTight = True
+# Variables to blind (of vertices)
+BPHY8cf.BlindedVars = "Bsmumu_mass.Bsmumu_MUCALC_mass"
+# Pass flag indicating blinded candidates
+BPHY8cf.BlindingFlag = "Bsmumu_blinded"
+# Blinding key for testing
+## BPHY8cf.BlindingKey = "0b0408d1f5c4760e7d4b50e97095"
+# Blinding key for production
+# key for Run 2 - 2015/16 only analysis
+## BPHY8cf.BlindingKey = "0b04087bdac4564252fd778ac351"
+# keys for full Run 2 analysis
+BPHY8_data15BlindingKey = "0b040820229968c09fec401ace33"
+BPHY8_data16BlindingKey = "0b04083901ad3d2bb3881ffca6a7"
+BPHY8_data17BlindingKey = "0b040831a13a9c83f9936cf5b703"
+BPHY8_data18BlindingKey = "0b040893fc715e9b346759bf4f3b"
+# default is data15
+BPHY8cf.BlindingKey = BPHY8_data15BlindingKey
+#
+# Thinning level
+# 0 - simple vertex thinning using Thin_vtxTrk.
+# 1 - thinning subdecay vertex candidates using Thin_vtxTrk.
+# 2 - thinning subdecay vertex candidates using BmumuThinningTool.
+# 3 - thinning subdecay vertex candidates using BmumuThinningTool,
+# but keeping all PVs and refittedPVs
+# 4 - thinning subdecay vertex candidates using BmumuThinningTool,
+# but keeping all PVs and refittedPVs and all ID tracks
+# 5 - thinning subdecay vertex candidates using BmumuThinningTool,
+# but keeping all PVs, all refittedPVs, all ID tracks and all muons
+#
+BPHY8cf.thinLevel = 3
+#
+# Track particle collection
+BPHY8cf.TrkPartContName = "InDetTrackParticles"
+#
+# Primary vertex collection
+BPHY8cf.PVContName = "PrimaryVertices"
+#
+# Trigger navigation object thinning
+#
+# Apply thinning?
+BPHY8cf.doTrigNavThinning = True
+#
+# Keep muon based HLT items for now
+BPHY8cf.TrigNavThinList = [ "HLT_[0-9]*mu[0-9]+.*" ]
+#
+# Add containers for soft B tagging vertices
+BPHY8cf.doAddSoftBVertices = True
+#
+# Muon collection
+BPHY8cf.MuonCollection = "Muons"
+#
+# Apply MCP calibration to muons? (only for MC)
+#
+# Options:
+# 0 : none
+# 1 : apply calibration on-the-fly inside the muon container
+# (calibration effects B candidate building)
+# 2 : apply calibration and store it in an extra container for
+# calibrated muons
+# (calibration does not effect B candidate building)
+# 3 : apply calibration and store it in an extra container for
+# calibrated muons and use this container for B candidate building
+#
+BPHY8cf.useCalibratedMuons = 3
+## BPHY8cf.useCalibratedMuons = 2
+
+# make sure data are not affected
+# Update: Needs to be applied to data as well
+## if not BPHY8cf.isSimulation:
+## BPHY8cf.useCalibratedMuons = 0
+
+#
+# Configuration for MuonCalibrationAndSmearingTool
+#
+# Set string values to "_READ_" to only read the default values
+# from the tool.
+#
+# THE FOLLOWING COMMENT IS VOID AS OF 2017-07-30.
+# Note: Several JOs of the MuonCalibrationAndSmearingTool are not
+# (yet) available in AtlasDerivation-20.7.8.x caches which uses
+# MuonMomentumCorrections-01-00-35 instead of the latest
+# MuonMomentumCorrections-01-00-60.
+# For now these options will be disabled further below.
+#
+# Note: (2018-05-05 -> 2018-11-29)
+# Formerly used the rel. 21 pre-recommendations from
+# https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MCPAnalysisGuidelinesMC16
+#
+# Note: (2018-11-29)
+# Now updated to new rel. 21 pre-recommendations
+# Page revision r18 (as of 2018-11-27)
+# https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MCPAnalysisConsolidationMC16
+#
+# Note: (2020-01-15)
+# Now updated to new release 21 recommendatons for full run 2 (winter update)
+# Page revision r17 (as of 2019-11-13)
+# https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MCPAnalysisWinterMC16#Momentum_corrections
+#
+# Note: (2020-03-31)
+# Now updated to new release 21 recommendations for full run 2 / setup 1
+# Page reivision r37 (as of 2020-03-23)
+# https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MCPAnalysisGuidelinesMC16#Momentum_corrections
+#
+# MC
+if BPHY8cf.isSimulation:
+#
+# for MC16a
+ if BPHY8cf.mcCampaign == "mc16a":
+ BPHY8cf.McstYear = "Data16"
+ BPHY8cf.McstRelease = "Recs2020_03_03"
+ BPHY8cf.McstStatComb = False
+ BPHY8cf.McstSagittaCorr = True
+ BPHY8cf.McstSagittaRelease = "sagittaBiasDataAll_03_02_19_Data16"
+ BPHY8cf.McstDoSagittaMCDistortion = False
+ BPHY8cf.McstSagittaCorrPhaseSpace = True
+#
+# for MC16d
+ elif BPHY8cf.mcCampaign == "mc16d":
+ BPHY8cf.McstYear = "Data17"
+ BPHY8cf.McstRelease = "Recs2020_03_03"
+ BPHY8cf.McstStatComb = False
+ BPHY8cf.McstSagittaCorr = True
+ BPHY8cf.McstSagittaRelease = "sagittaBiasDataAll_03_02_19_Data17"
+ BPHY8cf.McstDoSagittaMCDistortion = False
+ BPHY8cf.McstSagittaCorrPhaseSpace = True
+#
+# for MC16e
+ elif BPHY8cf.mcCampaign == "mc16e":
+ BPHY8cf.McstYear = "Data18"
+ BPHY8cf.McstRelease = "Recs2020_03_03"
+ BPHY8cf.McstStatComb = False
+ BPHY8cf.McstSagittaCorr = True
+ BPHY8cf.McstSagittaRelease = "sagittaBiasDataAll_03_02_19_Data18"
+ BPHY8cf.McstDoSagittaMCDistortion = False
+ BPHY8cf.McstSagittaCorrPhaseSpace = True
+#
+# default (like for mc16a)
+ else:
+ BPHY8cf.McstYear = "Data16"
+ BPHY8cf.McstRelease = "Recs2020_03_03"
+ BPHY8cf.McstStatComb = False
+ BPHY8cf.McstSagittaCorr = True
+ BPHY8cf.McstSagittaRelease = "sagittaBiasDataAll_03_02_19_Data16"
+ BPHY8cf.McstDoSagittaMCDistortion = False
+ BPHY8cf.McstSagittaCorrPhaseSpace = True
+#
+# data 15
+else:
+ # Note: The recommendation page sets McstYear to 'Data16'
+ if BPHY8cf.projectTag.startswith("data15"):
+ BPHY8cf.McstYear = "Data16"
+ BPHY8cf.McstRelease = "Recs2020_03_03"
+ BPHY8cf.McstStatComb = False
+ BPHY8cf.McstSagittaCorr = True
+ BPHY8cf.McstSagittaRelease = "sagittaBiasDataAll_03_02_19_Data16"
+ BPHY8cf.McstDoSagittaMCDistortion = False
+ BPHY8cf.McstSagittaCorrPhaseSpace = True
+#
+# data 16
+ if BPHY8cf.projectTag.startswith("data16"):
+ BPHY8cf.McstYear = "Data16"
+ BPHY8cf.McstRelease = "Recs2020_03_03"
+ BPHY8cf.McstStatComb = False
+ BPHY8cf.McstSagittaCorr = True
+ BPHY8cf.McstSagittaRelease = "sagittaBiasDataAll_03_02_19_Data16"
+ BPHY8cf.McstDoSagittaMCDistortion = False
+ BPHY8cf.McstSagittaCorrPhaseSpace = True
+#
+# data 17
+ if BPHY8cf.projectTag.startswith("data17"):
+ BPHY8cf.McstYear = "Data17"
+ BPHY8cf.McstRelease = "Recs2020_03_03"
+ BPHY8cf.McstStatComb = False
+ BPHY8cf.McstSagittaCorr = True
+ BPHY8cf.McstSagittaRelease = "sagittaBiasDataAll_03_02_19_Data17"
+ BPHY8cf.McstDoSagittaMCDistortion = False
+ BPHY8cf.McstSagittaCorrPhaseSpace = True
+#
+# data 18
+ if BPHY8cf.projectTag.startswith("data18"):
+ BPHY8cf.McstYear = "Data18";
+ BPHY8cf.McstRelease = "Recs2020_03_03"
+ BPHY8cf.McstStatComb = False
+ BPHY8cf.McstSagittaCorr = True
+ BPHY8cf.McstSagittaRelease = "sagittaBiasDataAll_03_02_19_Data18"
+ BPHY8cf.McstDoSagittaMCDistortion = False
+ BPHY8cf.McstSagittaCorrPhaseSpace = True
+
+# wide mumu mass range?
+BPHY8cf.doUseWideMuMuMassRange = False
+
+# other default settings
+BPHY8cf.GlobalChi2CutBase = 15.
+
+# Global mass values (in MeV, from PDG 2015)
+BPHY8cf.GlobalMuonMass = 105.6584
+BPHY8cf.GlobalPionMass = 139.57061
+BPHY8cf.GlobalKaonMass = 493.677
+BPHY8cf.GlobalJpsiMass = 3096.92
+BPHY8cf.GlobalBplusMass = 5279.29
+BPHY8cf.GlobalB0Mass = 5279.61
+BPHY8cf.GlobalBsMass = 5366.79
+
+# Cut values for kaon candidates
+BPHY8cf.GlobalKaonPtCut = 1000.
+BPHY8cf.GlobalKaonEtaCut = 2.5
+
+# primary vertex association types (interpreted bit-wise)
+## BPHY8cf.doVertexType = 15 # ALL
+BPHY8cf.doVertexType = 8 # only Z0_BA
+## BPHY8cf.doVertexType = 9 # only SUM_PT2 and Z0_BA
+
+# minimum number of tracks in PV considered for PV association
+BPHY8cf.minNTracksInPV = 3
+
+# add 3-dimensional proper time information?
+BPHY8cf.do3dProperTime = True
+
+# use invariant mass based on combined muon track information in mass cuts?
+BPHY8cf.useMuCalcMass = True
+
+# add MUCALC mass from non-modified muons for debugging
+BPHY8cf.addMucalcMassForDebug = False
+
+# PV types to be considered in calculation of minLogChi2ToAnyPV variable
+BPHY8cf.MinChi2ToAnyPVTypes = [1, 3]
+
+# MCP cuts for JpsiFinder
+BPHY8cf.useJpsiFinderMCPCuts = False
+
+# reject muons in JpsiPlus1Track or JpsiPlus2Track finders
+BPHY8cf.GlobalMuonsUsedInJpsi = "NONE" # default to turn it off
+
+# mode of minLogChi2ToAnyPV calculation:
+# 0 : no such calculation
+# 1 : use all PVs of requested type(s)
+# 2 : exclude PVs associated to SVs
+# 3 : replace PVs associated to SVs by
+# corresponding refitted PVs
+BPHY8cf.AddMinChi2ToAnyPVMode = 3
+
+# Vertex isolation -- track selection requirements
+# (Sizes of all lists below need to be identical!)
+# Set to "Custom" (for strings) or -1. (for numerics) to disable setting
+BPHY8cf.IsoTrackCategoryName = ["LoosePt05", "LooSiHi1Pt05"]
+BPHY8cf.IsoTrackCutLevel = ["Loose" , "Loose" ]
+BPHY8cf.IsoTrackPtCut = [ 500. , 500. ]
+BPHY8cf.IsoTrackEtaCut = [ -1. , -1. ]
+BPHY8cf.IsoTrackPixelHits = [ -1 , 1 ]
+BPHY8cf.IsoTrackSCTHits = [ -1 , 2 ]
+BPHY8cf.IsoTrackbLayerHits = [ -1 , -1 ]
+BPHY8cf.IsoTrackIBLHits = [ -1 , -1 ]
+# Vertex isolation -- cone sizes
+# (Sizes of all lists below need to be identical!)
+# Note: IsoDoTrkImpLogChi2Cut = 2 implements old method used
+# for the 2015/16 analysis
+BPHY8cf.IsolationConeSizes = [ 0.7, 0.7, 1.0]
+BPHY8cf.IsoTrkImpLogChi2Max = [ 5.0, 5.0, 0.0]
+BPHY8cf.IsoDoTrkImpLogChi2Cut = [ 2 , 1 , 0 ]
+# Track types to be used (bit pattern)
+# track sets to consider:
+# bit : meaning
+# 0 : tracks close to PV associated
+# with SV
+# 1 : tracks associated with dummy PV
+# ("type-0 PV tracks")
+# 2 : tracks associated with PV of type 1
+# 3 : tracks associated with PV of type 2
+# 4 : tracks associated with PV of type 3
+# 5 : tracks associated with PV with types other than 0 to 4.
+# 6 : tracks with missing pointer to PV (NULL pointer)
+# 7-24: tracks being closest to assoc. PV
+# decimal useRefittedPVs doDCAin3D chi2DefToUse
+# 7 : 128 yes no 0
+# 8 : 256 no no 0
+# 9 : 512 yes yes 0
+# 10 : 1024 no yes 0
+# 11 : 2048 yes no 1
+# 12 : 4096 no no 1
+# 13 : 8192 yes yes 1
+# 14 : 16384 no yes 1
+# 15 : 32768 yes no 2
+# 16 : 65536 no no 2
+# 17 : 131072 yes yes 2
+# 18 : 262144 no yes 2
+# 19 : 524288 yes -- 3
+# 20 : 1048576 no -- 3
+# 21 : 2097152 yes -- 4
+# 22 : 4194304 no -- 4
+# 23 : 8388608 yes -- 5
+# 24 : 16777216 no -- 5
+# 25 : 33554432 yes yes 6
+# 26 : 67108864 no yes 6
+# 27 : 134217728 yes yes 7
+# 28 : 268435456 no yes 7
+# 29 : 536870912 yes yes 8
+# 30 : 1073741824 no yes 8
+# 31 : 2147483648 yes yes 9
+# 32 : 4294967296 no yes 9
+# useRefittedPVs:
+# replace PV associated to decay candidate
+# by the refitted PV
+# doDCAin3D:
+# use d0 and z0 in the determination of
+# of the point of closest approach of
+# a track to a vertex
+# chi2DefToUse:
+# PV uncertainties in the chi2 calculation
+# in addition to track uncertainties
+# 0 : from track perigee (old method)
+# (only track uncertainties)
+# 1 : from track perigee with
+# uncertainties from track and vertex
+# 2 : simple extrapolation from track
+# parameters with uncertainties from
+# track and vertex (extrapolation
+# used for track swimming)
+# 3 : CalcLogChi2toPV method from NtupleMaker
+# using xAOD::TrackingHelpers.
+# (only track uncertainties)
+# 4 : CalcLogChi2toPV method from NtupleMaker
+# using xAOD::TrackingHelpers.
+# (track and vertex uncertainties)
+# 5 : use TrackVertexAssociationTool
+# 6 : full 3D chi2 from track perigee with uncertainties
+# from track and vertex (sum of 3x3 covariance matrices)
+# 7 : full 3D chi2 from track perigee with uncertainties
+# from track and vertex (sum of 2x2 covariance matrices)
+# 8 : simple extrapolation from track parameters with uncertainties
+# from track and vertex (sum of 3x3 covariance matrices)
+# 9 simple extrapolation from track parameters with uncertainties
+# from track and vertex (sum of 2x2 covariance matrices)
+# (E.g. 127 means to consider all tracks.)
+BPHY8cf.useIsoTrackTypes = [ 35, 8388608, 134217728, 127]
+# Working point for TrackVertexAssociationTool (for chi2DefToUse == 5)
+BPHY8cf.IsoTvaWorkingPoint = "Loose"
+# use of speed-optimized algorithm
+BPHY8cf.IsoUseOptimizedAlgo = True
+## BPHY8cf.IsoUseOptimizedAlgo = False
+#
+# Combinations to keep: save from removal as non-needed branches
+# Tuples: (isolation settings|track types|ID track selection)
+# Note: use an empty list to keep all
+BPHY8cf.IsoIncludes = ['07_LC50d2|35|LoosePt05', # ACH
+ '10_LC00d0|134217728|LooSiHi1Pt05', # BEJ
+ '10_LC00d0|8388608|LooSiHi1Pt05', # BGJ
+ '07_LC50d1|127|LooSiHi1Pt05' ] # BDI
+
+# Isolation for muons from B candidate -- track selection requirements
+# (Sizes of all lists below need to be identical!)
+# Set to "Custom" (for strings) or -1. (for numerics) to disable setting
+BPHY8cf.MuIsoTrackCategoryName = ["LoosePt05", "LooSiHi1Pt05"]
+BPHY8cf.MuIsoTrackCutLevel = ["Loose" , "Loose" ]
+BPHY8cf.MuIsoTrackPtCut = [ 500. , 500. ]
+BPHY8cf.MuIsoTrackEtaCut = [ -1. , -1. ]
+BPHY8cf.MuIsoTrackPixelHits = [ -1 , 1 ]
+BPHY8cf.MuIsoTrackSCTHits = [ -1 , 2 ]
+BPHY8cf.MuIsoTrackbLayerHits = [ -1 , -1 ]
+BPHY8cf.MuIsoTrackIBLHits = [ -1 , -1 ]
+# Muon isolation -- cone sizes
+# (Sizes of all lists below need to be identical!)
+# Note: MuIsoDoTrkImpLogChi2Cut = 2 implements old method used
+# for the 2015/16 analysis
+BPHY8cf.MuIsolationConeSizes = [ 0.7, 0.7, 1.0]
+BPHY8cf.MuIsoTrkImpLogChi2Max = [ 5.0, 5.0, 0.0]
+BPHY8cf.MuIsoDoTrkImpLogChi2Cut = [ 2 , 1 , 0 ]
+# Track types to be used (bit pattern)
+# track sets to consider:
+# bit : meaning
+# 0 : tracks close to PV associated
+# with SV
+# 1 : tracks associated with dummy PV
+# ("type-0 PV tracks")
+# 2 : tracks associated with PV of type 1
+# 3 : tracks associated with PV of type 2
+# 4 : tracks associated with PV of type 3
+# 5 : tracks associated with PV with types other than 0 to 4.
+# 6 : tracks with missing pointer to PV (NULL pointer)
+# 7-24: tracks being closest to assoc. PV
+# decimal useRefittedPVs doDCAin3D chi2DefToUse
+# 7 : 128 yes no 0
+# 8 : 256 no no 0
+# 9 : 512 yes yes 0
+# 10 : 1024 no yes 0
+# 11 : 2048 yes no 1
+# 12 : 4096 no no 1
+# 13 : 8192 yes yes 1
+# 14 : 16384 no yes 1
+# 15 : 32768 yes no 2
+# 16 : 65536 no no 2
+# 17 : 131072 yes yes 2
+# 18 : 262144 no yes 2
+# 19 : 524288 yes -- 3
+# 20 : 1048576 no -- 3
+# 21 : 2097152 yes -- 4
+# 22 : 4194304 no -- 4
+# 23 : 8388608 yes -- 5
+# 24 : 16777216 no -- 5
+# 25 : 33554432 yes yes 6
+# 26 : 67108864 no yes 6
+# 27 : 134217728 yes yes 7
+# 28 : 268435456 no yes 7
+# 29 : 536870912 yes yes 8
+# 30 : 1073741824 no yes 8
+# 31 : 2147483648 yes yes 9
+# 32 : 4294967296 no yes 9
+# useRefittedPVs:
+# replace PV associated to decay candidate
+# by the refitted PV
+# doDCAin3D:
+# use d0 and z0 in the determination of
+# of the point of closest approach of
+# a track to a vertex
+# chi2DefToUse:
+# PV uncertainties in the chi2 calculation
+# in addition to track uncertainties
+# 0 : from track perigee (old method)
+# (only track uncertainties)
+# 1 : from track perigee with
+# uncertainties from track and vertex
+# 2 : simple extrapolation from track
+# parameters with uncertainties from
+# track and vertex (extrapolation
+# used for track swimming)
+# 3 : CalcLogChi2toPV method from NtupleMaker
+# using xAOD::TrackingHelpers.
+# (only track uncertainties)
+# 4 : CalcLogChi2toPV method from NtupleMaker
+# using xAOD::TrackingHelpers.
+# (track and vertex uncertainties)
+# 5 : use TrackVertexAssociationTool
+# 6 : full 3D chi2 from track perigee with uncertainties
+# from track and vertex (sum of 3x3 covariance matrices)
+# 7 : full 3D chi2 from track perigee with uncertainties
+# from track and vertex (sum of 2x2 covariance matrices)
+# 8 : simple extrapolation from track parameters with uncertainties
+# from track and vertex (sum of 3x3 covariance matrices)
+# 9 simple extrapolation from track parameters with uncertainties
+# from track and vertex (sum of 2x2 covariance matrices)
+# (E.g. 127 means to consider all tracks.)
+BPHY8cf.useMuIsoTrackTypes = [ 35, 8388608, 134217728, 127]
+# Working point for TrackVertexAssociationTool (for chi2DefToUse == 5)
+BPHY8cf.MuIsoTvaWorkingPoint = "Loose"
+#
+# Combinations to keep: save from removal as non-needed branches
+# Tuples: (isolation settings|track types|ID track selection)
+# Note: use an empty list to keep all
+BPHY8cf.MuIsoIncludes = ['07_LC50d2|35|LoosePt05', # ACH
+ '10_LC00d0|134217728|LooSiHi1Pt05', # BEJ
+ '10_LC00d0|8388608|LooSiHi1Pt05', # BGJB
+ '07_LC50d1|127|LooSiHi1Pt05' ] # BDI
+
+# Closest track finding -- track selection requirements
+# Set to "Custom" (for strings) or -1. (for numerics) to disable setting
+BPHY8cf.CloseTrackCategoryName = ["LoosePt05", "LooSiHi1Pt05"]
+BPHY8cf.CloseTrackCutLevel = ["Loose" , "Loose" ]
+BPHY8cf.CloseTrackPtCut = [ 500. , 500. ]
+BPHY8cf.CloseTrackEtaCut = [ -1. , -1. ]
+BPHY8cf.CloseTrackPixelHits = [ -1 , 1 ]
+BPHY8cf.CloseTrackSCTHits = [ -1 , 2 ]
+BPHY8cf.CloseTrackbLayerHits = [ -1 , -1 ]
+BPHY8cf.CloseTrackIBLHits = [ -1 , -1 ]
+# Track types to be used (bit pattern)
+# track sets to consider:
+# bit : meaning
+# 0 : tracks close to PV associated
+# with SV
+# 1 : tracks associated with dummy PV
+# ("type-0 PV tracks")
+# 2 : tracks associated with PV of type 1
+# 3 : tracks associated with PV of type 2
+# 4 : tracks associated with PV of type 3
+# 5 : tracks associated with PV with types other than 0 to 4.
+# 6 : tracks with missing pointer to PV (NULL pointer)
+# 7-24: tracks being closest to assoc. PV
+# decimal useRefittedPVs doDCAin3D chi2DefToUse
+# 7 : 128 yes no 0
+# 8 : 256 no no 0
+# 9 : 512 yes yes 0
+# 10 : 1024 no yes 0
+# 11 : 2048 yes no 1
+# 12 : 4096 no no 1
+# 13 : 8192 yes yes 1
+# 14 : 16384 no yes 1
+# 15 : 32768 yes no 2
+# 16 : 65536 no no 2
+# 17 : 131072 yes yes 2
+# 18 : 262144 no yes 2
+# 19 : 524288 yes -- 3
+# 20 : 1048576 no -- 3
+# 21 : 2097152 yes -- 4
+# 22 : 4194304 no -- 4
+# 23 : 8388608 yes -- 5
+# 24 : 16777216 no -- 5
+# 25 : 33554432 yes yes 6
+# 26 : 67108864 no yes 6
+# 27 : 134217728 yes yes 7
+# 28 : 268435456 no yes 7
+# 29 : 536870912 yes yes 8
+# 30 : 1073741824 no yes 8
+# 31 : 2147483648 yes yes 9
+# 32 : 4294967296 no yes 9
+# useRefittedPVs:
+# replace PV associated to decay candidate
+# by the refitted PV
+# doDCAin3D:
+# use d0 and z0 in the determination of
+# of the point of closest approach of
+# a track to a vertex
+# chi2DefToUse:
+# PV uncertainties in the chi2 calculation
+# in addition to track uncertainties
+# 0 : from track perigee (old method)
+# (only track uncertainties)
+# 1 : from track perigee with
+# uncertainties from track and vertex
+# 2 : simple extrapolation from track
+# parameters with uncertainties from
+# track and vertex (extrapolation
+# used for track swimming)
+# 3 : CalcLogChi2toPV method from NtupleMaker
+# using xAOD::TrackingHelpers.
+# (only track uncertainties)
+# 4 : CalcLogChi2toPV method from NtupleMaker
+# using xAOD::TrackingHelpers.
+# (track and vertex uncertainties)
+# 5 : use TrackVertexAssociationTool
+# 6 : full 3D chi2 from track perigee with uncertainties
+# from track and vertex (sum of 3x3 covariance matrices)
+# 7 : full 3D chi2 from track perigee with uncertainties
+# from track and vertex (sum of 2x2 covariance matrices)
+# 8 : simple extrapolation from track parameters with uncertainties
+# from track and vertex (sum of 3x3 covariance matrices)
+# 9 simple extrapolation from track parameters with uncertainties
+# from track and vertex (sum of 2x2 covariance matrices)
+# (E.g. 127 means to consider all tracks.)
+#
+# Correspondence to Run 1 settings:
+#
+# Option to only use tracks from specific primary vertices:
+# (always excluding B decay tracks)
+# CloseTrackOption:
+# old new
+# 0 : 63 : use all tracks (default)
+# 1 : 1 : use only tracks from PV associated with B vertex
+# 2 : 1 : use all tracks which are not from PVs other than
+# PV associated with B vertex
+# 3 : 35 : use all tracks which are not from PVs other than
+# PV associated with B vertex but including those
+# from the dummy vertex (type 0 vertex)
+# 4 : 127: same as option 3 but using the vertex pointers
+# for comparing in old setup; including tracks
+# with broken (NULL) vertex pointers as well
+BPHY8cf.useCloseTrackTypes = [ 35, 8388608, 134217728]
+# Working point for TrackVertexAssociationTool (for chi2DefToUse == 5)
+BPHY8cf.CloseTrackTvaWorkingPoint = "Loose"
+#
+# Close tracks chi2 related settings
+# (The next five lists need to be exactly of the same length.)
+BPHY8cf.CloseTrackChi2SetName = [ "201516", "f2dc2" ]
+# use corrected chi2 calculation including SV uncertainties
+# 0 : from track perigee (old method, only track uncertainties)
+# 1 : from track perigee with uncertainties from track and vertex
+# 2 : simple extrapolation from track parameters with uncertainties
+# from track and vertex (extrapolation used for track swimming)
+# 3 : CalcLogChi2toPV method from NtupleMaker using xAOD::TrackingHelpers.
+# (only track uncertainties)
+# 4 : CalcLogChi2toPV method from NtupleMaker using xAOD::TrackingHelpers.
+# (track and vertex uncertainties)
+# 5 : use TrackVertexAssociationTool
+# 6 : full 3D chi2 from track perigee with uncertainties
+# from track and vertex (sum of 3x3 covariance matrices)
+# 7 : full 3D chi2 from track perigee with uncertainties
+# from track and vertex (sum of 2x2 covariance matrices)
+# 8 : simple extrapolation from track parameters with uncertainties
+# from track and vertex (sum of 3x3 covariance matrices)
+# 9 simple extrapolation from track parameters with uncertainties
+# from track and vertex (sum of 2x2 covariance matrices)
+# N.B.: Settings 3, 4 and 5 may be less reasonable here. Do not use.
+BPHY8cf.CloseTrackCorrChi2 = [ 0 , 7 ]
+# use 3-dimensional information in minimization
+BPHY8cf.CloseTrackMinDCAin3D = [ True , True ]
+# maximum chi2 distance of closest track to B vertex
+BPHY8cf.CloseTrackMaxLogChi2 = [ 7. , 7. ]
+# maximum chi2 distance of closest track to B vertex for track counting
+BPHY8cf.NCloseTrackMaxLogChi2 = [ 1. , 2. ]
+#
+# Combinations to keep: save from removal as non-needed branches
+# Tuples: (close track chi2 set|track types|ID track selection)
+# Note: use an empty list to keep all
+BPHY8cf.CloseTrackIncludes = ['201516|35|LoosePt05', # ACK
+ 'f2dc2|134217728|LooSiHi1Pt05', # BEL
+ 'f2dc2|8388608|LooSiHi1Pt05' ] # BGL
+
+# track/muon isolation and closest track tools
+# debugging level for track types (output to log)
+# (Set to 1 to enable, 0 otherwise.)
+BPHY8cf.DebugTrackTypes = 0
+
+# BTrackVertexMapLogger / BPhysTrackVertexMapTools
+# maximum number of events to dump track-to-vertex assoc. maps for
+# (Set to -1 for no limit, to 0 to disable.)
+BPHY8cf.DebugTrkToVtxMaxEvents = 0
+#====================================================================
+# General job setup
+#====================================================================
+# for MC run specific channel(s) only,
+# for data run 2-, 3- and 4-prong algorithms in parallel
+if BPHY8cf.isSimulation:
+ # MC channel number (ie dataset number for MC)
+ if len(BPHY8_f.infos['mc_channel_number']) > 0:
+ BPHY8cf.mcChNumber = int((BPHY8_f.infos['mc_channel_number'])[0])
+ if (BPHY8cf.mcChNumber in BPHY8cf.mcBsmumu):
+ BPHY8cf.doChannels.append("Bsmumu")
+ if (BPHY8cf.mcChNumber in BPHY8cf.mcBplusJpsiKplus):
+ BPHY8cf.doChannels.append("BJpsiK")
+ if (BPHY8cf.mcChNumber in BPHY8cf.mcBsJpsiPhi):
+ BPHY8cf.doChannels.append("BsJpsiPhi")
+ if (BPHY8cf.mcChNumber in BPHY8cf.mcBplusJpsiPiplus):
+ BPHY8cf.doChannels.append("BJpsiPi")
+ if (BPHY8cf.mcChNumber in BPHY8cf.mcBhh):
+ BPHY8cf.doChannels.append("Bhh")
+ # use trigger?
+ if (BPHY8cf.mcChNumber in BPHY8cf.mcNoTrigger):
+ BPHY8cf.doTriggerInfo = False
+ # for special MC channels keep all ID tracks and all muons
+ if BPHY8cf.mcChNumber in BPHY8cf.specMcChannels:
+ BPHY8cf.thinLevel = 5
+ # no blind search for MC
+ BPHY8cf.doBmumuBlinding = False
+else:
+ # for data
+ BPHY8cf.doChannels += ["Bsmumu", "BJpsiK", "BsJpsiPhi"]
+ # for special data runs keep all ID tracks and all muons
+ if BPHY8cf.runNumber in BPHY8cf.specDataRuns:
+ BPHY8cf.thinLevel = 5
+ # blinding key by year
+ if BPHY8cf.projectTag.startswith("data15"):
+ BPHY8cf.BlindingKey = BPHY8_data15BlindingKey
+ elif BPHY8cf.projectTag.startswith("data16"):
+ BPHY8cf.BlindingKey = BPHY8_data16BlindingKey
+ elif BPHY8cf.projectTag.startswith("data17"):
+ BPHY8cf.BlindingKey = BPHY8_data17BlindingKey
+ elif BPHY8cf.projectTag.startswith("data18"):
+ BPHY8cf.BlindingKey = BPHY8_data18BlindingKey
+
+# disable soft B tagging vertices if BJpsiK channel is not run
+if not "BJpsiK" in BPHY8cf.doChannels:
+ BPHY8cf.doAddSoftBVertices = False
+
+print("BPHY8 job setup: run : %d" % BPHY8cf.runNumber)
+print("BPHY8 job setup: MC channel number : %d" % BPHY8cf.mcChNumber)
+print("BPHY8 job setup: isSimulation : %s" % BPHY8cf.isSimulation)
+print("BPHY8 job setup: doChannels :", end=' ')
+for BPHY8_channel in BPHY8cf.doChannels:
+ print("%s" % (BPHY8_channel), end=' ')
+print()
+print("BPHY8 job setup: thin level : %d" % BPHY8cf.thinLevel)
+print("BPHY8 job setup: soft B vertices : %d" % BPHY8cf.doAddSoftBVertices)
+
+# abort if no channels are to be run on
+assert len(BPHY8cf.doChannels) > 0
+
+#====================================================================
+# Mass ranges
+#====================================================================
+BPHY8cf.GlobalBMassUpperCut = 7000.
+BPHY8cf.GlobalBMassLowerCut = 3500.
+BPHY8cf.GlobalTrksMassUpperCut = 7500.
+BPHY8cf.GlobalTrksMassLowerCut = 3000.
+BPHY8cf.GlobalDiMuonMassUpperCut = 7000.
+BPHY8cf.GlobalDiMuonMassLowerCut = 2000.
+BPHY8cf.GlobalJpsiMassUpperCut = 7000.
+BPHY8cf.GlobalJpsiMassLowerCut = 2000.
+BPHY8cf.GlobalBlindLowerCut = 5166.
+BPHY8cf.GlobalBlindUpperCut = 5526.
+
+if BPHY8cf.doUseWideMuMuMassRange:
+ BPHY8cf.GlobalBMassUpperCut = 10000.
+ BPHY8cf.GlobalBMassLowerCut = 3250.
+ BPHY8cf.GlobalTrksMassUpperCut = 10500.
+ BPHY8cf.GlobalTrksMassLowerCut = 2750.
+ BPHY8cf.GlobalDiMuonMassUpperCut = 10000.
+ BPHY8cf.GlobalDiMuonMassLowerCut = 2000.
+ BPHY8cf.GlobalJpsiMassUpperCut = 10000.
+ BPHY8cf.GlobalJpsiMassLowerCut = 2000.
+
+#====================================================================
+# Vertexing chi2 cuts for n-prong decays
+#====================================================================
+# The global chi2 cut times NdF
+BPHY8cf.Chi2Cut2Prong = BPHY8cf.GlobalChi2CutBase * 1.
+BPHY8cf.Chi2Cut3Prong = BPHY8cf.GlobalChi2CutBase * 4.
+BPHY8cf.Chi2Cut4Prong = BPHY8cf.GlobalChi2CutBase * 6.
+
+#====================================================================
+# Muons or tracks for JpsiFinder
+#====================================================================
+BPHY8cf.JfTwoMuons = True
+BPHY8cf.JfTwoTracks = False
+BPHY8cf.JfTrackThresholdPt = 0. # MeV
+if "Bhh" in BPHY8cf.doChannels:
+ BPHY8cf.JfTwoMuons = False
+ BPHY8cf.JfTwoTracks = True
+ BPHY8cf.JfTrackThresholdPt = 3500. # MeV
+
+#====================================================================
+# DEBUGGING SETUP
+#====================================================================
+#
+# Dump contents of this file to log
+if BPHY8cf.verbose > 4:
+ import inspect
+ thisfile = inspect.getfile(inspect.currentframe())
+ print("# >>>------------------ %s ------------------------" % thisfile)
+ with open (thisfile, 'r') as fin:
+ print(fin.read())
+ print("# <<<------------------ %s ------------------------" % thisfile)
+
+# required for track jets for Soft B Tagging
+if BPHY8cf.doAddSoftBVertices:
+ from DerivationFrameworkJetEtMiss.JetCommon import *
+
+#====================================================================
+# CALIBRATION SEQUENCES
+#====================================================================
+#
+# For parameters of the MuonCalibrationAndSmearingTool see:
+# https://twiki.cern.ch/twiki/bin/view/AtlasProtected/MCPAnalysisGuidelinesMC15#Muon_momentum_scale_and_resoluti
+#
+# ordered dicts
+from collections import OrderedDict
+BPHY8_CalibrationAlgs = OrderedDict()
+
+# Create calibrated muons if requested
+BPHY8cf.CalMuonCollection = BPHY8cf.MuonCollection
+BPHY8cf.UsedMuonCollection = BPHY8cf.MuonCollection
+BPHY8cf.AllMuonCollections = [ BPHY8cf.MuonCollection ]
+if BPHY8cf.useCalibratedMuons > 0:
+ BPHY8cf.adjustMucalcKinematics = True
+ if BPHY8cf.useCalibratedMuons > 1:
+ BPHY8cf.CalMuonCollection = BPHY8cf.DerivationName+"_CalibratedMuons"
+ BPHY8cf.adjustMucalcKinematics = False
+ BPHY8cf.AllMuonCollections += [ BPHY8cf.CalMuonCollection ]
+ if BPHY8cf.useCalibratedMuons > 2:
+ BPHY8cf.UsedMuonCollection = BPHY8cf.CalMuonCollection
+ BPHY8cf.adjustMucalcKinematics = True
+ BPHY8_MuonCalTool = CfgMgr.CP__MuonCalibrationAndSmearingTool(
+ BPHY8cf.DerivationName+"_MCPTool",
+ OutputLevel = INFO )
+ if BPHY8cf.McstYear != "_READ_":
+ BPHY8_MuonCalTool.Year = BPHY8cf.McstYear
+ if BPHY8cf.McstRelease != "_READ_":
+ BPHY8_MuonCalTool.Release = BPHY8cf.McstRelease
+ # read back string values
+ BPHY8cf.McstYear = getPropertyValue(BPHY8_MuonCalTool, "Year")
+ BPHY8cf.McstRelease = getPropertyValue(BPHY8_MuonCalTool, "Release")
+ # additional options for MuonMomentumCorrections-01-00-64 and up
+ # Don't decorate with Eigen (from MuonMomentumCorrections-01-00-62
+ # onwards, see ATLASG-1126)
+ BPHY8_MuonCalTool.noEigenDecor = True
+ BPHY8_MuonCalTool.StatComb = BPHY8cf.McstStatComb
+ BPHY8_MuonCalTool.SagittaCorr = BPHY8cf.McstSagittaCorr
+ BPHY8_MuonCalTool.doSagittaMCDistortion = BPHY8cf.McstDoSagittaMCDistortion
+ BPHY8_MuonCalTool.SagittaCorrPhaseSpace = BPHY8cf.McstSagittaCorrPhaseSpace
+ if BPHY8cf.McstSagittaRelease != "_READ_":
+ BPHY8_MuonCalTool.SagittaRelease = BPHY8cf.McstSagittaRelease
+ # read back string value
+ BPHY8cf.McstSagittaRelease = getPropertyValue(BPHY8_MuonCalTool,
+ "SagittaRelease")
+ ToolSvc += BPHY8_MuonCalTool
+ print(BPHY8_MuonCalTool)
+ pprint(BPHY8_MuonCalTool.properties())
+ BPHY8_CalibrationAlgs["CalMuonProvider"] = CfgMgr.CP__CalibratedMuonsProvider(
+ BPHY8cf.DerivationName+"_CalMuonProvider",
+ Input = BPHY8cf.MuonCollection,
+ Output = BPHY8cf.CalMuonCollection,
+ Tool = BPHY8_MuonCalTool,
+ OutputLevel = INFO ) # output only if set to VERBOSE
+
+# for quick debugging
+## BPHY8cf.adjustMucalcKinematics = False
+
+for BPHY8_name in list(BPHY8_CalibrationAlgs.keys()):
+ print(BPHY8_CalibrationAlgs[BPHY8_name])
+ pprint(BPHY8_CalibrationAlgs[BPHY8_name].properties())
+
+#====================================================================
+# Muon extrapolation for trigger scaling
+#====================================================================
+# Introduced by BPhys trigger group, see merge request 7857
+# (https://gitlab.cern.ch/atlas/athena/merge_requests/7857)
+#
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__MuonExtrapolationTool
+
+BPHY8_MuonExtrapTool = DerivationFramework__MuonExtrapolationTool(
+ name = "BPHY8_MuonExtrapolationTool",
+ MuonCollection = BPHY8cf.UsedMuonCollection,
+ OutputLevel = INFO )
+
+ToolSvc += BPHY8_MuonExtrapTool
+print(BPHY8_MuonExtrapTool)
+pprint(BPHY8_MuonExtrapTool.properties())
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+# setup vertexing tools and services
+# superseeded by BPHYVertexTools
+## include( "JpsiUpsilonTools/configureServices.py" )
+
+# we need to have the DiMuon finder running for channels with Jpsi as well
+BPHY8_recoList = []
+if [BPHY8_i for BPHY8_i in BPHY8cf.doChannels \
+ if BPHY8_i in ["Bsmumu", "BJpsiK", "BsJpsiPhi", "BJpsiPi", "Bhh"]]:
+ BPHY8_recoList += ["DiMuon"]
+if "BJpsiK" in BPHY8cf.doChannels: BPHY8_recoList += [ "BJpsiK" ]
+if "BsJpsiPhi" in BPHY8cf.doChannels: BPHY8_recoList += [ "BsJpsiPhi" ]
+if "BJpsiPi" in BPHY8cf.doChannels: BPHY8_recoList += [ "BJpsiPi" ]
+
+# setup of vertexing tools per channel
+include("DerivationFrameworkBPhys/configureVertexing.py")
+BPHY8_VertexTools = OrderedDict()
+for BPHY8_reco in BPHY8_recoList:
+ BPHY8_VertexTools[BPHY8_reco] = BPHYVertexTools(BPHY8cf.DerivationName+"_"+BPHY8_reco)
+ print(BPHY8_VertexTools[BPHY8_reco])
+
+# setup of vertex finder tools
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import \
+ Analysis__JpsiFinder, Analysis__JpsiPlus1Track, Analysis__JpsiPlus2Tracks
+
+BPHY8_FinderTools = OrderedDict()
+for BPHY8_reco in BPHY8_recoList:
+# a) for DiMuon
+ if BPHY8_reco == "DiMuon":
+ BPHY8_FinderTools[BPHY8_reco] = Analysis__JpsiFinder(
+ name = BPHY8cf.DerivationName+"_"+BPHY8_reco+"_Finder",
+ OutputLevel = INFO,
+ muAndMu = BPHY8cf.JfTwoMuons,
+ muAndTrack = False,
+ TrackAndTrack = BPHY8cf.JfTwoTracks,
+ doTagAndProbe = False,
+ assumeDiMuons = False, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ track1Mass = BPHY8cf.GlobalMuonMass,
+ track2Mass = BPHY8cf.GlobalMuonMass,
+ muonThresholdPt = 0.,
+ trackThresholdPt = BPHY8cf.JfTrackThresholdPt,
+ invMassUpper = BPHY8cf.GlobalDiMuonMassUpperCut,
+ invMassLower = BPHY8cf.GlobalDiMuonMassLowerCut,
+ # For JpsiFinder the cut is really on chi2 and not on chi2/ndf
+ Chi2Cut = BPHY8cf.Chi2Cut2Prong,
+ oppChargesOnly = True,
+ sameChargesOnly = False,
+ allChargeCombinations = False,
+ allMuons = True,
+ combOnly = False,
+ atLeastOneComb = False,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = BPHY8cf.UsedMuonCollection,
+ TrackParticleCollection = BPHY8cf.TrkPartContName,
+ V0VertexFitterTool = BPHY8_VertexTools[BPHY8_reco].TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY8_VertexTools[BPHY8_reco].TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY8_VertexTools[BPHY8_reco].InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY8_VertexTools[BPHY8_reco].VtxPointEstimator,
+ useMCPCuts = BPHY8cf.useJpsiFinderMCPCuts )
+
+# b) for BJpsiK or BJpsiPi
+ if BPHY8_reco in [ "BJpsiK", "BJpsiPi" ] :
+ BPHY8_kaonHypo = (False if BPHY8_reco == "BJpsiPi" else True)
+ BPHY8_FinderTools[BPHY8_reco] = Analysis__JpsiPlus1Track(
+ name = BPHY8cf.DerivationName+"_"+BPHY8_reco+"_Finder",
+ OutputLevel = INFO,
+ pionHypothesis = not BPHY8_kaonHypo,
+ kaonHypothesis = BPHY8_kaonHypo,
+ trkThresholdPt = BPHY8cf.GlobalKaonPtCut,
+ trkMaxEta = BPHY8cf.GlobalKaonEtaCut,
+ BThresholdPt = 1000.,
+ TrkTrippletMassUpper = BPHY8cf.GlobalTrksMassUpperCut,
+ TrkTrippletMassLower = BPHY8cf.GlobalTrksMassLowerCut,
+ BMassUpper = BPHY8cf.GlobalBMassUpperCut,
+ BMassLower = BPHY8cf.GlobalBMassLowerCut,
+ JpsiContainerKey = BPHY8cf.DerivationName+"DiMuonCandidates",
+ JpsiMassUpper = BPHY8cf.GlobalJpsiMassUpperCut,
+ JpsiMassLower = BPHY8cf.GlobalJpsiMassLowerCut,
+ MuonsUsedInJpsi = BPHY8cf.GlobalMuonsUsedInJpsi,
+ TrackParticleCollection = BPHY8cf.TrkPartContName,
+ TrkVertexFitterTool = BPHY8_VertexTools[BPHY8_reco].TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY8_VertexTools[BPHY8_reco].InDetTrackSelectorTool,
+ # This JO should rather be named Chi2byNdfCut
+ Chi2Cut = BPHY8cf.GlobalChi2CutBase,
+ UseMassConstraint = True,
+ ExcludeJpsiMuonsOnly = True,
+ ExcludeCrossJpsiTracks = False)
+
+# c) for BsJpsiPhi
+ if BPHY8_reco == "BsJpsiPhi":
+ BPHY8_FinderTools[BPHY8_reco] = Analysis__JpsiPlus2Tracks(
+ name = BPHY8cf.DerivationName+"_"+BPHY8_reco+"_Finder",
+ OutputLevel = INFO,
+ pionpionHypothesis = False,
+ kaonkaonHypothesis = True,
+ kaonpionHypothesis = False,
+ trkThresholdPt = BPHY8cf.GlobalKaonPtCut,
+ trkMaxEta = BPHY8cf.GlobalKaonEtaCut,
+ BThresholdPt = 1000.,
+ TrkQuadrupletMassUpper = BPHY8cf.GlobalTrksMassUpperCut,
+ TrkQuadrupletMassLower = BPHY8cf.GlobalTrksMassLowerCut,
+ BMassUpper = BPHY8cf.GlobalBMassUpperCut,
+ BMassLower = BPHY8cf.GlobalBMassLowerCut,
+ JpsiContainerKey = BPHY8cf.DerivationName+"DiMuonCandidates",
+ JpsiMassUpper = BPHY8cf.GlobalJpsiMassUpperCut,
+ JpsiMassLower = BPHY8cf.GlobalJpsiMassLowerCut,
+ MuonsUsedInJpsi = BPHY8cf.GlobalMuonsUsedInJpsi,
+ TrackParticleCollection = BPHY8cf.TrkPartContName,
+ TrkVertexFitterTool = BPHY8_VertexTools[BPHY8_reco].TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY8_VertexTools[BPHY8_reco].InDetTrackSelectorTool,
+ # This JO should rather be named Chi2byNdfCut
+ Chi2Cut = BPHY8cf.GlobalChi2CutBase,
+ UseMassConstraint = True,
+ ExcludeJpsiMuonsOnly = True,
+ ExcludeCrossJpsiTracks = False)
+
+ToolSvc += list(BPHY8_FinderTools.values())
+for BPHY8_name in list(BPHY8_FinderTools.keys()):
+ print(BPHY8_FinderTools[BPHY8_name])
+ pprint(BPHY8_FinderTools[BPHY8_name].properties())
+
+#--------------------------------------------------------------------
+# Setup the vertex reconstruction "call" tool(s). They are part of the
+# derivation framework.
+# These Augmentation tools add output vertex collection(s) into the
+# StoreGate and add basic decorations which do not depend on the vertex
+# mass hypothesis (e.g. lxy, ptError, etc).
+# There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need
+# two instance of the Reco tool if the JpsiFinder mass window is wide enough.
+#
+# The reconstruction tools must be interleaved with the vertex selection
+# and augmentation tools as e.g. the Jpsimumu container ist needed for
+# ????
+#
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__Reco_Vertex
+BPHY8_RecoTools = OrderedDict()
+for BPHY8_reco in BPHY8_recoList:
+# a) for DiMuon
+ if BPHY8_reco == "DiMuon":
+ BPHY8_RecoTools[BPHY8_reco] = DerivationFramework__Reco_Vertex(
+ name = BPHY8cf.DerivationName+"_"+BPHY8_reco+"_Reco",
+ JpsiFinder = BPHY8_FinderTools[BPHY8_reco],
+ OutputVtxContainerName = BPHY8cf.DerivationName+BPHY8_reco+"Candidates",
+ PVContainerName = BPHY8cf.PVContName,
+ RefPVContainerName = BPHY8cf.DerivationName+"DiMuonRefittedPrimaryVertices",
+ RefitPV = True,
+ Do3d = BPHY8cf.do3dProperTime,
+ MaxPVrefit = 100000,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ DoVertexType = BPHY8cf.doVertexType)
+# b) for BJpsiK
+ if BPHY8_reco in [ "BJpsiK", "BJpsiPi" ] :
+ BPHY8_RecoTools[BPHY8_reco] = DerivationFramework__Reco_Vertex(
+ name = BPHY8cf.DerivationName+"_"+BPHY8_reco+"_Reco",
+ Jpsi1PlusTrackName = BPHY8_FinderTools[BPHY8_reco],
+ OutputVtxContainerName = BPHY8cf.DerivationName+BPHY8_reco+"Candidates",
+ PVContainerName = BPHY8cf.PVContName,
+ RefPVContainerName = BPHY8cf.DerivationName+BPHY8_reco+"RefittedPrimaryVertices",
+ RefitPV = True,
+ Do3d = BPHY8cf.do3dProperTime,
+ MaxPVrefit = 100000,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ DoVertexType = BPHY8cf.doVertexType)
+# c) for BsJpsiPhi
+ if BPHY8_reco == "BsJpsiPhi":
+ BPHY8_RecoTools[BPHY8_reco] = DerivationFramework__Reco_Vertex(
+ name = BPHY8cf.DerivationName+"_"+BPHY8_reco+"_Reco",
+ Jpsi2PlusTrackName = BPHY8_FinderTools[BPHY8_reco],
+ OutputVtxContainerName = BPHY8cf.DerivationName+BPHY8_reco+"Candidates",
+ PVContainerName = BPHY8cf.PVContName,
+ RefPVContainerName = BPHY8cf.DerivationName+BPHY8_reco+"RefittedPrimaryVertices",
+ RefitPV = True,
+ Do3d = BPHY8cf.do3dProperTime,
+ MaxPVrefit = 100000,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ DoVertexType = BPHY8cf.doVertexType)
+
+ToolSvc += list(BPHY8_RecoTools.values())
+for BPHY8_name in list(BPHY8_RecoTools.keys()):
+ print(BPHY8_RecoTools[BPHY8_name])
+ pprint(BPHY8_RecoTools[BPHY8_name].properties())
+
+#--------------------------------------------------------------------
+# Augmentation of vertices by MUCALC mass and it's error
+#
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__BPhysAddMuonBasedInvMass
+
+BPHY8_MuMassTools = OrderedDict()
+# a) for Bsmumu
+if "Bsmumu" in BPHY8cf.doChannels:
+ # augment B(s)->mumu candidates
+ BPHY8_MuMassTools["Bsmumu"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_Bsmumu",
+ BranchPrefix = "Bsmumu",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = BPHY8cf.adjustMucalcKinematics,
+ VertexContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+# b) for BJpsiK, BsJpsiPhi and BJpsiPi retain the Jpsi
+if [i for i in BPHY8cf.doChannels if i in ["BJpsiK", "BsJpsiPhi", "BJpsiPi"]]:
+ BPHY8_MuMassTools["Jpsimumu"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_Jpsimumu",
+ BranchPrefix = "Jpsimumu",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = BPHY8cf.adjustMucalcKinematics,
+ VertexContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+# c) for BJpsiK
+if "BJpsiK" in BPHY8cf.doChannels:
+ # augment B+/- ->JpsiK+/- candidates
+ BPHY8_MuMassTools["BJpsiK"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_BJpsiK",
+ BranchPrefix = "BJpsiK",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = BPHY8cf.adjustMucalcKinematics,
+ VertexContainerName = BPHY8cf.DerivationName+"BJpsiKCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalKaonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+# d) for BsJpsiPhi
+if "BsJpsiPhi" in BPHY8cf.doChannels:
+ # augment Bs ->JpsiPhi candidates
+ BPHY8_MuMassTools["BsJpsiPhi"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_BsJpsiPhi",
+ BranchPrefix = "BsJpsiPhi",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = BPHY8cf.adjustMucalcKinematics,
+ VertexContainerName = BPHY8cf.DerivationName+"BsJpsiPhiCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalKaonMass, BPHY8cf.GlobalKaonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+# e) for BJpsiPi
+if "BJpsiPi" in BPHY8cf.doChannels:
+ # augment B+/- ->JpsiPi+/- candidates
+ BPHY8_MuMassTools["BJpsiPi"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_BJpsiPi",
+ BranchPrefix = "BJpsiPi",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = BPHY8cf.adjustMucalcKinematics,
+ VertexContainerName = BPHY8cf.DerivationName+"BJpsiPiCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalPionMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+# f) for Bhh
+if "Bhh" in BPHY8cf.doChannels:
+ # augment B->hh candidates
+ BPHY8_MuMassTools["Bhh"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_Bhh",
+ BranchPrefix = "Bhh",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = BPHY8cf.adjustMucalcKinematics,
+ VertexContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+
+######################## duplication for debugging only #######################
+
+if BPHY8cf.addMucalcMassForDebug:
+ # a) for Bsmumu
+ if "Bsmumu" in BPHY8cf.doChannels:
+ # augment B(s)->mumu candidates
+ BPHY8_MuMassTools["Bsmumu2"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_Bsmumu2",
+ BranchPrefix = "Bsmumu2",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = False,
+ VertexContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+ # b) for BJpsiK and BsJpsiPhi retain the Jpsi
+ if [i for i in BPHY8cf.doChannels if i in ["BJpsiK", "BsJpsiPhi"]]:
+ BPHY8_MuMassTools["Jpsimumu2"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_Jpsimumu2",
+ BranchPrefix = "Jpsimumu2",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = False,
+ VertexContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+ # c) for BJpsiK
+ if "BJpsiK" in BPHY8cf.doChannels:
+ # augment B+/- ->JpsiK+/- candidates
+ BPHY8_MuMassTools["BJpsiK2"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_BJpsiK2",
+ BranchPrefix = "BJpsiK2",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = False,
+ VertexContainerName = BPHY8cf.DerivationName+"BJpsiKCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalKaonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+ # d) for BsJpsiPhi
+ if "BsJpsiPhi" in BPHY8cf.doChannels:
+ # augment Bs ->JpsiPhi candidates
+ BPHY8_MuMassTools["BsJpsiPhi2"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_BsJpsiPhi2",
+ BranchPrefix = "BsJpsiPhi2",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = False,
+ VertexContainerName = BPHY8cf.DerivationName+"BsJpsiPhiCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalKaonMass, BPHY8cf.GlobalKaonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+ # e) for BJpsiPi
+ if "BJpsiPi" in BPHY8cf.doChannels:
+ # augment B+/- ->JpsiPi+/- candidates
+ BPHY8_MuMassTools["BJpsiPi2"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_BJpsiPi2",
+ BranchPrefix = "BJpsiPi2",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = False,
+ VertexContainerName = BPHY8cf.DerivationName+"BJpsiPiCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalPionMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+ # f) for Bhh
+ if "Bhh" in BPHY8cf.doChannels:
+ # augment B->hh candidates
+ BPHY8_MuMassTools["Bhh2"] = DerivationFramework__BPhysAddMuonBasedInvMass(
+ name = "BPHY8_MuMass_Bhh2",
+ BranchPrefix = "Bhh2",
+ OutputLevel = WARNING,
+ AdjustToMuonKinematics = False,
+ VertexContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ AddMinChi2ToAnyPVMode = BPHY8cf.AddMinChi2ToAnyPVMode,
+ PrimaryVertexContainerName = BPHY8cf.PVContName,
+ MinNTracksInPV = BPHY8cf.minNTracksInPV,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType)
+
+######################## duplication for debugging only #######################
+
+ToolSvc += list(BPHY8_MuMassTools.values())
+for BPHY8_name in list(BPHY8_MuMassTools.keys()):
+ print(BPHY8_MuMassTools[BPHY8_name])
+ pprint(BPHY8_MuMassTools[BPHY8_name].properties())
+
+#--------------------------------------------------------------------
+# Augmentation of vertices by vertex track isolation values,
+# closest track information and muon isolation values.
+#
+# First: Set up track selections
+#
+from InDetTrackSelectionTool.InDetTrackSelectionToolConf \
+ import InDet__InDetTrackSelectionTool
+
+# a) for BVertexTrackIsoTool
+BPHY8_IsoTrkSelTools = OrderedDict()
+for i in range(len(BPHY8cf.IsoTrackCategoryName)):
+ BPHY8_name = BPHY8cf.DerivationName+"_iso_"+BPHY8cf.IsoTrackCategoryName[i]
+ BPHY8_Tool = InDet__InDetTrackSelectionTool(
+ name = BPHY8_name,
+ OutputLevel = INFO
+ )
+ if BPHY8cf.IsoTrackCutLevel[i] != "Custom" :
+ BPHY8_Tool.CutLevel = BPHY8cf.IsoTrackCutLevel[i]
+ if BPHY8cf.IsoTrackPtCut[i] > -1. :
+ BPHY8_Tool.minPt = BPHY8cf.IsoTrackPtCut[i]
+ if BPHY8cf.IsoTrackEtaCut[i] > -1. :
+ BPHY8_Tool.maxAbsEta = BPHY8cf.IsoTrackEtaCut[i]
+ if BPHY8cf.IsoTrackPixelHits[i] > -1 :
+ BPHY8_Tool.minNPixelHits = BPHY8cf.IsoTrackPixelHits[i]
+ if BPHY8cf.IsoTrackSCTHits[i] > -1 :
+ BPHY8_Tool.minNSctHits = BPHY8cf.IsoTrackSCTHits[i]
+ if BPHY8cf.IsoTrackIBLHits[i] > -1 :
+ BPHY8_Tool.minNInnermostLayerHits = BPHY8cf.IsoTrackIBLHits[i]
+ if BPHY8cf.IsoTrackbLayerHits[i] > -1 :
+ BPHY8_Tool.minNNextToInnermostLayerHits = BPHY8cf.IsoTrackbLayerHits[i]
+ BPHY8_IsoTrkSelTools[BPHY8_name] = BPHY8_Tool
+
+ToolSvc += list(BPHY8_IsoTrkSelTools.values())
+for BPHY8_name in list(BPHY8_IsoTrkSelTools.keys()):
+ print(BPHY8_IsoTrkSelTools[BPHY8_name])
+ pprint(BPHY8_IsoTrkSelTools[BPHY8_name].properties())
+
+# b) for BMuonTrackIsoTool
+BPHY8_MuIsoTrkSelTools = OrderedDict()
+for i in range(len(BPHY8cf.MuIsoTrackCategoryName)):
+ BPHY8_name = BPHY8cf.DerivationName+"_muiso_" + \
+ BPHY8cf.MuIsoTrackCategoryName[i]
+ BPHY8_Tool = InDet__InDetTrackSelectionTool(
+ name = BPHY8_name,
+ OutputLevel = INFO
+ )
+ if BPHY8cf.MuIsoTrackCutLevel[i] != "Custom" :
+ BPHY8_Tool.CutLevel = BPHY8cf.MuIsoTrackCutLevel[i]
+ if BPHY8cf.MuIsoTrackPtCut[i] > -1. :
+ BPHY8_Tool.minPt = BPHY8cf.MuIsoTrackPtCut[i]
+ if BPHY8cf.MuIsoTrackEtaCut[i] > -1. :
+ BPHY8_Tool.maxAbsEta = BPHY8cf.MuIsoTrackEtaCut[i]
+ if BPHY8cf.MuIsoTrackPixelHits[i] > -1 :
+ BPHY8_Tool.minNPixelHits = BPHY8cf.MuIsoTrackPixelHits[i]
+ if BPHY8cf.MuIsoTrackSCTHits[i] > -1 :
+ BPHY8_Tool.minNSctHits = BPHY8cf.MuIsoTrackSCTHits[i]
+ if BPHY8cf.MuIsoTrackIBLHits[i] > -1 :
+ BPHY8_Tool.minNInnermostLayerHits = BPHY8cf.MuIsoTrackIBLHits[i]
+ if BPHY8cf.MuIsoTrackbLayerHits[i] > -1 :
+ BPHY8_Tool.minNNextToInnermostLayerHits \
+ = BPHY8cf.MuIsoTrackbLayerHits[i]
+ BPHY8_MuIsoTrkSelTools[BPHY8_name] = BPHY8_Tool
+
+ToolSvc += list(BPHY8_MuIsoTrkSelTools.values())
+for BPHY8_name in list(BPHY8_MuIsoTrkSelTools.keys()):
+ print(BPHY8_MuIsoTrkSelTools[BPHY8_name])
+ pprint(BPHY8_MuIsoTrkSelTools[BPHY8_name].properties())
+
+# c) for ClosestTrackTool
+BPHY8_CtTrkSelTools = OrderedDict()
+for i in range(len(BPHY8cf.CloseTrackCategoryName)):
+ BPHY8_name = BPHY8cf.DerivationName+"_ct_"+BPHY8cf.CloseTrackCategoryName[i]
+ BPHY8_Tool = InDet__InDetTrackSelectionTool(
+ name = BPHY8_name,
+ OutputLevel = INFO
+ )
+ if BPHY8cf.CloseTrackCutLevel[i] != "Custom" :
+ BPHY8_Tool.CutLevel = BPHY8cf.CloseTrackCutLevel[i]
+ if BPHY8cf.CloseTrackPtCut[i] > -1. :
+ BPHY8_Tool.minPt = BPHY8cf.CloseTrackPtCut[i]
+ if BPHY8cf.CloseTrackEtaCut[i] > -1. :
+ BPHY8_Tool.maxAbsEta = BPHY8cf.CloseTrackEtaCut[i]
+ if BPHY8cf.CloseTrackPixelHits[i] > -1 :
+ BPHY8_Tool.minNPixelHits = BPHY8cf.CloseTrackPixelHits[i]
+ if BPHY8cf.CloseTrackSCTHits[i] > -1 :
+ BPHY8_Tool.minNSctHits = BPHY8cf.CloseTrackSCTHits[i]
+ if BPHY8cf.CloseTrackIBLHits[i] > -1 :
+ BPHY8_Tool.minNInnermostLayerHits = BPHY8cf.CloseTrackIBLHits[i]
+ if BPHY8cf.CloseTrackbLayerHits[i] > -1 :
+ BPHY8_Tool.minNNextToInnermostLayerHits \
+ = BPHY8cf.CloseTrackbLayerHits[i]
+ BPHY8_CtTrkSelTools[BPHY8_name] = BPHY8_Tool
+
+ToolSvc += list(BPHY8_CtTrkSelTools.values())
+for BPHY8_name in list(BPHY8_CtTrkSelTools.keys()):
+ print(BPHY8_CtTrkSelTools[BPHY8_name])
+ pprint(BPHY8_CtTrkSelTools[BPHY8_name].properties())
+
+#
+# Step 1.5: Set up track vertex assocation tool
+#
+from TrackVertexAssociationTool.TrackVertexAssociationToolConf \
+ import CP__TrackVertexAssociationTool
+
+BPHY8_TvaTools = OrderedDict()
+
+# a) for BVertexTrackIsoTool
+BPHY8_TvaTools["TrackVtxIsoTva"] = CP__TrackVertexAssociationTool(
+ name = BPHY8cf.DerivationName+"_VtxIsoTvaTool",
+ WorkingPoint = BPHY8cf.IsoTvaWorkingPoint,
+ OutputLevel = WARNING)
+
+# b) for BMuonTrackIsoTool
+BPHY8_TvaTools["TrackMuonIsoTva"] = CP__TrackVertexAssociationTool(
+ name = BPHY8cf.DerivationName+"_MuonIsoTvaTool",
+ WorkingPoint = BPHY8cf.MuIsoTvaWorkingPoint,
+ OutputLevel = WARNING)
+
+# c) for ClosestTrackTool
+BPHY8_TvaTools["TrackVtxCtTva"] = CP__TrackVertexAssociationTool(
+ name = BPHY8cf.DerivationName+"_VtxCtTvaTool",
+ WorkingPoint = BPHY8cf.CloseTrackTvaWorkingPoint,
+ OutputLevel = WARNING)
+
+# attach to ToolSvc
+ToolSvc += list(BPHY8_TvaTools.values())
+for BPHY8_name in list(BPHY8_TvaTools.keys()):
+ print(BPHY8_TvaTools[BPHY8_name])
+ pprint(BPHY8_TvaTools[BPHY8_name].properties())
+
+#
+# Second: Set up the B candidate vertex container arrays
+#
+BPHY8cf.VtxContNames = [];
+BPHY8cf.RefPVContNames = [];
+BPHY8cf.BranchPrefixes = [];
+if [i for i in BPHY8cf.doChannels \
+ if i in ["Bsmumu", "BJpsiK", "BsJpsiPhi", "BJpsiPi", "Bhh"]]:
+ BPHY8cf.VtxContNames += [ BPHY8cf.DerivationName+"DiMuonCandidates" ]
+ BPHY8cf.RefPVContNames += [ BPHY8cf.DerivationName
+ +"DiMuonRefittedPrimaryVertices" ]
+ BPHY8cf.BranchPrefixes += [ "DiMuon" ];
+if "BJpsiK" in BPHY8cf.doChannels:
+ BPHY8cf.VtxContNames += [ BPHY8cf.DerivationName+"BJpsiKCandidates" ]
+ BPHY8cf.RefPVContNames += [ BPHY8cf.DerivationName
+ +"BJpsiKRefittedPrimaryVertices" ]
+ BPHY8cf.BranchPrefixes += [ "BJpsiK" ];
+if "BsJpsiPhi" in BPHY8cf.doChannels:
+ BPHY8cf.VtxContNames += [ BPHY8cf.DerivationName+"BsJpsiPhiCandidates" ]
+ BPHY8cf.RefPVContNames += [ BPHY8cf.DerivationName
+ +"BsJpsiPhiRefittedPrimaryVertices" ]
+ BPHY8cf.BranchPrefixes += [ "BsJpsiPhi" ];
+if "BJpsiPi" in BPHY8cf.doChannels:
+ BPHY8cf.VtxContNames += [ BPHY8cf.DerivationName+"BJpsiPiCandidates" ]
+ BPHY8cf.RefPVContNames += [ BPHY8cf.DerivationName
+ +"BJpsiPiRefittedPrimaryVertices" ]
+ BPHY8cf.BranchPrefixes += [ "BJpsiPi" ];
+
+#
+# Third: Set up the real tools
+#
+BPHY8_IsoTools = OrderedDict()
+
+# a) BVertexTrackIsoTool
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__BVertexTrackIsoTool
+
+BPHY8_IsoTools["TrackVtxIso"] = DerivationFramework__BVertexTrackIsoTool(
+ name = "BPHY8_VtxIsoTool",
+ BranchPrefixes = BPHY8cf.BranchPrefixes,
+ BranchBaseName = "iso",
+ OutputLevel = INFO,
+ VertexContainerNames = BPHY8cf.VtxContNames,
+ RefPVContainerNames = BPHY8cf.RefPVContNames,
+ TrackParticleContainerName = BPHY8cf.TrkPartContName,
+ PVContainerName = BPHY8cf.PVContName,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ TrackSelectionTools = list(BPHY8_IsoTrkSelTools.values()),
+ TVATool = BPHY8_TvaTools["TrackVtxIsoTva"],
+ IsolationConeSizes = BPHY8cf.IsolationConeSizes,
+ IsoTrkImpLogChi2Max = BPHY8cf.IsoTrkImpLogChi2Max,
+ IsoDoTrkImpLogChi2Cut = BPHY8cf.IsoDoTrkImpLogChi2Cut,
+ DoVertexType = BPHY8cf.doVertexType,
+ UseTrackTypes = BPHY8cf.useIsoTrackTypes,
+ UseOptimizedAlgo = BPHY8cf.IsoUseOptimizedAlgo,
+ DebugTrackTypes = BPHY8cf.DebugTrackTypes,
+ DebugTracksInEvents = [])
+
+# b) BMuonTrackIsoTool
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__BMuonTrackIsoTool
+
+BPHY8_IsoTools["TrackMuonIso"] = DerivationFramework__BMuonTrackIsoTool(
+ name = "BPHY8_MuonIsoTool",
+ BranchPrefixes = BPHY8cf.BranchPrefixes,
+ BranchBaseName = "muiso",
+ OutputLevel = INFO,
+ VertexContainerNames = BPHY8cf.VtxContNames,
+ RefPVContainerNames = BPHY8cf.RefPVContNames,
+ TrackParticleContainerName = BPHY8cf.TrkPartContName,
+ PVContainerName = BPHY8cf.PVContName,
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ MuonContainerName = BPHY8cf.UsedMuonCollection,
+ TrackSelectionTools = list(BPHY8_MuIsoTrkSelTools.values()),
+ TVATool = BPHY8_TvaTools["TrackMuonIsoTva"],
+ IsolationConeSizes = BPHY8cf.MuIsolationConeSizes,
+ IsoTrkImpLogChi2Max = BPHY8cf.MuIsoTrkImpLogChi2Max,
+ IsoDoTrkImpLogChi2Cut = BPHY8cf.MuIsoDoTrkImpLogChi2Cut,
+ DoVertexType = BPHY8cf.doVertexType,
+ UseTrackTypes = BPHY8cf.useMuIsoTrackTypes,
+ DebugTrackTypes = BPHY8cf.DebugTrackTypes,
+ DebugTracksInEvents = [])
+
+# c) BVertexClosestTrackTool
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__BVertexClosestTrackTool
+
+BPHY8_IsoTools["TrackVtxCt"] = DerivationFramework__BVertexClosestTrackTool(
+ name = "BPHY8_VtxClosestTrkTool",
+ BranchPrefixes = BPHY8cf.BranchPrefixes,
+ BranchBaseName = "ct",
+ OutputLevel = INFO,
+ VertexContainerNames = BPHY8cf.VtxContNames,
+ RefPVContainerNames = BPHY8cf.RefPVContNames,
+ TrackParticleContainerName = BPHY8cf.TrkPartContName,
+ PVContainerName = BPHY8cf.PVContName,
+ TrackSelectionTools = list(BPHY8_CtTrkSelTools.values()),
+ TVATool = BPHY8_TvaTools["TrackVtxCtTva"],
+ PVTypesToConsider = BPHY8cf.MinChi2ToAnyPVTypes,
+ DoVertexType = BPHY8cf.doVertexType,
+ UseTrackTypes = BPHY8cf.useCloseTrackTypes,
+ CloseTrackChi2SetName = BPHY8cf.CloseTrackChi2SetName,
+ CloseTrackCorrChi2 = BPHY8cf.CloseTrackCorrChi2,
+ CloseTrackMinDCAin3D = BPHY8cf.CloseTrackMinDCAin3D,
+ CloseTrackMaxLogChi2 = BPHY8cf.CloseTrackMaxLogChi2,
+ NCloseTrackMaxLogChi2 = BPHY8cf.NCloseTrackMaxLogChi2,
+ DebugTrackTypes = BPHY8cf.DebugTrackTypes,
+ DebugTracksInEvents = [])
+
+#
+# Fourth: Add track-to-vertex map debugging
+#
+BPHY8_TtvmTools = OrderedDict();
+
+# a) configure BPhysTrackVertexMapTools
+# Configure only if not 0 events requested
+if BPHY8cf.DebugTrkToVtxMaxEvents != 0 :
+ for BPHY8_prefix, BPHY8_SVcont, BPHY8_refPVcont in \
+ zip(BPHY8cf.BranchPrefixes, BPHY8cf.VtxContNames,
+ BPHY8cf.RefPVContNames):
+ BPHY8_hypos = BPHY8_prefix
+ if BPHY8_hypos == "DiMuon":
+ BPHY8_hypos += "|Bsmumu|Jpsimumu"
+ BPHY8_TtvmTools[BPHY8_prefix] = CfgMgr.xAOD__BPhysTrackVertexMapTool(
+ "BPHY8_ttvm_"+BPHY8_prefix,
+ OutputLevel = INFO,
+ VertexContainerName = BPHY8_SVcont,
+ RefPVContainerName = BPHY8_refPVcont,
+ PVContainerName = BPHY8cf.PVContName,
+ TrackParticleContainerName = BPHY8cf.TrkPartContName,
+ DebugTrkToVtxMaxEvents = BPHY8cf.DebugTrkToVtxMaxEvents,
+ DumpPrefix = "TTV2> ",
+ HypoName = BPHY8_hypos )
+
+ ToolSvc += list(BPHY8_TtvmTools.values())
+ for BPHY8_name in list(BPHY8_TtvmTools.keys()):
+ print(BPHY8_TtvmTools[BPHY8_name])
+ pprint(BPHY8_TtvmTools[BPHY8_name].properties())
+
+# b) wrap into logger algorithm
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__BTrackVertexMapLogger
+
+# Configure only if not 0 events requested
+if BPHY8cf.DebugTrkToVtxMaxEvents != 0 :
+ BPHY8_IsoTools["TvmLogger"] = DerivationFramework__BTrackVertexMapLogger(
+ name = "BPHY8_TrackVertexMapLogger",
+ OutputLevel = INFO,
+ TrackVertexMapTools = list(BPHY8_TtvmTools.values()),
+ Enable = True)
+
+#
+# Fifth: Attach to ToolSvc
+#
+ToolSvc += list(BPHY8_IsoTools.values())
+for BPHY8_name in list(BPHY8_IsoTools.keys()):
+ print(BPHY8_IsoTools[BPHY8_name])
+ pprint(BPHY8_IsoTools[BPHY8_name].properties())
+
+#--------------------------------------------------------------------
+# Record the original counts for primary vertices and tracks
+#--------------------------------------------------------------------
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__AugOriginalCounts
+BPHY8_AugOriginalCounts = DerivationFramework__AugOriginalCounts(
+ name = "BPHY8_AugOriginalCounts",
+ VertexContainer = BPHY8cf.PVContName,
+ TrackContainer = BPHY8cf.TrkPartContName,
+ AddPVCountsByType = True,
+ AddNTracksToPVs = True,
+ AddSqrtPt2SumToPVs = True)
+
+ToolSvc += BPHY8_AugOriginalCounts
+pprint(BPHY8_AugOriginalCounts.properties())
+
+#--------------------------------------------------------------------
+# Setup the vertex selection and augmentation tool(s). These tools decorate
+# the vertices with variables that depend on the vertex mass hypothesis,
+# e.g. invariant mass, proper decay time, etc.
+# Property HypothesisName is used as a prefix for these decorations.
+# They also perform tighter selection, flagging the vertecis that passed.
+# The flag is a Char_t branch named "passed_"+HypothesisName. It is used
+# later by the "SelectEvent" and "Thin_vtxTrk" tools to determine which
+# events and candidates should be kept in the output stream.
+# Multiple instances of the Select_* tools can be used on a single input
+# collection as long as they use different "HypothesisName" flags.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__Select_Bmumu
+
+BPHY8_SelectTools = OrderedDict()
+# a) for Bsmumu
+if "Bsmumu" in BPHY8cf.doChannels:
+ # augment and select B(s)->mumu candidates
+ BPHY8_SelectTools["Bsmumu"] = DerivationFramework__Select_Bmumu(
+ name = "BPHY8_Select_Bsmumu",
+ HypothesisName = "Bsmumu",
+ InputVtxContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ VtxMassHypo = BPHY8cf.GlobalBsMass,
+ MassMin = BPHY8cf.GlobalBMassLowerCut,
+ MassMax = BPHY8cf.GlobalBMassUpperCut,
+ Chi2Max = BPHY8cf.Chi2Cut2Prong,
+ DoVertexType = BPHY8cf.doVertexType,
+ Do3d = BPHY8cf.do3dProperTime,
+ BlindMassMin = BPHY8cf.GlobalBlindLowerCut,
+ BlindMassMax = BPHY8cf.GlobalBlindUpperCut,
+ DoBlinding = BPHY8cf.doBmumuBlinding,
+ DoCutBlinded = BPHY8cf.doCutBlinded,
+ BlindOnlyAllMuonsTight = BPHY8cf.blindOnlyAllMuonsTight,
+ UseMuCalcMass = BPHY8cf.useMuCalcMass,
+ OutputLevel = WARNING)
+# b) for BJpsiK and BsJpsiPhi retain the Jpsi
+if [i for i in BPHY8cf.doChannels if i in ["BJpsiK", "BsJpsiPhi"]]:
+ BPHY8_SelectTools["Jpsimumu"] = DerivationFramework__Select_Bmumu(
+ name = "BPHY8_Select_Jpsimumu",
+ HypothesisName = "Jpsimumu",
+ InputVtxContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ VtxMassHypo = BPHY8cf.GlobalJpsiMass,
+ MassMin = BPHY8cf.GlobalJpsiMassLowerCut,
+ MassMax = BPHY8cf.GlobalJpsiMassUpperCut,
+ Chi2Max = BPHY8cf.Chi2Cut2Prong,
+ DoVertexType = BPHY8cf.doVertexType,
+ Do3d = BPHY8cf.do3dProperTime,
+ UseMuCalcMass = BPHY8cf.useMuCalcMass,
+ OutputLevel = WARNING)
+# c) for BJpsiK
+if "BJpsiK" in BPHY8cf.doChannels:
+ # augment and select B+/- ->JpsiK+/- candidates
+ BPHY8_SelectTools["BJpsiK"] = DerivationFramework__Select_Bmumu(
+ name = "BPHY8_Select_BJpsiK",
+ HypothesisName = "BJpsiK",
+ InputVtxContainerName = BPHY8cf.DerivationName+"BJpsiKCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalKaonMass],
+ VtxMassHypo = BPHY8cf.GlobalBplusMass,
+ MassMin = BPHY8cf.GlobalBMassLowerCut,
+ MassMax = BPHY8cf.GlobalBMassUpperCut,
+ Chi2Max = BPHY8cf.Chi2Cut3Prong,
+ DoVertexType = BPHY8cf.doVertexType,
+ Do3d = BPHY8cf.do3dProperTime,
+ UseMuCalcMass = BPHY8cf.useMuCalcMass,
+ SubDecVtxContNames = [BPHY8cf.DerivationName+"DiMuonCandidates"],
+ SubDecVtxHypoCondNames = ["Jpsimumu"],
+ SubDecVtxHypoFlagNames = ["JpsimumuSubDecay"],
+ OutputLevel = WARNING)
+# d) for BsJpsiPhi
+if "BsJpsiPhi" in BPHY8cf.doChannels:
+ # augment and select Bs ->JpsiPhi candidates
+ BPHY8_SelectTools["BsJpsiPhi"] = DerivationFramework__Select_Bmumu(
+ name = "BPHY8_Select_BsJpsiPhi",
+ HypothesisName = "BsJpsiPhi",
+ InputVtxContainerName = BPHY8cf.DerivationName+"BsJpsiPhiCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalKaonMass, BPHY8cf.GlobalKaonMass],
+ VtxMassHypo = BPHY8cf.GlobalBsMass,
+ MassMin = BPHY8cf.GlobalBMassLowerCut,
+ MassMax = BPHY8cf.GlobalBMassUpperCut,
+ Chi2Max = BPHY8cf.Chi2Cut4Prong,
+ DoVertexType = BPHY8cf.doVertexType,
+ Do3d = BPHY8cf.do3dProperTime,
+ UseMuCalcMass = BPHY8cf.useMuCalcMass,
+ SubDecVtxContNames = [BPHY8cf.DerivationName+"DiMuonCandidates"],
+ SubDecVtxHypoCondNames = ["Jpsimumu"],
+ SubDecVtxHypoFlagNames = ["JpsimumuSubDecay"],
+ OutputLevel = WARNING)
+# e) for BJpsiPi
+if "BJpsiPi" in BPHY8cf.doChannels:
+ # augment and select B+/- ->JpsiPi+/- candidates
+ BPHY8_SelectTools["BJpsiPi"] = DerivationFramework__Select_Bmumu(
+ name = "BPHY8_Select_BJpsiPi",
+ HypothesisName = "BJpsiPi",
+ InputVtxContainerName = BPHY8cf.DerivationName+"BJpsiPiCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalPionMass],
+ VtxMassHypo = BPHY8cf.GlobalBplusMass,
+ MassMin = BPHY8cf.GlobalBMassLowerCut,
+ MassMax = BPHY8cf.GlobalBMassUpperCut,
+ Chi2Max = BPHY8cf.Chi2Cut3Prong,
+ DoVertexType = BPHY8cf.doVertexType,
+ Do3d = BPHY8cf.do3dProperTime,
+ UseMuCalcMass = BPHY8cf.useMuCalcMass,
+ SubDecVtxContNames = [BPHY8cf.DerivationName+"DiMuonCandidates"],
+ SubDecVtxHypoCondNames = ["Jpsimumu"],
+ SubDecVtxHypoFlagNames = ["JpsimumuSubDecay"],
+ OutputLevel = WARNING)
+# f) for Bhh
+if "Bhh" in BPHY8cf.doChannels:
+ # augment and select B->hh candidates
+ BPHY8_SelectTools["Bhh"] = DerivationFramework__Select_Bmumu(
+ name = "BPHY8_Select_Bhh",
+ HypothesisName = "Bhh",
+ InputVtxContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ TrkMasses = [BPHY8cf.GlobalMuonMass, BPHY8cf.GlobalMuonMass],
+ VtxMassHypo = BPHY8cf.GlobalBsMass,
+ MassMin = BPHY8cf.GlobalBMassLowerCut,
+ MassMax = BPHY8cf.GlobalBMassUpperCut,
+ Chi2Max = BPHY8cf.Chi2Cut2Prong,
+ DoVertexType = BPHY8cf.doVertexType,
+ Do3d = BPHY8cf.do3dProperTime,
+ UseMuCalcMass = BPHY8cf.useMuCalcMass,
+ OutputLevel = WARNING)
+
+ToolSvc += list(BPHY8_SelectTools.values())
+for BPHY8_name in list(BPHY8_SelectTools.keys()):
+ print(BPHY8_SelectTools[BPHY8_name])
+ pprint(BPHY8_SelectTools[BPHY8_name].properties())
+
+#--------------------------------------------------------------------
+# Setup the vertex variable blinding tools.
+# These tools are only used by the Bsmumu channel in case
+# blinding is enabled.
+
+BPHY8_BlindingTools = OrderedDict()
+BPHY8_BlinderTools = OrderedDict()
+
+if BPHY8cf.doBmumuBlinding and not BPHY8cf.doCutBlinded:
+ # BlindingTools
+ from BPhysTools.BPhysToolsConf import xAOD__BPhysBlindingTool
+ # 1) for Bsmumu
+ if "Bsmumu" in BPHY8cf.doChannels :
+ # setup blinding tool
+ BPHY8_BlindingTools["Bsmumu"] = xAOD__BPhysBlindingTool(
+ name = "BPHY8_BlindingTool_Bsmumu",
+ VertexContainerName = BPHY8cf.DerivationName+"DiMuonCandidates",
+ VarToBlindNames = BPHY8cf.BlindedVars,
+ BlindingFlag = BPHY8cf.BlindingFlag,
+ NegativeSigns = [True, True],
+ BlindingKey = BPHY8cf.BlindingKey,
+ OutputLevel = INFO)
+
+ ToolSvc += list(BPHY8_BlindingTools.values())
+ for BPHY8_name in list(BPHY8_BlindingTools.keys()):
+ print(BPHY8_BlindingTools[BPHY8_name])
+ pprint(BPHY8_BlindingTools[BPHY8_name].properties())
+
+ # Blinders
+ from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__BPhysVarBlinder
+ # a2) for Bsmumu
+ if "Bsmumu" in BPHY8cf.doChannels :
+ # blind mass values for B(s)->mumu candidates
+ BPHY8_BlinderTools["Bsmumu"] = DerivationFramework__BPhysVarBlinder(
+ name = "BPHY8_Blinder_Bsmumu",
+ BlindingTool = BPHY8_BlindingTools["Bsmumu"],
+ EnableBlinding = True,
+ OutputLevel = INFO)
+
+ ToolSvc += list(BPHY8_BlinderTools.values())
+ for BPHY8_name in list(BPHY8_BlinderTools.keys()):
+ print(BPHY8_BlinderTools[BPHY8_name])
+ pprint(BPHY8_BlinderTools[BPHY8_name].properties())
+
+#====================================================================
+# Skimming tool to select only events with the correct vertices
+#====================================================================
+#--------------------------------------------------------------------
+# Select the event. We only want to keep events that contain certain
+# vertices which passed certain selection. This is specified by the
+# "SelectionExpression" property, which contains the expression in the
+# following format:
+#
+# "ContainerName.passed_HypoName > count"
+#
+# where "ContainerName" is output container form some Reco_* tool,
+# "HypoName" is the hypothesis name setup in some "Select_*" tool and
+# "count" is the number of candidates passing the selection you want to keep.
+#
+
+# Build expression depending on "select tools" used:
+# If any of them marked any candidate passed, add expression for it.
+BPHY8_expressions = []
+for BPHY8_tool in list(BPHY8_SelectTools.values()):
+ BPHY8_passName = BPHY8_tool.HypothesisName
+ if BPHY8_tool.HypothesisName == "Jpsimumu" and BPHY8cf.thinLevel > 0:
+ BPHY8_passName = "JpsimumuSubDecay"
+ BPHY8_expressions += [ "count(%s.passed_%s) > 0" % \
+ (BPHY8_tool.InputVtxContainerName,
+ BPHY8_passName) ]
+BPHY8cf.SelExpression = " || ".join(BPHY8_expressions)
+
+from DerivationFrameworkTools.DerivationFrameworkToolsConf \
+ import DerivationFramework__xAODStringSkimmingTool
+BPHY8_SkimmingTool = DerivationFramework__xAODStringSkimmingTool(
+ name = "BPHY8_SelectEvent",
+ expression = BPHY8cf.SelExpression)
+
+ToolSvc += BPHY8_SkimmingTool
+print(BPHY8_SkimmingTool)
+pprint(BPHY8_SkimmingTool.properties())
+
+# Check for global ToolSvc:
+print(">>> Checking ToolSvc tools: <<<")
+for BPHY8_i in ToolSvc:
+ print(BPHY8_i)
+print(">>> End of ToolSvc tools. <<<")
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+BPHY8_streamName = derivationFlags.WriteDAOD_BPHY8Stream.StreamName
+BPHY8_fileName = buildFileName( derivationFlags.WriteDAOD_BPHY8Stream )
+BPHY8Stream = MSMgr.NewPoolRootStream(BPHY8_streamName, BPHY8_fileName )
+BPHY8Stream.AcceptAlgs(["BPHY8Kernel"])
+#
+# Special lines for thinning
+# Thinning service name must match the one passed to the thinning tools
+##
+## NOTE: We use the ThinningHelper which already instantiates a ThinningSvc
+##
+## from AthenaServices.Configurables import ThinningSvc, createThinningSvc
+## BPHY8_augStream = MSMgr.GetStream( BPHY8_streamName )
+## BPHY8_evtStream = BPHY8_augStream.GetEventStream()
+## svcMgr += createThinningSvc(svcName=BPHY8cf.DerivationName+"ThinningSvc",
+## outStreams=[BPHY8_evtStream] )
+
+# Additional metadata output
+BPHY8Stream.AddMetaDataItem([ "xAOD::FileMetaData#%s*" %
+ BPHY8cf.DerivationName,
+ "xAOD::FileMetaDataAuxInfo#%s*Aux." %
+ BPHY8cf.DerivationName] )
+
+#====================================================================
+# Thinning Helper and various thinning tools
+#====================================================================
+#--------------------------------------------------------------------
+# Setup the thinning helper, only tool able to perform thinning
+# of trigger navigation information.
+#
+from DerivationFrameworkCore.ThinningHelper import ThinningHelper
+BPHY8ThinningHelper = ThinningHelper( BPHY8cf.DerivationName+"ThinningHelper" )
+
+if BPHY8cf.doTrigNavThinning and BPHY8cf.doTriggerInfo:
+ BPHY8ThinningHelper.TriggerChains = '|'.join(BPHY8cf.TrigNavThinList)
+
+BPHY8ThinningHelper.AppendToStream( BPHY8Stream )
+
+#--------------------------------------------------------------------
+# Thinning tools
+BPHY8ThinningTools = []
+
+#
+# MC Truth Thinning
+#
+if BPHY8cf.isSimulation:
+ #
+ # PDG-ID list of truth decay particles whose decay chains are to be recorded
+ # B mesons
+ BPHY8cf.TruthDecayParents = [511, 521, 10511, 10521, 513, 523, 10513, 10523, 20513, 20523, 515, 525, 531, 10531, 533, 10533, 20533, 535, 541, 10541, 543, 10543, 20543, 545]
+ # b bbar mesons
+ BPHY8cf.TruthDecayParents += [551,10551,100551,110551,200551,210551,553,10553,20553,30553,100553,110553,120553,130553,200553,210553,220553,300553,9000553,9010553,555,10555,20555,100555,110555,120555,200555,557,100557]
+ BPHY8cf.TruthDecayParents += [5122,5112,5212,5222,5114,5214,5224,5132,5232,5312,5322,5314,5324,5332,5334,5142,5242,5412,5422,5414,5424,5342,5432,5434,5442,5444,5512,5522,5514,5524,5532,5534,5542,5544,5554]
+ # Charmed mesons
+ ## BPHY8cf.TruthDecayParents += [411, 421, 10411, 10421, 413, 423, 10413, 10423, 20413, 20423, 415, 425, 431, 10431, 433, 10433, 20433, 435]
+ # c cbar mesons
+ ## BPHY8cf.TruthDecayParents += [441, 10441, 100441, 443, 10443, 20443, 100443, 30443, 9000443, 9010443, 9020443, 445, 100445]
+ # charmed baryons
+ ## BPHY8cf.TruthDecayParents += [4122, 4222, 4212, 4112, 4224, 4214, 4114, 4232, 4132, 4322, 4312, 4324, 4314, 4332, 4334, 4412, 4422, 4414, 4424, 4432, 4434, 4444]
+
+ # compose ParticleSelectionString
+ BPHY8_ParticleSelConds = []
+ for BPHY8_pdgid in BPHY8cf.TruthDecayParents:
+ BPHY8_ParticleSelConds.append("abs(TruthParticles.pdgId) == %d" %
+ BPHY8_pdgid)
+ BPHY8_ParticleSelection = " || ".join(BPHY8_ParticleSelConds)
+
+ # Only save truth information directly associated with B decays.
+ # We'll skip the GEANT particles (barcode >= 200000).
+ from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf \
+ import DerivationFramework__GenericTruthThinning
+ BPHY8TruthThinTool = DerivationFramework__GenericTruthThinning(
+ name = BPHY8cf.DerivationName+"TruthThinTool",
+ ParticleSelectionString = BPHY8_ParticleSelection,
+ PreserveGeneratorDescendants = True,
+ PreserveDescendants = False,
+ PreserveAncestors = False)
+
+ ToolSvc += BPHY8TruthThinTool
+ BPHY8ThinningTools.append(BPHY8TruthThinTool)
+ print(BPHY8TruthThinTool)
+ pprint(BPHY8TruthThinTool.properties())
+
+#
+# Vertex thinning
+#
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__Thin_vtxTrk
+
+# Build list of input containers and passed flags depending on
+# "select tools" used.
+import re
+BPHY8_vtxContainers = []
+BPHY8_refPVContainers = []
+BPHY8_passedFlags = []
+for BPHY8_tool in list(BPHY8_SelectTools.values()):
+ BPHY8_vtxContainers.append(BPHY8_tool.InputVtxContainerName)
+ BPHY8_refPVContainers.append(re.sub('Candidates$',
+ 'RefittedPrimaryVertices',
+ BPHY8_tool.InputVtxContainerName))
+ BPHY8_passName = BPHY8_tool.HypothesisName
+ if BPHY8_tool.HypothesisName == "Jpsimumu" and BPHY8cf.thinLevel > 0:
+ BPHY8_passName = "JpsimumuSubDecay"
+ BPHY8_passedFlags.append("passed_%s" % BPHY8_passName)
+#
+# Use the general Thin_vtxTrk tool to thin the vertex containers only.
+#
+if BPHY8cf.thinLevel < 2:
+ BPHY8Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(
+ name = BPHY8cf.DerivationName+"Thin_vtxTrk",
+ TrackParticleContainerName = BPHY8cf.TrkPartContName,
+ VertexContainerNames = BPHY8_vtxContainers,
+ PassFlags = BPHY8_passedFlags,
+ ThinTracks = False)
+ ToolSvc += BPHY8Thin_vtxTrk
+ BPHY8ThinningTools.append(BPHY8Thin_vtxTrk)
+ print(BPHY8Thin_vtxTrk)
+ pprint(BPHY8Thin_vtxTrk.properties())
+
+#
+# Bmumu PV, muon collections and ID track thinnning
+#
+if BPHY8cf.thinLevel > 1:
+ from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf \
+ import DerivationFramework__BmumuThinningTool
+ BPHY8BmumuThinningTool = DerivationFramework__BmumuThinningTool(
+ name = BPHY8cf.DerivationName+"BmumuThinningTool",
+ TrackParticleContainerName = BPHY8cf.TrkPartContName,
+ VertexContainerNames = BPHY8_vtxContainers,
+ VertexPassFlags = BPHY8_passedFlags,
+ RefPVContainerNames = BPHY8_refPVContainers,
+ # RefPVContainerNames = BPHY8cf.RefPVContNames,
+ AlignPassToVertexList = True,
+ PVContainerName = BPHY8cf.PVContName,
+ MuonContainerName = BPHY8cf.MuonCollection,
+ CalibMuonContainerName = BPHY8cf.CalMuonCollection,
+ MatchCalibratedMuons = (BPHY8cf.useCalibratedMuons > 2),
+ MarkMatchedMuons = (BPHY8cf.useCalibratedMuons > 2),
+ MarkMatchedCalMuons = (BPHY8cf.useCalibratedMuons > 1
+ and BPHY8cf.useCalibratedMuons < 3),
+ SyncMatchedMuonsBothWays = True,
+ AllowFastMuonMaskSync = True,
+ KeepTracksForMuons = True,
+ KeepTracksForCalMuons = True,
+ KeepMuonsForTracks = True,
+ KeepCalMuonsForTracks = True,
+ KeepCloseTracks = True,
+ ThinMuons = (BPHY8cf.thinLevel < 5),
+ CloseTrackBranchPrefixes = BPHY8cf.BranchPrefixes,
+ CloseTrackBranchBaseName = BPHY8_IsoTools["TrackVtxCt"].BranchBaseName,
+ ThinPVs = (BPHY8cf.thinLevel == 2),
+ ThinRefittedPVs = (BPHY8cf.thinLevel == 2),
+ ThinTracks = (BPHY8cf.thinLevel < 4),
+ KeepTracksForSelectedPVs = False,
+ OutputLevel = INFO)
+ ToolSvc += BPHY8BmumuThinningTool
+ BPHY8ThinningTools.append(BPHY8BmumuThinningTool)
+ print(BPHY8BmumuThinningTool)
+ pprint(BPHY8BmumuThinningTool.properties())
+
+#====================================================================
+# CREATE THE DERIVATION KERNEL ALGORITHM AND PASS THE ABOVE TOOLS
+#====================================================================
+# IMPORTANT bit. Don't forget to pass the tools to the DerivationKernel!
+# If you don't do that, they will not be be executed!
+# The name of the kernel (BPHY8Kernel in this case) must be unique to
+# this derivation.
+# Make use of a AthSequence in order to run the muon calibrations
+# beforehand if requested.
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+BPHY8_seq = CfgMgr.AthSequencer("BPHY8Sequence")
+DerivationFrameworkJob += BPHY8_seq
+BPHY8_seq += list(BPHY8_CalibrationAlgs.values())
+
+# required for Soft B tagging
+if BPHY8cf.doAddSoftBVertices:
+ from DerivationFrameworkJetEtMiss.ExtendedJetCommon import replaceAODReducedJets
+ OutputJets["BPHY8"] = []
+ reducedJetList = ["AntiKt4PV0TrackJets"]
+ replaceAODReducedJets(reducedJetList, BPHY8_seq, "BPHY8")
+
+ from SoftBVrtClusterTool.SoftBVrtConfig import addSoftBVrt
+ addSoftBVrt(BPHY8_seq,'Loose')
+ addSoftBVrt(BPHY8_seq,'Medium')
+ addSoftBVrt(BPHY8_seq,'Tight')
+
+BPHY8_seq += CfgMgr.DerivationFramework__DerivationKernel(
+ "BPHY8Kernel",
+ OutputLevel = INFO,
+ AugmentationTools = [ BPHY8_MetaDataTool, BPHY8_AugOriginalCounts,
+ BPHY8_MuonExtrapTool] \
+ + list(BPHY8_RecoTools.values()) + list(BPHY8_MuMassTools.values()) \
+ + list(BPHY8_IsoTools.values()) \
+ + list(BPHY8_SelectTools.values()) \
+ + list(BPHY8_BlinderTools.values()),
+ SkimmingTools = [BPHY8_SkimmingTool],
+ ThinningTools = BPHY8ThinningTools
+ )
+
+#====================================================================
+# Slimming
+#====================================================================
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY8SlimmingHelper = SlimmingHelper("BPHY8SlimmingHelper")
+BPHY8_AllVariables = []
+BPHY8_StaticContent = []
+BPHY8_SmartCollections = []
+BPHY8_ExtraVariables = []
+
+# Needed for trigger objects
+BPHY8SlimmingHelper.IncludeMuonTriggerContent = BPHY8cf.doTriggerInfo
+BPHY8SlimmingHelper.IncludeBPhysTriggerContent = BPHY8cf.doTriggerInfo
+
+# primary vertices
+BPHY8_SmartCollections += [BPHY8cf.PVContName]
+#
+# 2018-03-12: These extra variables are not used by NtupleMaker
+# which are removed by using SmartCollection instead of
+# AllVariables.
+## BPHY8_ExtraVariables += ["%s.covariance" % BPHY8cf.PVContName
+## + ".chiSquared.numberDoF.sumPt2"
+## + ".trackParticleLinks.trackWeights.neutralWeights"]
+#
+# 2018-05-04: The covariance matrix is occasionally used by the NtupleMaker
+# 2019-11-15: adding original number of tracks and sqrt(sum(pt^2))
+BPHY8_ExtraVariables += ["%s.covariance" % BPHY8cf.PVContName
+ +".OrigNTracks.OrigSqrtPt2Sum"]
+
+for BPHY8_reco in BPHY8_recoList:
+ BPHY8_StaticContent \
+ += ["xAOD::VertexContainer#BPHY8"+BPHY8_reco+"RefittedPrimaryVertices"]
+ BPHY8_StaticContent \
+ += ["xAOD::VertexAuxContainer#BPHY8"+BPHY8_reco+"RefittedPrimaryVerticesAux."]
+
+# combined / extrapolated muon track particles
+# (note: for tagged muons there is no extra TrackParticle collection since
+# the ID tracks are stored in InDetTrackParticles collection)
+BPHY8_AllVariables += ["CombinedMuonTrackParticles"]
+
+BPHY8_AllVariables += ["ExtrapolatedMuonTrackParticles"]
+# TODO: copy smart slimming for calibrated muons.
+if BPHY8cf.useCalibratedMuons > 1:
+ BPHY8_AllVariables += [BPHY8cf.CalMuonCollection]
+ BPHY8SlimmingHelper.AppendToDictionary = {
+ '%s' % BPHY8cf.CalMuonCollection : 'xAOD::MuonContainer',
+ '%sAux' % BPHY8cf.CalMuonCollection : 'xAOD::ShallowAuxContainer' }
+
+# muon container
+## AllVariables += [BPHY8cf.MuonCollection]
+# smart collection adds info needed for CP tools
+BPHY8_SmartCollections += [BPHY8cf.MuonCollection]
+BPHY8_ExtraVariables += ["%s.etcone30.etcone40" % BPHY8cf.MuonCollection
+ +".momentumBalanceSignificance"
+ +".scatteringCurvatureSignificance"
+ +".scatteringNeighbourSignificance"
+ +".msInnerMatchDOF.msInnerMatchChi2"
+ +".msOuterMatchDOF.msOuterMatchChi2"
+ +".EnergyLoss.ParamEnergyLoss.MeasEnergyLoss"
+ +".ET_Core" ]
+
+# ID track particles
+BPHY8_SmartCollections += [BPHY8cf.TrkPartContName]
+BPHY8_ExtraVariables += ["%s.vx.vy" % BPHY8cf.TrkPartContName]
+
+# decay candidates
+# we have to disable vxTrackAtVertex branch since it is not xAOD compatible
+# also remove not needed isolation and close-track branches from DxAOD
+BPHY8_DoVertexTypeStr = ['PV_MIN_Z0_BA']
+BPHY8_IsoBranches = ['iso', 'iso_Ntracks']
+BPHY8_MuIsoBranches = ['muiso', 'muiso_Ntracks', 'muiso+muLink']
+BPHY8_CtBranches = ['ct_DCA', 'ct_DCAError', 'ct_ZCA', 'ct_ZCAError',
+ 'ct_NTracksChi2','ct_CloseTrack+Link']
+from DerivationFrameworkBPhys.BPhysPyHelpers import BPhysFilterBranches
+for BPHY8_name in list(BPHY8_RecoTools.keys()):
+ BPHY8_StaticContent += ["xAOD::VertexContainer#%s" %
+ BPHY8_RecoTools[BPHY8_name].OutputVtxContainerName]
+ BPHY8_StaticContent += ["xAOD::VertexAuxContainer#%sAux." %
+ BPHY8_RecoTools[BPHY8_name].OutputVtxContainerName]
+ BPHY8_str = "xAOD::VertexAuxContainer#%sAux" % \
+ BPHY8_RecoTools[BPHY8_name].OutputVtxContainerName
+ BPHY8_str += ".-vxTrackAtVertex"
+ # isolation branches
+ BPHY8_cones = ["%02d_LC%02dd%01d" % \
+ (int(cs*10), int(BPHY8cf.IsoTrkImpLogChi2Max[i]*10),
+ BPHY8cf.IsoDoTrkImpLogChi2Cut[i])
+ for i,cs in enumerate(BPHY8cf.IsolationConeSizes)]
+ BPHY8_str += BPhysFilterBranches(BPHY8_name,
+ BPHY8_IsoBranches,
+ BPHY8cf.IsoIncludes,
+ BPHY8_DoVertexTypeStr,
+ BPHY8cf.IsoTrackCategoryName,
+ BPHY8cf.useIsoTrackTypes,
+ BPHY8_cones,
+ False)
+ # muon isolation branches
+ BPHY8_cones = ["%02d_LC%02dd%01d" % \
+ (int(cs*10), int(BPHY8cf.MuIsoTrkImpLogChi2Max[i]*10),
+ BPHY8cf.MuIsoDoTrkImpLogChi2Cut[i])
+ for i,cs in enumerate(BPHY8cf.MuIsolationConeSizes)]
+ BPHY8_str += BPhysFilterBranches(BPHY8_name,
+ BPHY8_MuIsoBranches,
+ BPHY8cf.MuIsoIncludes,
+ BPHY8_DoVertexTypeStr,
+ BPHY8cf.MuIsoTrackCategoryName,
+ BPHY8cf.useMuIsoTrackTypes,
+ BPHY8_cones,
+ False)
+ # close track branches
+ BPHY8_str += BPhysFilterBranches(BPHY8_name,
+ BPHY8_CtBranches,
+ BPHY8cf.CloseTrackIncludes,
+ BPHY8_DoVertexTypeStr,
+ BPHY8cf.CloseTrackCategoryName,
+ BPHY8cf.useCloseTrackTypes,
+ BPHY8cf.CloseTrackChi2SetName,
+ True)
+ print(("Branches to be removed: %s" % BPHY8_str))
+ BPHY8_StaticContent += [ BPHY8_str ]
+
+# Truth information for MC only
+if BPHY8cf.isSimulation:
+ BPHY8_AllVariables += ["TruthEvents","TruthParticles","TruthVertices"]
+
+# required for Soft B Tagging
+if BPHY8cf.doAddSoftBVertices:
+ excludedVertexAuxData = "-vxTrackAtVertex.-MvfFitInfo.-isInitialized.-VTAV"
+ BPHY8_StaticContent += ["xAOD::VertexContainer#"
+ +"SoftBVrtClusterTool_Tight_Vertices"]
+ BPHY8_StaticContent += ["xAOD::VertexAuxContainer#"
+ +"SoftBVrtClusterTool_Tight_VerticesAux."
+ + excludedVertexAuxData]
+ BPHY8_StaticContent += ["xAOD::VertexContainer#"
+ +"SoftBVrtClusterTool_Medium_Vertices"]
+ BPHY8_StaticContent += ["xAOD::VertexAuxContainer#"
+ +"SoftBVrtClusterTool_Medium_VerticesAux."
+ + excludedVertexAuxData]
+ BPHY8_StaticContent += ["xAOD::VertexContainer#"
+ +"SoftBVrtClusterTool_Loose_Vertices"]
+ BPHY8_StaticContent += ["xAOD::VertexAuxContainer#"
+ +"SoftBVrtClusterTool_Loose_VerticesAux."
+ + excludedVertexAuxData]
+
+BPHY8SlimmingHelper.AllVariables = BPHY8_AllVariables
+BPHY8SlimmingHelper.SmartCollections = BPHY8_SmartCollections
+BPHY8SlimmingHelper.StaticContent = BPHY8_StaticContent
+BPHY8SlimmingHelper.ExtraVariables = BPHY8_ExtraVariables
+BPHY8SlimmingHelper.AppendContentToStream(BPHY8Stream)
+
+#====================================================================
+# END OF BPHY8.py
+#====================================================================
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY9.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY9.py
new file mode 100644
index 00000000000..a617264e2ce
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/BPHY9.py
@@ -0,0 +1,398 @@
+#********************************************************************
+# BPHY9.py
+# reductionConf flag BPHY9 in Reco_tf.py
+#********************************************************************
+
+from DerivationFrameworkCore.DerivationFrameworkMaster import *
+from DerivationFrameworkInDet.InDetCommon import *
+from DerivationFrameworkJetEtMiss.JetCommon import *
+from DerivationFrameworkEGamma.EGammaCommon import *
+from DerivationFrameworkMuons.MuonsCommon import *
+from DerivationFrameworkHiggs.TruthCategories import *
+from AthenaCommon.GlobalFlags import globalflags
+
+is_MC = globalflags.DataSource()=='geant4'
+
+print('is_MC = ',is_MC)
+
+
+if is_MC:
+ from DerivationFrameworkMCTruth.MCTruthCommon import addStandardTruthContents
+ addStandardTruthContents()
+ from DerivationFrameworkMCTruth.HFHadronsCommon import *
+
+#====================================================================
+# SET UP STREAM
+#====================================================================
+streamName = derivationFlags.WriteDAOD_BPHY9Stream.StreamName
+fileName = buildFileName( derivationFlags.WriteDAOD_BPHY9Stream )
+BPHY9Stream = MSMgr.NewPoolRootStream( streamName, fileName )
+BPHY9Stream.AcceptAlgs(['BPHY9Kernel'])
+
+#====================================================================
+# AUGMENTATION TOOLS
+#====================================================================
+augmentationTools = []
+
+#--------------------------------------------------------------------
+# Jpsi vertexing Tool
+#--------------------------------------------------------------------
+# 1/ setup vertexing tools and services
+include('DerivationFrameworkBPhys/configureVertexing.py')
+BPHY9_VertexTools = BPHYVertexTools('BPHY9')
+
+# 2/ Setup the vertex fitter tools (e.g. JpsiFinder, JpsiPlus1Track, etc).
+# These are general tools independent of DerivationFramework that do the
+# actual vertex fitting and some pre-selection.
+from JpsiUpsilonTools.JpsiUpsilonToolsConf import Analysis__JpsiFinder
+BPHY9JpsiFinder = Analysis__JpsiFinder(name = 'BPHY9JpsiFinder',
+ OutputLevel = INFO,
+ muAndMu = True,
+ muAndTrack = False,
+ TrackAndTrack = False,
+ assumeDiMuons = True, # If true, will assume dimu hypothesis and use PDG value for mu mass
+ invMassUpper = 100000.0,
+ invMassLower = 0.0,
+ Chi2Cut = 200.,
+ oppChargesOnly = True,
+ atLeastOneComb = True,
+ useCombinedMeasurement = False, # Only takes effect if combOnly=True
+ muonCollectionKey = 'Muons',
+ TrackParticleCollection = 'InDetTrackParticles',
+ V0VertexFitterTool = BPHY9_VertexTools.TrkV0Fitter, # V0 vertex fitter
+ useV0Fitter = False, # if False a TrkVertexFitterTool will be used
+ TrkVertexFitterTool = BPHY9_VertexTools.TrkVKalVrtFitter, # VKalVrt vertex fitter
+ TrackSelectorTool = BPHY9_VertexTools.InDetTrackSelectorTool,
+ VertexPointEstimator = BPHY9_VertexTools.VtxPointEstimator,
+ useMCPCuts = False)
+ToolSvc += BPHY9JpsiFinder
+print(BPHY9JpsiFinder)
+
+# 3/ Setup the vertex reconstruction 'call' tool(s). They are part of the derivation framework. These Augmentation tools add
+# output vertex collection(s) into the StoreGate and add basic decorations which do not depend on the vertex mass hypothesis
+# (e.g. lxy, ptError, etc). There should be one tool per topology, i.e. Jpsi and Psi(2S) do not need two instance of the
+# Reco tool is the JpsiFinder mass window is wide enough.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Reco_Vertex
+BPHY9_Reco_mumu = DerivationFramework__Reco_Vertex(name = 'BPHY9_Reco_mumu',
+ VertexSearchTool = BPHY9JpsiFinder,
+ OutputVtxContainerName = 'BPHY9OniaCandidates',
+ PVContainerName = 'PrimaryVertices',
+ RefPVContainerName = 'BPHY9RefittedPrimaryVertices',
+ RefitPV = True,
+ MaxPVrefit = 100000,
+ DoVertexType = 7)
+ToolSvc += BPHY9_Reco_mumu
+print(BPHY9_Reco_mumu)
+
+# 4/ Setup the vertex selection and augmentation tool(s). These tools decorate the vertices with variables that depend
+# on the vertex mass hypothesis, e.g. invariant mass, proper decay time, etc. Property HypothesisName is used as a
+# prefix for these decorations. They also perform tighter selection, flagging the vertecis that passed. The flag is
+# a Char_t branch named 'passed_'+HypothesisName. It is used later by the 'SelectEvent' and 'Thin_vtxTrk' tools to
+# determine which events and candidates should be kept in the output stream. Multiple instances of the Select_* tools
+# can be used on a single input collection as long as they use different 'HypothesisName' flags.
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Select_onia2mumu
+
+# 4a/ augment and select Jpsi->mumu candidates
+BPHY9_Select_Jpsi2mumu = DerivationFramework__Select_onia2mumu(name = 'BPHY9_Select_Jpsi2mumu',
+ HypothesisName = 'Jpsi',
+ InputVtxContainerName = 'BPHY9OniaCandidates',
+ VtxMassHypo = 3096.916,
+ MassMin = 2000.0,
+ MassMax = 3600.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+ToolSvc += BPHY9_Select_Jpsi2mumu
+print(BPHY9_Select_Jpsi2mumu)
+
+# 4b/ augment and select Psi(2S)->mumu candidates
+BPHY9_Select_Psi2mumu = DerivationFramework__Select_onia2mumu(name = 'BPHY9_Select_Psi2mumu',
+ HypothesisName = 'Psi',
+ InputVtxContainerName = 'BPHY9OniaCandidates',
+ VtxMassHypo = 3686.09,
+ MassMin = 3300.0,
+ MassMax = 4500.0,
+ Chi2Max = 200,
+ DoVertexType = 7)
+ToolSvc += BPHY9_Select_Psi2mumu
+print(BPHY9_Select_Psi2mumu)
+
+# 5/ select the event. We only want to keep events that contain certain vertices which passed certain selection.
+# This is specified by the 'SelectionExpression' property, which contains the expression in the following format:
+# 'ContainerName.passed_HypoName > count'
+# where 'ContainerName' is output container form some Reco_* tool, 'HypoName' is the hypothesis name setup in some 'Select_*'
+# tool and 'count' is the number of candidates passing the selection you want to keep.
+
+# Skimming
+# a/ High pt lepton
+ptSelection = '( count(Electrons.pt > 20*GeV) > 0 || count(Muons.pt > 20*GeV) > 0 )'
+# b/ >3 total leptons
+threelepSelection = '( count(Muons.pt > 0) + count(Electrons.pt > 0) >= 3 )'
+# c/ di-muon vertex near Onia peak
+oniaSelection = '( count(BPHY9OniaCandidates.passed_Jpsi) > 0 || count(BPHY9OniaCandidates.passed_Psi) > 0 )'
+# &
+expression = oniaSelection + ' && ' + threelepSelection + ' && ' + ptSelection
+from DerivationFrameworkTools.DerivationFrameworkToolsConf import DerivationFramework__xAODStringSkimmingTool
+BPHY9_SelectEvent = DerivationFramework__xAODStringSkimmingTool(name = 'BPHY9_SelectEvent',
+ expression = expression)
+ToolSvc += BPHY9_SelectEvent
+
+# 6/ Track and vertex thinning. We want to remove all reconstructed secondary vertices which hasn't passed any of the
+# selections defined by (Select_*) tools. We also want to keep only tracks which are associates with either muons or
+# any of the vertices that passed the selection. Multiple thinning tools can perform the selection. The final thinning
+# decision is based OR of all the decisions (by default, although it can be changed by the JO).
+
+# 6a/ Thining out vertices that didn't pass any selection and idetifying tracks associated with selected vertices. The
+# 'VertexContainerNames' is a list of the vertex containers, and 'PassFlags' contains all pass flags for Select_*
+# tools that must be satisfied. The vertex is kept is it satisfy any of the listed selections.
+
+from DerivationFrameworkBPhys.DerivationFrameworkBPhysConf import DerivationFramework__Thin_vtxTrk
+BPHY9Thin_vtxTrk = DerivationFramework__Thin_vtxTrk(name = 'BPHY9Thin_vtxTrk',
+ TrackParticleContainerName = 'InDetTrackParticles',
+ VertexContainerNames = ['BPHY9OniaCandidates'],
+ PassFlags = ['passed_Jpsi', 'passed_Psi'] )
+ToolSvc += BPHY9Thin_vtxTrk
+
+# 6b/ thinning out tracks that are not attached to muons. The final thinning decision is based on the OR operation
+# between decision from this and the previous tools.
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY9MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = 'BPHY9MuonTPThinningTool',
+ MuonKey = 'Muons',
+ InDetTrackParticlesKey = 'InDetTrackParticles')
+ToolSvc += BPHY9MuonTPThinningTool
+
+# 6c/ Only save truth informtion directly associated with Onia
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__GenericTruthThinning
+BPHY9TruthThinTool = DerivationFramework__GenericTruthThinning(name = 'BPHY9TruthThinTool',
+ ParticleSelectionString = 'TruthParticles.pdgId==443 || TruthParticles.pdgId==100443',
+ PreserveDescendants = True,
+ PreserveAncestors = True)
+ToolSvc += BPHY9TruthThinTool
+print(BPHY9TruthThinTool)
+
+#==============================================================================
+# BACKGROUND ELECTRON DECORATION TYPE/ORIGIN
+#==============================================================================
+# PhysicsAnalysis/DerivationFramework/DerivationFrameworkEGamma/trunk/src/BkgElectronClassification.cxx
+
+if is_MC:
+ from MCTruthClassifier.MCTruthClassifierBase import MCTruthClassifier as BkgElectronMCTruthClassifier
+ from DerivationFrameworkEGamma.DerivationFrameworkEGammaConf import DerivationFramework__BkgElectronClassification
+ BPHY9BkgElectronClassificationTool = DerivationFramework__BkgElectronClassification (name = 'BkgElectronClassificationTool',
+ MCTruthClassifierTool = BkgElectronMCTruthClassifier)
+ ToolSvc += BPHY9BkgElectronClassificationTool
+ augmentationTools.append(BPHY9BkgElectronClassificationTool)
+ print('BkgElectronClassificationTool: ', BPHY9BkgElectronClassificationTool)
+
+#====================================================================
+# THINNING TOOLS
+#====================================================================
+thinningTools=[]
+
+# Establish the thinning helper (which will set up the services behind the scenes)
+from DerivationFrameworkCore.ThinningHelper import ThinningHelper
+BPHY9ThinningHelper = ThinningHelper( 'BPHY9ThinningHelper' )
+
+# Trigger Thinning Tool
+elTrig = '^(?!.*_[0-9]*(mu|j|xe|tau|ht|xs|te))(?!HLT_e.*_[0-9]*e.*)HLT_e.*lhloose.*'\
+ +'|^(?!.*_[0-9]*(mu|j|xe|tau|ht|xs|te))(?!HLT_e.*_[0-9]*e.*)HLT_e.*lhmedium.*'\
+ +'|^(?!.*_[0-9]*(mu|j|xe|tau|ht|xs|te))(?!HLT_e.*_[0-9]*e.*)HLT_e.*lhtight.*'\
+ +'|^(?!.*_[0-9]*(mu|j|xe|tau|ht|xs|te))(?!HLT_e.*_[0-9]*e.*)HLT_e.*lhvloose.*'
+muTrig = '^(?!.*_[0-9]*(e|j|xe|tau|ht|xs|te))(?!HLT_mu.*_[0-9]*mu.*)HLT_mu.*'
+BPHY9ThinningHelper.TriggerChains = elTrig + '|' + muTrig
+BPHY9ThinningHelper.AppendToStream( BPHY9Stream )
+
+# Jet tracks
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__JetTrackParticleThinning
+BPHY9JetTPThinningTool = DerivationFramework__JetTrackParticleThinning(name = 'BPHY9JetTPThinningTool',
+ JetKey = 'AntiKt4EMTopoJets',
+ InDetTrackParticlesKey = 'InDetTrackParticles',
+ ApplyAnd = True)
+ToolSvc += BPHY9JetTPThinningTool
+thinningTools.append(BPHY9JetTPThinningTool)
+
+# Tracks associated with Muons
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__MuonTrackParticleThinning
+BPHY9MuonTPThinningTool = DerivationFramework__MuonTrackParticleThinning(name = 'BPHY9MuonTPThinningTool',
+ MuonKey = 'Muons',
+ InDetTrackParticlesKey = 'InDetTrackParticles')
+ToolSvc += BPHY9MuonTPThinningTool
+thinningTools.append(BPHY9MuonTPThinningTool)
+
+# Tracks associated with Electrons
+from DerivationFrameworkInDet.DerivationFrameworkInDetConf import DerivationFramework__EgammaTrackParticleThinning
+BPHY9ElectronTPThinningTool = DerivationFramework__EgammaTrackParticleThinning(name = 'BPHY9ElectronTPThinningTool',
+ SGKey = 'Electrons',
+ InDetTrackParticlesKey = 'InDetTrackParticles')
+ToolSvc += BPHY9ElectronTPThinningTool
+thinningTools.append(BPHY9ElectronTPThinningTool)
+
+#====================================================================
+# Truth Thinning
+#====================================================================
+# Truth selection strings
+truth_cond_lep_list = [
+'(abs(TruthParticles.pdgId)>=11 && abs(TruthParticles.pdgId)<=14)',
+'(TruthParticles.pt > 4.0*GeV)',
+'(TruthParticles.status == 1)',
+'(TruthParticles.barcode<200000)']
+truth_cond_lep = ' && '.join(truth_cond_lep_list)
+truth_cond_photon = '(abs(TruthParticles.pdgId)==22) && (TruthParticles.pt>1*GeV)'
+truth_cond_comb = '('+truth_cond_lep+') || ('+truth_cond_photon+')'
+
+# PreserveGeneratorDescendants only keeps particles that came directly from the event generator
+# PreserveDescendants keeps all particles including those that come from Geant processes
+BPHY9TruthTool = DerivationFramework__GenericTruthThinning(name = 'BPHY9TruthTool',
+ ParticleSelectionString = truth_cond_comb,
+ PreserveDescendants = True,
+ PreserveGeneratorDescendants = False,
+ PreserveAncestors = True,
+ TauHandling = False)
+
+from DerivationFrameworkMCTruth.DerivationFrameworkMCTruthConf import DerivationFramework__MenuTruthThinning
+BPHY9TruthToolMenu = DerivationFramework__MenuTruthThinning(name = 'BPHY9TruthToolMenu',
+ WritePartons = False,
+ WriteHadrons = False,
+ WriteBHadrons = False,
+ WriteGeant = False,
+ GeantPhotonPtThresh = -1.0,
+ WriteTauHad = False,
+ PartonPtThresh = -1.0,
+ WriteBSM = False,
+ WriteBosons = True,
+ WriteBSMProducts = False,
+ WriteBosonProducts = True,
+ WriteTopAndDecays = True,
+ WriteEverything = False,
+ WriteAllLeptons = True,
+ WriteStatus3 = False,
+ WriteFirstN = -1)
+
+if is_MC:
+ ToolSvc += BPHY9TruthTool
+ thinningTools.append(BPHY9TruthTool)
+ ToolSvc += BPHY9TruthToolMenu
+ thinningTools.append(BPHY9TruthToolMenu)
+
+#=======================================
+# CREATE PRIVATE SEQUENCE
+#=======================================
+BPHY9Seq = CfgMgr.AthSequencer('BPHY9Sequence')
+from DerivationFrameworkFlavourTag.FlavourTagCommon import FlavorTagInit
+FlavorTagInit(JetCollections=['AntiKt4EMPFlowJets'], Sequencer=BPHY9Seq)
+#=======================================
+# CREATE THE DERIVATION KERNEL ALGORITHM
+#=======================================
+BPHY9ThinningTools = [BPHY9Thin_vtxTrk, BPHY9MuonTPThinningTool]
+if is_MC:
+ BPHY9ThinningTools.append(BPHY9TruthThinTool)
+
+from DerivationFrameworkCore.DerivationFrameworkCoreConf import DerivationFramework__DerivationKernel
+DerivationFrameworkJob += CfgMgr.DerivationFramework__DerivationKernel(
+ 'BPHY9Kernel',
+ AugmentationTools = [BPHY9_Reco_mumu, BPHY9_Select_Jpsi2mumu, BPHY9_Select_Psi2mumu],
+ SkimmingTools = [BPHY9_SelectEvent])
+
+#====================================================================
+# JetTagNonPromptLepton decorations
+#====================================================================
+import JetTagNonPromptLepton.JetTagNonPromptLeptonConfig as JetTagConfig
+# Build AntiKt4PV0TrackJets and run b-tagging
+JetTagConfig.ConfigureAntiKt4PV0TrackJets(BPHY9Seq, 'BPHY9')
+# Add BDT decoration algs
+BPHY9Seq += JetTagConfig.GetDecoratePromptLeptonAlgs()
+DerivationFrameworkJob += BPHY9Seq
+
+#====================================================================
+# SLIMMING TOOL
+#====================================================================
+from DerivationFrameworkCore.SlimmingHelper import SlimmingHelper
+BPHY9SlimmingHelper = SlimmingHelper('BPHY9SlimmingHelper')
+
+# Slimming for recontruction content
+BPHY9SlimmingHelper.AllVariables = []
+
+BPHY9SlimmingHelper.SmartCollections = ['AntiKt4EMPFlowJets',
+ 'AntiKt4EMPFlowJets_BTagging201903',
+ 'AntiKt4EMTopoJets',
+ 'AntiKt4EMTopoJets_BTagging201810',
+ 'BTagging_AntiKt4EMPFlow_201903',
+ 'BTagging_AntiKt4EMTopo_201810',
+ 'Electrons',
+ 'InDetTrackParticles',
+ 'MET_Reference_AntiKt4EMPFlow',
+ 'MET_Reference_AntiKt4EMTopo',
+ 'Muons',
+ 'PrimaryVertices']
+
+extraJetVariables = '.JetEMScaleMomentum_pt.JetEMScaleMomentum_eta.JetEMScaleMomentum_phi.JetEMScaleMomentum_m'\
+ +'.ConeTruthLabelID.PartonTruthLabelID.SumPtTrkPt1000.Jvt.JvtJvfcorr.JvtRpt'\
+ +'.HECFrac.LArQuality.HECQuality.NegativeE.AverageLArQF'
+
+BPHY9SlimmingHelper.ExtraVariables = ['AntiKt4EMPFlowJets'+extraJetVariables,
+ 'AntiKt4EMTopoJets'+extraJetVariables,
+ 'CombinedMuonTrackParticles'+'.z0'
+ +'.vz'
+ +'.definingParametersCovMatrix',
+ 'Electrons'+'.author'
+ +'.charge',
+ 'ExtrapolatedMuonTrackParticles'+'.z0'
+ +'.vz'
+ +'.definingParametersCovMatrix',
+ 'GSFTrackParticles'+'.z0'
+ +'.vz'
+ +'.definingParametersCovMatrix',
+ 'Muons'+'.clusterLink'
+ +'.allAuthors'
+ +'.charge'
+ +'.extrapolatedMuonSpectrometerTrackParticleLink'
+ +'.scatteringCurvatureSignificance'
+ +'.scatteringNeighbourSignificance',
+ 'PrimaryVertices'+'.x'
+ +'.y']
+
+BPHY9Stream.StaticContent = []
+
+# Slimming for truth content
+if is_MC:
+ BPHY9SlimmingHelper.AllVariables += ['TruthParticles',
+ 'TruthEvents',
+ 'TruthVertices']
+
+ BPHY9SlimmingHelper.SmartCollections += ['AntiKt4TruthJets',
+ 'AntiKt4TruthWZJets']
+
+ BPHY9SlimmingHelper.ExtraVariables += ['CombinedMuonTrackParticles'+'.truthOrigin'
+ +'.truthType'
+ +'.truthParticleLink',
+ 'Electrons'+'.truthOrigin'
+ +'.truthType'
+ +'.truthParticleLink'
+ +'.bkgTruthType'
+ +'.bkgTruthOrigin'
+ +'.bkgTruthParticleLink'
+ +'.bkgMotherPdgId'
+ +'.deltaPhi1',
+ 'InDetTrackParticles'+'.truthOrigin'
+ +'.truthType'
+ +'.truthParticleLink',
+ 'MuonTruthParticles'+'.truthOrigin'
+ +'.truthType'
+ +'.truthParticleLink']
+
+ BPHY9SlimmingHelper.StaticContent += ['xAOD::TruthParticleContainer#TruthMuons',
+ 'xAOD::TruthParticleAuxContainer#TruthMuonsAux.',
+ 'xAOD::TruthParticleContainer#TruthElectrons',
+ 'xAOD::TruthParticleAuxContainer#TruthElectronsAux.',
+ 'xAOD::TruthParticleContainer#TruthNeutrinos',
+ 'xAOD::TruthParticleAuxContainer#TruthNeutrinosAux.']
+
+# Slimming for trigger content
+BPHY9SlimmingHelper.IncludeEGammaTriggerContent = True
+BPHY9SlimmingHelper.IncludeMuonTriggerContent = True
+
+# Slimming for charmonia content
+BPHY9Stream.AddItem('xAOD::VertexContainer#BPHY9OniaCandidates')
+BPHY9Stream.AddItem('xAOD::VertexAuxContainer#BPHY9OniaCandidatesAux.')
+BPHY9Stream.AddItem('xAOD::VertexAuxContainer#BPHY9OniaCandidatesAux.-vxTrackAtVertex')
+
+BPHY9SlimmingHelper.AppendContentToStream(BPHY9Stream)
\ No newline at end of file
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/SaveExtraMetadataInMerge_jobOFragment.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/SaveExtraMetadataInMerge_jobOFragment.py
new file mode 100644
index 00000000000..0e7742c69c7
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/SaveExtraMetadataInMerge_jobOFragment.py
@@ -0,0 +1,53 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+#
+# JobOption fragment to be used during DAOD merging. It takes care of
+# propagating all B-physics metadata objects to the output file.
+#
+
+# Python import(s):
+import re
+
+# Core import(s):
+from RecExConfig.InputFilePeeker import inputFileSummary
+from OutputStreamAthenaPool.MultipleStreamManager import MSMgr
+from AthenaCommon.Logging import logging
+
+# Create a logger:
+_logger = logging.getLogger( "SaveExtraMetadataInMerge_jobOFragment" )
+
+# Find the exact name of xAOD::FileMetaData_vX in the inputFileSummary
+# dictionary:
+mdType = ""
+for key in list(inputFileSummary[ 'metadata_itemsDic' ].keys()):
+ if re.match( 'xAOD::FileMetaData_v[0-9]+', key ):
+ mdType = key
+ break
+ pass
+
+# If there is, then let's do the rest of the setup:
+if mdType != "":
+
+ # Loop over the keys of all the xAOD::FileMetaData objects:
+ for key in inputFileSummary[ 'metadata_itemsDic' ][ mdType ]:
+
+ # If it doesn't look like a b-physics metadata object, then leave
+ # it alone:
+ if not key.endswith( '_MetaData' ):
+ continue
+
+ # Create the metadata tool for propagating this info:
+ toolName = "BPhysFileMetadataTool_%s" % key
+ ToolSvc += CfgMgr.xAODMaker__FileMetaDataTool( toolName,
+ InputKey = key,
+ OutputKey = key )
+ svcMgr.MetaDataSvc.MetaDataTools += [ getattr( ToolSvc, toolName ) ]
+ _logger.info( "Created tool: %s" % toolName )
+
+ # Add the metadata to the output stream(s):
+ outputItems = [ 'xAOD::FileMetaData#%s' % key,
+ 'xAOD::FileMetaDataAuxInfo#%sAux.' % key ]
+ MSMgr.AddMetaDataItemToAllStreams( outputItems )
+ _logger.info( "Added metatata items: %s" % str( outputItems ) )
+
+ pass
+ pass
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureConversionFinder.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureConversionFinder.py
new file mode 100644
index 00000000000..67b775ec061
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureConversionFinder.py
@@ -0,0 +1,69 @@
+#
+# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+#
+#====================================================================
+# Collection of tools to run the conversion finder
+#====================================================================
+
+class BPHYConversionFinderTools:
+
+ def __init__(self, derivation = ""):
+
+ if derivation == "":
+ print('--------> FATAL: BPHYConversionFinderTools, "derivation" string not set!')
+ import sys
+ sys.exit()
+
+
+ prefix = derivation+"ConversionFinderTools"
+
+ from AthenaCommon.AppMgr import ToolSvc
+
+ # set up extrapolator
+ from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
+ self.Extrapolator = AtlasExtrapolator(name = prefix+"_AtlasExtrapolator")
+ ToolSvc += self.Extrapolator
+ print(self.Extrapolator)
+
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.InDetSecVxFitterTool = Trk__TrkVKalVrtFitter(name = prefix+"_Fitter",
+ Extrapolator = self.Extrapolator,
+ MakeExtendedVertex = True,
+ FirstMeasuredPoint = False,
+ Robustness = 6,
+ InputParticleMasses = [0.511,0.511],
+ VertexForConstraint = [0.,0.,0.],
+ CovVrtForConstraint = [0.015*0.015,0.,0.015*0.015,0.,0.,10000.*10000.],
+ FirstMeasuredPointLimit = True,
+ usePhiCnst = True,
+ useThetaCnst = True)
+ ToolSvc += self.InDetSecVxFitterTool
+ print(self.InDetSecVxFitterTool)
+
+
+ from TrkVertexSeedFinderUtils.TrkVertexSeedFinderUtilsConf import Trk__SeedNewtonTrkDistanceFinder
+ self.InDetSecVxTrkDistanceFinder = Trk__SeedNewtonTrkDistanceFinder(name = prefix+"_TrkDistanceFinder")
+ ToolSvc += self.InDetSecVxTrkDistanceFinder
+ print(self.InDetSecVxTrkDistanceFinder)
+
+
+ from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
+ self.InDetSecVtxPointEstimator = InDet__VertexPointEstimator(name = prefix+"_PointEstimator",
+ MinDeltaR = [-5.,-25.,-50.], # D-R1-R2 min cut
+ MaxDeltaR = [5.,10.,10.] , # D-R1-R2 max cut
+ MaxPhi = [0.05, 0.5, 0.5]) # dphi cut at vertex
+ ToolSvc += self.InDetSecVtxPointEstimator
+ print(self.InDetSecVtxPointEstimator)
+
+
+ from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionPostSelector
+ self.InDetSecVtxPostSelector = InDet__ConversionPostSelector(name = prefix+"_PostSelector",
+ MaxChi2Vtx = [10.,10.,10.],
+ MaxInvariantMass = [10000.,10000.,10000.],
+ MinFitMomentum = [0.,0.,0.],
+ MinRadius = [10.0,10.0,10.0],
+ MinPt = 0.0,
+ MaxdR = -10000.0,
+ MaxPhiVtxTrk = 10000.0)
+ ToolSvc += self.InDetSecVtxPostSelector
+ print(self.InDetSecVtxPostSelector)
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureSimpleV0Finder.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureSimpleV0Finder.py
new file mode 100644
index 00000000000..bf1f8ca02ee
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureSimpleV0Finder.py
@@ -0,0 +1,201 @@
+#====================================================================
+# Collection of tools required by V0Finder
+#====================================================================
+
+class BPHYV0FinderTools:
+
+ def __init__(self, derivation = ""):
+
+ if derivation == "":
+ print('--------> FATAL: BPHYV0FinderTools, "derivation" string not set!')
+ import sys
+ sys.exit()
+
+ from AthenaCommon.AppMgr import ToolSvc
+
+ # set up extrapolator
+ from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
+ self.InDetExtrapolator = AtlasExtrapolator(name = derivation+"_AtlasExtrapolator")
+ ToolSvc += self.InDetExtrapolator
+ print(self.InDetExtrapolator)
+
+ # Vertex point estimator
+ from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
+ self.V0VtxPointEstimator = InDet__VertexPointEstimator(name = derivation+"_VtxPointEstimator",
+ MaxTrkXYDiffAtVtx = [20.,20.,20.],
+ MaxTrkZDiffAtVtx = [100.,100.,100.],
+ MaxTrkXYValue = [400.,400.,400.],
+ MinArcLength = [-800.,-800.,-800.],
+ MaxArcLength = [800.,800.,800.],
+ MinDeltaR = [-10000.,-10000.,-10000.],
+ MaxDeltaR = [10000.,10000.,10000.],
+ MaxPhi = [10000., 10000., 10000.],
+ MaxChi2OfVtxEstimation = 2000.)
+ ToolSvc += self.V0VtxPointEstimator
+ print(self.V0VtxPointEstimator)
+
+ from InDetRecExample.InDetKeys import InDetKeys
+
+ from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels
+ self.V0PrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(name = derivation+"_V0PrdAssociationTool",
+ PixelClusterAmbiguitiesMapName = InDetKeys.GangedPixelMap())
+ ToolSvc += self.V0PrdAssociationTool
+ print(self.V0PrdAssociationTool)
+
+ from RecExConfig.RecFlags import rec
+ CountDeadModulesAfterLastHit=False
+ #rec.Commissioning=False
+
+ from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool
+ self.V0HoleSearchTool = InDet__InDetTrackHoleSearchTool(name = derivation+"_V0HoleSearchTool",
+ Extrapolator = self.InDetExtrapolator,
+ usePixel = DetFlags.haveRIO.pixel_on(),
+ useSCT = DetFlags.haveRIO.SCT_on(),
+ #Commissioning = rec.Commissioning())
+ CountDeadModulesAfterLastHit = CountDeadModulesAfterLastHit)
+ ToolSvc += self.V0HoleSearchTool
+ print(self.V0HoleSearchTool)
+
+ from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool
+ self.V0TrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(name = derivation+"_InDetSummaryHelper",
+ AssoTool = self.V0PrdAssociationTool,
+ DoSharedHits = False,
+ HoleSearch = self.V0HoleSearchTool,
+ usePixel = DetFlags.haveRIO.pixel_on(),
+ useSCT = DetFlags.haveRIO.SCT_on(),
+ useTRT = DetFlags.haveRIO.TRT_on())
+ ToolSvc += self.V0TrackSummaryHelperTool
+ print(self.V0TrackSummaryHelperTool)
+
+ from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
+ self.V0TrackSummaryTool = Trk__TrackSummaryTool(name = derivation+"_V0TrackSummaryTool",
+ InDetSummaryHelperTool = self.V0TrackSummaryHelperTool,
+ doSharedHits = False,
+ InDetHoleSearchTool = self.V0HoleSearchTool)
+ ToolSvc += self.V0TrackSummaryTool
+ print(self.V0TrackSummaryTool)
+
+
+
+ from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetConversionTrackSelectorTool
+ self.InDetV0VxTrackSelector = InDet__InDetConversionTrackSelectorTool(name = derivation+"InDetV0VxTrackSelector",
+ TrackSummaryTool = self.V0TrackSummaryTool,
+ Extrapolator = self.InDetExtrapolator,
+ # Extrapolator = "Trk::Extrapolator/InDetExtrapolator",
+ maxTrtD0 = 50.,
+ maxSiZ0 = 250.,
+ significanceD0_Si = 1.,
+ significanceD0_Trt = 1.,
+ significanceZ0_Trt = 3.,
+ minPt = 400.0,
+ IsConversion = False)
+ ToolSvc += self.InDetV0VxTrackSelector
+ print(self.InDetV0VxTrackSelector)
+
+
+ # configure vertex fitters
+
+ from TrkV0Fitter.TrkV0FitterConf import Trk__TrkV0VertexFitter
+ self.BPhysV0Fitter = Trk__TrkV0VertexFitter(name = derivation+'_BPhysV0Fitter',
+ MaxIterations = 10,
+ Use_deltaR = False,
+ FirstMeasuredPoint = True,
+ Extrapolator = self.InDetExtrapolator)
+ ToolSvc += self.BPhysV0Fitter
+ print(self.BPhysV0Fitter)
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysVKVertexFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKVFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+ ToolSvc += self.BPhysVKVertexFitter
+ print(self.BPhysVKVertexFitter)
+
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysKshortFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKKVFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True,
+ InputParticleMasses = [139.57,139.57],
+ MassForConstraint = 497.672)
+ ToolSvc += self.BPhysKshortFitter
+ print(self.BPhysKshortFitter)
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysLambdaFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKLFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True,
+ InputParticleMasses = [938.272,139.57],
+ MassForConstraint = 1115.68)
+ ToolSvc += self.BPhysLambdaFitter
+ print(self.BPhysLambdaFitter)
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysLambdabarFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKLbFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True,
+ InputParticleMasses = [139.57,938.272],
+ MassForConstraint = 1115.68)
+ ToolSvc += self.BPhysLambdabarFitter
+ print(self.BPhysLambdabarFitter)
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysGammaFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKGFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ Robustness = 6,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True,
+ usePhiCnst = True,
+ useThetaCnst = True,
+ InputParticleMasses = [0.511,0.511])
+ ToolSvc += self.BPhysGammaFitter
+ print(self.BPhysGammaFitter)
+
+##--------------------------------------------
+## Setup V0Finder
+##--------------------------------------------
+ from InDetV0Finder.InDetV0FinderConf import InDet__InDetV0FinderTool
+ self.V0FinderTool = InDet__InDetV0FinderTool(name = derivation+'_InDetV0FinderTool',
+ TrackParticleCollection = InDetKeys.xAODTrackParticleContainer(),
+ #TrackParticleCollection = "InDetTrackParticles",
+ useV0Fitter = True,
+ VertexFitterTool = self.BPhysV0Fitter,
+ VKVertexFitterTool = self.BPhysVKVertexFitter,
+ KshortFitterTool = self.BPhysKshortFitter,
+ LambdaFitterTool = self.BPhysLambdaFitter,
+ LambdabarFitterTool = self.BPhysLambdabarFitter,
+ GammaFitterTool = self.BPhysGammaFitter,
+ TrackSelectorTool = self.InDetV0VxTrackSelector,
+ VertexPointEstimator = self.V0VtxPointEstimator,
+ doSimpleV0 = True,
+ #useorigin = False,
+ #useTRTplusTRT = True,
+ #useTRTplusSi = True,
+ useVertexCollection = True,
+ #trkSelPV = True,
+ Extrapolator = self.InDetExtrapolator)
+ #Extrapolator = "Trk::Extrapolator/InDetExtrapolator")
+ ToolSvc += self.V0FinderTool
+ print(self.V0FinderTool)
+
+ #from InDetV0Finder.InDetV0FinderConf import InDet__InDetV0Finder
+ #self.InDetV0Finder = InDet__InDetV0Finder(name = derivation+'InDetV0Finder',
+ # #decorateV0 = False,
+ # InDetV0FinderToolName = V0FinderTool,
+ # V0ContainerName = InDetKeys.xAODV0VertexContainer(),
+ # KshortContainerName = InDetKeys.xAODKshortVertexContainer(),
+ # LambdaContainerName = InDetKeys.xAODLambdaVertexContainer(),
+ # LambdabarContainerName = InDetKeys.xAODLambdabarVertexContainer())
+ #topSequence += self.InDetV0Finder
+ #print self.InDetV0Finder
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureV0Finder.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureV0Finder.py
new file mode 100644
index 00000000000..0add564e26b
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureV0Finder.py
@@ -0,0 +1,202 @@
+#====================================================================
+# Collection of tools required by V0Finder
+#====================================================================
+
+class BPHYV0FinderTools:
+
+ def __init__(self, derivation = ""):
+
+ if derivation == "":
+ print('--------> FATAL: BPHYV0FinderTools, "derivation" string not set!')
+ import sys
+ sys.exit()
+
+ from AthenaCommon.AppMgr import ToolSvc
+
+ # set up extrapolator
+ from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
+ self.InDetExtrapolator = AtlasExtrapolator(name = derivation+"_AtlasExtrapolator")
+ ToolSvc += self.InDetExtrapolator
+ print(self.InDetExtrapolator)
+
+ # Vertex point estimator
+ from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
+ self.V0VtxPointEstimator = InDet__VertexPointEstimator(name = derivation+"_VtxPointEstimator",
+ MaxTrkXYDiffAtVtx = [20.,20.,20.],
+ MaxTrkZDiffAtVtx = [100.,100.,100.],
+ MaxTrkXYValue = [400.,400.,400.],
+ MinArcLength = [-800.,-800.,-800.],
+ MaxArcLength = [800.,800.,800.],
+ MinDeltaR = [-10000.,-10000.,-10000.],
+ MaxDeltaR = [10000.,10000.,10000.],
+ MaxPhi = [10000., 10000., 10000.],
+ MaxChi2OfVtxEstimation = 2000.)
+ ToolSvc += self.V0VtxPointEstimator
+ print(self.V0VtxPointEstimator)
+
+ from InDetRecExample.InDetKeys import InDetKeys
+
+ from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels
+ self.V0PrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(name = derivation+"_V0PrdAssociationTool",
+ PixelClusterAmbiguitiesMapName = InDetKeys.GangedPixelMap())
+ ToolSvc += self.V0PrdAssociationTool
+ print(self.V0PrdAssociationTool)
+
+ from RecExConfig.RecFlags import rec
+ CountDeadModulesAfterLastHit=False
+ #rec.Commissioning=False
+
+ from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool
+ self.V0HoleSearchTool = InDet__InDetTrackHoleSearchTool(name = derivation+"_V0HoleSearchTool",
+ Extrapolator = self.InDetExtrapolator,
+ usePixel = DetFlags.haveRIO.pixel_on(),
+ useSCT = DetFlags.haveRIO.SCT_on(),
+ #Commissioning = rec.Commissioning())
+ CountDeadModulesAfterLastHit = CountDeadModulesAfterLastHit)
+ ToolSvc += self.V0HoleSearchTool
+ print(self.V0HoleSearchTool)
+
+ from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool
+ self.V0TrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(name = derivation+"_InDetSummaryHelper",
+ AssoTool = self.V0PrdAssociationTool,
+ DoSharedHits = False,
+ HoleSearch = self.V0HoleSearchTool,
+ usePixel = DetFlags.haveRIO.pixel_on(),
+ useSCT = DetFlags.haveRIO.SCT_on(),
+ useTRT = DetFlags.haveRIO.TRT_on())
+ ToolSvc += self.V0TrackSummaryHelperTool
+ print(self.V0TrackSummaryHelperTool)
+
+ from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
+ self.V0TrackSummaryTool = Trk__TrackSummaryTool(name = derivation+"_V0TrackSummaryTool",
+ InDetSummaryHelperTool = self.V0TrackSummaryHelperTool,
+ doSharedHits = False,
+ InDetHoleSearchTool = self.V0HoleSearchTool)
+ ToolSvc += self.V0TrackSummaryTool
+ print(self.V0TrackSummaryTool)
+
+
+
+ from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetConversionTrackSelectorTool
+ self.InDetV0VxTrackSelector = InDet__InDetConversionTrackSelectorTool(name = derivation+"InDetV0VxTrackSelector",
+ TrackSummaryTool = self.V0TrackSummaryTool,
+ Extrapolator = self.InDetExtrapolator,
+ # Extrapolator = "Trk::Extrapolator/InDetExtrapolator",
+ maxTrtD0 = 50.,
+ maxSiZ0 = 250.,
+ significanceD0_Si = 1.,
+ significanceD0_Trt = 1.,
+ significanceZ0_Trt = 3.,
+ minPt = 400.0,
+ IsConversion = False)
+ ToolSvc += self.InDetV0VxTrackSelector
+ print(self.InDetV0VxTrackSelector)
+
+
+ # configure vertex fitters
+
+ from TrkV0Fitter.TrkV0FitterConf import Trk__TrkV0VertexFitter
+ self.BPhysV0Fitter = Trk__TrkV0VertexFitter(name = derivation+'_BPhysV0Fitter',
+ MaxIterations = 10,
+ Use_deltaR = False,
+ FirstMeasuredPoint = True,
+ Extrapolator = self.InDetExtrapolator)
+ ToolSvc += self.BPhysV0Fitter
+ print(self.BPhysV0Fitter)
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysVKVertexFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKVFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True)
+ ToolSvc += self.BPhysVKVertexFitter
+ print(self.BPhysVKVertexFitter)
+
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysKshortFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKKVFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True,
+ InputParticleMasses = [139.57,139.57],
+ MassForConstraint = 497.672)
+ ToolSvc += self.BPhysKshortFitter
+ print(self.BPhysKshortFitter)
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysLambdaFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKLFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True,
+ InputParticleMasses = [938.272,139.57],
+ MassForConstraint = 1115.68)
+ ToolSvc += self.BPhysLambdaFitter
+ print(self.BPhysLambdaFitter)
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysLambdabarFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKLbFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True,
+ InputParticleMasses = [139.57,938.272],
+ MassForConstraint = 1115.68)
+ ToolSvc += self.BPhysLambdabarFitter
+ print(self.BPhysLambdabarFitter)
+#
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.BPhysGammaFitter = Trk__TrkVKalVrtFitter(name = derivation+"_BPhysVKGFitter",
+ Extrapolator = self.InDetExtrapolator,
+ IterationNumber = 30,
+ Robustness = 6,
+ FirstMeasuredPoint = True,
+ MakeExtendedVertex = True,
+ usePhiCnst = True,
+ useThetaCnst = True,
+ InputParticleMasses = [0.511,0.511])
+ ToolSvc += self.BPhysGammaFitter
+ print(self.BPhysGammaFitter)
+
+##--------------------------------------------
+## Setup V0Finder
+##--------------------------------------------
+ from InDetV0Finder.InDetV0FinderConf import InDet__InDetV0FinderTool
+ self.V0FinderTool = InDet__InDetV0FinderTool(name = derivation+'_InDetV0FinderTool',
+ TrackParticleCollection = InDetKeys.xAODTrackParticleContainer(),
+ #TrackParticleCollection = "InDetTrackParticles",
+ useV0Fitter = True,
+ VertexFitterTool = self.BPhysV0Fitter,
+ VKVertexFitterTool = self.BPhysVKVertexFitter,
+ KshortFitterTool = self.BPhysKshortFitter,
+ LambdaFitterTool = self.BPhysLambdaFitter,
+ LambdabarFitterTool = self.BPhysLambdabarFitter,
+ GammaFitterTool = self.BPhysGammaFitter,
+ TrackSelectorTool = self.InDetV0VxTrackSelector,
+ VertexPointEstimator = self.V0VtxPointEstimator,
+ doSimpleV0 = False,
+ #doSimpleV0 = True,
+ #useorigin = False,
+ #useTRTplusTRT = True,
+ #useTRTplusSi = True,
+ useVertexCollection = True,
+ #trkSelPV = True,
+ Extrapolator = self.InDetExtrapolator)
+ #Extrapolator = "Trk::Extrapolator/InDetExtrapolator")
+ ToolSvc += self.V0FinderTool
+ print(self.V0FinderTool)
+
+ #from InDetV0Finder.InDetV0FinderConf import InDet__InDetV0Finder
+ #self.InDetV0Finder = InDet__InDetV0Finder(name = derivation+'InDetV0Finder',
+ # #decorateV0 = False,
+ # InDetV0FinderToolName = V0FinderTool,
+ # V0ContainerName = InDetKeys.xAODV0VertexContainer(),
+ # KshortContainerName = InDetKeys.xAODKshortVertexContainer(),
+ # LambdaContainerName = InDetKeys.xAODLambdaVertexContainer(),
+ # LambdabarContainerName = InDetKeys.xAODLambdabarVertexContainer())
+ #topSequence += self.InDetV0Finder
+ #print self.InDetV0Finder
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureVertexing.py b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureVertexing.py
new file mode 100644
index 00000000000..a3746d92509
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/share/configureVertexing.py
@@ -0,0 +1,148 @@
+#====================================================================
+# Collection of tools required by JpsiFinder
+# Based on JpsiUpsilonTools/configureServices.py
+#====================================================================
+
+class BPHYVertexTools:
+
+ def __init__(self, derivation = ""):
+
+ if derivation == "":
+ print ('--------> FATAL: BPHYVertexTools, "derivation" string not set!')
+ import sys
+ sys.exit()
+
+ from AthenaCommon.AppMgr import ToolSvc
+
+ # set up extrapolator
+ from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
+ self.InDetExtrapolator = AtlasExtrapolator(name = derivation+"_AtlasExtrapolator")
+ ToolSvc += self.InDetExtrapolator
+ print((self.InDetExtrapolator))
+
+ # Vertex point estimator
+ from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
+ self.VtxPointEstimator = InDet__VertexPointEstimator(name = derivation+"_VtxPointEstimator",
+ MinDeltaR = [-10000.,-10000.,-10000.],
+ MaxDeltaR = [10000.,10000.,10000.],
+ MaxPhi = [10000., 10000., 10000.],
+ MaxChi2OfVtxEstimation = 2000.)
+ ToolSvc += self.VtxPointEstimator
+ print((self.VtxPointEstimator))
+
+ from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionFinderUtils
+ self.InDetConversionHelper = InDet__ConversionFinderUtils(name = derivation+"_InDetConversionFinderUtils")
+ ToolSvc += self.InDetConversionHelper
+ print((self.InDetConversionHelper))
+
+ from InDetRecExample.InDetKeys import InDetKeys
+
+ from InDetAssociationTools.InDetAssociationToolsConf import InDet__InDetPRD_AssociationToolGangedPixels
+ self.InDetPrdAssociationTool = InDet__InDetPRD_AssociationToolGangedPixels(name = derivation+"_InDetPrdAssociationTool",
+ PixelClusterAmbiguitiesMapName = InDetKeys.GangedPixelMap())
+ ToolSvc += self.InDetPrdAssociationTool
+ print((self.InDetPrdAssociationTool))
+
+ from RecExConfig.RecFlags import rec
+ CountDeadModulesAfterLastHit=False
+ #rec.Commissioning=False
+
+ from InDetTrackHoleSearch.InDetTrackHoleSearchConf import InDet__InDetTrackHoleSearchTool
+ self.InDetHoleSearchTool = InDet__InDetTrackHoleSearchTool(name = derivation+"_InDetHoleSearchTool",
+ Extrapolator = self.InDetExtrapolator,
+ #usePixel = DetFlags.haveRIO.pixel_on(),
+ #useSCT = DetFlags.haveRIO.SCT_on(),
+ #Commissioning = rec.Commissioning())
+ CountDeadModulesAfterLastHit = CountDeadModulesAfterLastHit)
+ ToolSvc += self.InDetHoleSearchTool
+ print((self.InDetHoleSearchTool))
+
+ from InDetTrackSummaryHelperTool.InDetTrackSummaryHelperToolConf import InDet__InDetTrackSummaryHelperTool
+ self.InDetTrackSummaryHelperTool = InDet__InDetTrackSummaryHelperTool(name = derivation+"_InDetSummaryHelper",
+ AssoTool = self.InDetPrdAssociationTool,
+ DoSharedHits = False,
+ HoleSearch = self.InDetHoleSearchTool,
+ usePixel = DetFlags.haveRIO.pixel_on(),
+ useSCT = DetFlags.haveRIO.SCT_on(),
+ useTRT = DetFlags.haveRIO.TRT_on())
+ ToolSvc += self.InDetTrackSummaryHelperTool
+ print((self.InDetTrackSummaryHelperTool))
+
+ from TrkTrackSummaryTool.TrkTrackSummaryToolConf import Trk__TrackSummaryTool
+ self.InDetTrackSummaryTool = Trk__TrackSummaryTool(name = derivation+"_InDetTrackSummaryTool",
+ InDetSummaryHelperTool = self.InDetTrackSummaryHelperTool,
+ doSharedHits = False,
+ #InDetHoleSearchTool = self.InDetHoleSearchTool
+ )
+ ToolSvc += self.InDetTrackSummaryTool
+ print((self.InDetTrackSummaryTool))
+
+ # =====================================================
+ # THIS IS WHERE THE USER CONTROLS MAIN TRACK SELECTIONS
+ # =====================================================
+ from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetDetailedTrackSelectorTool
+ self.InDetTrackSelectorTool = InDet__InDetDetailedTrackSelectorTool(name = derivation+"_InDetDetailedTrackSelectorTool",
+ pTMin = 400.0,
+ IPd0Max = 10000.0,
+ IPz0Max = 10000.0,
+ z0Max = 10000.0,
+ sigIPd0Max = 10000.0,
+ sigIPz0Max = 10000.0,
+ d0significanceMax = -1.,
+ z0significanceMax = -1.,
+ etaMax = 9999.,
+ useTrackSummaryInfo = True,
+ nHitBLayer = 0,
+ nHitPix = 1,
+ nHitBLayerPlusPix = 1,
+ nHitSct = 2,
+ nHitSi = 3,
+ nHitTrt = 0,
+ nHitTrtHighEFractionMax = 10000.0,
+ useSharedHitInfo = False,
+ useTrackQualityInfo = True,
+ fitChi2OnNdfMax = 10000.0,
+ TrtMaxEtaAcceptance = 1.9,
+ TrackSummaryTool = self.InDetTrackSummaryTool,
+ Extrapolator = self.InDetExtrapolator
+ )
+
+ ToolSvc += self.InDetTrackSelectorTool
+ print((self.InDetTrackSelectorTool))
+
+ # configure vertex fitters
+ from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
+ self.TrkVKalVrtFitter = Trk__TrkVKalVrtFitter(
+ name = derivation+"_VKalVrtFitter",
+ Extrapolator = self.InDetExtrapolator,
+ # MagFieldSvc = InDetMagField,
+ FirstMeasuredPoint = False,
+ #FirstMeasuredPointLimit = True,
+ MakeExtendedVertex = True)
+ ToolSvc += self.TrkVKalVrtFitter
+ print((self.TrkVKalVrtFitter))
+
+ from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__FullLinearizedTrackFactory
+ self.InDetLinFactory = Trk__FullLinearizedTrackFactory(name = derivation+"_Trk::InDetFullLinearizedTrackFactory",
+ Extrapolator = self.InDetExtrapolator,
+ # MagneticFieldTool = InDetMagField
+ )
+ ToolSvc += self.InDetLinFactory
+ print((self.InDetLinFactory))
+
+
+ from TrkV0Fitter.TrkV0FitterConf import Trk__TrkV0VertexFitter
+ self.TrkV0Fitter = Trk__TrkV0VertexFitter(name = derivation+"_TrkV0FitterName",
+ MaxIterations = 10,
+ Use_deltaR = False,
+ Extrapolator = self.InDetExtrapolator,
+ # MagneticFieldTool = InDetMagField
+ )
+ ToolSvc += self.TrkV0Fitter
+ print((self.TrkV0Fitter))
+
+ # Primary vertex refitting
+ from TrkVertexFitterUtils.TrkVertexFitterUtilsConf import Trk__KalmanVertexUpdator
+ self.VertexUpdator = Trk__KalmanVertexUpdator(name = derivation+"_KalmanVertexUpdator")
+ ToolSvc += self.VertexUpdator
+ print((self.VertexUpdator))
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/AugOriginalCounts.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/AugOriginalCounts.cxx
new file mode 100644
index 00000000000..68c294d70fb
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/AugOriginalCounts.cxx
@@ -0,0 +1,150 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file AugOriginalCounts.cxx
+ *
+ */
+
+#include "DerivationFrameworkBPhys/AugOriginalCounts.h"
+#include <StoreGate/WriteDecorHandle.h>
+#include "GaudiKernel/EventContext.h"
+
+using namespace xAOD;
+namespace DerivationFramework {
+
+ AugOriginalCounts::AugOriginalCounts(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_TrackContainername("InDetTrackParticles"),
+ m_PVContainername("PrimaryVertices")
+ {
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ declareProperty("TrackContainer", m_TrackContainername);
+ declareProperty("VertexContainer", m_PVContainername);
+ declareProperty("AddPVCountsByType", m_addPVCountsByType = false);
+ // decorate PVs with track counts and/or sqrt(sum(pt^2))
+ // (needed if track collection will be thinned)
+ declareProperty("AddNTracksToPVs", m_addNTracksToPVs = false);
+ declareProperty("AddSqrtPt2SumToPVs", m_addSqrtPt2SumToPVs = false);
+ }
+
+ StatusCode AugOriginalCounts::initialize()
+ {
+ ATH_CHECK(m_TrackContainername.initialize(SG::AllowEmpty));
+ ATH_CHECK(m_PVContainername.initialize(SG::AllowEmpty));
+
+ if(!m_PVContainername.empty()){
+ std::string pvstring = "EventInfo.OriginalCount_";
+ pvstring += m_PVContainername.key();
+ m_OrigPVNTracks = std::move(pvstring);
+ ATH_CHECK(m_OrigPVNTracks.initialize());
+ }
+ if ( m_addPVCountsByType ) {
+ std::string pv0string = "EventInfo.OriginalCount_type0_"+m_PVContainername.key();
+ std::string pv1string = "EventInfo.OriginalCount_type1_"+m_PVContainername.key();
+ std::string pv2string = "EventInfo.OriginalCount_type2_"+m_PVContainername.key();
+ std::string pv3string = "EventInfo.OriginalCount_type3_"+m_PVContainername.key();
+ std::string pvUstring = "EventInfo.OriginalCount_typeUnknown_"+m_PVContainername.key();
+ m_OrigNtype0 = std::move(pv0string);
+ m_OrigNtype1 = std::move(pv1string);
+ m_OrigNtype2 = std::move(pv2string);
+ m_OrigNtype3 = std::move(pv3string);
+ m_OrigNtypeUnknown = std::move(pvUstring);
+ ATH_CHECK(m_OrigNtype0.initialize());
+ ATH_CHECK(m_OrigNtype1.initialize());
+ ATH_CHECK(m_OrigNtype2.initialize());
+ ATH_CHECK(m_OrigNtype3.initialize());
+ ATH_CHECK(m_OrigNtypeUnknown.initialize());
+ }
+ if ( m_addSqrtPt2SumToPVs ) {
+ std::string trackcon = m_PVContainername.key();
+ trackcon += ".OriginalCount_";
+ trackcon += m_TrackContainername.key();
+ m_OrigSqrtPt2Sum = std::move(trackcon);
+ ATH_CHECK(m_OrigSqrtPt2Sum.initialize());
+ }
+ if ( m_addNTracksToPVs ) {
+ std::string name = m_PVContainername.key();
+ name+= ".OrigNTracks";
+ m_d_nPVTracks = std::move(name);
+ ATH_CHECK(m_d_nPVTracks.initialize());
+ }
+ if(!m_TrackContainername.empty()){
+ m_OrigNTracksKeys = "EventInfo.OriginalCount_" + m_TrackContainername.key();
+ ATH_CHECK(m_OrigNTracksKeys.initialize());
+ }
+ return StatusCode::SUCCESS;
+ }
+
+ StatusCode AugOriginalCounts::addBranches() const
+ {
+
+ const EventContext& ctx = Gaudi::Hive::currentContext();
+
+ if(!m_PVContainername.empty()){
+
+ SG::WriteDecorHandle<xAOD::EventInfo, int> PV_count(m_OrigPVNTracks, ctx);
+ SG::ReadHandle<xAOD::VertexContainer> vertices(m_PVContainername, ctx);
+ PV_count(0) = vertices->size();
+
+ if ( m_addPVCountsByType ) {
+ SG::WriteDecorHandle<xAOD::EventInfo, int> PV0_count(m_OrigNtype0, ctx);
+ SG::WriteDecorHandle<xAOD::EventInfo, int> PV1_count(m_OrigNtype1, ctx);
+ SG::WriteDecorHandle<xAOD::EventInfo, int> PV2_count(m_OrigNtype2, ctx);
+ SG::WriteDecorHandle<xAOD::EventInfo, int> PV3_count(m_OrigNtype3, ctx);
+ SG::WriteDecorHandle<xAOD::EventInfo, int> PVUnk_count(m_OrigNtypeUnknown, ctx);
+
+ // now count
+ constexpr int nvtypes = 5;
+ int nvtc[] = {0, 0, 0, 0, 0};
+ for (auto vtx : *vertices) {
+ VxType::VertexType vt = vtx->vertexType();
+ if ( vt >=0 && vt < nvtypes ) {
+ nvtc[vt]++; // vertex types 0 - 3
+ } else {
+ nvtc[nvtypes-1]++; // unknown
+ }
+ }
+ PV0_count(0) = nvtc[0];
+ PV1_count(0) = nvtc[1];
+ PV2_count(0) = nvtc[2];
+ PV3_count(0) = nvtc[3];
+ PVUnk_count(0) = nvtc[4];
+ } // m_addPVCountsByType
+
+ // decorate PVs with track counts
+ // (needed if track collection will be thinned)
+ if ( m_addNTracksToPVs ) {
+ SG::WriteDecorHandle<xAOD::VertexContainer, int> d_nPVTracks(m_d_nPVTracks, ctx);
+ for (auto vtx : *vertices) {
+ d_nPVTracks(*vtx) = (int)vtx->nTrackParticles();
+ }
+ } // m_addNTracksToPVs
+
+ // decorate PVs with sqrt(sum(pt^2)) of tracks
+ // (needed if track collection will be thinned)
+ if ( m_addSqrtPt2SumToPVs ) {
+ SG::WriteDecorHandle<xAOD::VertexContainer, float> d_pvSqrtPt2Sum(m_OrigSqrtPt2Sum, ctx);
+ for (auto vtx : *vertices) {
+ float sqrtPt2Sum(0.);
+ for (auto tp : vtx->trackParticleLinks()) {
+ sqrtPt2Sum += std::sqrt(pow((*tp)->pt(),2));
+ }
+ d_pvSqrtPt2Sum(*vtx) = sqrtPt2Sum;
+ }
+ } // m_addSqrtPt2SumToPVs
+ }
+
+ if(!m_TrackContainername.empty()){
+ SG::ReadHandle<xAOD::TrackParticleContainer> tracks(m_TrackContainername, ctx);
+ SG::WriteDecorHandle<xAOD::EventInfo, int> track_count(m_OrigNTracksKeys, ctx);
+ track_count(0) = tracks->size();
+ }
+
+ return StatusCode::SUCCESS;
+ }
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BMuonTrackIsoTool.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BMuonTrackIsoTool.cxx
new file mode 100644
index 00000000000..6cc8a053a1e
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BMuonTrackIsoTool.cxx
@@ -0,0 +1,448 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BMuonTrackIsoTool.cxx
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Add muon track isolation information for different configurations,
+// different track selections and different PV-to-SV association methods.
+//
+// For an usage example see BPHY8.py .
+//
+// Job options provided by this class:
+// - MuonContainerName -- name of muon container
+// - IsolationConeSizes -- List of isolation cone sizes
+// - IsoTrkImpLogChi2Max -- List of maximum log(chi2) cuts for
+// association of tracks to the primary
+// vertex picked.
+// - IsoDoTrkImpLogChi2Cut -- apply log(chi2) cuts
+// 0 : don't apply log(chi2) cuts
+// 1 : apply log(chi2) cuts
+// 2 : apply log(chi2) cuts [former version]
+// (The last two job options must
+// contain the same number of elements
+// as the IsolationConeSizes list.)
+//
+//============================================================================
+//
+#include "DerivationFrameworkBPhys/BMuonTrackIsoTool.h"
+#include "xAODMuon/MuonContainer.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
+#include "EventPrimitives/EventPrimitivesHelpers.h"
+
+#include "boost/format.hpp"
+#include "TVector3.h"
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+namespace DerivationFramework {
+
+ //-------------------------------------------------------------------------
+ //
+ // helper class
+ BMuonTrackIsoTool::MuIsoItem::MuIsoItem(std::string Name,
+ std::string Bname,
+ std::string Prefix) :
+ BaseItem(Name, Bname, Prefix) {
+ }
+
+ BMuonTrackIsoTool::MuIsoItem::~MuIsoItem() {
+ }
+
+ void BMuonTrackIsoTool::MuIsoItem::resetVals() {
+ vIsoValues.clear();
+ vNTracks.clear();
+ vMuons.clear();
+ }
+
+ void BMuonTrackIsoTool::MuIsoItem::copyVals(const BaseItem& item) {
+ copyVals((const MuIsoItem&)item);
+ }
+
+ void BMuonTrackIsoTool::MuIsoItem::copyVals(const MuIsoItem& item) {
+ vIsoValues = item.vIsoValues;
+ vNTracks = item.vNTracks;
+ vMuons = item.vMuons;
+ }
+
+ void BMuonTrackIsoTool::MuIsoItem::fill(double isoValue, int nTracks,
+ const xAOD::Muon* muon) {
+ vIsoValues.push_back(isoValue);
+ vNTracks.push_back(nTracks);
+ vMuons.push_back(muon);
+ }
+
+ std::string BMuonTrackIsoTool::MuIsoItem::muIsoName() {
+ return buildName();
+ }
+
+ std::string BMuonTrackIsoTool::MuIsoItem::nTracksName() {
+ return buildName("Ntracks");
+ }
+
+ std::string BMuonTrackIsoTool::MuIsoItem::muLinkName() {
+ return buildName("", "_muLink");
+ }
+
+ //--------------------------------------------------------------------------
+ BMuonTrackIsoTool::BMuonTrackIsoTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p)
+ : BPhysVertexTrackBase(t,n,p) {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ declareProperty("MuonContainerName" , m_muonContainerName="");
+ declareProperty("IsolationConeSizes" , m_isoConeSizes);
+ declareProperty("IsoTrkImpLogChi2Max" , m_isoTrkImpLogChi2Max);
+ declareProperty("IsoDoTrkImpLogChi2Cut" , m_isoDoTrkImpLogChi2Cut);
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BMuonTrackIsoTool::initializeHook() {
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initializeHook() -- begin");
+
+ // check like-sized arrays
+ if ( m_isoConeSizes.size() != m_isoTrkImpLogChi2Max.size() ||
+ m_isoConeSizes.size() != m_isoDoTrkImpLogChi2Cut.size() ) {
+ ATH_MSG_ERROR("Size mismatch of IsolationConeSizes ("
+ << m_isoConeSizes.size()
+ << "), IsoTrkImpChi2Max ("
+ << m_isoTrkImpLogChi2Max.size()
+ << ") and IsoDoTrkImpChi2Cut ("
+ << m_isoDoTrkImpLogChi2Cut.size() << ") lists!");
+ }
+
+ // check muon container name
+ if ( m_muonContainerName == "" ) {
+ ATH_MSG_ERROR("No muon container name provided!");
+ }
+
+ // initialize results array
+ initResults();
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initializeHook() -- end");
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BMuonTrackIsoTool::finalizeHook() {
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::finalizeHook()");
+
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode
+ BMuonTrackIsoTool::addBranchesVCSetupHook(size_t ivc) const {
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::addBranchesVCLoopHook() -- begin");
+
+ ATH_MSG_DEBUG("BMuonTrackisoTool::addBranchesVCSetupHook: "
+ << "Vertex container index " << ivc
+ << " for collection " << m_vertexContainerNames[ivc]
+ << " with prefix " << m_branchPrefixes[ivc]);
+
+ setResultsPrefix(m_branchPrefixes[ivc]);
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::addBranchesVCSetupHook() -- end");
+
+ // nothing to do here
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode
+ BMuonTrackIsoTool::addBranchesSVLoopHook(const xAOD::Vertex* vtx) const {
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::addBranchesSVLoopHook() -- begin");
+
+ // retrieve muon container
+ m_muons = NULL;
+ if ( m_muonContainerName != "" ) {
+ CHECK(evtStore()->retrieve(m_muons, m_muonContainerName));
+ ATH_MSG_DEBUG("Found muon collection with key " << m_muonContainerName);
+ }
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::addBranchesSVLoopHook(): "
+ "calculate muon track isolation ...");
+ CHECK(calculateValues(vtx));
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::addBranchesSVLoopHook(): "
+ "save muon track isolation ...");
+ // save the isolation values
+ CHECK(saveIsolation(vtx));
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::addBranchesSVLoopHook() -- end");
+
+ // nothing to do here
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Calculate track isolation variables -- faster method with caching
+ //--------------------------------------------------------------------------
+ StatusCode
+ BMuonTrackIsoTool::calcValuesHook(const xAOD::Vertex* vtx,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const {
+
+ ATH_MSG_DEBUG("calcValuesHook: ipv: " << ipv
+ << ", its: " << its << ", itt: " << itt);
+
+ // candidate tracks and momentum
+ xAOD::BPhysHelper cand(vtx);
+ TVector3 candP = cand.totalP();
+ const xAOD::Vertex* candRefPV = cand.pv(m_pvAssocTypes[ipv]);
+
+ MuonBag muons;
+ // TrackBag candMuTracks = findAllMuonIdTracksInDecay(cand, muons);
+ std::vector<TVector3> candMuTracks = findMuonRefTrackMomenta(cand, muons);
+
+ TrackBag tracks = selectTracks(m_tracks, cand, ipv, its, itt);
+
+ ATH_MSG_DEBUG("calcValuesHook: found " << muons.size() <<
+ " muons and " << candMuTracks.size() <<
+ " tracks from B cand; " << tracks.size() <<
+ " tracks to check.");
+
+ // loop over isolation cones (pt and deltaR)
+ unsigned int nCones = m_isoConeSizes.size();
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ MuIsoItem& iso = m_results[ic][its][ipv][itt];
+ // reset
+ iso.resetVals();
+
+ // loop over refitted ID tracks for muons in candidate
+ unsigned int id(0);
+ // for (TrackBag::const_iterator muTrkItr = candMuTracks.begin();
+ // muTrkItr != candMuTracks.end(); ++muTrkItr, ++id) {
+ for (id=0; id < candMuTracks.size(); ++id) {
+
+ // make sure there was an ID track for the muon
+ // if ( *muTrkItr != NULL ) {
+ if ( candMuTracks[id].Mag() > 0. ) {
+
+ const double& coneSize = m_isoConeSizes[ic];
+ const double& logChi2Max = m_isoTrkImpLogChi2Max[ic];
+ const int& doLogChi2 = m_isoDoTrkImpLogChi2Cut[ic];
+
+ double nTracksInCone = 0;
+ double ptSumInCone = 0.;
+
+ double isoValue(-5.);
+
+ // make sure candRefPV exists
+ if ( candRefPV != NULL ) {
+
+ for (TrackBag::const_iterator trkItr = tracks.begin();
+ trkItr != tracks.end(); ++trkItr) {
+ double deltaR = candMuTracks[id].DeltaR((*trkItr)->p4().Vect());
+ if ( deltaR < coneSize ) {
+ double logChi2 = (doLogChi2 > 0) ?
+ getTrackCandPVLogChi2(*trkItr, candRefPV) : -9999.;
+ // next line needed exactly as is for backward validation
+ if ( doLogChi2 == 2 ) logChi2 = abs(logChi2);
+ if ( doLogChi2 == 0 || logChi2 < logChi2Max ) {
+ nTracksInCone++;
+ ptSumInCone += (*trkItr)->pt();
+ }
+ } // deltaR
+ }
+ // calculate result
+ if ( ptSumInCone + candMuTracks[id].Pt() > 0. ) {
+ isoValue = candMuTracks[id].Pt()
+ / ( ptSumInCone + candMuTracks[id].Pt() );
+ }
+
+ } else {
+ isoValue = -10.;
+ } // if candRefPV != NULL
+
+ const xAOD::Muon* muon = id < muons.size() ? muons.at(id) : NULL;
+ iso.fill(isoValue, nTracksInCone, muon);
+ } // if *muTrkItr != NULL
+ } // for muTrkItr
+ } // for ic
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Fill track isolation values from cache if found
+ //--------------------------------------------------------------------------
+ bool BMuonTrackIsoTool::fastFillHook(const xAOD::Vertex* vtx,
+ const int ipv) const {
+
+ ATH_MSG_DEBUG("fastFillHook: ipv: " << ipv);
+
+ bool found(false);
+
+ StringIntMap_t::iterator itpv =
+ m_pvAssocResMap.find(buildPvAssocCacheName(vtx, ipv));
+ if ( itpv != m_pvAssocResMap.end() ) {
+ found = true;
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ m_results[ic][its][ipv][itt]
+ .copyVals(m_results[ic][its][itpv->second][itt]);
+ } // for its
+ } // for ic
+ } // for itt
+ } // if found
+
+ ATH_MSG_DEBUG("fastFillHook: cache index: "
+ << buildPvAssocCacheName(vtx, ipv)
+ << ", found ? " << found
+ << ", ipv_ref: "
+ << (found ? itpv->second : -1));
+
+ return found;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode
+ BMuonTrackIsoTool::saveIsolation(const xAOD::Vertex* vtx) const {
+
+ typedef ElementLink<xAOD::MuonContainer> MuonLink_t;
+ typedef std::vector<MuonLink_t> MuonLinkVector_t;
+
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ MuIsoItem result = m_results[ic][its][ipv][itt];
+ SG::AuxElement::Decorator< std::vector<float> >
+ dv_iso_values(result.muIsoName());
+ SG::AuxElement::Decorator< std::vector<int> >
+ dv_iso_ntracks(result.nTracksName());
+ dv_iso_values(*vtx) = result.vIsoValues;
+ dv_iso_ntracks(*vtx) = result.vNTracks;
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::saveIsolation() -- isobn: "
+ << result.muIsoName() << ", ntbn: "
+ << result.nTracksName());
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::saveIsolation() -- vertex: ("
+ << vtx->x() << ", "
+ << vtx->y() << ", "
+ << vtx->z() << "), N(iso): "
+ << result.vIsoValues.size() << ", N(nTracks): "
+ << result.vNTracks.size());
+ MuonLinkVector_t links;
+ for (const xAOD::Muon* muon : result.vMuons) {
+ if ( muon != NULL ) {
+ MuonLink_t link(muon, *m_muons);
+ links.push_back(link);
+ } else {
+ ATH_MSG_WARNING("BMuonTrackIsoTool::saveIsolation(): "
+ << " *muon == NULL -- EL not saved!");
+ }
+ }
+ vtx->auxdecor<MuonLinkVector_t>(result.muLinkName()) = links;
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::saveIsolation() -- muLinks: "
+ << "N_saved = " << links.size() );
+ } // for itt
+ } // for ic
+ } // for ipv
+ } // for its
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ void BMuonTrackIsoTool::setResultsPrefix(std::string prefix) const {
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::setResultsPrefix -- begin");
+
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ m_results[ic][its][ipv][itt].setPrefix(prefix);
+ } // for itt
+ } // for ic
+ } // for ipv
+ } // for its
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::setResultsPrefix -- end");
+ }
+ //--------------------------------------------------------------------------
+ void BMuonTrackIsoTool::initResults() {
+
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults -- begin");
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults : nCones = " << nCones);
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults : nTrackSels = "
+ << nTrackSels);
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults : nPvAssocs = "
+ << nPvAssocs);
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults : nTrackTypes = "
+ << nTrackTypes);
+ m_results.resize(boost::extents[nCones][nTrackSels][nPvAssocs][nTrackTypes]);
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults -- its = " << its);
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults -- ipv = " << ipv);
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults -- ic = " << ic);
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults -- itt = " << itt);
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults :"
+ << m_branchBaseName << buildBranchName(ic, its,
+ ipv, itt));
+
+ m_results[ic][its][ipv][itt].setup(buildBranchName(ic, its,
+ ipv, itt),
+ m_branchBaseName);
+ } // for itt
+ } // for ic
+ } // for ipv
+ } // for its
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::initResults -- end");
+ }
+ //--------------------------------------------------------------------------
+ std::string BMuonTrackIsoTool::buildBranchName(unsigned int ic,
+ unsigned int its,
+ unsigned int ipv,
+ unsigned int itt) const {
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::buildBranchName -- begin");
+
+ double coneSize = m_isoConeSizes[ic];
+ double logChi2Max = m_isoTrkImpLogChi2Max[ic];
+ int doLogChi2 = m_isoDoTrkImpLogChi2Cut[ic];
+
+ // format it nicely
+ boost::format f("%02d_LC%02dd%1d_%s");
+ f % (int)(coneSize*10.) % (int)(logChi2Max*10.) % doLogChi2
+ % buildBranchBaseName(its, ipv, itt);
+
+ ATH_MSG_DEBUG("BMuonTrackIsoTool::buildBranchName: " << f.str());
+
+ return f.str();
+ }
+ //--------------------------------------------------------------------------
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysAddMuonBasedInvMass.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysAddMuonBasedInvMass.cxx
new file mode 100644
index 00000000000..79a285ffcfe
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysAddMuonBasedInvMass.cxx
@@ -0,0 +1,702 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file BPhysAddMuonBasedInvMass.cxx
+ * @author Wolfgang Walkowiak <wolfgang.walkowiak@cern.ch>
+ */
+
+// includes
+#include "DerivationFrameworkBPhys/BPhysAddMuonBasedInvMass.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODMuon/MuonContainer.h"
+#include "xAODBase/IParticleHelpers.h"
+#include "xAODBPhys/BPhysHelper.h"
+// for Amg::error():
+#include "EventPrimitives/EventPrimitivesHelpers.h"
+
+#include <sstream>
+#include <limits>
+
+namespace DerivationFramework {
+
+ //--------------------------------------------------------------------------
+ BPhysAddMuonBasedInvMass::BPhysAddMuonBasedInvMass(const std::string& t,
+ const std::string& n,
+ const IInterface* p)
+ : AthAlgTool(t,n,p), m_trackToVertexTool("Reco::TrackToVertex") {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare branch prefix
+ declareProperty("BranchPrefix", m_branchPrefix = "_NONE_");
+ // Necessary containers
+ declareProperty("VertexContainerName" , m_vertexContainerName = "");
+ // track mass assignment
+ declareProperty("TrkMasses", m_trkMasses = std::vector<double>());
+ // track-to-vertex tool
+ declareProperty("TrackToVertexTool" , m_trackToVertexTool);
+ // adjust track from muon kinematics?
+ declareProperty("AdjustToMuonKinematics", m_adjustToMuonKinematics = false);
+ // add minChi2ToAnyPV decoration
+ declareProperty("AddMinChi2ToAnyPVMode" , m_addMinChi2ToAnyPVMode = 0);
+ // name of container for primary vertices
+ declareProperty("PrimaryVertexContainerName", m_pvContainerName = "");
+ // minimum number of tracks in PV for PV to be considered in calculation
+ // of minChi2MuToAnyPV variable
+ declareProperty("MinNTracksInPV" , m_minNTracksInPV = 0);
+ // list of primary vertex types to consider
+ declareProperty("PVTypesToConsider" , m_pvTypesToConsider = {1,3});
+ // PV-to-SV association types to be considered
+ declareProperty("DoVertexType" , m_doVertexType = 63);
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysAddMuonBasedInvMass::initialize() {
+
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::initialize() -- begin");
+
+ // candidate vertices container
+ if ( m_vertexContainerName == "" ) {
+ ATH_MSG_ERROR("No vertex container name provided!");
+ }
+
+ // TrackToVertexTool
+ CHECK(m_trackToVertexTool.retrieve());
+
+ // PV container if needed
+ if ( m_addMinChi2ToAnyPVMode > 0 && m_pvContainerName == "" ) {
+ ATH_MSG_ERROR("No primary vertex container name provided!");
+ }
+
+ // PV type list if needed
+ if ( m_addMinChi2ToAnyPVMode > 0 && m_pvTypesToConsider.size() == 0 ) {
+ ATH_MSG_ERROR("No primary vertex types to be considered provided!");
+ }
+
+ // PV-to-SV association type if needed
+ if ( m_addMinChi2ToAnyPVMode > 1 && m_doVertexType < 1 ) {
+ ATH_MSG_ERROR("No PV-to-SV association types to be considered provided!");
+ }
+
+ ATH_MSG_INFO("BPhysAddMuonBasedInvMass::initialize(): "
+ << "AdjustToMuonKinematics = " << m_adjustToMuonKinematics);
+
+ ATH_MSG_INFO("BPhysAddMuonBasedInvMass::initialize(): "
+ << "AddMinChi2ToAnyPVMode = " << m_addMinChi2ToAnyPVMode);
+
+ // initialize PV-to-SV association type vector
+ initPvAssocTypeVec();
+
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::initialize() -- end");
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysAddMuonBasedInvMass::finalize() {
+
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::finalize()");
+
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysAddMuonBasedInvMass::addBranches() const {
+
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::addBranches() -- begin");
+
+ // vertex container and its auxilliary store
+ xAOD::VertexContainer* vtxContainer = NULL;
+ xAOD::VertexAuxContainer* vtxAuxContainer = NULL;
+
+ // retrieve from StoreGate
+ CHECK(evtStore()->retrieve(vtxContainer , m_vertexContainerName));
+ CHECK(evtStore()->retrieve(vtxAuxContainer, m_vertexContainerName+"Aux."));
+
+ const xAOD::VertexContainer* pvContainer = NULL;
+ if ( m_addMinChi2ToAnyPVMode > 0 ) {
+ CHECK(evtStore()->retrieve(pvContainer , m_pvContainerName));
+ }
+
+ // apply the decorations
+ std::string branchPrefix("");
+ if ( m_branchPrefix != "" && m_branchPrefix != "_NONE_" ) {
+ branchPrefix = m_branchPrefix + "_";
+ }
+
+ // loop over secondary vertices
+ for (xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
+ vtxItr!=vtxContainer->end(); ++vtxItr) {
+
+ xAOD::BPhysHelper vtx(*vtxItr);
+
+ SG::AuxElement::Decorator< float >
+ d_mucalc_mass(branchPrefix+"MUCALC_mass");
+ SG::AuxElement::Decorator< float >
+ d_mucalc_massErr(branchPrefix+"MUCALC_massErr");
+
+ // TODO: check number of muons requested!
+ std::pair<double,double> MuCalcCandMass =
+ getMuCalcMass(vtx, m_trkMasses, 2);
+
+ // fill default values
+ d_mucalc_mass(**vtxItr) = MuCalcCandMass.first;
+ d_mucalc_massErr(**vtxItr) = MuCalcCandMass.second;
+
+ // add MinChi2ToAnyPV information if requested
+ if ( m_addMinChi2ToAnyPVMode > 0 ) {
+
+ if (m_addMinChi2ToAnyPVMode == 1) {
+ // w.r.t. to all PVs
+ SG::AuxElement::Decorator< float >
+ d_minChi2ToAnyPV(branchPrefix+"minLogChi2ToAnyPV");
+ // fill it
+ d_minChi2ToAnyPV(**vtxItr) =
+ getMinChi2ToAnyPV(vtx, pvContainer, m_pvTypesToConsider,
+ m_minNTracksInPV, m_addMinChi2ToAnyPVMode,
+ xAOD::BPhysHelper::PV_MIN_A0); // dummy
+ } else if (m_addMinChi2ToAnyPVMode > 1 && m_addMinChi2ToAnyPVMode < 4) {
+ // skip or replace associated PVs
+ for (auto pvAssocType : m_pvAssocTypes) {
+ SG::AuxElement::Decorator< float >
+ d_minChi2ToAnyPV(branchPrefix+"minLogChi2ToAnyPV_"
+ +xAOD::BPhysHelper::pv_type_str[pvAssocType]);
+ // fill it
+ d_minChi2ToAnyPV(**vtxItr) =
+ getMinChi2ToAnyPV(vtx, pvContainer, m_pvTypesToConsider,
+ m_minNTracksInPV, m_addMinChi2ToAnyPVMode,
+ pvAssocType);
+
+ } // for pvAssocType
+ } else {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::addBranches():"
+ << " Undefined AddMinChi2ToAnyPVMode value: "
+ << m_addMinChi2ToAnyPVMode);
+ }
+ } // if m_addMinChi2ToAnyPVMode
+ } // end of loop over vertices
+
+ // clean cache
+ clearAdjTpCache();
+
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::addBranches() -- end");
+
+ // nothing to do here
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Calculate invariant mass based on muon system information if available.
+ //
+ std::pair<double, double>
+ BPhysAddMuonBasedInvMass::getMuCalcMass(xAOD::BPhysHelper& vtx,
+ std::vector<double> trkMasses,
+ int nMuRequested) const {
+
+ std::pair<double, double> mpe(0., -1.);
+
+ std::pair<TrackBag, int> tracksWithMu = getTracksWithMuons(vtx);
+
+ if ( tracksWithMu.second == nMuRequested ) {
+ if ( tracksWithMu.first.size() == trkMasses.size() ) {
+ mpe = getInvariantMassWithError(tracksWithMu.first,
+ trkMasses,
+ vtx.vtx()->position());
+ } else {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMuCalcMass:"
+ << " vector sizes disagree!"
+ << " tracksWithMu: " << tracksWithMu.first.size()
+ << " BtrkMasses: " << trkMasses.size());
+ }
+ } else {
+ mpe.second = -10 - tracksWithMu.second;
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::getMuCalcMass:"
+ << " muon number mismatch:"
+ << " tracksWithMu: " << tracksWithMu.second
+ << " requested: " << nMuRequested);
+ }
+ return mpe;
+ }
+ //--------------------------------------------------------------------------
+ // Obtain a set of ID tracks for a set of muons
+ //--------------------------------------------------------------------------
+ TrackBag BPhysAddMuonBasedInvMass::getIdTracksForMuons(MuonBag& muons) const {
+
+ TrackBag muTracks;
+
+ for (auto &muon : muons) {
+ if ( muon != nullptr ) {
+ const xAOD::TrackParticle* trk =
+ muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
+ if ( trk != nullptr ) {
+ muTracks.push_back(trk);
+ } else {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getIdTracksForMuon:"
+ << " no ID track for muon found.");
+ }
+ } else {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getIdTracksForMuon:"
+ << " muon pointer is NULL!");
+ }
+ } // for muon
+ return muTracks;
+ }
+ //--------------------------------------------------------------------------
+ // Obtain a set of tracks with muon track information if available
+ //--------------------------------------------------------------------------
+ std::pair<TrackBag, int>
+ BPhysAddMuonBasedInvMass::getTracksWithMuons(xAOD::BPhysHelper& vtx) const {
+
+ TrackBag tracksWithMu;
+ int nMuFound = 0;
+ std::vector<int> vnMuFound;
+
+ MuonBag muons = findAllMuonsInDecay(vtx);
+
+ if ( muons.size() > 0 ) {
+ for (int itrk=0; itrk<vtx.nRefTrks(); ++itrk) {
+ // only charged tracks are of interest
+ if ( abs(vtx.refTrkCharge(itrk)) > 0. ) {
+ const xAOD::TrackParticle* trkParticle =
+ (xAOD::TrackParticle*)vtx.refTrkOrigin(itrk);
+ for (unsigned int imu = 0; imu<muons.size(); ++imu) {
+ if ( vtx.refTrkOrigin(itrk) ==
+ muons.at(imu)->trackParticle(xAOD::Muon::InnerDetectorTrackParticle) ) {
+ const xAOD::TrackParticle* trkMuon =
+ adjustTrackParticle(muons.at(imu));
+ if ( trkMuon != NULL ) {
+ trkParticle = trkMuon;
+ nMuFound++;
+ break;
+ }
+ }
+ } // for imu
+ tracksWithMu.push_back(trkParticle);
+ vnMuFound.push_back(nMuFound);
+ } // for charged track
+ } // for itrk
+ } else {
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::getTracksWithMuons: "
+ "vertex contains no muons, but "
+ << vtx.nRefTrks() << " refitted tracks ...");
+ }
+ // debug output
+ std::string svnMuFound = "[";
+ for (unsigned int i=0; i<vnMuFound.size(); ++i) {
+ svnMuFound += std::to_string(vnMuFound[i]) + ',';
+ }
+ svnMuFound.back() = ']';
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::getTracksWithMuons: "
+ "nMuFound = " << nMuFound
+ << "\nvnMuFound = " << svnMuFound );
+
+ return std::pair<TrackBag, int>(tracksWithMu, nMuFound);
+ }
+ //--------------------------------------------------------------------------
+ // adjustTrackParticle: extract primary track particle from muon
+ // if configured adjust pt, eta and phi of it before returning
+ // a pointer to it.
+ //--------------------------------------------------------------------------
+ const xAOD::TrackParticle* BPhysAddMuonBasedInvMass
+ ::adjustTrackParticle(const xAOD::Muon* muon) const {
+
+ const xAOD::TrackParticle* tp = NULL;
+ const xAOD::TrackParticle* org = muon->primaryTrackParticle();
+
+ if ( m_adjustToMuonKinematics ) {
+ if ( org != NULL ) {
+ TpMap_t::iterator it = m_adjTpCache.find(org);
+ if ( it != m_adjTpCache.end() ) {
+ // copy cached link
+ tp = it->second;
+ ATH_MSG_DEBUG("adjustTrackParticle(): from cache: tp = " << tp);
+ } else {
+ // copy object -- this does not work because of seg fault later
+ // xAOD::TrackParticle* newTp = new xAOD::TrackParticle(*org);
+
+ // create new object and copy properties
+ xAOD::TrackParticle* newTp = new xAOD::TrackParticle();
+ newTp->makePrivateStore(*org);
+
+ // ajdust pt, eta and phi to the muon's properties
+ xAOD::IParticle::FourMom_t p4 = muon->p4();
+ float qoverp = p4.P() > 0. ? 1./p4.P() : 10.e6;
+ if ( org->qOverP() < 0. ) qoverp *= -1.;
+ newTp->setDefiningParameters(org->d0(), org->z0(),
+ p4.Phi(), p4.Theta(), qoverp);
+ // cache new TrackParticle
+ m_adjTpCache[org] = newTp;
+ tp = newTp;
+ ATH_MSG_DEBUG("adjustTrackParticle(): new tp = " << tp
+ << " org = " << org);
+ } // if it != end()
+ } // if != NULL
+ } else {
+ // copy pointer
+ tp = org;
+ ATH_MSG_DEBUG("adjustTrackParticle(): copy: org: " << org
+ << " -> tp: " << tp);
+ }
+
+ // debug output
+ if ( org != NULL ) {
+ ATH_MSG_DEBUG("adjustTrackParticle(): org: " << org << " ("
+ << org->d0() << "," << org->z0() << "," << org->phi0()
+ << "," << org->theta() << "," << org->qOverP() << ") pt: "
+ << org->pt());
+ } else {
+ ATH_MSG_DEBUG("adjustTrackParticle(): org = NULL");
+ }
+ if ( org != NULL ) {
+ ATH_MSG_DEBUG("adjustTrackParticle(): tp : " << tp << " ("
+ << tp->d0() << "," << tp->z0() << "," << tp->phi0()
+ << "," << tp->theta() << "," << tp->qOverP() << ") pt: "
+ << tp->pt());
+ } else {
+ ATH_MSG_DEBUG("adjustTrackParticle(): tp = NULL");
+ }
+ return tp;
+ }
+ //--------------------------------------------------------------------------
+ // clearAdjTpCache: clear the cache of adjusted TrackParticles
+ //--------------------------------------------------------------------------
+ void BPhysAddMuonBasedInvMass::clearAdjTpCache() const {
+
+ for ( TpMap_t::iterator it = m_adjTpCache.begin(); it != m_adjTpCache.end();
+ ++it) {
+ if ( it->second != NULL ) {
+ const_cast<xAOD::TrackParticle*>(it->second)->releasePrivateStore();
+ delete(it->second);
+ it->second = NULL;
+ }
+ m_adjTpCache.clear();
+ }
+ }
+ //--------------------------------------------------------------------------
+ // findAllMuonsInDecay: returns a vector of xAOD::Muon objects found
+ // in this vertex and subsequent decay vertices.
+ // Recursively calls itself if necessary.
+ //--------------------------------------------------------------------------
+ MuonBag BPhysAddMuonBasedInvMass::findAllMuonsInDecay(xAOD::BPhysHelper& vtx)
+ const {
+
+ MuonBag muons = vtx.muons();
+
+ // loop over preceeding vertices
+ for (int ivtx = 0; ivtx < vtx.nPrecedingVertices(); ++ivtx) {
+ xAOD::BPhysHelper precVtx(vtx.precedingVertex(ivtx));
+ MuonBag muonsForVtx = findAllMuonsInDecay(precVtx);
+ muons.insert(muons.end(), muonsForVtx.begin(), muonsForVtx.end());
+ }
+ return muons;
+ }
+ //--------------------------------------------------------------------------
+ // getMinChi2ToAnyPV:
+ // Find minimum chi2 distance of signal muons w.r.t any primary vertex
+ // of required types and with a minimum number of tracks cut.
+ // It also depends on the mode w.r.t. the treatment of the associated
+ // primary vertex and the type of PV-to-SV association.
+ // Returns this minimum chi2.
+ //--------------------------------------------------------------------------
+ double
+ BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV(xAOD::BPhysHelper& vtx,
+ const xAOD::VertexContainer*
+ pvContainer,
+ const std::vector<int>& pvtypes,
+ const int minNTracksInPV,
+ const int mode,
+ const xAOD::BPhysHelper::pv_type&
+ pvAssocType) const {
+
+ MuonBag muons = findAllMuonsInDecay(vtx);
+ TrackBag tracks = getIdTracksForMuons(muons);
+ const xAOD::Vertex* origPV = nullptr;
+ const xAOD::Vertex* refPV = nullptr;
+
+ if ( mode > 1 ) {
+ // need to obtain original PV
+ origPV = vtx.origPv(pvAssocType);
+ if ( origPV == nullptr ) {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV:"
+ << " origPV == NULL for pvAssocType = "
+ << pvAssocType);
+ }
+ if ( mode > 2 ) {
+ refPV = vtx.pv(pvAssocType);
+ if ( refPV == nullptr ) {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV:"
+ << " refPV == NULL for pvAssocType = "
+ << pvAssocType);
+ }
+ }
+ }
+
+ double minChi2 = std::numeric_limits<double>::max();
+
+ for (const auto pvtx : *pvContainer) {
+ if ( pvtx != nullptr ) {
+ if ( std::find(pvtypes.begin(),pvtypes.end(),pvtx->vertexType())
+ != pvtypes.end() ) {
+ const xAOD::Vertex* cvtx = pvtx;
+ // switch if PV matches original PV and replacement is requested
+ if ( mode > 1 && pvtx == origPV ) {
+ // mode 2 -- skip
+ switch(mode) {
+ case 2: // skip current PV
+ continue;
+ break;
+ case 3: // replace by refitted PV
+ if ( refPV != nullptr ) {
+ cvtx = refPV;
+ } else {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV:"
+ << " refPV == NULL!");
+ continue;
+ }
+ break;
+ }
+ }
+ if ( (int)cvtx->nTrackParticles() >= minNTracksInPV ) {
+ for (auto &track : tracks) {
+ const Amg::Vector3D pos = cvtx->position();
+ minChi2 = std::min(minChi2, getTrackPVChi2(*track, pos));
+ } // for track
+ } // if minNTracksInPV
+ } // if pvTypes in pvtypes vector
+ } else {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getMinChi2ToAnyPV:"
+ << " pvtx == NULL!");
+ } // if vtx != nullptr
+ } // for pvtx
+
+ return minChi2;
+ }
+ //--------------------------------------------------------------------------
+ // getTrackPVChi2:
+ // Calculate the chi2 ( = log((d0/d0e)^2+(z0/z0e)^2) contribution of
+ // a track at the position closest to the given PV.
+ //--------------------------------------------------------------------------
+ double
+ BPhysAddMuonBasedInvMass::getTrackPVChi2(const xAOD::TrackParticle& track,
+ const Amg::Vector3D& pos) const {
+
+ double chi2 = -100.;
+
+ const Trk::Perigee* trkPerigee =
+ m_trackToVertexTool->perigeeAtVertex(track, pos);
+ if ( trkPerigee != NULL ) {
+ const AmgSymMatrix(5)* locError = trkPerigee->covariance();
+ if ( locError != NULL ) {
+ double d0 = trkPerigee->parameters()[Trk::d0];
+ double z0 = trkPerigee->parameters()[Trk::z0];
+ double d0Err = Amg::error(*locError, Trk::d0);
+ double z0Err = Amg::error(*locError, Trk::z0);
+ if (fabs(d0Err) > 0. && fabs(z0Err) > 0.) {
+ chi2 = log( pow(d0/d0Err,2.0) + pow(z0/z0Err,2.0) );
+ } else {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getTrackPVChi2():"
+ << " d0 = " << d0 << ", d0Err = " << d0Err
+ << ", z0 = " << z0 << ", z0Err = " << z0Err);
+ }
+ } // locError != NULL
+ delete trkPerigee;
+ trkPerigee = nullptr;
+ } else {
+ ATH_MSG_WARNING("getTrackPVChi2: Could not get perigee");
+ }
+
+ return chi2;
+}
+ //--------------------------------------------------------------------------
+ // getInvariantMassWithError: returns invariant mass and mass error given
+ // a set of tracks, their mass hypotheses and a reference position.
+ // Each track must have a separate mass hypothesis in
+ // the vector, and they must be in the same order as the tracks in the
+ // track vector. Otherwise it will go horribly wrong.
+ //--------------------------------------------------------------------------
+ std::pair<double,double> BPhysAddMuonBasedInvMass::
+ getInvariantMassWithError(TrackBag trksIn,
+ std::vector<double> massHypotheses,
+ const Amg::Vector3D& pos) const {
+
+ std::pair<double, double> mass(0.,0.);
+
+ // ensure there is a mass hypothesis for each track
+ if ( trksIn.size() == massHypotheses.size() ) {
+ std::vector<const xAOD::TrackParticle*>::iterator trItr = trksIn.begin();
+ std::vector<const xAOD::TrackParticle*>::iterator trItrEnd =trksIn.end();
+ std::vector<double>::iterator massHypItr = massHypotheses.begin();
+
+ double pxTmp,pyTmp,pzTmp,massTmp,eTmp;
+
+ std::vector<TLorentzVector> trkMom;
+ TLorentzVector totMom;
+ std::vector<const Trk::Perigee*> trkPer;
+
+ for (;trItr != trItrEnd; trItr++,massHypItr++){
+ const Trk::Perigee* trkPerigee =
+ m_trackToVertexTool->perigeeAtVertex(*(*trItr), pos);
+ trkPer.push_back(trkPerigee);
+ if ( trkPerigee != NULL ) {
+ // try to get the correct momentum measurement
+ pxTmp = trkPerigee->momentum()[Trk::px];
+ pyTmp = trkPerigee->momentum()[Trk::py];
+ pzTmp = trkPerigee->momentum()[Trk::pz];
+ ATH_MSG_DEBUG("getInvariantMassWithError(): pvec = ("
+ << pxTmp << "," << pyTmp << "," << pzTmp << ")");
+ } else {
+ // otherwise default to this one
+ pxTmp = ((*trItr)->p4()).Px();
+ pyTmp = ((*trItr)->p4()).Py();
+ pzTmp = ((*trItr)->p4()).Pz();
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getInvariantMassError: "
+ "defaulting to simple momentum!");
+ }
+ massTmp = *massHypItr;
+ eTmp = pxTmp*pxTmp+pyTmp*pyTmp+pzTmp*pzTmp+massTmp*massTmp;
+ eTmp = eTmp > 0. ? sqrt(eTmp) : 0.;
+ TLorentzVector tmpMom(pxTmp, pyTmp, pzTmp, eTmp);
+ trkMom.push_back(tmpMom);
+ totMom += tmpMom;
+ }
+ mass.first = totMom.M();
+ double mErr2 = 0.;
+ // reset trItr
+ trItr = trksIn.begin();
+ std::vector<TLorentzVector>::iterator tmItr = trkMom.begin();
+ std::vector<const Trk::Perigee*>::iterator perItr = trkPer.begin();
+ AmgVector(3) dMdP;
+ dMdP.setZero();
+ for (; tmItr != trkMom.end(); ++tmItr, ++trItr, ++perItr) {
+ dMdP(0) = (totMom.E() * tmItr->Px()/tmItr->E() - totMom.Px())/totMom.M();
+ dMdP(1) = (totMom.E() * tmItr->Py()/tmItr->E() - totMom.Py())/totMom.M();
+ dMdP(2) = (totMom.E() * tmItr->Pz()/tmItr->E() - totMom.Pz())/totMom.M();
+ if ( *perItr != NULL ) {
+ mErr2 += (dMdP.transpose() * getMomentumCov(*perItr) * dMdP)(0,0);
+ } else {
+ mErr2 += (dMdP.transpose() * getMomentumCov(*trItr ) * dMdP)(0,0);
+ }
+ }
+ mass.second = mErr2 > 0. ? sqrt(mErr2) : 0.;
+ // clean up
+ for ( perItr = trkPer.begin(); perItr != trkPer.end(); ++perItr) {
+ delete (*perItr);
+ }
+ } else {
+ ATH_MSG_WARNING("BPhysAddMuonBasedInvMass::getInvariantMassError: "
+ "size mismatch of tracks and mass hypotheses vectors!");
+ } // if size comparison
+
+ return mass;
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Extract the 3x3 momentum covariance matrix in (x,y,z) notation
+ // from the (phi, theta, qoverp) notation from a TrackParticle.
+ //
+ //--------------------------------------------------------------------------
+ AmgSymMatrix(3) BPhysAddMuonBasedInvMass
+ ::getMomentumCov(const xAOD::TrackParticle* track) const {
+
+ AmgSymMatrix(3) cov;
+ cov.setZero();
+
+ if ( track != NULL ) {
+ cov = getMomentumCov( &track->perigeeParameters() );
+ }
+ return cov;
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Extract the 3x3 momentum covariance matrix in (x,y,z) notation
+ // from the (phi, theta, qoverp) notation from a Perigee.
+ //
+ //--------------------------------------------------------------------------
+ AmgSymMatrix(3) BPhysAddMuonBasedInvMass
+ ::getMomentumCov(const Trk::Perigee* perigee) const {
+
+ AmgSymMatrix(3) cov;
+ cov.setZero();
+
+ if ( perigee != NULL ) {
+ cov = getMomentumCov(perigee->parameters(), *perigee->covariance());
+ }
+ return cov;
+ }
+ //--------------------------------------------------------------------------
+ // Extract the 3x3 momentum covariance matrix in (x,y,z) notation
+ // from the (phi, theta, qoverp) notation from a vector of
+ // track parameters and the error matrix
+ //
+ // Coding ideas orignally taken from
+ // V0Tools::massErrorVKalVrt(...),
+ // Code converted from BPhysToolBox::getMomentumCov(...).
+ //--------------------------------------------------------------------------
+ //
+ AmgSymMatrix(3) BPhysAddMuonBasedInvMass
+ ::getMomentumCov(const AmgVector(5)& pars,
+ const AmgSymMatrix(5)& cMatrix) const {
+
+ AmgSymMatrix(3) cov;
+ cov.setZero();
+
+ AmgMatrix(3,3) der;
+ der.setZero();
+
+ double phi = pars[Trk::phi];
+ double theta = pars[Trk::theta];
+ double qoverp = pars[Trk::qOverP];
+
+ if ( qoverp != 0. ) {
+ AmgVector(3) p( cos(phi)*sin(theta)/fabs(qoverp),
+ sin(phi)*sin(theta)/fabs(qoverp),
+ cos(theta)/fabs(qoverp) );
+
+ // d(px,py,pz)/d(phi,theta,qoverp)
+ der(0,0) = - p.y();
+ der(1,0) = p.x();
+ der(2,0) = 0.;
+ der(0,1) = cos(phi) * p.z();
+ der(1,1) = sin(phi) * p.z();
+ der(2,1) = - sin(theta) / fabs(qoverp);
+ der(0,2) = - p.x()/qoverp;
+ der(1,2) = - p.y()/qoverp;
+ der(2,2) = - p.z()/qoverp;
+
+ for (unsigned int i=0; i<3; i++) {
+ for (unsigned int j=0; j<3; j++) {
+ for (unsigned int k=0; k<3; k++) {
+ for (unsigned int l=0; l<3; l++) {
+ cov(i,j) += der(i,k)*cMatrix(k+2,l+2)*der(j,l);
+ }
+ }
+ }
+ }
+
+ // debug output
+ ATH_MSG_DEBUG("BPhysAddMuonBasedInvMass::getTracksWithMuons:"
+ << "\nlocalErrCov:\n"
+ << std::setprecision(10) << cMatrix
+ << "\ncov:\n"
+ << std::setprecision(10) << cov
+ << "\np: " << std::setprecision(10) << p
+ << "\nder:\n"
+ << std::setprecision(10) << der);
+ } // if qoverp
+
+ return cov;
+ }
+ //--------------------------------------------------------------------------
+ // Initialize PV-to-SV association type vector
+ //--------------------------------------------------------------------------
+ void BPhysAddMuonBasedInvMass::initPvAssocTypeVec() {
+
+ m_pvAssocTypes.clear();
+ for (unsigned int i=0; i<xAOD::BPhysHelper::n_pv_types; ++i) {
+ if ( (m_doVertexType & (1 << i)) > 0 )
+ m_pvAssocTypes.push_back((xAOD::BPhysHelper::pv_type)i);
+ }
+ }
+ //--------------------------------------------------------------------------
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysConversionFinder.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysConversionFinder.cxx
new file mode 100644
index 00000000000..de43d2bf118
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysConversionFinder.cxx
@@ -0,0 +1,589 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+/////////////////////////////////////////////////////////////////
+// BPhysConversionFinder.cxx, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Author: A. Chisholm <andrew.chisholm@cern.ch>
+#include "DerivationFrameworkBPhys/BPhysConversionFinder.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "GaudiKernel/IPartPropSvc.h"
+#include "GeoPrimitives/GeoPrimitivesHelpers.h"
+#include "TrkVertexFitterInterfaces/IVertexFitter.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+
+namespace DerivationFramework {
+
+ BPhysConversionFinder::BPhysConversionFinder(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_v0Tools("Trk::V0Tools"),
+ m_vertexFitter("Trk::TrkVKalVrtFitter"),
+ m_vertexEstimator("InDet::VertexPointEstimator"),
+ m_distanceTool("Trk::SeedNewtonDistanceFinder/InDetConversionTrkDistanceFinder"),
+ m_postSelector("InDet::ConversionPostSelector"),
+ m_cascadeFitter("Trk::TrkVKalVrtFitter"),
+ m_inputTrackParticleContainerName("InDetTrackParticles"),
+ m_conversionContainerName("BPhysConversionCandidates"),
+ m_maxDistBetweenTracks(10.0),
+ m_maxDeltaCotTheta(0.3),
+ m_requireDeltaM(true),
+ m_maxDeltaM(3000.0)
+ {
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare user-defined properties
+ declareProperty("DiMuonVertexContainer", m_diMuonCollectionToCheck);
+ declareProperty("PassFlagsToCheck", m_passFlagsToCheck);
+ declareProperty("V0Tools", m_v0Tools);
+ declareProperty("VertexFitterTool", m_vertexFitter);
+ declareProperty("VertexEstimator", m_vertexEstimator);
+ declareProperty("DistanceTool", m_distanceTool);
+ declareProperty("ConversionPostSelector", m_postSelector);
+ declareProperty("CascadeFitter", m_cascadeFitter);
+ declareProperty("InputTrackParticleContainerName", m_inputTrackParticleContainerName);
+ declareProperty("ConversionContainerName", m_conversionContainerName);
+ declareProperty("MaxDistBetweenTracks", m_maxDistBetweenTracks = 10.0); // Maximum allowed distance of minimum approach
+ declareProperty("MaxDeltaCotTheta", m_maxDeltaCotTheta = 0.3); // Maximum allowed dCotTheta between tracks
+ declareProperty("RequireDeltaM", m_requireDeltaM = true); // Only save a conversions if it's a chi_c,b candidate (must then pass "MaxDeltaM" requirement), if "False" all conversions in the event will be saved
+ declareProperty("MaxDeltaM", m_maxDeltaM = 3000.0); // Maximum mass difference between di-muon+conversion and di-muon
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode BPhysConversionFinder::initialize()
+ {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ ATH_CHECK( m_v0Tools.retrieve() );
+ ATH_CHECK( m_vertexFitter.retrieve() );
+ ATH_CHECK( m_vertexEstimator.retrieve() );
+ ATH_CHECK( m_distanceTool.retrieve() );
+ ATH_CHECK( m_postSelector.retrieve() );
+ ATH_CHECK( m_cascadeFitter.retrieve() );
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode BPhysConversionFinder::finalize()
+ {
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode BPhysConversionFinder::addBranches() const
+ {
+
+ int nTrackPairs_Init = 0;
+ int nTrackPairs_Selected = 0;
+ int nConv_VertexFit = 0;
+ int nConv_Selected = 0;
+ int nConv_Selected_DeltaM = 0;
+
+ std::vector<const xAOD::Vertex*> oniaVertices;
+ oniaVertices.clear();
+
+ //------------------------------------
+ // Look for di-muons
+ //------------------------------------
+ const xAOD::VertexContainer* diMuonContainer = NULL;
+ ATH_CHECK( evtStore()->retrieve(diMuonContainer, m_diMuonCollectionToCheck) );
+
+ if(diMuonContainer->size() == 0) {
+
+ ATH_MSG_DEBUG("Vertex Container (" << m_diMuonCollectionToCheck << ") is empty");
+
+ } else {
+
+ ATH_MSG_DEBUG("Vertex Container (" << m_diMuonCollectionToCheck << ") contains " << diMuonContainer->size() << " vertices");
+
+ for(xAOD::VertexContainer::const_iterator vtxItr = diMuonContainer->begin(); vtxItr != diMuonContainer->end(); ++vtxItr) {
+
+ const xAOD::Vertex* vertex = (*vtxItr);
+
+ bool passedHypothesis = false;
+
+ for(const auto &flag : m_passFlagsToCheck) {
+ bool pass = vertex->auxdata<Char_t>(flag);
+ if(pass) passedHypothesis = true;
+ }
+
+ if(passedHypothesis) {
+ oniaVertices.push_back(vertex);
+ }
+
+ }
+ }
+ //------------------------------------
+
+ // Output conversion container
+ std::unique_ptr<xAOD::VertexContainer> conversionContainer( new xAOD::VertexContainer() );
+ std::unique_ptr<xAOD::VertexAuxContainer> conversionAuxContainer( new xAOD::VertexAuxContainer() );
+ conversionContainer->setStore(conversionAuxContainer.get());
+
+ // Only call conversion finder if we've found a di-muon candidate or
+ // we really want to look for conversions independently
+ const bool callConvFinder = !m_requireDeltaM || oniaVertices.size() > 0;
+
+ if(callConvFinder) {
+
+ // Retrieve track particles from StoreGate
+ const xAOD::TrackParticleContainer* inputTrackParticles = NULL;
+ ATH_CHECK( evtStore()->retrieve(inputTrackParticles,m_inputTrackParticleContainerName) );
+
+ ATH_MSG_DEBUG("Track particle container size " << inputTrackParticles->size());
+
+ // Track Selection
+ std::vector<const xAOD::TrackParticle*> posTracks; posTracks.clear();
+ std::vector<const xAOD::TrackParticle*> negTracks; negTracks.clear();
+
+ // Track Loop
+ for(xAOD::TrackParticleContainer::const_iterator trkItr = inputTrackParticles->begin(); trkItr != inputTrackParticles->end(); ++trkItr) {
+
+ const xAOD::TrackParticle* track = (*trkItr);
+
+ uint8_t nSCT(0);
+ uint8_t nPIX(0);
+
+ track->summaryValue(nPIX,xAOD::numberOfPixelHits);
+ track->summaryValue(nSCT,xAOD::numberOfSCTHits);
+
+ // Don't want TRT-only tracks
+ // Require Si hits on all tracks
+ if( nSCT + nPIX < 1 ) continue;
+
+ if( track->charge() > 0.0) {
+ posTracks.push_back(track);
+ } else {
+ negTracks.push_back(track);
+ }
+
+ } // Track Loop
+
+ ATH_MSG_DEBUG(posTracks.size() + negTracks.size() << " tracks pass pre-selection");
+
+ std::vector<const xAOD::TrackParticle*>::const_iterator tpIt1;
+ std::vector<const xAOD::TrackParticle*>::const_iterator tpIt2;
+
+ // Pos Track Loop
+ for(tpIt1 = posTracks.begin(); tpIt1 != posTracks.end(); ++tpIt1) {
+
+ const xAOD::TrackParticle* trackParticle1 = (*tpIt1);
+
+ const Trk::Perigee& trackPerigee1 = trackParticle1->perigeeParameters();
+
+ // Neg Track Loop
+ for(tpIt2 = negTracks.begin(); tpIt2 != negTracks.end(); ++tpIt2) {
+
+ if (*tpIt1 == *tpIt2) continue;
+
+ const xAOD::TrackParticle* trackParticle2 = (*tpIt2);
+
+ const Trk::Perigee& trackPerigee2 = trackParticle2->perigeeParameters();
+
+ nTrackPairs_Init++;
+
+ //------------------------------------
+ // Track pair selection
+ //------------------------------------
+ const double deltaCotTheta = fabs(1./tan(trackPerigee1.parameters()[Trk::theta]) - 1./tan(trackPerigee2.parameters()[Trk::theta]));
+ if(deltaCotTheta > m_maxDeltaCotTheta) continue;
+
+ double distance = 1000000.;
+ std::optional<std::pair<Amg::Vector3D,Amg::Vector3D>> result = m_distanceTool->CalculateMinimumDistance(trackParticle1->perigeeParameters(),trackParticle2->perigeeParameters() );
+ bool gotDistance = result.has_value();
+ if(gotDistance) distance = Amg::distance (result->first, result->second);
+ if(!gotDistance || (distance > m_maxDistBetweenTracks)) continue;
+ //------------------------------------
+
+ //------------------------------------
+ // Estimate starting point + cuts on compatiblity of tracks
+ //------------------------------------
+ int sflag = 0;
+ int errorcode = 0;
+ std::map<std::string, float> vertexOutput;
+ Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&trackPerigee1,&trackPerigee2,sflag,errorcode, vertexOutput);
+ if(errorcode != 0) continue;
+ //------------------------------------
+
+ nTrackPairs_Selected++;
+
+ std::vector<const xAOD::TrackParticle*> trackPair;
+ trackPair.clear();
+ trackPair.push_back(trackParticle1);
+ trackPair.push_back(trackParticle2);
+
+ // Do the vertex fit
+ std::unique_ptr<xAOD::Vertex> convVertexCandidate( m_vertexFitter->fit(trackPair, startingPoint) );
+
+ // Check for successful fit
+ if(convVertexCandidate != NULL) {
+
+ ATH_MSG_DEBUG("Vertex Fit Succeeded");
+
+ convVertexCandidate->clearTracks();
+ ElementLink<xAOD::TrackParticleContainer> newLink1;
+ newLink1.setElement(*tpIt1);
+ newLink1.setStorableObject(*inputTrackParticles);
+ ElementLink<xAOD::TrackParticleContainer> newLink2;
+ newLink2.setElement(*tpIt2);
+ newLink2.setStorableObject(*inputTrackParticles);
+ convVertexCandidate->addTrackAtVertex(newLink1);
+ convVertexCandidate->addTrackAtVertex(newLink2);
+
+ nConv_VertexFit++;
+
+ //------------------------------------
+ // Post-vertexing cuts
+ //------------------------------------
+
+ // This is empty and only present for compatiblity.
+ // The cut this informtion pertains to is not used for Si-Si conversions so this is OK
+ std::vector<Amg::Vector3D> positionList;
+
+ // Apply Si-Si converion post-selection
+ if( !m_postSelector->selectConversionCandidate(convVertexCandidate.get(),0,positionList) ) {
+ convVertexCandidate.reset();
+ continue;
+ }
+ //------------------------------------
+
+ nConv_Selected++;
+
+ // Get photon momentum 3-vector
+ const xAOD::Vertex * constConvVertex = convVertexCandidate.get();
+ Amg::Vector3D momentum = m_v0Tools->V0Momentum(constConvVertex);
+
+ TLorentzVector photon;
+ photon.SetXYZM(momentum.x(),momentum.y(),momentum.z(),0.0);
+
+ //------------------------------------
+ // Check if conversion is consistent with a chi_c,b candidate
+ // by requiring a small mass difference w.r.t. any di-muon in event
+ //------------------------------------
+ bool passDeltaM = false;
+
+ // Use to keep track of which dimuon(s) gave a chi_c/b candidate
+ std::vector<const xAOD::Vertex*> candidateOniaVertices;
+ candidateOniaVertices.clear();
+
+ for ( std::vector<const xAOD::Vertex*>::const_iterator vtxItr = oniaVertices.begin(); vtxItr != oniaVertices.end(); ++vtxItr ) {
+
+ const xAOD::Vertex* oniaVertex = (*vtxItr);
+
+ std::vector<float> diMuon_Px = oniaVertex->auxdata< std::vector<float> >("RefTrackPx");
+ std::vector<float> diMuon_Py = oniaVertex->auxdata< std::vector<float> >("RefTrackPy");
+ std::vector<float> diMuon_Pz = oniaVertex->auxdata< std::vector<float> >("RefTrackPz");
+
+ TLorentzVector muon1, muon2;
+ muon1.SetXYZM(diMuon_Px.at(0),diMuon_Py.at(0),diMuon_Pz.at(0),105.658);
+ muon2.SetXYZM(diMuon_Px.at(1),diMuon_Py.at(1),diMuon_Pz.at(1),105.658);
+
+ TLorentzVector diMuon = muon1 + muon2;
+
+ const double deltaM = (diMuon+photon).M() - diMuon.M();
+
+ ATH_MSG_DEBUG("Candidate DeltaM = " << deltaM << " MeV DiMuon " << oniaVertex->index() << " ( Mass = " << diMuon.M() << " MeV )");
+
+ // Did we find a one di-muon + photon candidate with a mass diff. consistent with chi_c/b?
+ if(deltaM < m_maxDeltaM) {
+ passDeltaM = true;
+ candidateOniaVertices.push_back(oniaVertex);
+ }
+
+ }
+
+ // Only keep the conversion candidate if it's consistent with a chi_c,b decay
+ if(m_requireDeltaM && !passDeltaM) {
+ convVertexCandidate.reset();
+ continue;
+ }
+ //------------------------------------
+
+ //------------------------------------
+ // Final conversion candidates
+ //------------------------------------
+ nConv_Selected_DeltaM++;
+
+ // Keep track of which dimuon(s) gave a chi_c/b candidate
+ std::vector< ElementLink<xAOD::VertexContainer> > diMuonLinks;
+ diMuonLinks.clear();
+
+ // Output of cascade fits with various di-muon mass hypotheses
+ std::vector<float> fit_Psi1S_Px, fit_Psi1S_Py, fit_Psi1S_Pz, fit_Psi1S_M, fit_Psi1S_ChiSq;
+ std::vector<float> fit_Psi2S_Px, fit_Psi2S_Py, fit_Psi2S_Pz, fit_Psi2S_M, fit_Psi2S_ChiSq;
+ std::vector<float> fit_Upsi1S_Px, fit_Upsi1S_Py, fit_Upsi1S_Pz, fit_Upsi1S_M, fit_Upsi1S_ChiSq;
+ std::vector<float> fit_Upsi2S_Px, fit_Upsi2S_Py, fit_Upsi2S_Pz, fit_Upsi2S_M, fit_Upsi2S_ChiSq;
+ std::vector<float> fit_Upsi3S_Px, fit_Upsi3S_Py, fit_Upsi3S_Pz, fit_Upsi3S_M, fit_Upsi3S_ChiSq;
+
+ // Loop over di-muon vertices associated with a candidate
+ for(std::vector<const xAOD::Vertex*>::const_iterator vtxItr = candidateOniaVertices.begin(); vtxItr != candidateOniaVertices.end(); ++vtxItr ) {
+
+ //------------------------------------
+ // Add an element link to each dimuon which formed a
+ // candidate, leading to the decision to save this conversion
+ //------------------------------------
+ ElementLink<xAOD::VertexContainer> myLink;
+ myLink.setElement(*vtxItr);
+ myLink.setStorableObject(*diMuonContainer);
+
+ if(!myLink.isValid()) {
+ ATH_MSG_WARNING("Invalid DiMuon ElementLink!");
+ }
+
+ diMuonLinks.push_back(myLink);
+ //------------------------------------
+
+ // Check which mass window this di-muon passed
+ bool passed_Psi = (*vtxItr)->auxdata<Char_t>("passed_Psi");
+ bool passed_Upsi = (*vtxItr)->auxdata<Char_t>("passed_Upsi");
+
+ //------------------------------------
+ // Cascade fit with J/psi mass hypothesis
+ //------------------------------------
+ float fitChiSq_Psi1S = 99999;
+ TLorentzVector fitResult_Psi1S;
+
+ // Only bother with the fit if di-muon mass is within the relveant range,
+ // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
+ if(passed_Psi) {
+ ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,3096.916,fitResult_Psi1S,fitChiSq_Psi1S) );
+ }
+
+ fit_Psi1S_Px.push_back(fitResult_Psi1S.Px());
+ fit_Psi1S_Py.push_back(fitResult_Psi1S.Py());
+ fit_Psi1S_Pz.push_back(fitResult_Psi1S.Pz());
+ fit_Psi1S_M.push_back(fitResult_Psi1S.M());
+ fit_Psi1S_ChiSq.push_back(fitChiSq_Psi1S);
+
+ //------------------------------------
+ // Cascade fit with psi(2S) mass hypothesis
+ //------------------------------------
+ float fitChiSq_Psi2S = 99999;
+ TLorentzVector fitResult_Psi2S;
+
+ // Only bother with the fit if di-muon mass is within the relveant range,
+ // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
+ if(passed_Psi) {
+ ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,3686.097,fitResult_Psi2S,fitChiSq_Psi2S) );
+ }
+
+ fit_Psi2S_Px.push_back(fitResult_Psi2S.Px());
+ fit_Psi2S_Py.push_back(fitResult_Psi2S.Py());
+ fit_Psi2S_Pz.push_back(fitResult_Psi2S.Pz());
+ fit_Psi2S_M.push_back(fitResult_Psi2S.M());
+ fit_Psi2S_ChiSq.push_back(fitChiSq_Psi2S);
+
+ //------------------------------------
+ // Cascade fit with Upsi(1S) mass hypothesis
+ //------------------------------------
+ float fitChiSq_Upsi1S = 99999;
+ TLorentzVector fitResult_Upsi1S;
+
+ // Only bother with the fit if di-muon mass is within the relveant range,
+ // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
+ if(passed_Upsi) {
+ ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,9460.30,fitResult_Upsi1S,fitChiSq_Upsi1S) );
+ }
+
+ fit_Upsi1S_Px.push_back(fitResult_Upsi1S.Px());
+ fit_Upsi1S_Py.push_back(fitResult_Upsi1S.Py());
+ fit_Upsi1S_Pz.push_back(fitResult_Upsi1S.Pz());
+ fit_Upsi1S_M.push_back(fitResult_Upsi1S.M());
+ fit_Upsi1S_ChiSq.push_back(fitChiSq_Upsi1S);
+
+ //------------------------------------
+ // Cascade fit with Upsi(2S) mass hypothesis
+ //------------------------------------
+ float fitChiSq_Upsi2S = 99999;
+ TLorentzVector fitResult_Upsi2S;
+
+ // Only bother with the fit if di-muon mass is within the relveant range,
+ // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
+ if(passed_Upsi) {
+ ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,10023.26,fitResult_Upsi2S,fitChiSq_Upsi2S) );
+ }
+
+ fit_Upsi2S_Px.push_back(fitResult_Upsi2S.Px());
+ fit_Upsi2S_Py.push_back(fitResult_Upsi2S.Py());
+ fit_Upsi2S_Pz.push_back(fitResult_Upsi2S.Pz());
+ fit_Upsi2S_M.push_back(fitResult_Upsi2S.M());
+ fit_Upsi2S_ChiSq.push_back(fitChiSq_Upsi2S);
+
+ //------------------------------------
+ // Cascade fit with Upsi(3S) mass hypothesis
+ //------------------------------------
+ float fitChiSq_Upsi3S = 99999;
+ TLorentzVector fitResult_Upsi3S;
+
+ // Only bother with the fit if di-muon mass is within the relveant range,
+ // but still fill an dummy 4-vector to preserve one to one correspondance with "DiMuonLinks"
+ if(passed_Upsi) {
+ ATH_CHECK( doCascadeFit(*vtxItr,constConvVertex,10355.2,fitResult_Upsi3S,fitChiSq_Upsi3S) );
+ }
+
+ fit_Upsi3S_Px.push_back(fitResult_Upsi3S.Px());
+ fit_Upsi3S_Py.push_back(fitResult_Upsi3S.Py());
+ fit_Upsi3S_Pz.push_back(fitResult_Upsi3S.Pz());
+ fit_Upsi3S_M.push_back(fitResult_Upsi3S.M());
+ fit_Upsi3S_ChiSq.push_back(fitChiSq_Upsi3S);
+
+ }
+
+ //------------------------------------
+ // Decorate selected conversions
+ //------------------------------------
+ ATH_MSG_DEBUG("Decorating conversion vertices");
+
+ convVertexCandidate->auxdata< std::vector< ElementLink<xAOD::VertexContainer> > >("DiMuonLinks") = diMuonLinks;
+
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi1S_Px") = fit_Psi1S_Px;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi1S_Py") = fit_Psi1S_Py;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi1S_Pz") = fit_Psi1S_Pz;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi1S_M") = fit_Psi1S_M;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi1S_ChiSq") = fit_Psi1S_ChiSq;
+
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi2S_Px") = fit_Psi2S_Px;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi2S_Py") = fit_Psi2S_Py;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi2S_Pz") = fit_Psi2S_Pz;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi2S_M") = fit_Psi2S_M;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Psi2S_ChiSq") = fit_Psi2S_ChiSq;
+
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi1S_Px") = fit_Upsi1S_Px;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi1S_Py") = fit_Upsi1S_Py;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi1S_Pz") = fit_Upsi1S_Pz;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi1S_M") = fit_Upsi1S_M;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi1S_ChiSq") = fit_Upsi1S_ChiSq;
+
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi2S_Px") = fit_Upsi2S_Px;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi2S_Py") = fit_Upsi2S_Py;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi2S_Pz") = fit_Upsi2S_Pz;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi2S_M") = fit_Upsi2S_M;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi2S_ChiSq") = fit_Upsi2S_ChiSq;
+
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi3S_Px") = fit_Upsi3S_Px;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi3S_Py") = fit_Upsi3S_Py;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi3S_Pz") = fit_Upsi3S_Pz;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi3S_M") = fit_Upsi3S_M;
+ convVertexCandidate->auxdata< std::vector<float> >("CascadeFit_Upsi3S_ChiSq") = fit_Upsi3S_ChiSq;
+
+ convVertexCandidate->auxdata<float>("px") = momentum.x();
+ convVertexCandidate->auxdata<float>("py") = momentum.y();
+ convVertexCandidate->auxdata<float>("pz") = momentum.z();
+
+ convVertexCandidate->auxdata<float>("deltaCotThetaTrk") = deltaCotTheta;
+ convVertexCandidate->auxdata<float>("minimumDistanceTrk") = distance;
+
+ convVertexCandidate->auxdata<float>("deltaPhiTracks") = vertexOutput["deltaPhiTracks"];
+ convVertexCandidate->auxdata<float>("DR1R2") = vertexOutput["DR1R2"];
+
+ convVertexCandidate->auxdata<Char_t>("passed") = true; // Used in event skimming
+
+ conversionContainer->push_back(convVertexCandidate.release());
+
+ } else {
+ ATH_MSG_DEBUG("Vertex Fit Failed");
+ }
+
+ } // Neg Track Loop
+
+ } // Pos Track Loop
+
+ } // callConvFinder
+
+ // Write the results to StoreGate
+ CHECK(evtStore()->record(conversionContainer.release(), m_conversionContainerName));
+ CHECK(evtStore()->record(conversionAuxContainer.release(), m_conversionContainerName+"Aux."));
+
+ ATH_MSG_DEBUG("-------------------------");
+ ATH_MSG_DEBUG("Number of track pairs: " << nTrackPairs_Init);
+ ATH_MSG_DEBUG("Number of track pairs selected: " << nTrackPairs_Selected);
+ ATH_MSG_DEBUG("Number of successful vertex fits: " << nConv_VertexFit);
+ ATH_MSG_DEBUG("Number of selected vertices: " << nConv_Selected);
+ ATH_MSG_DEBUG("Number of selected vertices (after DeltaM req.): " << nConv_Selected_DeltaM);
+
+ return StatusCode::SUCCESS;
+ }
+
+ StatusCode BPhysConversionFinder::doCascadeFit(const xAOD::Vertex * diMuonVertex, const xAOD::Vertex * convVertex, const double diMuonMassConstraint, TLorentzVector & fitMom, float & chiSq) const {
+
+ std::vector<const xAOD::TrackParticle*> diMuonTracks;
+ diMuonTracks.push_back(diMuonVertex->trackParticle(0));
+ diMuonTracks.push_back(diMuonVertex->trackParticle(1));
+
+ std::vector<double> diMuonTrackMasses;
+ diMuonTrackMasses.push_back(105.658);
+ diMuonTrackMasses.push_back(105.658);
+
+ std::vector<const xAOD::TrackParticle*> convTracks;
+ convTracks.push_back(convVertex->trackParticle(0));
+ convTracks.push_back(convVertex->trackParticle(1));
+
+ std::vector<double> convTrackMasses;
+ convTrackMasses.push_back(0.511);
+ convTrackMasses.push_back(0.511);
+
+ // Reset
+ std::unique_ptr<Trk::IVKalState> state = m_cascadeFitter->makeState();
+
+ // Set Robustness
+ m_cascadeFitter->setRobustness(0, *state);
+
+ // Build up the topology
+
+ // Vertex list
+ std::vector<Trk::VertexID> vrtList;
+ // V0 vertex
+ Trk::VertexID vID;
+ vID = m_cascadeFitter->startVertex(convTracks,convTrackMasses,*state,0.0); // Constrain converision mass to zero
+
+ vrtList.push_back(vID);
+
+ // chi_c/b vertex
+ Trk::VertexID vID2 = m_cascadeFitter->nextVertex(diMuonTracks,diMuonTrackMasses,vrtList,*state);
+
+ std::vector<Trk::VertexID> cnstV;
+ cnstV.clear();
+ if ( !m_cascadeFitter->addMassConstraint(vID2,diMuonTracks,cnstV,*state,diMuonMassConstraint).isSuccess() ) {
+ ATH_MSG_WARNING("addMassConstraint failed");
+ }
+
+ // Do the fit
+ std::unique_ptr<Trk::VxCascadeInfo> result(m_cascadeFitter->fitCascade(*state));
+
+ const std::vector< std::vector<TLorentzVector> > &moms = result->getParticleMoms();
+
+ // Check for a successful fit
+ if(result != NULL) {
+
+ if(moms.size() > 2) ATH_MSG_WARNING("DoCascadeFit - More than two output momentum!?");
+
+ TLorentzVector conv_Fit = moms.at(0).at(0) + moms.at(0).at(1);
+ TLorentzVector diMuon_Fit = moms.at(1).at(0) + moms.at(1).at(1);
+
+ // Momentum of DiMuon + photon system
+ fitMom = diMuon_Fit + conv_Fit;
+
+ chiSq = result->fitChi2()/result->nDoF();
+
+ // Done with the fit result
+ result.reset();
+
+ }
+
+ return StatusCode::SUCCESS;
+
+ }
+
+
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysMetadataBase.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysMetadataBase.cxx
new file mode 100644
index 00000000000..cfabb3f2356
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysMetadataBase.cxx
@@ -0,0 +1,270 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BPhysMetadataBase.cxx
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+// - w.w., 2017-01-22: Added use of BPhysMetaDataTool.
+// - w.w., 2017-05-27: Removed use of BPhysMetaDataTool and
+// IOVDbMetaDataTool.
+// - w.w., 2019-12-05: Added long and vector<long> types
+//
+// Store JO metadata in the output file.
+//
+// It uses a FileMetaData object to store job option information
+// as metadata in a specific branch whose name needs to prefixed by
+// the derivation format name.
+//
+// This is a base class. Inherit from it to add the job options you want
+// to store. For a usage example, see
+// Bmumu_metadata.h / Bmumu_metadata.cxx
+// and
+// BPHY8.py .
+//
+// Job options provided by the base class:
+// - DerivationName -- assign the name of the derivation format
+// - MetadataFolderName -- assign the name of the metadata folder,
+// should start with the derivation format name,
+// defaults to DerivationName if not set.
+//
+//============================================================================
+//
+
+#include "DerivationFrameworkBPhys/BPhysMetadataBase.h"
+#include "xAODMetaData/FileMetaData.h"
+#include "xAODMetaData/FileMetaDataAuxInfo.h"
+
+namespace DerivationFramework {
+
+ //--------------------------------------------------------------------------
+ BPhysMetadataBase::BPhysMetadataBase(const std::string& t,
+ const std::string& n,
+ const IInterface* p)
+ : AthAlgTool(t,n,p),
+ m_outputMetaStore("StoreGateSvc/MetaDataStore", n) {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare derivation format name
+ declareProperty("DerivationName", m_derivationName = "_NOSUCHFORMAT_");
+
+ // Declare metadata folder name (should start with derivation name)
+ declareProperty("MetadataFolderName", m_mdFolderName = "_NONE_");
+
+ // Prefix would typically be the derivation format name
+ declareProperty("Prefix", m_prefix = "");
+
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysMetadataBase::initialize() {
+
+ ATH_MSG_DEBUG("BPhysMetaDataBase::initialize() -- begin");
+
+ // handle general prefix
+ if ( m_prefix == "" ) {
+ if ( m_derivationName == "_NOSUCHFORMAT_" ) {
+ m_prefix = name() +"_";
+ } else {
+ m_prefix = m_derivationName + "_";
+ }
+ }
+
+ CHECK( saveMetaDataBPhys() );
+
+ ATH_MSG_DEBUG("BPhysMetaDataBase::initialize() -- end");
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysMetadataBase::finalize() {
+
+ ATH_MSG_DEBUG("BPhysMetaDataBase::finalize()");
+
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysMetadataBase::addBranches() const {
+
+ // nothing to do here
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+#define SET_VALUES_IMP( TYPE, MAP ) \
+ for (auto const &ent : MAP) { \
+ fm->auxdata< TYPE >( m_prefix + ent.first ) = ent.second; \
+ }
+
+ StatusCode BPhysMetadataBase::saveMetaDataBPhys() const {
+
+ ATH_MSG_DEBUG("BPhysMetaDataBase::saveMetaDataBPhys() -- begin");
+
+ std::string mdFolderKey = buildFolderName() + "_MetaData";
+ // protection
+ if ( m_outputMetaStore->contains< xAOD::FileMetaData >( mdFolderKey ) ) {
+ ATH_MSG_WARNING("saveMetaDataBPhys2: "
+ "xAOD::FileMetaData already in output: "
+ << mdFolderKey
+ << " -- BPhys metadata will NOT be saved!");
+ } else {
+ // create a FileMetaData object
+ auto fm = std::make_unique< xAOD::FileMetaData >();
+ auto fmAux = std::make_unique< xAOD::FileMetaDataAuxInfo >();
+ fm->setStore( fmAux.get() );
+
+ // fill it
+ fm->auxdata< std::string >(m_prefix+"DerivationName" ) =
+ m_derivationName;
+ fm->auxdata< std::string >(m_prefix+"MetaDataFolderName") =
+ m_mdFolderName;
+
+ // fill it with contents of maps
+ SET_VALUES_IMP( int , m_propInt );
+ SET_VALUES_IMP( long , m_propLong );
+ SET_VALUES_IMP( double , m_propDouble );
+ SET_VALUES_IMP( bool , m_propBool );
+ SET_VALUES_IMP( std::string , m_propString );
+ SET_VALUES_IMP( std::vector<int> , m_propVInt );
+ SET_VALUES_IMP( std::vector<long> , m_propVLong );
+ SET_VALUES_IMP( std::vector<double> , m_propVDouble );
+ SET_VALUES_IMP( std::vector<bool> , m_propVBool );
+ SET_VALUES_IMP( std::vector<std::string>, m_propVString );
+
+ // record it
+ ATH_CHECK( m_outputMetaStore->record( std::move(fm), mdFolderKey ) );
+ ATH_CHECK( m_outputMetaStore->record( std::move(fmAux),
+ mdFolderKey+"Aux." ) );
+ }
+
+ return StatusCode::SUCCESS;
+ }
+#undef SET_VALUES_IMP
+ //--------------------------------------------------------------------------
+ std::string BPhysMetadataBase::buildFolderName(const std::string& fname) const {
+
+ std::string result = fname;
+ if ( m_mdFolderName != "_NONE_" && m_mdFolderName != "" ) {
+ result += m_mdFolderName;
+ } else {
+ if ( m_derivationName != "_NOSUCHFORMAT_" && m_derivationName != "" ) {
+ result += m_derivationName;
+ } else {
+ // default to the tool's name
+ result += name();
+ }
+ }
+ return result;
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyI(const std::string& name, int val) {
+ ATH_MSG_INFO("Calling recordProperty(int)");
+ declareProperty(name, m_propInt[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyL(const std::string& name, long val) {
+ ATH_MSG_INFO("Calling recordProperty(long)");
+ declareProperty(name, m_propLong[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyD(const std::string& name, double val) {
+ ATH_MSG_INFO("Calling recordProperty(double)");
+ declareProperty(name, m_propDouble[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyB(const std::string& name, bool val) {
+ ATH_MSG_INFO("Calling recordProperty(bool)");
+ declareProperty(name, m_propBool[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyS(const std::string& name, const std::string& val) {
+ ATH_MSG_INFO("Calling recordProperty(string)");
+ declareProperty(name, m_propString[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyVI(const std::string& name,
+ const std::vector<int>& val) {
+ ATH_MSG_INFO("Calling recordProperty(vector<int>)");
+ declareProperty(name, m_propVInt[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyVL(const std::string& name,
+ const std::vector<long>& val) {
+ ATH_MSG_INFO("Calling recordProperty(vector<long>)");
+ declareProperty(name, m_propVLong[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyVD(const std::string& name,
+ const std::vector<double>& val) {
+ ATH_MSG_INFO("Calling recordProperty(vector<double>)");
+ declareProperty(name, m_propVDouble[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyVB(const std::string& name,
+ const std::vector<bool>& val) {
+ ATH_MSG_INFO("Calling recordProperty(vector<bool>)");
+ declareProperty(name, m_propVBool[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ void BPhysMetadataBase::recordPropertyVS(const std::string& name,
+ const std::vector<std::string>& val) {
+ ATH_MSG_INFO("Calling recordProperty(vector<string>)");
+ declareProperty(name, m_propVString[name] = val);
+ }
+ //--------------------------------------------------------------------------
+ std::string BPhysMetadataBase::vecToString(const std::vector<int>& v) const {
+ std::string str("[");
+ for (unsigned int i=0; i<v.size(); ++i) {
+ str += std::to_string(v[i]);
+ if ( i < v.size()-1 ) str += ",";
+ }
+ str += "]";
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ std::string BPhysMetadataBase::vecToString(const std::vector<long>& v) const {
+ std::string str("[");
+ for (unsigned int i=0; i<v.size(); ++i) {
+ str += std::to_string(v[i]);
+ if ( i < v.size()-1 ) str += ",";
+ }
+ str += "]";
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ std::string BPhysMetadataBase::vecToString(const std::vector<double>& v) const {
+ std::string str("[");
+ for (unsigned int i=0; i<v.size(); ++i) {
+ str += std::to_string(v[i]);
+ if ( i < v.size()-1 ) str += ",";
+ }
+ str += "]";
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ std::string BPhysMetadataBase::vecToString(const std::vector<bool>& v) const {
+ std::string str("[");
+ for (unsigned int i=0; i<v.size(); ++i) {
+ str += std::to_string(v[i]);
+ if ( i < v.size()-1 ) str += ",";
+ }
+ str += "]";
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ std::string BPhysMetadataBase::vecToString(const std::vector<std::string>& v) const {
+ std::string str("[");
+ for (unsigned int i=0; i<v.size(); ++i) {
+ str += "'";
+ str += v[i];
+ str += "'";
+ if ( i < v.size()-1 ) str += ",";
+ }
+ str += "]";
+ return str;
+ }
+ //--------------------------------------------------------------------------
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVCascadeTools.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVCascadeTools.cxx
new file mode 100644
index 00000000000..09a3822d6d7
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVCascadeTools.cxx
@@ -0,0 +1,475 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "DerivationFrameworkBPhys/BPhysPVCascadeTools.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "TVector3.h"
+#include "DerivationFrameworkBPhys/BPhysPVTools.h"
+#include "TrkVKalVrtFitter/VxCascadeInfo.h"
+#include "DerivationFrameworkBPhys/LocalVector.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include "HepPDT/ParticleDataTable.hh"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+#include <limits>
+#include <iostream>
+
+DerivationFramework::BPhysPVCascadeTools::BPhysPVCascadeTools(const CascadeTools *cascadeTools) :
+ m_cascadeTools(cascadeTools), m_beamSpotData(nullptr), m_PV_minNTracks(0),
+ m_copyAllVertices(true)
+{
+}
+
+DerivationFramework::BPhysPVCascadeTools::BPhysPVCascadeTools(const CascadeTools *cascadeTools,
+ const InDet::BeamSpotData* beamSpotSvc) :
+ m_cascadeTools(cascadeTools), m_beamSpotData(beamSpotSvc), m_PV_minNTracks(0),
+ m_copyAllVertices(true)
+{
+}
+
+void DerivationFramework::BPhysPVCascadeTools::FillBPhysHelper(const std::vector<TLorentzVector> &mom, Amg::MatrixX cov, xAOD::BPhysHelper &vtx,
+ const xAOD::Vertex* PV, const xAOD::VertexContainer* PvContainer,
+ xAOD::BPhysHelper::pv_type pvtype, int refitCode) const {
+
+ BPHYS_CHECK( vtx.setPv ( PV, PvContainer, pvtype ) );
+
+ // cout << "BPhysPVCascadeTools::FillBPhysHelper for pvtype = " << pvtype << endl;
+ // cout << "lxy " << m_cascadeTools->lxy(mom, vtx.vtx(), PV) << " error " << m_cascadeTools->lxyError(mom, cov, vtx.vtx(), PV) << endl;
+
+ // set variables calculated from PV
+ BPHYS_CHECK( vtx.setLxy ( m_cascadeTools->lxy (mom, vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setLxyErr ( m_cascadeTools->lxyError (mom, cov, vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setA0 ( m_cascadeTools->a0 (mom, vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setA0Err ( m_cascadeTools->a0Error (mom, cov, vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setA0xy ( m_cascadeTools->a0xy (mom, vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setA0xyErr( m_cascadeTools->a0xyError (mom, cov, vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setZ0 ( m_cascadeTools->a0z (mom, vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setZ0Err ( m_cascadeTools->a0zError (mom, cov, vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setRefitPVStatus ( refitCode, pvtype ) );
+
+}
+
+void DerivationFramework::BPhysPVCascadeTools::ProcessVertex(const std::vector<TLorentzVector> &mom, Amg::MatrixX cov, xAOD::BPhysHypoHelper &vtx,
+ xAOD::BPhysHelper::pv_type pvtype, double mass) const {
+
+ const xAOD::Vertex* pv = vtx.pv(pvtype);
+ if (pv) {
+ // decorate the vertex.
+ vtx.setTau( m_cascadeTools->tau(mom, vtx.vtx(), pv), pvtype, xAOD::BPhysHypoHelper::TAU_INV_MASS );
+ vtx.setTauErr( m_cascadeTools->tauError(mom, cov, vtx.vtx(), pv), pvtype, xAOD::BPhysHypoHelper::TAU_INV_MASS );
+ // Proper decay time assuming constant mass hypothesis
+ vtx.setTau( m_cascadeTools->tau(mom, vtx.vtx(), pv, mass), pvtype, xAOD::BPhysHypoHelper::TAU_CONST_MASS );
+ vtx.setTauErr( m_cascadeTools->tauError(mom, cov, vtx.vtx(), pv, mass), pvtype, xAOD::BPhysHypoHelper::TAU_CONST_MASS );
+ //enum pv_type {PV_MAX_SUM_PT2, PV_MIN_A0, PV_MIN_Z0, PV_MIN_Z0_BA};
+ } else {
+ const float errConst = -9999999.;
+ BPHYS_CHECK( vtx.setTau( errConst, pvtype, xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+ BPHYS_CHECK( vtx.setTauErr( errConst, pvtype, xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+ BPHYS_CHECK( vtx.setTau(errConst, pvtype, xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+ BPHYS_CHECK( vtx.setTauErr( errConst, pvtype, xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+ }
+
+}
+
+void DerivationFramework::BPhysPVCascadeTools::FillBPhysHelperNULL(xAOD::BPhysHelper &vtx,
+ const xAOD::VertexContainer* PvContainer,
+ xAOD::BPhysHelper::pv_type pvtype) {
+ DerivationFramework::BPhysPVTools::FillBPhysHelperNULL(vtx, PvContainer, pvtype);
+}
+
+size_t DerivationFramework::BPhysPVCascadeTools::FindLowZIndex(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &Obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks) const {
+ size_t lowZ = 0;
+ if(PVlist.empty()) {
+ lowZ=std::numeric_limits<std::size_t>::max();
+ return lowZ;
+ }
+ size_t size = PVlist.size();
+ double lowA0zcalc = fabs(m_cascadeTools->a0z (mom, Obj.vtx(), PVlist[0]));
+ for(size_t i =1; i<size; i++) {
+ if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
+ double a0z = fabs(m_cascadeTools->a0z(mom, Obj.vtx(), PVlist[i]));
+ if(a0z < lowA0zcalc) {
+ lowA0zcalc = a0z;
+ lowZ =i;
+ }
+ }
+ }
+ return lowZ;
+}
+
+size_t DerivationFramework::BPhysPVCascadeTools::FindHighPtIndex(const std::vector<const xAOD::Vertex*> &PVlist) {
+ return DerivationFramework::BPhysPVTools::FindHighPtIndex(PVlist);
+}
+
+size_t DerivationFramework::BPhysPVCascadeTools::FindLowA0Index(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &Obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks) const {
+ size_t lowA0 = 0;
+ if(PVlist.empty()) {
+ lowA0=std::numeric_limits<std::size_t>::max();
+ return lowA0;
+ }
+ size_t size = PVlist.size();
+ double lowA0calc = m_cascadeTools->a0(mom, Obj.vtx(), PVlist[0]);
+ for(size_t i =1; i<size; i++) {
+ if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
+ double a0 = m_cascadeTools->a0(mom, Obj.vtx(), PVlist[i]);
+ if(a0 < lowA0calc) {
+ lowA0calc = a0;
+ lowA0 =i;
+ }
+ }
+ }
+ return lowA0;
+}
+
+std::vector<const xAOD::Vertex*> DerivationFramework::BPhysPVCascadeTools::GetGoodPV(const xAOD::VertexContainer* pvContainer) {
+ typedef xAOD::VxType::VertexType VertexType;
+ VertexType Pvtx = xAOD::VxType::PriVtx;
+ VertexType Pileupvtx = xAOD::VxType::PileUp;
+ std::vector<const xAOD::Vertex*> goodPrimaryVertices;
+ goodPrimaryVertices.reserve(pvContainer->size());
+
+ for (auto ptr = pvContainer->begin(); ptr!= pvContainer->end(); ++ptr) {
+ VertexType thistype = (*ptr)->vertexType();
+ if ( thistype == Pileupvtx || thistype == Pvtx ) {
+ goodPrimaryVertices.push_back(*ptr);
+ } else {
+// cout << "vertex type " << thistype << endl;
+ }
+ }
+ return goodPrimaryVertices;
+}
+//-----------------------------------------------------------------------------
+//
+void DerivationFramework::BPhysPVCascadeTools::SetMinNTracksInPV(size_t PV_minNTracks)
+{
+
+ m_PV_minNTracks = PV_minNTracks;
+}
+//-----------------------------------------------------------------------------
+//
+const Amg::Vector3D& DerivationFramework::BPhysPVCascadeTools::GetBeamSpot() const noexcept {
+ if(m_beamSpotData) return m_beamSpotData->beamPos();
+ else {
+ static const Amg::Vector3D defaultBS(-10000.,-10000.,-10000.);
+ return defaultBS;
+ }
+}
+//-----------------------------------------------------------------------------
+//
+size_t DerivationFramework::BPhysPVCascadeTools::FindLowZ0BAIndex(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks) const {
+
+ size_t ilowZ0BA = std::numeric_limits<std::size_t>::max();
+ double lowZ0BAcalc = std::numeric_limits<double>::max();
+ for (size_t i = 0; i<PVlist.size(); ++i) {
+ if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
+ double z0BA = m_cascadeTools->a0(mom, obj.vtx(), PVlist[i]);
+ if (z0BA < lowZ0BAcalc) {
+ lowZ0BAcalc = z0BA;
+ ilowZ0BA = i;
+ }
+ }
+ }
+ return ilowZ0BA;
+}
+//-----------------------------------------------------------------------------
+//
+double DerivationFramework::BPhysPVCascadeTools::DistInZtoDOCA(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper &obj, const xAOD::Vertex* vertex) const {
+
+ Amg::Vector3D pv = vertex->position();
+ Amg::Vector3D xDOCA = DocaExtrapToBeamSpot(mom, obj);
+ Amg::Vector3D vec = pv - xDOCA;
+ return vec.z();
+}
+//-----------------------------------------------------------------------------
+//
+Amg::Vector3D DerivationFramework::BPhysPVCascadeTools::DocaExtrapToBeamSpot(const std::vector<TLorentzVector> &mom, const xAOD::BPhysHelper& obj) const {
+
+ Amg::Vector3D xDOCA(-99999., -99999., -99999.);
+ TLorentzVector totalMom;
+ unsigned int NTrk = mom.size();
+ for( unsigned int it=0; it<NTrk; it++) totalMom += mom[it];
+ TVector3 totP = totalMom.Vect();
+ Amg::Vector3D pSV(totP.X(), totP.Y(), totP.Z());
+ Amg::Vector3D pT(pSV.x(), pSV.y(), 0.);
+ if ( pT.mag2() > 0 ) {
+ Amg::Vector3D xBS = GetBeamSpot();
+ Amg::Vector3D xSV = obj.vtx()->position();
+ Amg::Vector3D xT(xSV.x()-xBS.x(), xSV.y()-xBS.y(), 0.);
+ xDOCA = xSV - pSV*pT.dot(xT)/pT.mag2();
+ } else {
+ std::cout << "BPhysPVCascadeTools::DocaExtrapToBeamSpot: WARNING pT == 0."
+ << std::endl;
+ }
+ return xDOCA;
+}
+
+void DerivationFramework::BPhysPVCascadeTools::PrepareVertexLinks(Trk::VxCascadeInfo *result, const xAOD::TrackParticleContainer* importedTrackCollection)
+{
+ auto &collection = result->vertices();
+ for(auto v : collection)
+ {
+ std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
+ for(unsigned int i=0; i< v->trackParticleLinks().size(); i++)
+ {
+ ElementLink<DataVector<xAOD::TrackParticle> > mylink=v->trackParticleLinks()[i]; // makes a copy (non-const)
+ mylink.setStorableObject(*importedTrackCollection, true);
+ newLinkVector.push_back( mylink );
+ }
+ v->clearTracks();
+ v->setTrackParticleLinks( newLinkVector );
+ }
+}
+
+std::vector<const xAOD::TrackParticle*> DerivationFramework::BPhysPVCascadeTools::CollectAllChargedTracks(const std::vector<xAOD::Vertex*> &cascadeVertices)
+{
+ std::vector<const xAOD::TrackParticle*> exclTrk;
+ for( size_t jt=0; jt<cascadeVertices.size(); jt++) {
+ for( size_t it=0; it<cascadeVertices[jt]->vxTrackAtVertex().size(); it++) {
+ if(cascadeVertices[jt]->trackParticle(it)->charge() != 0) exclTrk.push_back(cascadeVertices[jt]->trackParticle(it));
+ }
+ }
+ return exclTrk;
+}
+
+StatusCode DerivationFramework::BPhysPVCascadeTools::FillCandwithRefittedVertices( bool refitPV,
+ const xAOD::VertexContainer* pvContainer, xAOD::VertexContainer* refPvContainer,
+ const Analysis::PrimaryVertexRefitter *pvRefitter, size_t in_PV_max, int DoVertexType,
+ Trk::VxCascadeInfo* casc, int index,
+ double mass, xAOD::BPhysHypoHelper &vtx)
+{
+ const std::vector<TLorentzVector> &mom = casc->getParticleMoms()[index];
+ const Amg::MatrixX &cov = casc->getCovariance()[index];
+ const std::vector<xAOD::Vertex*> &cascadeVertices = casc->vertices();
+ const bool doPt = (DoVertexType & 1) != 0;
+ const bool doA0 = (DoVertexType & 2) != 0;
+ const bool doZ0 = (DoVertexType & 4) != 0;
+ const bool doZ0BA = (DoVertexType & 8) != 0;
+
+ // Collect the tracks that should be excluded from the PV
+ std::vector<const xAOD::TrackParticle*> exclTrk = CollectAllChargedTracks(cascadeVertices);
+
+
+ const std::vector<const xAOD::Vertex*> GoodPVs = GetGoodPV(pvContainer);
+ // 2) PV dependent variables
+ if (GoodPVs.empty() == false) {
+ if (refitPV) {
+ size_t pVmax =std::min((size_t)in_PV_max, GoodPVs.size());
+ std::vector<const xAOD::Vertex*> refPVvertexes;
+ std::vector<const xAOD::Vertex*> refPVvertexes_toDelete;
+ std::vector<int> exitCode;
+ refPVvertexes.reserve(pVmax);
+ refPVvertexes_toDelete.reserve(pVmax);
+ exitCode.reserve(pVmax);
+
+ // Refit the primary vertex and set the related decorations.
+
+ for (size_t i =0; i < pVmax ; i++) {
+ const xAOD::Vertex* oldPV = GoodPVs.at(i);
+ // when set to false this will return null when a new vertex is not required
+// ATH_MSG_DEBUG("old PV x " << oldPV->x() << " y " << oldPV->y() << " z " << oldPV->z());
+ int exitcode = 0;
+ const xAOD::Vertex* refPV = pvRefitter->refitVertex(oldPV, exclTrk, m_copyAllVertices, &exitcode);
+// if (refPV) ATH_MSG_DEBUG("ref PV x " << refPV->x() << " y " << refPV->y() << " z " << refPV->z());
+ exitCode.push_back(exitcode);
+ // we want positioning to match the goodPrimaryVertices
+ if (refPV == nullptr) {
+ refPVvertexes.push_back(oldPV);
+ refPVvertexes_toDelete.push_back(nullptr);
+ } else {
+ refPVvertexes.push_back(refPV);
+ refPVvertexes_toDelete.push_back(refPV);
+ }
+ }
+ LocalVector<size_t, 4> indexesUsed;
+ LocalVector<std::pair<size_t, xAOD::BPhysHelper::pv_type>, 4> indexestoProcess;
+
+ if(doPt){
+ indexestoProcess.push_back(std::make_pair
+ (FindHighPtIndex(refPVvertexes), xAOD::BPhysHelper::PV_MAX_SUM_PT2));
+ }
+ if(doA0) {
+ indexestoProcess.push_back(std::make_pair( FindLowA0Index(mom, vtx, refPVvertexes, m_PV_minNTracks),
+ xAOD::BPhysHelper::PV_MIN_A0));
+ }
+ if(doZ0) {
+ indexestoProcess.push_back(std::make_pair(FindLowZIndex(mom, vtx, refPVvertexes, m_PV_minNTracks),
+ xAOD::BPhysHelper::PV_MIN_Z0));
+ }
+ if(doZ0BA) {
+ size_t lowZBA = FindLowZ0BAIndex(mom, vtx, refPVvertexes, m_PV_minNTracks);
+ if( lowZBA < pVmax ) {
+ indexestoProcess.push_back(std::make_pair(lowZBA, xAOD::BPhysHelper::PV_MIN_Z0_BA));
+ }
+ else FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
+ }
+
+ for(size_t i =0 ; i<indexestoProcess.size(); i++){
+ //if refitted add to refitted container
+ auto index = indexestoProcess[i].first;
+ auto pvtype = indexestoProcess[i].second;
+ const xAOD::VertexContainer* ParentContainer =
+ (refPVvertexes_toDelete.at(index)) ? refPvContainer : pvContainer;
+ if(ParentContainer == refPvContainer && !indexesUsed.contains(index)) {
+ // store the new vertex
+ refPvContainer->push_back(const_cast<xAOD::Vertex*>(refPVvertexes.at(index)));
+ indexesUsed.push_back(index);
+ }
+ FillBPhysHelper(mom, cov, vtx, refPVvertexes[index],
+ ParentContainer, pvtype, exitCode[index]);
+ vtx.setOrigPv(GoodPVs[index], pvContainer, pvtype);
+ }
+ //nullify ptrs we want to keep so these won't get deleted
+ //"delete null" is valid in C++ and does nothing so this is quicker than a lot of if statements
+ for(size_t x : indexesUsed) refPVvertexes_toDelete[x] = nullptr;
+ //Loop over toDELETE container, anything that is used or was not refitted is null
+ //This cleans up all extra vertices that were created and not used
+ for(const xAOD::Vertex* ptr : refPVvertexes_toDelete) delete ptr;
+ refPVvertexes.clear(); // Clear lists of now dangling ptrs
+ refPVvertexes_toDelete.clear();
+ exitCode.clear();
+
+ } else {
+ // 2.a) the first PV with the largest sum pT.
+ if(doPt) {
+ size_t highPtindex = FindHighPtIndex(GoodPVs); // Should be 0 in PV ordering
+ FillBPhysHelper(mom, cov, vtx, GoodPVs[highPtindex], pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, 0);
+ }
+ // 2.b) the closest in 3D:
+ if(doA0) {
+ size_t lowA0 = FindLowA0Index(mom, vtx, GoodPVs, m_PV_minNTracks);
+ FillBPhysHelper(mom, cov, vtx, GoodPVs[lowA0], pvContainer, xAOD::BPhysHelper::PV_MIN_A0, 0);
+ }
+ // 2.c) the closest in Z:
+ if(doZ0) {
+ size_t lowZ = FindLowZIndex(mom, vtx, GoodPVs, m_PV_minNTracks);
+ FillBPhysHelper(mom, cov, vtx, GoodPVs[lowZ], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, 0);
+ }
+ // 2.d) the closest in Z (DOCA w.r.t. beam axis):
+ if(doZ0BA) {
+ size_t lowZBA = FindLowZ0BAIndex(mom, vtx, GoodPVs, m_PV_minNTracks);
+ if ( lowZBA < GoodPVs.size() ) { // safety against vector index out-of-bounds
+ FillBPhysHelper(mom, cov, vtx, GoodPVs[lowZBA], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
+ } else {
+ // nothing found -- fill NULL
+ FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
+ }
+ }
+ } // refitPV
+ } else {
+
+ if(pvContainer->empty()) return StatusCode::FAILURE;
+ const xAOD::Vertex* Dummy = pvContainer->at(0);
+
+ // 2.a) the first PV with the largest sum pT.
+ if(doPt) {
+ FillBPhysHelper(mom, cov, vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, 0);
+ if(refitPV) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
+ }
+ // 2.b) the closest in 3D:
+ if(doA0) {
+ FillBPhysHelper(mom, cov, vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_A0, 0);
+ if(refitPV) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_A0);
+ }
+ // 2.c) the closest in Z:
+ if(doZ0) {
+ FillBPhysHelper(mom, cov, vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, 0);
+ if(refitPV) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0);
+ }
+ // 2.d) the closest in Z (DOCA w.r.t. beam axis):
+ if(doZ0BA) {
+ FillBPhysHelper(mom, cov, vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
+ if(refitPV) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
+ }
+ } // GoodPVs.empty()
+
+ // 3) proper decay time and error:
+ // retrieve the refitted PV (or the original one, if the PV refitting was turned off)
+ if(doPt) ProcessVertex(mom, cov, vtx, xAOD::BPhysHelper::PV_MAX_SUM_PT2, mass);
+ if(doA0) ProcessVertex(mom, cov, vtx, xAOD::BPhysHelper::PV_MIN_A0, mass);
+ if(doZ0) ProcessVertex(mom, cov, vtx, xAOD::BPhysHelper::PV_MIN_Z0, mass);
+ if(doZ0BA) ProcessVertex(mom, cov, vtx, xAOD::BPhysHelper::PV_MIN_Z0_BA, mass);
+
+ return StatusCode::SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+
+void DerivationFramework::BPhysPVCascadeTools::SetVectorInfo(xAOD::BPhysHelper &vtx, const Trk::VxCascadeInfo* casc){
+
+ const std::vector< std::vector<TLorentzVector> > &moms = casc->getParticleMoms();
+ const std::vector<xAOD::Vertex*> &cascadeVertices = casc->vertices();
+ // Get refitted track momenta from all vertices, charged tracks only
+ std::vector<float> px;
+ std::vector<float> py;
+ std::vector<float> pz;
+ for( size_t jt=0; jt<moms.size(); jt++) {
+ for( size_t it=0; it<cascadeVertices[jt]->vxTrackAtVertex().size(); it++) {
+ px.push_back( moms[jt][it].Px() );
+ py.push_back( moms[jt][it].Py() );
+ pz.push_back( moms[jt][it].Pz() );
+ }
+ }
+ vtx.setRefTrks(std::move(px),std::move(py),std::move(pz));
+
+}
+
+bool DerivationFramework::BPhysPVCascadeTools::uniqueCollection(const std::vector<const xAOD::TrackParticle*>&col){
+ for(auto p : col){
+ if(std::count(col.begin(), col.end(), p) > 1) return false;
+ }
+ return true;
+}
+
+bool DerivationFramework::BPhysPVCascadeTools::uniqueCollection(const std::vector<const xAOD::TrackParticle*>&col1, const std::vector<const xAOD::TrackParticle*>&col2){
+ for(auto p : col1){
+ if((std::count(col1.begin(), col1.end(), p) + std::count(col2.begin(), col2.end(), p)) > 1) return false;
+ }
+ for(auto p : col2){
+ if((std::count(col1.begin(), col1.end(), p) + std::count(col2.begin(), col2.end(), p)) > 1) return false;
+ }
+ return true;
+}
+
+bool DerivationFramework::BPhysPVCascadeTools::LinkVertices(SG::AuxElement::Decorator<VertexLinkVector> &decor, const std::vector<const xAOD::Vertex*>& vertices,
+ const xAOD::VertexContainer* vertexContainer, const xAOD::Vertex* vert){
+ // create tmp vector of preceding vertex links
+ VertexLinkVector precedingVertexLinks;
+
+ // loop over input precedingVertices
+ auto precedingVerticesItr = vertices.begin();
+ for(; precedingVerticesItr!=vertices.end(); ++precedingVerticesItr) {
+ // sanity check 1: protect against null pointers
+ if( !(*precedingVerticesItr) )
+ return false;
+
+ // create element link
+ VertexLink vertexLink;
+ vertexLink.setElement(*precedingVerticesItr);
+ vertexLink.setStorableObject(*vertexContainer);
+
+ // sanity check 2: is the link valid?
+ if( !vertexLink.isValid() )
+ return false;
+
+ // link is OK, store it in the tmp vector
+ precedingVertexLinks.push_back( vertexLink );
+
+ } // end of loop over preceding vertices
+
+ // all OK: store preceding vertex links in the aux store
+ decor(*vert) = precedingVertexLinks;
+ return true;
+}
+
+double DerivationFramework::BPhysPVCascadeTools::getParticleMass(const HepPDT::ParticleDataTable* pdt, int pdgcode){
+ auto ptr = pdt->particle( pdgcode );
+ return ptr ? ptr->mass() : 0.;
+}
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVThinningTool.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVThinningTool.cxx
new file mode 100644
index 00000000000..33e5030c830
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVThinningTool.cxx
@@ -0,0 +1,134 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/////////////////////////////////////////////////////////////////
+// ThinningToolExample.cxx
+///////////////////////////////////////////////////////////////////
+// Author: James Catmore (James.Catmore@cern.ch)
+// This is a trivial example of an implementation of a thinning tool
+// which removes all ID tracks which do not pass a user-defined cut
+
+#include "DerivationFrameworkBPhys/BPhysPVThinningTool.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/TrackParticle.h"
+#include "StoreGate/ThinningHandle.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "StoreGate/ThinningHandle.h"
+#include <algorithm>
+#include <numeric>
+#include <vector>
+#include <string>
+
+using namespace std;
+using namespace xAOD;
+// Constructor
+DerivationFramework::BPhysPVThinningTool::BPhysPVThinningTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p ) :
+ AthAlgTool(t,n,p),
+ m_TrackContainerName("InDetTrackParticles"),
+ m_PVContainerName("PrimaryVertices"),
+ m_ntot(0),
+ m_npass(0), m_tracks_kept(0), m_keepTracks(false)
+{
+ declareInterface<DerivationFramework::IThinningTool>(this);
+ declareProperty("CandidateCollections" , m_BPhyCandList);
+ declareProperty("KeepPVTracks", m_keepTracks);
+ declareProperty("TrackParticleContainerName", m_TrackContainerName);
+ declareProperty("PrimaryVertexContainerName", m_PVContainerName);
+}
+
+// Destructor
+DerivationFramework::BPhysPVThinningTool::~BPhysPVThinningTool() {
+}
+
+// Athena initialize and finalize
+StatusCode DerivationFramework::BPhysPVThinningTool::initialize()
+{
+ ATH_MSG_VERBOSE("initialize() ...");
+ ATH_CHECK(m_BPhyCandList.initialize());
+ if(not m_TrackContainerName.key().empty()) ATH_CHECK(m_TrackContainerName.initialize(m_streamName));
+ ATH_CHECK(m_PVContainerName.initialize(m_streamName));
+
+ return StatusCode::SUCCESS;
+}
+StatusCode DerivationFramework::BPhysPVThinningTool::finalize()
+{
+ ATH_MSG_VERBOSE("finalize() ...");
+ ATH_MSG_INFO("Processed "<< m_ntot <<" PV, "<< m_npass<< " were retained ");
+ if(m_keepTracks) ATH_MSG_INFO("Additional tracks kept " << m_tracks_kept);
+ return StatusCode::SUCCESS;
+}
+
+// The thinning itself
+StatusCode DerivationFramework::BPhysPVThinningTool::doThinning() const
+{
+
+ // Get the track container
+ SG::ThinningHandle<xAOD::VertexContainer> PV_col(m_PVContainerName);
+ if(!PV_col.isValid()) {
+ ATH_MSG_ERROR ("Couldn't retrieve VertexContainer with key PrimaryVertices");
+ return StatusCode::FAILURE;
+ }
+ m_ntot+=PV_col->size();
+ // Loop over tracks, see if they pass, set mask
+ std::vector<bool> mask(PV_col->size(), false);
+
+ BPhysHelper::pv_type pvtypes[] = {BPhysHelper::PV_MAX_SUM_PT2,
+ BPhysHelper::PV_MIN_A0,
+ BPhysHelper::PV_MIN_Z0,
+ BPhysHelper::PV_MIN_Z0_BA};
+
+
+
+ for(auto &str : m_BPhyCandList) {
+ SG::ReadHandle<xAOD::VertexContainer> Container(str);
+ ATH_CHECK(Container.isValid());
+ size_t s = Container->size();
+ for(size_t i = 0; i<s; i++) {
+ xAOD::BPhysHelper vtx(Container->at(i));
+
+ for(size_t i =0; i < 4; i++) {
+ const xAOD::Vertex* origPv = vtx.origPv(pvtypes[i]);
+ if(origPv==nullptr) continue;
+ auto pvit = std::find (PV_col->begin(), PV_col->end(), origPv);
+ if(pvit == PV_col->end()) {
+ ATH_MSG_WARNING("PV not found in container");
+ continue;
+ }
+ size_t x = std::distance(PV_col->begin(), pvit);
+ mask.at(x) = true;
+ }
+
+ }
+ }
+
+ m_npass += std::accumulate(mask.begin(), mask.end(), 0);
+
+ if(m_keepTracks){
+ SG::ThinningHandle<xAOD::TrackParticleContainer> importedTrackParticles(m_TrackContainerName);
+ std::vector<bool> trackmask(importedTrackParticles->size(), false);
+ size_t pvnum = mask.size();
+ for(size_t i =0; i<pvnum;i++){
+ if(mask[i] == false) continue;
+ auto vtx = PV_col->at(i);
+ size_t s = vtx->nTrackParticles();
+ for(size_t j=0;j<s;j++){
+ auto trackit = std::find(importedTrackParticles->begin(), importedTrackParticles->end(), vtx->trackParticle(j));
+ if(trackit == importedTrackParticles->end()){
+ ATH_MSG_WARNING("track not found in container");
+ continue;
+ }
+ size_t x = std::distance(importedTrackParticles->begin(), trackit);
+ trackmask.at(x) = true;
+ }
+ }
+ importedTrackParticles.keep(trackmask, SG::ThinningHandleBase::Op::Or);
+ m_tracks_kept += std::accumulate(trackmask.begin(), trackmask.end(), 0);
+ }
+ PV_col.keep(mask, SG::ThinningHandleBase::Op::Or);
+
+ return StatusCode::SUCCESS;
+}
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVTools.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVTools.cxx
new file mode 100644
index 00000000000..6bb75c4d31d
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysPVTools.cxx
@@ -0,0 +1,545 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "DerivationFrameworkBPhys/BPhysPVTools.h"
+#include "xAODTracking/VertexContainer.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include "TVector3.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+
+#include <limits>
+#include <iostream>
+#include <cmath>
+using namespace std;
+
+DerivationFramework::BPhysPVTools::BPhysPVTools(const Trk::V0Tools *v0Tools) :
+ m_v0Tools(v0Tools), m_beamSpotData(nullptr), m_PV_minNTracks(0),
+ m_3dCalc(false)
+{
+}
+
+DerivationFramework::BPhysPVTools::BPhysPVTools(const Trk::V0Tools *v0Tools, const InDet::BeamSpotData *beamSpotSvc) :
+ m_v0Tools(v0Tools), m_beamSpotData(beamSpotSvc), m_PV_minNTracks(0),
+ m_3dCalc(false)
+{
+}
+
+void DerivationFramework::BPhysPVTools::FillBPhysHelper(xAOD::BPhysHelper &vtx,
+ const xAOD::Vertex* PV, const xAOD::VertexContainer* PvContainer,
+ xAOD::BPhysHelper::pv_type pvtype, int refitCode) const {
+
+ BPHYS_CHECK( vtx.setPv ( PV, PvContainer, pvtype ) );
+
+ // cout << "BPhysPVTools::FillBPhysHelper for pvtype = " << pvtype << endl;
+
+ // set variables calculated from PV
+ if(m_3dCalc){
+ BPHYS_CHECK( vtx.setLxyz ( m_v0Tools->lxyz (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setLxyzErr ( m_v0Tools->lxyzError (vtx.vtx(), PV), pvtype ) );
+ }
+ BPHYS_CHECK( vtx.setLxy ( m_v0Tools->lxy (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setLxyErr ( m_v0Tools->lxyError (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setA0 ( m_v0Tools->a0 (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setA0Err ( m_v0Tools->a0Error (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setA0xy ( m_v0Tools->a0xy (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setA0xyErr( m_v0Tools->a0xyError (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setZ0 ( m_v0Tools->a0z (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setZ0Err ( m_v0Tools->a0zError (vtx.vtx(), PV), pvtype ) );
+ BPHYS_CHECK( vtx.setRefitPVStatus ( refitCode, pvtype ) );
+
+}
+
+void DerivationFramework::BPhysPVTools::FillBPhysHelperNULL(xAOD::BPhysHelper &vtx,
+ const xAOD::VertexContainer* PvContainer,
+ xAOD::BPhysHelper::pv_type pvtype, bool do3d) {
+ const xAOD::Vertex* PV = nullptr;
+ BPHYS_CHECK( vtx.setPv ( PV, PvContainer, pvtype ) );
+ constexpr float errConst = std::numeric_limits<float>::lowest();
+ // set variables claculated from PV
+ if(do3d){
+ BPHYS_CHECK( vtx.setLxyz ( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setLxyzErr ( errConst, pvtype ) );
+ }
+ BPHYS_CHECK( vtx.setLxy ( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setLxyErr ( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setA0 ( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setA0Err ( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setA0xy ( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setA0xyErr( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setZ0 ( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setZ0Err ( errConst, pvtype ) );
+ BPHYS_CHECK( vtx.setRefitPVStatus ( 0, pvtype ) );
+}
+
+size_t DerivationFramework::BPhysPVTools::FindLowZIndex(const xAOD::BPhysHelper &Obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks) const {
+ size_t lowZ = 0;
+ if(PVlist.empty()) {
+ lowZ=std::numeric_limits<std::size_t>::max();
+ return lowZ;
+ }
+ size_t size = PVlist.size();
+ double lowA0zcalc = fabs(m_v0Tools->a0z (Obj.vtx(), PVlist[0]));
+ for(size_t i =1; i<size; i++) {
+ if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
+ double a0z = fabs(m_v0Tools->a0z(Obj.vtx(), PVlist[i]));
+ if(a0z < lowA0zcalc) {
+ lowA0zcalc = a0z;
+ lowZ =i;
+ }
+ }
+ }
+ return lowZ;
+}
+
+void DerivationFramework::BPhysPVTools::DecorateWithDummyVertex(xAOD::VertexContainer* vtxContainer,
+ const xAOD::VertexContainer* pvContainer, const xAOD::Vertex* Dummy,
+ int DoVertexType, const bool SetOrignal) const {
+ const bool doPt = (DoVertexType & 1) != 0;
+ const bool doA0 = (DoVertexType & 2) != 0;
+ const bool doZ0 = (DoVertexType & 4) != 0;
+ const bool doZ0BA = (DoVertexType & 8) != 0;
+
+ xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
+ for(; vtxItr!=vtxContainer->end(); ++vtxItr) {
+ xAOD::BPhysHelper vtx(*vtxItr);
+
+ // 1) pT error
+ double ptErr = m_v0Tools->pTError( vtx.vtx() );
+ BPHYS_CHECK( vtx.setPtErr(ptErr) );
+ if(doPt) {
+ // 2.a) the first PV with the largest sum pT.
+ FillBPhysHelper(vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, 0);
+ if(SetOrignal) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
+ }
+
+ if(doA0) {
+ // 2.b) the closest in 3D:
+ FillBPhysHelper(vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_A0, 0);
+ if(SetOrignal) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_A0);
+ }
+
+ if(doZ0) {
+ FillBPhysHelper(vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, 0);
+ if(SetOrignal) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0);
+ }
+
+ if(doZ0BA) {
+ FillBPhysHelper(vtx, Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
+ if(SetOrignal) vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
+ }
+ }
+}
+
+void DerivationFramework::BPhysPVTools::DecorateWithNULL(xAOD::VertexContainer* vtxContainer,
+ const xAOD::VertexContainer* pvContainer, int DoVertexType) const {
+ const bool doPt = (DoVertexType & 1) != 0;
+ const bool doA0 = (DoVertexType & 2) != 0;
+ const bool doZ0 = (DoVertexType & 4) != 0;
+ const bool doZ0BA = (DoVertexType & 8) != 0;
+ xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
+ for(; vtxItr!=vtxContainer->end(); ++vtxItr) {
+ xAOD::BPhysHelper vtx(*vtxItr);
+
+ // 1) pT error
+ double ptErr = m_v0Tools->pTError( vtx.vtx() );
+ BPHYS_CHECK( vtx.setPtErr(ptErr) );
+ if(doPt) {
+ // 2.a) the first PV with the largest sum pT.
+ FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, m_3dCalc);
+ }
+
+ if(doA0) {
+ // 2.b) the closest in 3D:
+ FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_A0, m_3dCalc);
+ }
+
+ if(doZ0) {
+ FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, m_3dCalc);
+ }
+ if(doZ0BA) {
+ FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, m_3dCalc);
+ }
+ }
+}
+
+StatusCode DerivationFramework::BPhysPVTools::FillCandExistingVertices(xAOD::VertexContainer* vtxContainer,
+ const xAOD::VertexContainer* pvContainer, int DoVertexType) {
+
+
+
+ //----------------------------------------------------
+ // decorate the vertex
+ //----------------------------------------------------
+ // loop over candidates -- Don't apply PV_minNTracks requirement here
+ // because it may result in exclusion of the high-pt PV.
+ const std::vector<const xAOD::Vertex*> GoodPVs = GetGoodPV(pvContainer);
+
+
+ if(GoodPVs.empty() == false) {
+
+ const bool doPt = (DoVertexType & 1) != 0;
+ const bool doA0 = (DoVertexType & 2) != 0;
+ const bool doZ0 = (DoVertexType & 4) != 0;
+ const bool doZ0BA = (DoVertexType & 8) != 0;
+
+ xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
+ for(; vtxItr!=vtxContainer->end(); ++vtxItr) {
+ xAOD::BPhysHelper vtx(*vtxItr);
+
+ // 1) pT error
+ double ptErr = m_v0Tools->pTError( vtx.vtx() );
+ BPHYS_CHECK( vtx.setPtErr(ptErr) );
+
+ // 2) refit the primary vertex and set the related decorations.
+ if(doPt) {
+ size_t highPtindex = FindHighPtIndex(GoodPVs); //Should be 0 in PV ordering
+ // 2.a) the first PV with the largest sum pT.
+ FillBPhysHelper(vtx, GoodPVs[highPtindex], pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, 0);
+ }
+
+ if(doA0) {
+ // 2.b) the closest in 3D:
+ size_t lowA0 = FindLowA0Index(vtx, GoodPVs, m_PV_minNTracks);
+ FillBPhysHelper(vtx, GoodPVs[lowA0], pvContainer, xAOD::BPhysHelper::PV_MIN_A0, 0);
+ }
+
+ if(doZ0) {
+ size_t lowZ = FindLowZIndex(vtx, GoodPVs, m_PV_minNTracks);
+ FillBPhysHelper(vtx, GoodPVs[lowZ], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0, 0);
+ }
+
+ if(doZ0BA) {
+ size_t lowZBA = FindLowZ0BAIndex(vtx, GoodPVs, m_PV_minNTracks);
+ if ( lowZBA < GoodPVs.size() ) { // safety against vector index out-of-bounds
+ FillBPhysHelper(vtx, GoodPVs[lowZBA], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
+ } else {
+ // nothing found -- fill nullptr
+ FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, m_3dCalc);
+ }
+ }
+
+ }// end of loop over vertices
+ } //end of check for vertices
+ else {
+ // cout << "Warning: DerivationFramework::BPhysPVTools::FillCandExistingVertices No Primary Vertices Found trying to decorate wilth dummy \n";
+ if(pvContainer->empty()) return StatusCode::FAILURE;
+ const xAOD::Vertex* dummy = pvContainer->at(0); //No good vertices so last vertex must be dummy
+ DecorateWithDummyVertex(vtxContainer, pvContainer, dummy, DoVertexType, false);
+ }
+ return StatusCode::SUCCESS;
+}
+
+
+StatusCode DerivationFramework::BPhysPVTools::FillCandwithRefittedVertices(xAOD::VertexContainer* vtxContainer,
+ const xAOD::VertexContainer* pvContainer, xAOD::VertexContainer* refPvContainer,
+ const Analysis::PrimaryVertexRefitter *pvRefitter, size_t in_PV_max, int DoVertexType) {
+
+
+ //----------------------------------------------------
+ // decorate the vertex
+ //----------------------------------------------------
+ // loop over candidates -- Don't apply PV_minNTracks requirement here
+ // because it may result in exclusion of the high-pt PV.
+ std::vector<const xAOD::Vertex*> goodPrimaryVertices = GetGoodPV(pvContainer);
+
+ /*
+ cout << "BPhysPVTools::FillCandwithRefittedVertices: #PVs: all: "
+ << pvContainer->size() << " ref: " << refPvContainer->size()
+ << " good: " << goodPrimaryVertices.size()
+ << " PV_minNTracks: " << m_PV_minNTracks << endl;
+ */
+ if(goodPrimaryVertices.empty() == false) {
+
+ size_t pVmax =std::min(in_PV_max, goodPrimaryVertices.size());
+ std::vector<const xAOD::Vertex*> refPVvertexes;
+ std::vector<const xAOD::Vertex*> refPVvertexes_toDelete;
+ std::vector<int> exitCode;
+ refPVvertexes.reserve(pVmax);
+ refPVvertexes_toDelete.reserve(pVmax);
+ exitCode.reserve(pVmax);
+
+ bool doPt = (DoVertexType & 1) != 0;
+ bool doA0 = (DoVertexType & 2) != 0;
+ bool doZ0 = (DoVertexType & 4) != 0;
+ bool doZ0BA = (DoVertexType & 8) != 0;
+
+ xAOD::VertexContainer::iterator vtxItr = vtxContainer->begin();
+ for(; vtxItr!=vtxContainer->end(); ++vtxItr) {
+ xAOD::BPhysHelper vtx(*vtxItr);
+
+ // 1) pT error
+ double ptErr = m_v0Tools->pTError( vtx.vtx() );
+ BPHYS_CHECK( vtx.setPtErr(ptErr) );
+
+ for(size_t i =0; i < pVmax ; i++) {
+ const xAOD::Vertex* oldPV = goodPrimaryVertices.at(i);
+ //when set to false this will return nullptr when a new vertex is not required
+ int exit =0;
+ const xAOD::Vertex* refPV = pvRefitter->refitVertex(oldPV, vtx.vtx(), false, &exit);
+ exitCode.push_back(exit);
+ //I want positioning to match the goodPrimaryVertices
+ if(refPV == nullptr){
+ refPVvertexes.push_back(oldPV);
+ refPVvertexes_toDelete.push_back(nullptr);
+ }else{
+ refPVvertexes.push_back(refPV);
+ refPVvertexes_toDelete.push_back(refPV);
+ }
+ }
+
+ // 2) refit the primary vertex and set the related decorations.
+
+ size_t highPtindex = doPt ? FindHighPtIndex(refPVvertexes) : 9999999; //Should be 0 in PV ordering
+ size_t lowA0 = doA0 ?
+ FindLowA0Index(vtx, refPVvertexes, m_PV_minNTracks) : 9999998;
+ size_t lowZ = doZ0 ?
+ FindLowZIndex(vtx, refPVvertexes, m_PV_minNTracks) : 9999997;
+ size_t lowZBA = doZ0BA ?
+ FindLowZ0BAIndex(vtx, refPVvertexes, m_PV_minNTracks) : 9999996;
+ /*
+ cout << "BPhysPVTools::FillCandwithRefittedVertices: in_PV_max/pVMax = "
+ << in_PV_max << ", " << pVmax << endl;
+ cout << "BPhysPVTools::FillCandwithRefittedVertices: m_PV_minNTracks = "
+ << m_PV_minNTracks << endl;
+ cout << "BPhysPVTools::FillCandwithRefittedVertices: hPt,lowA0/Z/ZBA = "
+ << highPtindex << ", "
+ << lowA0 << ", " << lowZ << ", " << lowZBA << " "
+ << (lowA0 != lowZ ? "1!" : " ")
+ << (lowA0 != lowZBA ? "2!" : " ")
+ << (lowZ != lowZBA ? "3!" : " ")
+ << (highPtindex != lowA0 ? "4!" : " ")
+ << (highPtindex != lowZ ? "5!" : " ")
+ << (highPtindex != lowZBA ? "6!" : " ")
+ << endl;
+ */
+ if(doPt) {
+ //Choose old PV container if not refitted
+ const xAOD::VertexContainer* ParentContainer =
+ (refPVvertexes_toDelete.at(highPtindex)) ? refPvContainer : pvContainer;
+ if(ParentContainer == refPvContainer) //if refitted add to refitted container
+ refPvContainer->push_back(const_cast<xAOD::Vertex*>(refPVvertexes.at(highPtindex))); // store the new vertex
+
+ FillBPhysHelper(vtx, refPVvertexes[highPtindex],
+ ParentContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2, exitCode[highPtindex]);
+ vtx.setOrigPv(goodPrimaryVertices[highPtindex], pvContainer, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
+ }
+
+ if(doA0) {
+ const xAOD::VertexContainer* ParentContainer =
+ (refPVvertexes_toDelete.at(lowA0)) ? refPvContainer : pvContainer;
+ if(ParentContainer == refPvContainer && highPtindex!=lowA0)
+ refPvContainer->push_back(const_cast<xAOD::Vertex*>(refPVvertexes.at(lowA0))); // store the new vertex
+
+ FillBPhysHelper(vtx, refPVvertexes[lowA0],
+ ParentContainer, xAOD::BPhysHelper::PV_MIN_A0, exitCode[lowA0]);
+ vtx.setOrigPv(goodPrimaryVertices[lowA0], pvContainer, xAOD::BPhysHelper::PV_MIN_A0);
+ }
+
+
+ // 2.c) the closest in Z:
+ if(doZ0) {
+
+ const xAOD::VertexContainer* ParentContainer =
+ (refPVvertexes_toDelete.at(lowZ)) ? refPvContainer : pvContainer;
+ if(ParentContainer == refPvContainer && highPtindex!=lowZ && lowZ!=lowA0)
+ refPvContainer->push_back(const_cast<xAOD::Vertex*>(refPVvertexes.at(lowZ))); // store the new vertex
+
+ FillBPhysHelper(vtx, refPVvertexes[lowZ],
+ ParentContainer, xAOD::BPhysHelper::PV_MIN_Z0, exitCode[lowZ]);
+ vtx.setOrigPv(goodPrimaryVertices[lowZ], pvContainer, xAOD::BPhysHelper::PV_MIN_Z0);
+ }
+
+ // 2.d) the closest in Z (DOCA w.r.t. beam axis):
+ if (doZ0BA) {
+ if ( lowZBA < pVmax ) { // safety for vector indices
+ const xAOD::VertexContainer* ParentContainer =
+ (refPVvertexes_toDelete.at(lowZBA)) ?
+ refPvContainer : pvContainer;
+ if (ParentContainer == refPvContainer && highPtindex!=lowZBA
+ && lowZBA!=lowA0 && lowZBA != lowZ) {
+ // store the new vertex
+ refPvContainer->push_back(const_cast<xAOD::Vertex*>
+ (refPVvertexes.at(lowZBA)));
+ }
+ FillBPhysHelper(vtx, refPVvertexes[lowZBA],
+ ParentContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA,
+ exitCode[lowZBA]);
+ vtx.setOrigPv(goodPrimaryVertices[lowZBA], pvContainer,
+ xAOD::BPhysHelper::PV_MIN_Z0_BA);
+ } else {
+ // nothing found -- fill nullptr
+ FillBPhysHelperNULL(vtx, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, m_3dCalc);
+ // nothing found -- fill dummy vertex (type-0 vertex)
+ // if(pvContainer->empty()) return StatusCode::FAILURE;
+ // const xAOD::Vertex* dummy = pvContainer->at(pvContainer->size()-1); //No good vertices so last vertex must be dummy
+ // FillBPhysHelper(vtx, dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA, 0);
+ // vtx.setOrigPv(Dummy, pvContainer, xAOD::BPhysHelper::PV_MIN_Z0_BA);
+ }
+ }
+
+ //nullptrify ptrs we want to keep so these won't get deleted
+ //"delete nullptr" is valid in C++ and does nothing so this is quicker than a lot of if statements
+ if(doPt) refPVvertexes_toDelete[highPtindex] = nullptr;
+ if(doA0) refPVvertexes_toDelete[lowA0] = nullptr;
+ if(doZ0) refPVvertexes_toDelete[lowZ] = nullptr;
+ if(doZ0BA && lowZBA < pVmax) refPVvertexes_toDelete[lowZBA] = nullptr;
+ //Loop over toDELETE container, anything that is used or was not refitted is nullptr
+ //This cleans up all extra vertices that were created and not used
+ for(const xAOD::Vertex* ptr : refPVvertexes_toDelete) {
+ delete ptr;
+ }
+ refPVvertexes.clear();// Clear lists of now dangling ptrs
+ refPVvertexes_toDelete.clear();
+ exitCode.clear();
+ } // end of loop over vertices
+
+ } else {
+// cout << "Warning: DerivationFramework::BPhysPVTools::FillCandwithRefittedVertices No Primary Vertices Found trying to decorate wilth dummy \n";
+ if(pvContainer->empty()) return StatusCode::FAILURE;
+ const xAOD::Vertex* dummy = pvContainer->at(0); //No good vertices so last vertex must be dummy
+ DecorateWithDummyVertex(vtxContainer, pvContainer, dummy, DoVertexType, true);
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+size_t DerivationFramework::BPhysPVTools::FindHighPtIndex(const std::vector<const xAOD::Vertex*> &PVlist) {
+ // it SHOULD be the first one in the collection but it shouldn't take long to do a quick check
+ for(size_t i =0; i<PVlist.size(); i++) {
+ if(PVlist[i]->vertexType() == xAOD::VxType::PriVtx) return i;
+ }
+ cout << "FATAL ERROR High Pt Primary vertex not found - this should not happen\n";
+ return std::numeric_limits<std::size_t>::max(); //This should not happen
+}
+
+size_t DerivationFramework::BPhysPVTools::FindLowA0Index(const xAOD::BPhysHelper &Obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks) const {
+ size_t lowA0 = 0;
+ if(PVlist.empty()) {
+ lowA0=std::numeric_limits<std::size_t>::max();
+ return lowA0;
+ }
+ size_t size = PVlist.size();
+ double lowA0calc = m_v0Tools->a0(Obj.vtx(), PVlist[0]);
+ for(size_t i =1; i<size; i++) {
+ if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
+ double a0 = m_v0Tools->a0(Obj.vtx(), PVlist[i]);
+ if(a0 < lowA0calc) {
+ lowA0calc = a0;
+ lowA0 =i;
+ }
+ }
+ }
+ return lowA0;
+}
+
+vector<const xAOD::Vertex*> DerivationFramework::BPhysPVTools::GetGoodPV(const xAOD::VertexContainer* pvContainer) {
+ typedef xAOD::VxType::VertexType VertexType;
+ VertexType Pvtx = xAOD::VxType::PriVtx;
+ VertexType Pileupvtx = xAOD::VxType::PileUp;
+ std::vector<const xAOD::Vertex*> goodPrimaryVertices;
+ goodPrimaryVertices.reserve(pvContainer->size());
+
+ for (auto ptr = pvContainer->begin(); ptr!= pvContainer->end(); ++ptr) {
+ VertexType thistype = (*ptr)->vertexType();
+ if ( thistype == Pileupvtx || thistype == Pvtx ) {
+ goodPrimaryVertices.push_back(*ptr);
+ } else {
+// cout << "vertex type " << thistype << endl;
+ }
+ }
+ return goodPrimaryVertices;
+}
+//-----------------------------------------------------------------------------
+// added by WW:
+//
+void DerivationFramework::BPhysPVTools::SetMinNTracksInPV(size_t PV_minNTracks)
+{
+
+ m_PV_minNTracks = PV_minNTracks;
+}
+//-----------------------------------------------------------------------------
+// added by WW:
+//
+const Amg::Vector3D& DerivationFramework::BPhysPVTools::GetBeamSpot() const noexcept {
+
+ if(m_beamSpotData) return m_beamSpotData->beamPos();
+ else {
+ static const Amg::Vector3D defaultBS(-10000.,-10000.,-10000.);
+ return defaultBS;
+ }
+}
+//-----------------------------------------------------------------------------
+// added by WW:
+//
+size_t DerivationFramework::BPhysPVTools::FindLowZ0BAIndex(const xAOD::BPhysHelper &obj,
+ const std::vector<const xAOD::Vertex*> &PVlist,
+ const size_t PV_minNTracks) const {
+
+ size_t ilowZ0BA = std::numeric_limits<std::size_t>::max();
+ double lowZ0BAcalc = std::numeric_limits<double>::max();
+ for (size_t i = 0; i<PVlist.size(); ++i) {
+ if ( PVlist[i]->nTrackParticles() >= PV_minNTracks ) {
+ double z0BA = m_v0Tools->a0(obj.vtx(), PVlist[i]);
+ if (z0BA < lowZ0BAcalc) {
+ lowZ0BAcalc = z0BA;
+ ilowZ0BA = i;
+ }
+ }
+ }
+ return ilowZ0BA;
+}
+//-----------------------------------------------------------------------------
+// added by WW:
+//
+double DerivationFramework::BPhysPVTools::DistInZtoDOCA(const xAOD::BPhysHelper &obj, const xAOD::Vertex* vertex) const {
+
+ Amg::Vector3D pv = vertex->position();
+ Amg::Vector3D xDOCA = DocaExtrapToBeamSpot(obj);
+ Amg::Vector3D vec = pv - xDOCA;
+ return vec.z();
+}
+//-----------------------------------------------------------------------------
+// added by WW:
+//
+Amg::Vector3D DerivationFramework::BPhysPVTools::DocaExtrapToBeamSpot(const xAOD::BPhysHelper& obj) const {
+
+ Amg::Vector3D xDOCA(-99999., -99999., -99999.);
+ TVector3 totP(const_cast<xAOD::BPhysHelper&>(obj).totalP());
+ Amg::Vector3D pSV(totP.X(), totP.Y(), totP.Z());
+ Amg::Vector3D pT(pSV.x(), pSV.y(), 0.);
+ if ( pT.mag2() > 0 ) {
+ Amg::Vector3D xBS = GetBeamSpot();
+ Amg::Vector3D xSV = m_v0Tools->vtx(obj.vtx());
+ Amg::Vector3D xT(xSV.x()-xBS.x(), xSV.y()-xBS.y(), 0.);
+ xDOCA = xSV - pSV*pT.dot(xT)/pT.mag2();
+ } else {
+ std::cout << "BPhysPVTools::DocaExtrapToBeamSpot: WARNING pT == 0."
+ << std::endl;
+ }
+ return xDOCA;
+}
+
+void DerivationFramework::BPhysPVTools::PrepareVertexLinks(xAOD::Vertex* theResult,
+ const xAOD::TrackParticleContainer* importedTrackCollection)
+{
+ std::vector<ElementLink<DataVector<xAOD::TrackParticle> > > newLinkVector;
+ const auto &trkprtl = theResult->trackParticleLinks();
+ for(unsigned int i=0; i< trkprtl.size(); i++)
+ {
+ ElementLink<DataVector<xAOD::TrackParticle> > mylink=trkprtl[i]; //makes a copy (non-const)
+ mylink.setStorableObject(*importedTrackCollection, true);
+ newLinkVector.push_back( mylink );
+ }
+ theResult->clearTracks();
+ theResult->setTrackParticleLinks( newLinkVector );
+}
+
+
+//-----------------------------------------------------------------------------
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysVarBlinder.cxxNoCompile b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysVarBlinder.cxxNoCompile
new file mode 100644
index 00000000000..13a63f881ba
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysVarBlinder.cxxNoCompile
@@ -0,0 +1,72 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BPhysVarBlinder.cxx
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+//============================================================================
+//
+#include "BPhysTools/BPhysBlindingTool.h"
+#include "DerivationFrameworkBPhys/BPhysVarBlinder.h"
+
+namespace DerivationFramework {
+
+ //---------------------------------------------------------------------------
+ // Constructor
+ //---------------------------------------------------------------------------
+ BPhysVarBlinder::BPhysVarBlinder(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ CfAthAlgTool(t,n,p),
+ m_blindingTool("xAOD::BPhysBlindingTool") {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare tools
+ declareProperty("BlindingTool", m_blindingTool);
+
+ // Declare user-defined properties
+ declareProperty("EnableBlinding", m_enableBlinding = true);
+
+ }
+ //---------------------------------------------------------------------------
+ // Initialization
+ //---------------------------------------------------------------------------
+ StatusCode BPhysVarBlinder::initialize() {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // retrieve blinding tool
+ CHECK( m_blindingTool.retrieve() );
+
+ ATH_MSG_INFO("initialize(): EnableBlinding: " << m_enableBlinding);
+
+ return StatusCode::SUCCESS;
+ }
+ //---------------------------------------------------------------------------
+ // Finalization
+ //---------------------------------------------------------------------------
+ StatusCode BPhysVarBlinder::finalize() {
+
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+ //---------------------------------------------------------------------------
+ // Perform blinding
+ //---------------------------------------------------------------------------
+ StatusCode BPhysVarBlinder::addBranches() const {
+
+ if ( m_enableBlinding ) {
+ CHECK( m_blindingTool->doBlind() );
+ }
+
+ return StatusCode::SUCCESS;
+ }
+ //---------------------------------------------------------------------------
+
+} // namespace DerivationFramework
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysVertexTrackBase.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysVertexTrackBase.cxx
new file mode 100644
index 00000000000..2f2cef79bfc
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BPhysVertexTrackBase.cxx
@@ -0,0 +1,1480 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BPhysVertexTrackBase.cxx
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Base class for vertex-track related classes in need of
+// track-to-vertex association handling.
+//
+// Derived classes should overwrite the following methods instead
+// of the orginal initialize() etc methods:
+// - initializeHook()
+// - finalizeHook()
+// - addBranchesHook() -- only called at end of addBranches()
+// - addBranchesSVLoopHook() -- preferred (inside SV loop)
+//
+// From within addBranchesSVLoopHook()
+// - calculateValues()
+// should be called and the following hook methods should be overwritten:
+// - calcValuesHook() -- called for the actual calculation of values
+// - fastFillHook() -- called to check and apply caching of values
+//
+// For an usage example see BVertexTrackIsoTool and BPHY8.py .
+//
+// Job options provided by this class:
+// - BranchPrefixes -- vector of prefixes to assign to
+// added branches
+// (Must be of same size as VertexContainerNames
+// and in the same order.)
+// - BranchBaseName -- assign the base name of added branches
+// (default: iso)
+// - BranchSuffix -- assign the suffix of added branches
+// (default: empty = none)
+// - VertexContainerNames -- names of containers for secondary vertices
+// - TrackParticleContainerName -- name of container for TrackParticles
+// - TrackToVertexTool -- ToolHandle for track-to-vertex tool
+// - TrackSelectionTools -- Array of ToolHandles for track
+// selection tools; each tool should
+// be named XXXX_YYYY, where the YYYY
+// suffix string which needs to be unique;
+// will be used to name the isolation track
+// category (part of the new attribute names)
+// - RefPVContainerNames -- List of refitted PV container names.
+// (Must be of same size as VertexContainerNames
+// and in the same order.)
+// - DoVertexType -- PV-to-SV association types to be
+// considered (bitwise variable, see
+// xAODBPhys::BPhysHelper)
+// - UseTrackTypes -- List of or-ed bit-wise selection of
+// track sets to consider:
+// bit : meaning
+// 0 : tracks close to PV associated
+// with SV
+// 1 : tracks associated with dummy PV
+// ("type-0 PV tracks")
+// 2 : tracks associated with PV of type 1
+// 3 : tracks associated with PV of type 2
+// 4 : tracks associated with PV of type 3
+// 5 : tracks associated with PV with types
+// other than 0 to 4.
+// 6 : tracks with missing pointer to
+// PV (NULL pointer)
+// 7-22: tracks being closest to assoc. PV
+// useRefittedPVs doDCAin3D chi2DefToUse
+// 7 : yes no 0
+// 8 : no no 0
+// 9 : yes yes 0
+// 10 : no yes 0
+// 11 : yes no 1
+// 12 : no no 1
+// 13 : yes yes 1
+// 14 : no yes 1
+// 15 : yes no 2
+// 16 : no no 2
+// 17 : yes yes 2
+// 18 : no yes 2
+// 19 : yes -- 3
+// 20 : no -- 3
+// 21 : yes -- 4
+// 22 : no -- 4
+// 23 : yes -- 5
+// 24 : no -- 5
+// 25 : yes yes 6
+// 26 : no yes 6
+// 27 : yes yes 7
+// 28 : no yes 7
+// 29 : yes yes 8
+// 30 : no yes 8
+// 31 : yes yes 9
+// 32 : no yes 9
+// useRefittedPVs:
+// replace PV associated to decay candidate
+// by the refitted PV
+// doDCAin3D:
+// use d0 and z0 in the determination of
+// of the point of closest approach of
+// a track to a vertex
+// chi2DefToUse:
+// PV uncertainties in the chi2 calculation
+// in addition to track uncertainties
+// 0 : use old method
+// (only track uncertainties)
+// 1 : from track perigee with
+// uncertainties from track and vertex
+// 2 : simple extrapolation from track
+// parameters with uncertainties from
+// track and vertex (extrapolation
+// used for track swimming)
+// 3 : CalcLogChi2toPV method from NtupleMaker
+// using xAOD::TrackingHelpers.
+// (only track uncertainties)
+// 4 : CalcLogChi2toPV method from NtupleMaker
+// using xAOD::TrackingHelpers.
+// (track and vertex uncertainties)
+// 5 : use TrackVertexAssociationTool
+// 6 : full 3D chi2 from track perigee
+// with uncertainties from track and
+// vertex (sum of 3x3 covariance matrices)
+// 7 : full 3D chi2 from track perigee with
+// uncertainties from track and vertex
+// (sum of 2x2 covariance matrices)
+// 8 : simple extrapolation from track
+// parameters with uncertainties
+// from track and vertex
+// (sum of 3x3 covariance matrices)
+// 9 simple extrapolation from track
+// parameters with uncertainties
+// from track and vertex
+// (sum of 2x2 covariance matrices)
+// (E.g. 127 means to consider all tracks.)
+// - IncPrecVerticesInDecay -- Include preceeding vertices in search
+// for ID tracks and muons from decaying
+// particle. (May be a bit slower but
+// more accurate. Double-counting of track
+// or muon objects is excluded.
+// Default: True)
+// - MinNTracksInPV -- Minimum number of tracks in PV for
+// PV to be considered in calculation
+// of closest PV to a track
+// - PVTypesToConsider -- List of primary vertex types to consider
+// in calculation of closest PV to a track
+// - DebugTrackTypes -- Count tracks of specific types (bit
+// patterns w.r.t. vertex association)
+// and dump statistics to log file
+// 0 : disabled
+// 1 : count tracks of certain types
+// - DebugTracksInEvents -- debug track selections in detail for
+// a list of event numbers.
+//
+//
+//============================================================================
+//
+#include "DerivationFrameworkBPhys/BPhysVertexTrackBase.h"
+#include "xAODTracking/TrackParticlexAODHelpers.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
+#include "EventPrimitives/EventPrimitivesHelpers.h"
+#include "TrackVertexAssociationTool/TrackVertexAssociationTool.h"
+#include "TVector3.h"
+#include "TString.h"
+#include "boost/format.hpp"
+#include <algorithm>
+#include <sstream>
+#include <limits>
+
+namespace DerivationFramework {
+
+ //-------------------------------------------------------------------------
+ //
+ // helper class
+ BPhysVertexTrackBase::BaseItem::BaseItem(std::string Name,
+ std::string Bname,
+ std::string Prefix) :
+ name(std::move(Name)), bname(std::move(Bname)), prefix(std::move(Prefix)) {
+ }
+
+ BPhysVertexTrackBase::BaseItem::~BaseItem() {
+ }
+
+ void BPhysVertexTrackBase::BaseItem::setup(std::string Name,
+ std::string Bname,
+ std::string Prefix) {
+ name = std::move(Name);
+ bname = std::move(Bname);
+ prefix = std::move(Prefix);
+ }
+
+ void BPhysVertexTrackBase::BaseItem::setPrefix(std::string Prefix) {
+ prefix = std::move(Prefix);
+ }
+
+ void BPhysVertexTrackBase::BaseItem::resetVals() {
+ // needs to be implemented by derived class
+ }
+
+ std::string BPhysVertexTrackBase::BaseItem::buildName(std::string qualifier,
+ std::string suffix) {
+ boost::format f("%s%s%s%s%s");
+ f % (prefix.length() > 0 ? prefix+"_" : "")
+ % (bname.length() > 0 ? bname+"_" : "")
+ % (qualifier.length() > 0 ? qualifier+"_" : "")
+ % name
+ % suffix;
+ return f.str();
+ }
+
+ std::string BPhysVertexTrackBase::BaseItem::toString() const {
+ boost::format f("nm: %s\nbn: %s");
+ f % name % bname;
+ return f.str();
+ }
+ //-------------------------------------------------------------------------
+ //
+ // helper class (for track types)
+ //
+ BPhysVertexTrackBase::TrackTypeCounter::
+ TrackTypeCounter(BPhysVertexTrackBase& Parent, std::string Name)
+ : name(std::move(Name)), m_parent(Parent) {
+ }
+
+ BPhysVertexTrackBase::TrackTypeCounter::~TrackTypeCounter() {
+ }
+
+ void BPhysVertexTrackBase::TrackTypeCounter::addToCounter(uint64_t atype,
+ uint64_t rtype,
+ std::string prefix,
+ std::string suffix,
+ uint64_t counts) {
+ boost::format f("%sT%010d_R%010d%s");
+ f % (prefix.length() > 0 ? prefix+"_" : "")
+ % atype
+ % m_parent.m_useTrackTypes[rtype]
+ % (suffix.length() > 0 ? "_"+suffix : "");
+
+ addToCounter(f.str(), atype, counts);
+ }
+
+ void BPhysVertexTrackBase::TrackTypeCounter::addToCounter(std::string name,
+ uint64_t atype,
+ uint64_t counts) {
+
+ NameCountMap_t::const_iterator it = m_cnts.find(name);
+
+ if ( it != m_cnts.end() ) {
+ m_cnts[name].first += counts;
+ } else {
+ m_cnts[name] = std::make_pair(counts, atype);
+ }
+ }
+
+ std::string BPhysVertexTrackBase::TrackTypeCounter::
+ countsToString(uint indent) const {
+
+ boost::format f("%sCounters for %s:\n");
+ f % boost::io::group(std::setw(indent), " ") % name;
+ std::string str = f.str();
+
+ int lmax(0);
+ for (NameCountMap_t::const_iterator it = m_cnts.begin();
+ it != m_cnts.end(); ++it) {
+ lmax = std::max(lmax, (int)(it->first).length());
+ }
+
+ for (NameCountMap_t::const_iterator it = m_cnts.begin();
+ it != m_cnts.end(); ++it) {
+ boost::format f("%s%-s : %10lld %33s");
+ f % boost::io::group(std::setw(indent+4), " ")
+ % boost::io::group(std::setw(lmax), it->first)
+ % (it->second).first
+ % std::bitset<33>((it->second).second).to_string();
+ str += f.str() + "\n";
+ }
+ // clean up last newline
+ str.erase(str.length()-1);
+
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ //-------------------------------------------------------------------------
+ // static members
+ const int BPhysVertexTrackBase::n_track_types = 33;
+ const std::string BPhysVertexTrackBase::track_type_str[] =
+ {"ASSOCPV", "PVTYPE0", "PVTYPE1", "PVTYPE2", "PVTYPE3", "NONE", "NULLVP",
+ "CAPVRFN3U0", "CAPVNRN3U0", "CAPVRF3DU0", "CAPVNR3DU0",
+ "CAPVRFN3U1", "CAPVNRN3U1", "CAPVRF3DU1", "CAPVNR3DU1",
+ "CAPVRFN3U2", "CAPVNRN3U2", "CAPVRF3DU2", "CAPVNR3DU2",
+ "CAPVRFNNU3", "CAPVNRNNU3", "CAPVRFNNU4", "CAPVNRNNU4",
+ "CAPVRFNNU5", "CAPVNRNNU5", "CAPVRFNNU6", "CAPVNRNNU6",
+ "CAPVRFNNU7", "CAPVNRNNU7", "CAPVRFNNU8", "CAPVNRNNU8",
+ "CAPVRFNNU9", "CAPVNRNNU9"};
+ const uint64_t BPhysVertexTrackBase::track_type_bit[] =
+ {0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40,
+ 0x80, 0x100, 0x200, 0x400,
+ 0x800, 0x1000, 0x2000, 0x4000,
+ 0x8000, 0x10000, 0x20000, 0x40000,
+ 0x80000, 0x100000, 0x200000, 0x400000,
+ 0x800000, 0x1000000, 0x2000000, 0x4000000,
+ 0x8000000, 0x10000000, 0x20000000, 0x40000000,
+ 0x80000000, 0x100000000};
+ uint64_t BPhysVertexTrackBase::s_track_type_all_cached = 0x0;
+
+ // static methods
+ const std::string
+ BPhysVertexTrackBase::tts(BPhysVertexTrackBase::track_type type) {
+ return track_type_str[type];
+ }
+
+ uint64_t BPhysVertexTrackBase::ttb(BPhysVertexTrackBase::track_type type) {
+ return track_type_bit[type];
+ }
+
+ uint64_t BPhysVertexTrackBase::ttallMin() {
+ // only bits 0 - 6
+ return 127;
+ }
+
+ uint64_t BPhysVertexTrackBase::ttall() {
+ if ( s_track_type_all_cached == 0x0 ) {
+ for (unsigned int i=0; i<n_track_types; ++i) {
+ s_track_type_all_cached |= track_type_bit[i];
+ }
+ }
+ return s_track_type_all_cached;
+ }
+
+ uint64_t BPhysVertexTrackBase::rttor(const std::vector<uint64_t> &vtypes) {
+ // or of requested track types
+ uint64_t ttor(0);
+ for (size_t i=0; i<vtypes.size(); ++i) {
+ ttor |= vtypes[i];
+ }
+ return ttor;
+ }
+
+ // track to string
+ std::string
+ BPhysVertexTrackBase::trackToString(const xAOD::TrackParticle* track) {
+ std::string str;
+ if (track != nullptr) {
+ boost::format f("p(%10.4f,%10.4f,%10.4f)\n"
+ "d:(%10.5f,%10.5f,%10.5f,%10.5f,%10.6f)");
+ f % (track->p4()).Px() % (track->p4()).Py() % (track->p4()).Pz();
+ f % track->d0() % track->z0() % track->phi0() % track->theta();
+ f % track->qOverP();
+ str = f.str();
+ } // if track
+ return str;
+ }
+
+ //--------------------------------------------------------------------------
+ // Static utility method to prefix every line by a certain string
+ //--------------------------------------------------------------------------
+ std::string BPhysVertexTrackBase::wrapLines(std::string lines,
+ std::string prefix) {
+
+ std::string ostr;
+ std::istringstream stream(lines);
+ std::string line;
+ while ( std::getline(stream, line) ) {
+ if ( !ostr.length() == 0 ) ostr += "\n";
+ ostr += prefix + line;
+ }
+ return ostr;
+ }
+ //--------------------------------------------------------------------------
+ //--------------------------------------------------------------------------
+ BPhysVertexTrackBase::BPhysVertexTrackBase(const std::string& t,
+ const std::string& n,
+ const IInterface* p)
+ : AthAlgTool(t,n,p), m_trackToVertexTool("Reco::TrackToVertex"),
+ m_tvaTool("CP::TrackVertexAssociationTool"),
+ m_tvaToolHasWpLoose(false),
+ m_tracks(NULL), m_tracksAux(NULL), m_nEvtsSeen(0), m_eventInfo(nullptr),
+ m_trackTypesUsed(0), m_runNumber(0), m_evtNumber(0),
+ m_debugTracksInThisEvent(false) {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare branch prefix
+ declareProperty("BranchPrefixes", m_branchPrefixes);
+ declareProperty("BranchBaseName", m_branchBaseName = "iso");
+ declareProperty("BranchSuffix" , m_branchSuffix = "" );
+
+ // Necessary containers
+ declareProperty("VertexContainerNames" , m_vertexContainerNames);
+ declareProperty("TrackParticleContainerName",
+ m_trackParticleContainerName);
+ declareProperty("TrackToVertexTool" , m_trackToVertexTool);
+ declareProperty("TrackSelectionTools" , m_trackSelectionTools);
+ declareProperty("TVATool" , m_tvaTool);
+ declareProperty("PVContainerName", m_pvContainerName = "PrimaryVertices");
+ declareProperty("RefPVContainerNames" , m_refPVContainerNames);
+ declareProperty("DoVertexType" , m_doVertexType = 8);
+ declareProperty("UseTrackTypes" , m_useTrackTypes = {7});
+ declareProperty("IncPrecVerticesInDecay", m_incPrecVerticesInDecay = true);
+ declareProperty("MinNTracksInPV" , m_minNTracksInPV = 0);
+ declareProperty("PVTypesToConsider" , m_pvTypesToConsider = {1,3});
+ declareProperty("DebugTrackTypes" , m_debugTrackTypes=0);
+ declareProperty("DebugTracksInEvents" , m_debugTracksInEvents = {});
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysVertexTrackBase::initialize() {
+
+ ATH_MSG_DEBUG("BPhysVertexTrackBase::initialize() -- begin");
+
+ if ( m_vertexContainerNames.size() == 0 ) {
+ ATH_MSG_ERROR("No vertex container names provided!");
+ }
+ if ( m_refPVContainerNames.size() == 0 ) {
+ ATH_MSG_ERROR("No refitted PV container names provided!");
+ }
+ if ( m_trackParticleContainerName == "" ) {
+ ATH_MSG_ERROR("No track particle container name provided!");
+ }
+ if ( m_pvContainerName == "" ) {
+ ATH_MSG_ERROR("No PV container name provided!");
+ }
+ if ( m_vertexContainerNames.size() != m_refPVContainerNames.size() ) {
+ ATH_MSG_ERROR("Size mismatch of VertexContainerNames ("
+ << m_vertexContainerNames.size()
+ << ") and RefPVContainerNames ("
+ << m_refPVContainerNames.size() << ") lists!");
+ }
+
+ if ( m_vertexContainerNames.size() != m_branchPrefixes.size() ) {
+ ATH_MSG_ERROR("Size mismatch of VertexContainerNames ("
+ << m_vertexContainerNames.size()
+ << ") and BranchPrefixes ("
+ << m_branchPrefixes.size() << ") lists!");
+ }
+
+ // TrackToVertexTool
+ ATH_CHECK(m_trackToVertexTool.retrieve());
+
+ // TrackSelectionTools
+ for (auto selTool : m_trackSelectionTools ) {
+ ATH_CHECK(selTool.retrieve());
+ }
+
+ // TrackVertexAssociationTool
+ ATH_CHECK(m_tvaTool.retrieve());
+ // take note of working point
+ // const std::string tvaWp("Loose");
+ const std::string tvaWp =
+ dynamic_cast<CP::TrackVertexAssociationTool*>(m_tvaTool.get())->getProperty("WorkingPoint").toString();
+ m_tvaToolHasWpLoose = (tvaWp == "Loose");
+
+ // initialize PV-to-SV association type vector
+ initPvAssocTypeVec();
+
+ // initialize track type request pattern
+ m_trackTypesUsed = rttor(m_useTrackTypes);
+
+ // initialize track type counters
+ if ( m_debugTrackTypes > 0 ) {
+ m_mttc = std::make_unique<TrackTypeCounter>(*this, name());
+ }
+
+ ATH_MSG_DEBUG("BPhysVertexTrackBase::initialize() -- end");
+
+ return initializeHook();
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysVertexTrackBase::finalize() {
+
+ ATH_MSG_DEBUG("BPhysVertexTrackBase::finalize()");
+
+ // dump track type counters to log
+ if ( m_debugTrackTypes > 0 ) {
+ ATH_MSG_INFO("Track type counters:\n" << m_mttc->countsToString());
+ }
+
+ // everything all right
+ return finalizeHook();
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BPhysVertexTrackBase::addBranches() const {
+
+ ATH_MSG_DEBUG("BPhysVertexTrackBase::addBranches() -- begin");
+
+ // counter
+ m_nEvtsSeen++;
+
+ // run and event numbers
+ CHECK(evtStore()->retrieve(m_eventInfo));
+ m_runNumber = m_eventInfo->runNumber();
+ m_evtNumber = m_eventInfo->eventNumber();
+
+ // debug tracks in current event?
+ m_debugTracksInThisEvent = (std::find(m_debugTracksInEvents.begin(),
+ m_debugTracksInEvents.end(),
+ m_evtNumber)
+ != m_debugTracksInEvents.end());
+
+ // retrieve primary vertices container
+ m_pvtxContainer = NULL;
+ CHECK(evtStore()->retrieve(m_pvtxContainer, m_pvContainerName));
+ ATH_MSG_DEBUG("Found PV collection with key " << m_pvContainerName);
+
+
+ // retrieve ID track container
+ m_tracks = NULL;
+ m_tracksAux = NULL;
+ CHECK(evtStore()->retrieve(m_tracks, m_trackParticleContainerName));
+ if (evtStore()->contains<xAOD::
+ TrackParticleAuxContainer>(m_trackParticleContainerName+"Aux.")) {
+ CHECK(evtStore()->retrieve(m_tracksAux,
+ m_trackParticleContainerName+"Aux."));
+ } else {
+ ATH_MSG_DEBUG("No aux track collection with key "
+ << m_trackParticleContainerName+"Aux.");
+ }
+ ATH_MSG_DEBUG("Found track collection with key "
+ << m_trackParticleContainerName);
+
+ // Loop over all vertex containers
+ for (size_t i=0; i<m_vertexContainerNames.size(); ++i) {
+ // vertex container and its auxilliary store
+ const xAOD::VertexContainer* svtxContainer = NULL;
+ const xAOD::VertexAuxContainer* svtxAuxContainer = NULL;
+ // refitted primary vertex container and its auxilliary store
+ const xAOD::VertexContainer* refPVContainer = NULL;
+ const xAOD::VertexAuxContainer* refPVAuxContainer = NULL;
+
+ // retrieve from StoreGate
+ CHECK(evtStore()->retrieve(svtxContainer, m_vertexContainerNames[i]));
+ CHECK(evtStore()->retrieve(svtxAuxContainer,
+ m_vertexContainerNames[i]+"Aux."));
+ ATH_MSG_DEBUG("Found SV collection with key "
+ << m_vertexContainerNames[i]);
+ CHECK(evtStore()->retrieve(refPVContainer ,
+ m_refPVContainerNames[i]));
+ CHECK(evtStore()->retrieve(refPVAuxContainer,
+ m_refPVContainerNames[i]+"Aux."));
+ ATH_MSG_DEBUG("Found refitted PV collection with key "
+ << m_refPVContainerNames[i]);
+
+ // vertex container depending setup in derived class
+ CHECK(addBranchesVCSetupHook(i));
+
+ // loop over secondary vertices
+ for (xAOD::VertexContainer::const_iterator vtxItr =
+ svtxContainer->begin(); vtxItr!=svtxContainer->end();
+ ++vtxItr) {
+
+ CHECK(addBranchesSVLoopHook(*vtxItr));
+
+ } // end of loop over vertices
+ } // end of loop over vertex container names
+
+ ATH_MSG_DEBUG("BPhysVertexTrackBase::addBranches() -- end");
+
+ // nothing to do here
+ return addBranchesHook();
+ }
+
+ //--------------------------------------------------------------------------
+ // Hook method for initialize() -- to be overwritten by derived class
+ //--------------------------------------------------------------------------
+ StatusCode BPhysVertexTrackBase::initializeHook() {
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Hook method for finalize() -- to be overwritten by derived class
+ //--------------------------------------------------------------------------
+ StatusCode BPhysVertexTrackBase::finalizeHook() {
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Hook method for addBranches() -- to be overwritten by derived class
+ //--------------------------------------------------------------------------
+ StatusCode BPhysVertexTrackBase::addBranchesHook() const {
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Hook method for addBranches() VC setup
+ // -- to be overwritten by derived class
+ //--------------------------------------------------------------------------
+ StatusCode BPhysVertexTrackBase::addBranchesVCSetupHook(size_t ivc) const {
+
+ // just to avoid a compiler warning
+ ATH_MSG_DEBUG("addBranchesVCSetupHook: Vertex container index " << ivc
+ << " for collection " << m_vertexContainerNames[ivc]
+ << " with prefix " << m_branchPrefixes[ivc]);
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Hook method for addBranches() SV loop -- to be overwritten by derived class
+ //--------------------------------------------------------------------------
+ StatusCode
+ BPhysVertexTrackBase::addBranchesSVLoopHook(const xAOD::Vertex* vtx) const {
+
+ // just to avoid a compiler warning
+ ATH_MSG_DEBUG("addBranchesSVLoopHook: Vertex " << vtx);
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Calculate values -- used by calculateValues()
+ // -- to be overwritten by derived class
+ //--------------------------------------------------------------------------
+ StatusCode
+ BPhysVertexTrackBase::calcValuesHook(const xAOD::Vertex* vtx,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const {
+
+ // just to avoid a compiler warning
+ ATH_MSG_DEBUG("calcIsolationOpti: vtx: " << vtx << ", ipv: " << ipv
+ << ", its: " << its << ", itt: " << itt);
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Fill values from cache if found -- used by calculateValues()
+ // -- to be overwritten by derived class
+ //--------------------------------------------------------------------------
+ bool BPhysVertexTrackBase::fastFillHook(const xAOD::Vertex* vtx,
+ const int ipv) const {
+
+ // just to avoid a compiler warning
+ ATH_MSG_DEBUG("fastIsoFill: vtx: " << vtx << ", ipv: " << ipv);
+
+ return false;
+ }
+ //--------------------------------------------------------------------------
+ // Calculation loops -- needs to be called from inside the implementation
+ // of addBranchesSVLoopHook() in the derived class.
+ // Derived class also needs to provide override methods for
+ // - fastFillHook -- needs to return true if cached value is used
+ // - calcValuesHook -- actually calculating value(s)
+ //--------------------------------------------------------------------------
+ StatusCode
+ BPhysVertexTrackBase::calculateValues(const xAOD::Vertex* vtx) const {
+
+ ATH_MSG_DEBUG("BPhysVertexTrackBase::calculateValues -- begin");
+
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+
+ m_pvAssocResMap.clear();
+
+ const xAOD::BPhysHelper cand(vtx);
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ if ( ipv == 0 || ! fastFillHook(vtx, ipv) ) {
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ ATH_MSG_DEBUG("Calling calcValuesHook with ipv: " << ipv
+ << ", its: " << its << ", itt: " << itt);
+ CHECK(calcValuesHook(vtx, ipv, its, itt));
+ } // for itt
+ } // for its
+ // cache result index -- only needed once per ipv value
+ m_pvAssocResMap[buildPvAssocCacheName(vtx, ipv)] = ipv;
+ ATH_MSG_DEBUG("calculateValues: cache index: "
+ << buildPvAssocCacheName(vtx, ipv)
+ << " -- cached ipv: " << ipv);
+ } // if !fastFillHook()
+ } // for ipv
+
+ return StatusCode::SUCCESS;
+ }
+ //-------------------------------------------------------------------------
+ // Build SV-to-PV association cache index string
+ //-------------------------------------------------------------------------
+ std::string
+ BPhysVertexTrackBase::buildPvAssocCacheName(const xAOD::Vertex* vtx,
+ const int ipv) const {
+ xAOD::BPhysHelper cand(vtx);
+ boost::format f("SV_%p_RPV_%p");
+ f % cand.vtx() % cand.pv(m_pvAssocTypes[ipv]);
+
+ return f.str();
+ }
+ //--------------------------------------------------------------------------
+ // getTrackCandPVLogChi2()
+ // Calculate the logChi2 (= log((d0/d0e)^2+(z0/z0e)^2) contribution of a
+ // track at the position closest to the PV associated with the SV.
+ //--------------------------------------------------------------------------
+ double BPhysVertexTrackBase::getTrackCandPVLogChi2(const xAOD::TrackParticle*
+ track,
+ const xAOD::Vertex* vtx,
+ bool doDCAin3D,
+ int chi2DefToUse
+ ) const {
+
+ return getTrackLogChi2DCA(track, vtx, doDCAin3D, chi2DefToUse)[4];
+ }
+ //--------------------------------------------------------------------------
+ // getTrackLogChi2DCA()
+ // Calculate logChi2 (= log((d0/d0e)^2+(z0/z0e)^2) contribution of a
+ // track at the position closest to a position and
+ // the distance of closest approach of a track w.r.t.
+ // a position. Either only in the transverse plane or in 3 dimensions.
+ // Option chi2DefToUse:
+ // 0 : from track perigee with uncertainties from track only
+ // 1 : from track perigee with uncertainties from track and vertex
+ // 2 : simple extrapolation from track parameters
+ // with uncertainties from track and vertex
+ // 3 : CalcLogChi2toPV method from NtupleMaker using xAOD::TrackingHelpers.
+ // (only track uncertainties)
+ // 4 : CalcLogChi2toPV method from NtupleMaker using xAOD::TrackingHelpers.
+ // (track and vertex uncertainties)
+ // 5 : use TrackVertexAssociationTool
+ // 6 : full 3D chi2 from track perigee with uncertainties
+ // from track and vertex (sum of 3x3 covariance matrices)
+ // 7 : full 3D chi2 from track perigee with uncertainties
+ // from track and vertex (sum of 2x2 covariance matrices)
+ // 8 : simple extrapolation from track parameters with uncertainties
+ // from track and vertex (sum of 3x3 covariance matrices)
+ // 9 simple extrapolation from track parameters with uncertainties
+ // from track and vertex (sum of 2x2 covariance matrices)
+ // Returned vector components:
+ // 0: d0, 1: d0Err, 2: z0, 3: z0Err, 4: logChi2, 5: dca, 6: okFlag
+ // 7: vtxErrPart2, 8: trkErrPart2, 9: phi0Used
+ //--------------------------------------------------------------------------
+ std::vector<double>
+ BPhysVertexTrackBase::getTrackLogChi2DCA(const xAOD::TrackParticle* track,
+ const xAOD::Vertex* vtx,
+ bool doDCAin3D,
+ int chi2DefToUse) const {
+ // presets
+ std::vector<double> res = {-999., -99., -999., -99., -100., -100., -1.,
+ -99., -99., -999.};
+
+ const Amg::Vector3D pos = vtx->position();
+ const AmgSymMatrix(3) poscov = vtx->covariancePosition();
+
+ if ( track != NULL ) {
+ if ( chi2DefToUse < 2 || (chi2DefToUse > 5 && chi2DefToUse < 8) ) {
+ // use track perigee method
+ std::unique_ptr<const Trk::Perigee>
+ trkPerigee(m_trackToVertexTool->perigeeAtVertex(*track, pos));
+ if ( trkPerigee != NULL ) {
+ res[0] = trkPerigee->parameters()[Trk::d0];
+ res[2] = trkPerigee->parameters()[Trk::z0];
+ const AmgSymMatrix(5)* locError = trkPerigee->covariance();
+ if ( locError != NULL ) {
+ // uncertainties from track
+ res[1] = Amg::error(*locError, Trk::d0);
+ res[3] = Amg::error(*locError, Trk::z0);
+ if ( chi2DefToUse == 1 ) {
+ // add uncertainties from vertex
+ Amg::Vector3D perppt(trkPerigee->momentum().y()/trkPerigee->pT(),
+ -trkPerigee->momentum().x()/trkPerigee->pT(),
+ 0.);
+ double vtxD0Err2 = perppt.transpose()*poscov*perppt;
+ res[1] = sqrt( pow(res[1], 2.) + vtxD0Err2 );
+ res[3] = sqrt( pow(res[3], 2.) + poscov(2,2) );
+ }
+ if ( chi2DefToUse < 2 ) {
+ if ( fabs(res[1]) > 0. && fabs(res[3]) > 0. ) {
+ res[4] = log( pow(res[0]/res[1], 2.)
+ + pow(res[2]/res[3], 2.) );
+ res[6] = 2.; // ok
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
+ << " d0 = " << res[0] << ", d0Err = "
+ << res[1] << ", z0 = " << res[2]
+ << ", z0Err = " << res[3]);
+ }
+ }
+ // chi2DefToUse 6 or 7
+ if ( chi2DefToUse > 5 && chi2DefToUse < 8 ) {
+ double phi0 = trkPerigee->parameters()[Trk::phi0];
+ double doca = sqrt(pow(res[0],2.) + pow(res[2], 2.));
+ res[9] = phi0;
+ if ( doca > 0. ) {
+ if ( chi2DefToUse == 6 ) {
+ AmgMatrix(5,3) dmat = AmgMatrix(5,3)::Zero();
+ dmat(0,0) = -sin(phi0);
+ dmat(0,1) = cos(phi0);
+ dmat(1,2) = 1.;
+ dmat(2,0) = -res[0]*cos(phi0);
+ dmat(2,1) = -res[0]*sin(phi0);
+ AmgSymMatrix(3) mCovTrk3D = dmat.transpose()*(*locError)*dmat;
+ Amg::Vector3D dvec(-res[0]*sin(phi0), res[0]*cos(phi0),
+ res[2]); // (x,y,z)
+ Amg::Vector3D duvec = dvec.unit();
+ // log(chi2) = log( docavec^T * V^-1 * docavec )
+ res[4] = log( dvec.transpose() * (poscov+mCovTrk3D).inverse()
+ * dvec );
+ res[7] = duvec.transpose()*poscov*duvec;
+ res[8] = duvec.transpose()*mCovTrk3D*duvec;
+ res[6] = 3.; // ok
+ }
+ if ( chi2DefToUse == 7 ) {
+ AmgMatrix(3,2) dmat = AmgMatrix(3,2)::Zero();
+ dmat(0,0) = -sin(phi0);
+ dmat(1,0) = cos(phi0);
+ dmat(2,0) = 0.;
+ dmat(0,1) = 0.;
+ dmat(1,1) = 0.;
+ dmat(2,1) = 1.;
+ AmgSymMatrix(2) mCovVtx2D = dmat.transpose()*poscov*dmat;
+ AmgSymMatrix(2) mCovTrk2D = AmgSymMatrix(2)::Zero();
+ mCovTrk2D(0,0) = (*locError)(Trk::d0,Trk::d0);
+ mCovTrk2D(0,1) = (*locError)(Trk::d0,Trk::z0);
+ mCovTrk2D(1,0) = (*locError)(Trk::d0,Trk::z0);
+ mCovTrk2D(1,1) = (*locError)(Trk::z0,Trk::z0);
+ Amg::Vector2D dvec(res[0], res[2]); // (d0, z0)
+ Amg::Vector2D duvec = dvec.unit();
+ // log(chi2) = log( (d0, z0) * V^-1 * (d0, z0)^T )
+ res[4] = log( dvec.transpose()*(mCovVtx2D+mCovTrk2D).inverse()
+ * dvec );
+ res[7] = duvec.transpose()*mCovVtx2D*duvec;
+ res[8] = duvec.transpose()*mCovTrk2D*duvec;
+ res[6] = 4.; // ok
+ }
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
+ << " doca == 0 !");
+ }
+ } // if chi2DefToUse > 5 && chi2DefToUse < 8
+ res[5] = doDCAin3D ?
+ sqrt( pow(res[0], 2.) + pow(res[2], 2.) ) : res[0];
+ res[6] += 1.; // ok
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
+ " locError pointer is NULL!");
+ }
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
+ " trkPerigee pointer is NULL!");
+ } // if trkPerigee
+
+ } else if ( chi2DefToUse == 2
+ || (chi2DefToUse > 7 && chi2DefToUse < 10 )) {
+ // simple extrapolation method
+ // (directly taken from NtupleMaker for comparisons)
+
+ // SV position and covariance matrix
+ TVector3 SV_def(vtx->x(), vtx->y(), vtx->z());
+ const AmgSymMatrix(3)& SV_cov = poscov;
+
+ // chi2 track to SV
+ double px = ( track->p4() ).Px();
+ double py = ( track->p4() ).Py();
+ double pt = ( track->p4() ).Pt();
+ double d0 = track->d0();
+ double d0Err2 = track->definingParametersCovMatrixVec()[0];
+ double z0 = track->z0();
+ double z0Err2 = track->definingParametersCovMatrixVec()[2];
+ double theta = track->theta();
+ double d0z0Cov = track->definingParametersCovMatrixVec()[1];
+ double phi = track->phi();
+
+ TVector3 trk_origin( track->vx(), track->vy(), track->vz() );
+ TVector3 SV = SV_def - trk_origin;
+
+ // calc. error in direction perpendicular to pT (still x-y plane)
+ double upx = py/pt;
+ double upy = -px/pt;
+ double d0toSV = d0 + (SV[0]*upx + SV[1]*upy);
+ double d0toSVErr2 = upx*SV_cov(0, 0)*upx + 2*upx*SV_cov(1, 0)*upy
+ + upy*SV_cov(1, 1)*upy + d0Err2;
+
+ upx = px/pt;
+ upy = py/pt;
+ double cot_theta = cos(theta)/sin(theta);
+ double z0corr = (SV[0]*upx + SV[1]*upy)*cot_theta;
+ double z0toSV = z0 + z0corr - SV[2];
+ double z0toSVErr2 = SV_cov(2, 2) + z0Err2;
+
+ double docaSV = sqrt( pow(d0toSV, 2) + pow(z0toSV, 2) );
+
+ double chi2testSV(999.);
+ if ( chi2DefToUse == 2 ) {
+ if (d0toSVErr2 !=0 && z0toSVErr2 != 0)
+ chi2testSV = log(pow( d0toSV, 2)/d0toSVErr2
+ + pow( z0toSV, 2)/z0toSVErr2);
+ // set results
+ res = {d0toSV, sqrt(d0toSVErr2), z0toSV, sqrt(z0toSVErr2),
+ chi2testSV, (doDCAin3D ? docaSV : d0toSV), 4,
+ -99., -99., -999.};
+ }
+ if ( chi2DefToUse > 7 && chi2DefToUse < 10 ) {
+ if ( docaSV > 0. ) {
+ if ( chi2DefToUse == 8 ) {
+ AmgMatrix(5,3) dmat = AmgMatrix(5,3)::Zero();
+ dmat(0,0) = -sin(phi);
+ dmat(0,1) = cos(phi);
+ dmat(1,2) = 1.;
+ dmat(2,0) = -d0toSV*cos(phi);
+ dmat(2,1) = -d0toSV*sin(phi);
+ const AmgSymMatrix(5) mCovTrk5D =
+ track->definingParametersCovMatrix();
+ AmgSymMatrix(3) mCovTrk3D = dmat.transpose()*mCovTrk5D*dmat;
+ Amg::Vector3D dvec(-d0toSV*sin(phi), d0toSV*cos(phi),
+ z0toSV); // (x,y,z)
+ Amg::Vector3D duvec = dvec.unit();
+ // log(chi2) = log( docavec^T * V^-1 * docavec )
+ double chi2testSV = log( dvec.transpose()
+ * (poscov+mCovTrk3D).inverse()
+ * dvec );
+ double vtx3DErr2 = duvec.transpose()*poscov*duvec;
+ double trk3DErr2 = duvec.transpose()*mCovTrk3D*duvec;
+ // set results
+ res = {d0toSV, sqrt(d0Err2), z0toSV, sqrt(z0Err2),
+ chi2testSV, (doDCAin3D ? docaSV : d0toSV), 5,
+ vtx3DErr2, trk3DErr2, phi};
+ }
+ if ( chi2DefToUse == 9 ) {
+ AmgMatrix(3,2) dmat = AmgMatrix(3,2)::Zero();
+ dmat(0,0) = -sin(phi);
+ dmat(1,0) = cos(phi);
+ dmat(2,0) = 0.;
+ dmat(0,1) = 0.;
+ dmat(1,1) = 0.;
+ dmat(2,1) = 1.;
+ AmgSymMatrix(2) mCovVtx2D = dmat.transpose()*SV_cov*dmat;
+ AmgSymMatrix(2) mCovTrk2D = AmgSymMatrix(2)::Zero();
+ mCovTrk2D(0,0) = d0Err2;
+ mCovTrk2D(0,1) = d0z0Cov;
+ mCovTrk2D(1,0) = d0z0Cov;
+ mCovTrk2D(1,1) = z0Err2;
+ Amg::Vector2D dvec(d0toSV, z0toSV);
+ Amg::Vector2D duvec = dvec.unit();
+ // log(chi2) = log( (d0, z0) * V^-1 * (d0, z0)^T )
+ chi2testSV = log( dvec.transpose()*(mCovVtx2D+mCovTrk2D).inverse()
+ * dvec );
+ double vtx2DErr2 = duvec.transpose()*mCovVtx2D*duvec;
+ double trk2DErr2 = duvec.transpose()*mCovTrk2D*duvec;
+
+ if ( vtx2DErr2 < 0. || trk2DErr2 < 0. ) {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::"
+ "getTrackLogChi2DCA(): "
+ << "vtx2DErr2 = " << vtx2DErr2
+ << " trk2DErr2 = " << trk2DErr2
+ << " chi2testSV = " << chi2testSV);
+ ATH_MSG_WARNING("dvec = " << dvec);
+ ATH_MSG_WARNING("mCovVtx2D = " << mCovVtx2D);
+ ATH_MSG_WARNING("mCovTrk2D = " << mCovTrk2D);
+ ATH_MSG_WARNING("dmat = " << dmat);
+ ATH_MSG_WARNING("SV_cov = " << SV_cov);
+ ATH_MSG_WARNING("det(mCovVtx2D) = " << mCovVtx2D.determinant());
+ ATH_MSG_WARNING("det(mCovTrk2D) = " << mCovTrk2D.determinant());
+ ATH_MSG_WARNING("det(SV_cov) = " << SV_cov.determinant());
+ ATH_MSG_WARNING("d0toSV = " << d0toSV
+ << " z0toSV = " << z0toSV
+ << " phi = " << phi
+ << " docaSV = " << docaSV);
+ }
+
+ // set results
+ res = {d0toSV, sqrt(d0Err2), z0toSV, sqrt(z0Err2),
+ chi2testSV, (doDCAin3D ? docaSV : d0toSV), 6,
+ vtx2DErr2, trk2DErr2, phi};
+ }
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
+ << " docaSV == 0 !");
+ }
+ } // if chi2DefToUse > 7 && chi2DefToUse < 10
+
+ } else if ( chi2DefToUse > 2 && chi2DefToUse < 5 ) {
+ // CalcLogChi2toPV method using xAOD::TrackingHelpers
+ // (simply taken from NtupleMaker for comparisons)
+ // N.B. z0significance method of the helper doesn't include pv_z0
+ // uncertainty
+ double d0sign(0.);
+ if (chi2DefToUse == 4) {
+ d0sign =
+ xAOD::TrackingHelpers::d0significance(track,
+ m_eventInfo->beamPosSigmaX(),
+ m_eventInfo->beamPosSigmaY(),
+ m_eventInfo->beamPosSigmaXY()
+ );
+ } else {
+ d0sign = xAOD::TrackingHelpers::d0significance( track );
+ }
+ // trk z0 is expressed relative to the beamspot position along z-axis
+ // (trk->vz())
+ // DCA always in 3D
+ double z0toPV = track->z0() + track->vz() - vtx->z();
+ double z0Err2 = track->definingParametersCovMatrixVec()[2];
+ if (chi2DefToUse == 4) z0Err2+= vtx->covariancePosition()(2,2);
+ double z0sign = z0toPV / sqrt( z0Err2 );
+ double chi2 = log( pow(d0sign, 2.) + pow(z0sign, 2.) );
+ // set results
+ res = {-999., -99., z0toPV, sqrt(z0Err2), chi2, -100., 4, -99., -99.,
+ -999.};
+
+ } // if chi2DefToUse
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
+ " track pointer is NULL!");
+ res[6] = -2.;
+ } // if track != NULL
+ return res;
+ }
+ //--------------------------------------------------------------------------
+ // detTrackTypes(): returns a bit pattern of the applicable
+ // track types from {ASSOCPV, PVTYPE0, PVTYPE1, PVTYPE2, PVTYPE3, NONE,
+ // NULLVP, CAPVXXXXXXX, ...} (or'd).
+ //--------------------------------------------------------------------------
+ uint64_t BPhysVertexTrackBase::detTrackTypes(const xAOD::TrackParticle* track,
+ const xAOD::Vertex* candPV,
+ const xAOD::Vertex* candRefPV) const {
+ int bits = 0x0;
+
+ // PVTYPE0 - PVTYPE3, NONE
+ ATH_MSG_ERROR("BPhysVertexTrackBase::detTrackTypes must be adjusted due to changes in TrackParticle");
+
+ // ASOCPV
+ if ( candPV != NULL ) {
+ bool found(false);
+ for (size_t i=0; i<candPV->nTrackParticles(); ++i) {
+ if ( track == candPV->trackParticle(i) ) {
+ found = true;
+ break;
+ }
+ }
+ if ( found ) bits |= track_type_bit[ASSOCPV];
+ //
+ // CLOSEAPV
+ for (unsigned int i=7; i<n_track_types; ++i) {
+ if ( (track_type_bit[i] & m_trackTypesUsed) > 0x0 ) {
+ bool useRefittedPvs = ( i%2 == 1 );
+ bool doDCAin3D = ( (i-7)%4 > 1 );
+ int chi2DefToUse = (i-7)/4;
+ // adjustment above bit 20
+ if ( i > 20 ) {
+ doDCAin3D = true;
+ chi2DefToUse = (i-13)/2;
+ }
+ const xAOD::Vertex* minChi2PV(nullptr);
+ if ( chi2DefToUse == 5 ) {
+ minChi2PV =
+ findAssocPV(track, candPV, candRefPV, m_pvTypesToConsider,
+ m_minNTracksInPV, useRefittedPvs);
+ } else {
+ minChi2PV =
+ findMinChi2PV(track, candPV, candRefPV, m_pvTypesToConsider,
+ m_minNTracksInPV, useRefittedPvs,
+ doDCAin3D, chi2DefToUse).first;
+ } // if chi2DefToUse
+ if ( candPV == minChi2PV
+ || (candRefPV != nullptr && candRefPV == minChi2PV) ) {
+ bits |= track_type_bit[i];
+ }
+ } // if m_trackTypesUsed
+ } // for i
+
+ } // if candPV != NULL
+
+ return bits;
+ }
+ //--------------------------------------------------------------------------
+ // findAllTracksInDecay: returns a vector of xAOD::TrackParticle objects
+ // found in this vertex and subsequent decay vertices (if chosen).
+ //--------------------------------------------------------------------------
+ TrackBag BPhysVertexTrackBase::findAllTracksInDecay(xAOD::BPhysHelper& vtx)
+ const {
+
+ TrackBag tracks;
+ findAllTracksInDecay(vtx, tracks);
+
+ return tracks;
+ }
+ //--------------------------------------------------------------------------
+ // findAllTracksInDecay: fills a vector of xAOD::TrackParticle objects
+ // found in this vertex and subsequent decay vertices (if chosen).
+ // Method avoids duplicate entries in vector.
+ // Recursively calls itself if necessary.
+ //--------------------------------------------------------------------------
+ void BPhysVertexTrackBase::findAllTracksInDecay(xAOD::BPhysHelper& vtx,
+ TrackBag& tracks)
+ const {
+
+ for (unsigned int i=0; i < vtx.vtx()->nTrackParticles(); ++i) {
+ const xAOD::TrackParticle* track = vtx.vtx()->trackParticle(i);
+ if ( std::find(tracks.begin(),tracks.end(),track) == tracks.end() ) {
+ tracks.push_back(track);
+ } // if
+ } // for
+ // loop over preceeding vertices
+ if ( m_incPrecVerticesInDecay ) {
+ for (int ivtx = 0; ivtx < vtx.nPrecedingVertices(); ++ivtx) {
+ xAOD::BPhysHelper precVtx(vtx.precedingVertex(ivtx));
+ findAllTracksInDecay(precVtx, tracks);
+ } // if
+ } // for
+ }
+ //--------------------------------------------------------------------------
+ // findAllMuonsInDecay: returns a vector of xAOD::Muon objects
+ // found in this vertex and subsequent decay vertices (if chosen).
+ //--------------------------------------------------------------------------
+ MuonBag BPhysVertexTrackBase::findAllMuonsInDecay(xAOD::BPhysHelper& vtx)
+ const {
+
+ MuonBag muons;
+ findAllMuonsInDecay(vtx, muons);
+
+ return muons;
+ }
+ //--------------------------------------------------------------------------
+ // findAllMuonsInDecay: fills vector of xAOD::Muon objects
+ // found in this vertex and subsequent decay vertices (if chosen).
+ // Method avoids duplicate entries in vector.
+ // Recursively calls itself if necessary.
+ //--------------------------------------------------------------------------
+ void BPhysVertexTrackBase::findAllMuonsInDecay(xAOD::BPhysHelper& vtx,
+ MuonBag& muons)
+ const {
+
+ for (int i=0; i < vtx.nMuons(); ++i) {
+ if ( std::find(muons.begin(),muons.end(),vtx.muon(i)) == muons.end() ) {
+ muons.push_back(vtx.muon(i));
+ } // if
+ } // for
+ // loop over preceeding vertices
+ if ( m_incPrecVerticesInDecay ) {
+ for (int ivtx = 0; ivtx < vtx.nPrecedingVertices(); ++ivtx) {
+ xAOD::BPhysHelper precVtx(vtx.precedingVertex(ivtx));
+ findAllMuonsInDecay(precVtx, muons);
+ } // for
+ } // if
+ }
+ //--------------------------------------------------------------------------
+ // findAllMuonsIdTracksInDecay: returns a vector of xAOD::TrackParticle
+ // objects found in this vertex and subsequent decay vertices.
+ // Returns the tracks.
+ // The vector of track pointers reeturned may contain NULL elements.
+ //--------------------------------------------------------------------------
+ TrackBag
+ BPhysVertexTrackBase::findAllMuonIdTracksInDecay(xAOD::BPhysHelper& vtx,
+ MuonBag& muons) const {
+
+ TrackBag tracks;
+ muons = findAllMuonsInDecay(vtx);
+
+ for (MuonBag::const_iterator muItr = muons.begin(); muItr != muons.end();
+ ++muItr) {
+ const xAOD::TrackParticle* track =
+ (*muItr)->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
+ tracks.push_back(track);
+ } // for
+
+ return tracks;
+ }
+ //--------------------------------------------------------------------------
+ // findMuonRefTrackMomenta: returns a vector<TVector3> containing the
+ // three momenta of refitted tracks identified as muons.
+ // The vector may contain (0,0,0) elements indicating an error.
+ //--------------------------------------------------------------------------
+ std::vector<TVector3>
+ BPhysVertexTrackBase::findMuonRefTrackMomenta(xAOD::BPhysHelper& vtx,
+ MuonBag& muons) const {
+
+ std::vector<TVector3> refMuTracks;
+
+ // quick solution if nRefTrks == nMuons:
+ if ( vtx.nRefTrks() == vtx.nMuons() && !m_incPrecVerticesInDecay ) {
+ muons = vtx.muons();
+ for ( auto refMuTrack : vtx.refTrks() ) {
+ refMuTracks.push_back(refMuTrack);
+ }
+ } else {
+ TrackBag muonIdTracks = findAllMuonIdTracksInDecay(vtx, muons);
+ if ( vtx.nRefTrks() == (int)vtx.vtx()->nTrackParticles() ) {
+ for (int i=0; i<vtx.nRefTrks(); ++i) {
+ const xAOD::TrackParticle* otp =
+ (const xAOD::TrackParticle*)vtx.refTrkOrigin(i);
+ if ( otp != NULL ) {
+ if ( std::find(muonIdTracks.begin(), muonIdTracks.end(), otp)
+ != muonIdTracks.end() ) {
+ refMuTracks.push_back(vtx.refTrk(i));
+ }
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::findMuonRefTrackMomenta():"
+ " refTrkOrigin == NULL for refTrk # "
+ << i << " !");
+ }
+ } // for
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::findMuonRefTrackMomenta():"
+ " size mismatch #refTrks = " << vtx.nRefTrks()
+ << "#trackParticles = " << vtx.vtx()->nTrackParticles()
+ << " !");
+ } // if nRefTracks == nTrackParticles
+ // loop over preceeding vertices -- only if not all refMuTrks found yet
+ if ( m_incPrecVerticesInDecay && muons.size() > refMuTracks.size() ) {
+ for (int ivtx = 0; ivtx < vtx.nPrecedingVertices(); ++ivtx) {
+ xAOD::BPhysHelper precVtx(vtx.precedingVertex(ivtx));
+ std::vector<TVector3> precRefMuTracks =
+ findMuonRefTrackMomenta(precVtx, muons);
+ // append only if not yet contained in
+ for ( auto precRefMuTrack : precRefMuTracks ) {
+ if ( std::find(refMuTracks.begin(), refMuTracks.end(),
+ precRefMuTrack) == refMuTracks.end() ) {
+ refMuTracks.push_back(precRefMuTrack);
+ } // if
+ } // for
+ } // for ivtx
+ } // if
+ } // if (shortcut)
+
+ // debug output
+ if ( msgLvl( MSG::DEBUG ) ) {
+ ATH_MSG_DEBUG("BPhysVertexTrackBase::findMuonRefTrackMomenta():"
+ << " #muons: " << muons.size()
+ << " #refMuTrks: " << refMuTracks.size());
+ TString str = Form(">> refMuTracks(%d):\n", (int)refMuTracks.size());
+ for (unsigned int i=0; i < refMuTracks.size(); ++i) {
+ str += Form("(%10.4f,%10.4f,%10.4f) ",
+ refMuTracks[i].x(), refMuTracks[i].y(),
+ refMuTracks[i].z());
+ }
+ ATH_MSG_DEBUG(str.Data());
+ }
+
+ return refMuTracks;
+ }
+
+ //--------------------------------------------------------------------------
+ // selectTracks: returns a vector of xAOD::TrackParticle objects
+ // seleted from the input track collection according to the selection
+ // criteria and with respect to the B candidate vertex.
+ //--------------------------------------------------------------------------
+ TrackBag BPhysVertexTrackBase::selectTracks(const
+ xAOD::TrackParticleContainer*
+ inpTracks,
+ xAOD::BPhysHelper& cand,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const {
+
+ return selectTracks(inpTracks, findAllTracksInDecay(cand), cand,
+ ipv, its, itt);
+ }
+ //--------------------------------------------------------------------------
+ // selectTracks: returns a vector of xAOD::TrackParticle objects
+ // seleted from the input track collection according to the selection
+ // criteria and with respect to the B candidate vertex.
+ //--------------------------------------------------------------------------
+ TrackBag BPhysVertexTrackBase::selectTracks(const
+ xAOD::TrackParticleContainer*
+ inpTracks,
+ const TrackBag& exclTracks,
+ xAOD::BPhysHelper& cand,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const {
+
+ const xAOD::Vertex* candRefPV = cand.pv(m_pvAssocTypes[ipv]);
+ const xAOD::Vertex* candPV = cand.origPv(m_pvAssocTypes[ipv]);
+
+ ATH_MSG_DEBUG("selectTracks: Found " << exclTracks.size()
+ << " " << exclTracks
+ << " for decay candidate " << cand.vtx()
+ << "; candPV: " << candPV << " candRefPV: " << candRefPV);
+
+ std::string bname(buildBranchBaseName(its, ipv, itt));
+
+ // tracks to be considered
+ TrackBag tracks;
+ for (xAOD::TrackParticleContainer::const_iterator trkItr =
+ inpTracks->begin(); trkItr != inpTracks->end(); ++trkItr) {
+ const xAOD::TrackParticle* track = *trkItr;
+ uint64_t trackTypesForTrack(0x0);
+ // debug track types (before any cuts)
+ if ( m_debugTrackTypes > 0 ) {
+ trackTypesForTrack = detTrackTypes(track, candPV, candRefPV);
+ m_mttc->addToCounter(trackTypesForTrack, itt, bname, "all");
+ }
+ // track selection check
+ if ( ! m_trackSelectionTools[its]->accept(*track, candRefPV) ) continue;
+ // debug track types (after track selection cuts)
+ if ( m_debugTrackTypes > 0 ) {
+ m_mttc->addToCounter(trackTypesForTrack, itt, bname, "ats");
+ }
+
+ // calcluation of track type bits not necessary if all bits requested
+ if ( ! ((unsigned int)m_useTrackTypes[itt] == ttall() ||
+ (unsigned int)m_useTrackTypes[itt] == ttallMin()) ) {
+ // track type check -- determination if not in debugging mode
+ // delayed for execution speed reasons
+ if ( trackTypesForTrack == 0x0 ) {
+ trackTypesForTrack = detTrackTypes(track, candPV, candRefPV);
+ }
+ if ( (trackTypesForTrack & m_useTrackTypes[itt]) == 0x0 ) {
+ continue;
+ }
+ }
+ // debug track types (after track type cuts)
+ if ( m_debugTrackTypes > 0 ) {
+ m_mttc->addToCounter(trackTypesForTrack, itt, bname, "att");
+ }
+ // track not in list of tracks to exclude
+ if ( std::find(exclTracks.begin(), exclTracks.end(), track)
+ != exclTracks.end() ) continue;
+ // debug track types (after all cuts)
+ if ( m_debugTrackTypes > 0 ) {
+ m_mttc->addToCounter(trackTypesForTrack, itt, bname, "fin");
+ }
+ // tracks that survived so far
+ tracks.push_back(track);
+ } // for
+
+ return tracks;
+ }
+ //--------------------------------------------------------------------------
+ // buildBranchBaseName: build branch name from track selection, primary
+ // vertex association and track type qualifiers.
+ //--------------------------------------------------------------------------
+ std::string BPhysVertexTrackBase::buildBranchBaseName(unsigned int its,
+ unsigned int ipv,
+ unsigned int itt,
+ std::string preSuffix)
+ const {
+
+ ATH_MSG_DEBUG("BPhysVertexTrackBase::buildBranchBaseName -- begin");
+
+ std::string tsName = m_trackSelectionTools[its].name();
+ std::string pvAssoc = xAOD::BPhysHelper::pv_type_str[m_pvAssocTypes[ipv]];
+
+ // need to get part of tsname after last underscore
+ std::size_t ipos = tsName.find_last_of("_");
+ if ( ipos != std::string::npos ) tsName = tsName.substr(ipos+1);
+
+ // format it nicely
+ boost::format f("T%010d_%s_%s%s%s");
+ f % m_useTrackTypes[itt] % tsName % pvAssoc;
+ f % (preSuffix.length() > 0 ? "_"+preSuffix : "");
+ f % (m_branchSuffix.length() > 0 ? "_"+m_branchSuffix : "");
+
+ ATH_MSG_DEBUG("BPhysVertexBaseTrackBase::buildBranchBaseName: " << f.str());
+
+ return f.str();
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Initialize PV-to-SV association type vector
+ //
+ //--------------------------------------------------------------------------
+ void BPhysVertexTrackBase::initPvAssocTypeVec() {
+
+ m_pvAssocTypes.clear();
+ for (unsigned int i=0; i<xAOD::BPhysHelper::n_pv_types; ++i) {
+ if ( (m_doVertexType & (1 << i)) > 0 )
+ m_pvAssocTypes.push_back((xAOD::BPhysHelper::pv_type)i);
+ }
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Find primary vertex to which a track is closest to in terms of minimum
+ // chi2 to any primary vertex. Replace primary vertex by refitted primary
+ // vertex (for B candidate associated primary vertices)
+ // if appropriate (and available).
+ // Only consider primary vertices of specified primary vertex types and
+ // with a minimum number of tracks.
+ //
+ //--------------------------------------------------------------------------
+ std::pair<const xAOD::Vertex*, double>
+ BPhysVertexTrackBase::findMinChi2PV(const xAOD::TrackParticle* track,
+ const xAOD::Vertex* candPV,
+ const xAOD::Vertex* candRefPV,
+ const std::vector<uint64_t>& pvtypes,
+ const int minNTracksInPV,
+ const bool useRefittedPvs,
+ const bool doDCAin3D,
+ const int chi2DefToUse) const {
+
+ double minChi2 = std::numeric_limits<double>::max();
+ const xAOD::Vertex* minChi2PV(nullptr);
+
+ for (auto pvtx: *m_pvtxContainer) {
+ if ( pvtx != nullptr ) {
+ if ( std::find(pvtypes.begin(),pvtypes.end(),pvtx->vertexType())
+ != pvtypes.end() ) {
+ const xAOD::Vertex* cvtx = pvtx;
+ // replace by refitted PV if associated PV matches orignal PV
+ if ( useRefittedPvs && pvtx == candPV ) {
+ if ( candRefPV != nullptr ) {
+ cvtx = candRefPV;
+ } else {
+ ATH_MSG_WARNING(" BPhysVertexTrackBase::findMinChi2PV:"
+ << " candRefPV == NULL!");
+ continue;
+ }
+ } // if pvtx == candPV
+ if ( (int)cvtx->nTrackParticles() >= minNTracksInPV ) {
+ double chi2 = getTrackLogChi2DCA(track, cvtx, doDCAin3D,
+ chi2DefToUse)[4];
+ if ( chi2 < minChi2 ) {
+ minChi2 = chi2;
+ minChi2PV = cvtx;
+ } // if chi2 < minChi2
+ } // if minNTracksInPV
+ } // if pvTypes in pvtypes vector
+ } // if pvtx != nullptr
+ } // for pvtx
+
+ return std::make_pair(minChi2PV, minChi2);
+ }
+ //--------------------------------------------------------------------------
+ //
+ // Find primary vertex to which a track is closest using the
+ // TrackVertexAssociationTool. Replace primary vertex by refitted primary
+ // vertex (for B candidate associated primary vertices)
+ // if appropriate (and available).
+ // Only consider primary vertices of specified primary vertex types and
+ // with a minimum number of tracks.
+ //
+ //--------------------------------------------------------------------------
+ const xAOD::Vertex*
+ BPhysVertexTrackBase::findAssocPV(const xAOD::TrackParticle* track,
+ const xAOD::Vertex* candPV,
+ const xAOD::Vertex* candRefPV,
+ const std::vector<uint64_t>& pvtypes,
+ const int minNTracksInPV,
+ const bool useRefittedPvs) const {
+
+ // select PVs to be considered/replace candPV by candRefPV if requested
+ std::vector<const xAOD::Vertex*> vpvtx;
+ for (auto pvtx: *m_pvtxContainer) {
+ if ( pvtx != nullptr ) {
+ if ( std::find(pvtypes.begin(),pvtypes.end(),pvtx->vertexType())
+ != pvtypes.end() ) {
+ const xAOD::Vertex* cvtx = pvtx;
+ // replace by refitted PV if associated PV matches orignal PV
+ if ( useRefittedPvs && pvtx == candPV ) {
+ if ( candRefPV != nullptr ) {
+ cvtx = candRefPV;
+ } else {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::findAssocPV:"
+ << " candRefPV == NULL!");
+ continue;
+ }
+ } // if pvtx == candPV
+ if ( (int)cvtx->nTrackParticles() >= minNTracksInPV ) {
+ vpvtx.push_back(cvtx);
+ } // if minNTracksInPV
+ } // if pvTypes in pvtypes vector
+ } // if pvtx != nullptr
+ } // for pvtx
+
+ const xAOD::Vertex* assocPV(NULL);
+ if ( useRefittedPvs && m_tvaToolHasWpLoose ) {
+ // check whether track is in refitted PV - if so accept
+ // Need to do this here as the TrackVertexAssociationTool
+ // with WP 'Loose' only checks the track->vertex() pointer
+ // which always points to the original PV.
+ for (const auto &tp : candRefPV->trackParticleLinks()) {
+ if ( *tp == track ) {
+ // track is part of refitted PV -- accept it
+ assocPV = candRefPV;
+ break;
+ }
+ } // for tp
+ // if not matching use the TrackVertexAssociationTool (other PVs etc)
+ if ( assocPV == nullptr ) {
+ assocPV = m_tvaTool->getUniqueMatchVertex(*track, vpvtx);
+ }
+ } else {
+ assocPV = m_tvaTool->getUniqueMatchVertex(*track, vpvtx);
+ } // if useRefittedPvs && m_tvaToolHasWpLoose
+ if ( assocPV == nullptr ) {
+ ATH_MSG_WARNING("BPhysVertexTrackBase::findAssocPV:"
+ << " assocPV == NULL for track!"
+ << " len(vpvtx) = " << vpvtx.size()
+ << " useRefittedPvs = " << useRefittedPvs
+ << " minNTracksInPV = " << minNTracksInPV);
+ }
+
+ return assocPV;
+ }
+ //--------------------------------------------------------------------------
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BTrackVertexMapLogger.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BTrackVertexMapLogger.cxx
new file mode 100644
index 00000000000..aa3a40ab2a5
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BTrackVertexMapLogger.cxx
@@ -0,0 +1,104 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BTrackVertexMapLogger.cxx
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+// - w.w., 2017-01-22: Added use of BPhysMetaDataTool.
+//
+// Store JO metadata in the output file.
+//
+// It uses the BPhysMetaDataTool (default) or the IOVDbMetaDataTool to
+// store job option information as metadata in a specific branch whose
+// name needs to prefixed by the deriviation format name.
+// Note: Metadata stored by the IOVDbMetaDataTool is not readable on
+// 'RootCore' level.
+//
+// This is a base class. Inherit from it to add the job options you want
+// to store. For a usage example, see
+// Bmumu_metadata.h / Bmumu_metadata.cxx
+// and
+// BPHY8.py .
+//
+// Job options provided by the base class:
+// - DerivationName -- assign the name of the derivation format
+// - MetadataFolderName -- assign the name of the metadata folder,
+// should start with the derivation format name,
+// defaults to DerivationName if not set.
+// - UseIOVDbMetaDataTool -- use the IOVDbMetaDataTool to store
+// the additional metadata
+// - UseBPhysMetaDataTool -- use the BPhysMetaDataTool to store
+// the additional metadata
+//
+//============================================================================
+//
+
+#include "DerivationFrameworkBPhys/BTrackVertexMapLogger.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+
+namespace DerivationFramework {
+
+ //--------------------------------------------------------------------------
+ BTrackVertexMapLogger::BTrackVertexMapLogger(const std::string& t,
+ const std::string& n,
+ const IInterface* p)
+ : AthAlgTool(t,n,p) {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare BPhysTrackVertexMapTool handles
+ declareProperty("TrackVertexMapTools", m_ttvmTools);
+
+ // Enable log output?
+ declareProperty("Enable", m_enable = true);
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BTrackVertexMapLogger::initialize() {
+
+ ATH_MSG_DEBUG("BTrackVertexMapLogger::initialize() -- begin");
+
+ // get the BPhysTrackVertexMapTools
+ if ( m_enable ) {
+ for (auto ttvmTool : m_ttvmTools) {
+ ATH_CHECK( ttvmTool.retrieve() );
+ ATH_MSG_INFO("initialize: Successfully retrieved "
+ << ttvmTool.name() << " ....");
+ }
+ } // if m_enable
+
+ ATH_MSG_DEBUG("BTrackVertexMapLogger::initialize() -- end");
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BTrackVertexMapLogger::finalize() {
+
+ ATH_MSG_DEBUG("BTrackVertexMapLogger::finalize()");
+
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BTrackVertexMapLogger::addBranches() const {
+
+ ATH_MSG_DEBUG("BTrackVertexMapLogger::addBranches()");
+
+ // call the BPhysTrackVertexMapTools
+ if ( m_enable ) {
+ for (auto ttvmTool : m_ttvmTools) {
+ if ( ttvmTool->doLog() ) {
+ ATH_MSG_INFO("addBranches: dump for " << ttvmTool.name() << ":");
+ ATH_CHECK( ttvmTool->logEvent() );
+ } // if doLog()
+ } // for
+ } // if m_enable
+
+ // still everything is ok
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BVertexClosestTrackTool.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BVertexClosestTrackTool.cxx
new file mode 100644
index 00000000000..e6771bb459f
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BVertexClosestTrackTool.cxx
@@ -0,0 +1,672 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BVertexClosestTrackTool.cxx
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Add B vertex closest track information for different configurations,
+// different track selections and different PV-to-SV association methods.
+//
+// For an usage example see BPHY8.py .
+//
+// Job options provided by this class:
+// - CloseTrackChi2SetName -- list with labels for the following
+// four settings (all five lists must
+// be of exactly same length)
+// - CloseTrackCorrChi2 -- list with options for using the
+// SV uncertainties in the chi2 calculation
+// in addition to track uncertainties
+// 0 : use old method
+// (only track uncertainties)
+// 1 : from track perigee with
+// uncertainties from track and vertex
+// 2 : simple extrapolation from track
+// parameters with uncertainties from
+// track and vertex (extrapolation
+// used for track swimming)
+// - CloseTrackMinDCAin3D -- use 3-dimensional information in
+// minimization (list)
+// - CloseTrackMaxLogChi2 -- maximum chi2 distance of closest track
+// to B vertex (list)
+// - NCloseTrackMaxLogChi2 -- maximum chi2 distance of track
+// to B vertex for track counting (list)
+//
+//============================================================================
+//
+#include "DerivationFrameworkBPhys/BVertexClosestTrackTool.h"
+#include "xAODMuon/MuonContainer.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
+#include "EventPrimitives/EventPrimitivesHelpers.h"
+#include "AthLinks/ElementLink.h"
+
+#include "boost/format.hpp"
+#include "TVector3.h"
+#include <algorithm>
+#include <sstream>
+
+namespace DerivationFramework {
+
+ //-------------------------------------------------------------------------
+ //
+ // helper class
+ BVertexClosestTrackTool::CtItem::CtItem(std::string Name, std::string Prefix,
+ std::string Bname,
+ double Dca, double DcaErr,
+ double Zca, double ZcaErr,
+ double VtxNDErr2, double TrkNDErr2, double Phi0Used,
+ int NTrksChi2,
+ xAOD::TrackParticle* CloseTrack,
+ TrackBag Tracks,
+ std::vector<std::vector<double> > Vtap,
+ std::vector<unsigned short> Selpat)
+ : BaseItem(Name, Bname, Prefix), dca(Dca), dcaErr(DcaErr),
+ zca(Zca), zcaErr(ZcaErr), vtxNDErr2(VtxNDErr2), trkNDErr2(TrkNDErr2),
+ phi0Used(Phi0Used),
+ nTrksChi2(NTrksChi2), closeTrack(CloseTrack),
+ tracks(Tracks), vtap(Vtap), selpat(Selpat) {
+ }
+
+ BVertexClosestTrackTool::CtItem::~CtItem() {
+ }
+
+ void BVertexClosestTrackTool::CtItem::setup(std::string Name,
+ std::string Bname,
+ std::string Prefix) {
+ BaseItem::setup(Name, Bname, Prefix);
+ dca = -999.;
+ dcaErr = -99.;
+ zca = -999.;
+ zcaErr = -99.;
+ vtxNDErr2 = -99.;
+ trkNDErr2 = -99.;
+ phi0Used = -999.;
+ nTrksChi2 = 0;
+ closeTrack = NULL;
+ tracks.clear();
+ vtap.clear();
+ selpat.clear();
+ }
+
+ void BVertexClosestTrackTool::CtItem::setup(std::string Name,
+ std::string Bname,
+ std::string Prefix,
+ double Dca, double DcaErr,
+ double Zca, double ZcaErr,
+ double VtxNDErr2, double TrkNDErr2, double Phi0Used,
+ int NTrksChi2,
+ xAOD::TrackParticle*
+ CloseTrack,
+ TrackBag Tracks,
+ std::vector<std::vector<double> > Vtap,
+ std::vector<unsigned short> Selpat) {
+ BaseItem::setup(Name, Bname, Prefix);
+ dca = Dca;
+ dcaErr = DcaErr;
+ zca = Zca;
+ zcaErr = ZcaErr;
+ vtxNDErr2 = VtxNDErr2;
+ trkNDErr2 = TrkNDErr2;
+ phi0Used = Phi0Used;
+ nTrksChi2 = NTrksChi2;
+ closeTrack = CloseTrack;
+ tracks = Tracks;
+ vtap = Vtap;
+ selpat = Selpat;
+ }
+
+ void BVertexClosestTrackTool::CtItem::resetVals() {
+ dca = -999.;
+ dcaErr = -99.;
+ zca = -999.;
+ zcaErr = -99.;
+ vtxNDErr2 = -99.;
+ trkNDErr2 = -99.;
+ phi0Used = -999.;
+ nTrksChi2 = 0;
+ closeTrack = NULL;
+ tracks.clear();
+ vtap.clear();
+ selpat.clear();
+ }
+
+ void BVertexClosestTrackTool::CtItem::copyVals(const BaseItem& item) {
+ copyVals((const CtItem&)item);
+ }
+
+ void BVertexClosestTrackTool::CtItem::copyVals(const CtItem& item) {
+ dca = item.dca;
+ dcaErr = item.dcaErr;
+ zca = item.zca;
+ zcaErr = item.zcaErr;
+ vtxNDErr2 = item.vtxNDErr2;
+ trkNDErr2 = item.trkNDErr2;
+ phi0Used = item.phi0Used;
+ nTrksChi2 = item.nTrksChi2;
+ closeTrack = item.closeTrack;
+ tracks = item.tracks;
+ vtap = item.vtap;
+ selpat = item.selpat;
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::dcaName() {
+ return buildName("DCA");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::dcaErrName() {
+ return buildName("DCAError");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::zcaName() {
+ return buildName("ZCA");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::zcaErrName() {
+ return buildName("ZCAError");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::vtxNDErr2Name() {
+ return buildName("VtxNDError2");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::trkNDErr2Name() {
+ return buildName("TrkNDError2");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::phi0UsedName() {
+ return buildName("Phi0Used");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::nTrksChi2Name() {
+ return buildName("NTracksChi2");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::closeTrackName() {
+ return buildName("CloseTrack", "_Link");
+ }
+
+ std::string BVertexClosestTrackTool::CtItem::toString() const {
+ boost::format f1("dca: %10.6f %10.6f zca: %10.6f %10.6f nt: %10d");
+ f1 % dca % dcaErr % zca % zcaErr % nTrksChi2;
+ boost::format f2("%s\n %s\n");
+ f2 % BPhysVertexTrackBase::BaseItem::toString();
+ f2 % f1.str();
+ std::string rstr = f2.str();
+ rstr += "per track: p(px, py, pz)\n";
+ rstr += " d(d0, z0, phi, theta, qoverp)\n";
+ rstr += " d0, d0Err, z0, z0Err, logChi2, dca, okFlag\n";
+ rstr += " vtxNDErr2, trkNDErr2, phi0Used\n";
+ rstr += " vtxNDErr, trkNDErr, log(chi2Err2Sum)\n";
+ // loop over tracks
+ if (tracks.size() == vtap.size() && vtap.size() == selpat.size()) {
+ for (unsigned int i=0; i<tracks.size(); ++i) {
+ boost::format f3(" %3d %2d ");
+ f3 % i % selpat[i];
+ std::string f3str = f3.str();
+ // 0: d0, 1: d0Err, 2: z0, 3: z0Err, 4: logChi2, 5: dca, 6: okFlag
+ // 7: vtxNDErr2, 8: trkNDErr2, 9: phi0Used
+ boost::format f4("%s\nd0: %10.4f %10.4f z0: %10.4f %10.4f "
+ "lc2: %10.4f dca: %10.4f ok: %3f\n"
+ "vtxNDErr2: %10.4f trkNDErr2: %10.4f "
+ "phi0Used: %10.4f\n"
+ "vtxNDErr: %10.4f trkNDErr2 %10.4f "
+ "logChi2Err2Sum: %10.4f");
+ f4 % trackToString(tracks[i]);
+ f4 % vtap[i][0] % vtap[i][1] % vtap[i][2] % vtap[i][3];
+ f4 % vtap[i][4] % vtap[i][5] % vtap[i][6];
+ f4 % vtap[i][7] % vtap[i][8] % vtap[i][9];
+ f4 % (vtap[i][7] < 0. ? -99. : sqrt(vtap[i][7]));
+ f4 % (vtap[i][8] < 0. ? -99. : sqrt(vtap[i][8]));
+ f4 % (vtap[i][7]+vtap[i][8] > 0. ?
+ log(vtap[i][5]*vtap[i][5]/(vtap[i][7]+vtap[i][8])) : -999.);
+ std::string tstr = wrapLines(f4.str(),
+ std::string(f3str.length(), ' '));
+ tstr.replace(0,f3str.length(),f3str);
+ rstr.append(tstr+"\n");
+ } // for i
+ } else {
+ boost::format f5("Mismatch: nTracks: %d nVtap: %d nSelpat: %d\n");
+ f5 % tracks.size() % vtap.size() % selpat.size();
+ rstr.append(f5.str());
+ } // if sizes
+
+ rstr.erase(rstr.length()-1);
+ return rstr;
+ }
+
+ //--------------------------------------------------------------------------
+ BVertexClosestTrackTool::BVertexClosestTrackTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p)
+ : BPhysVertexTrackBase(t,n,p), m_lastRunNumber(0), m_lastEvtNumber(0),
+ m_svIdx(0) {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ declareProperty("CloseTrackChi2SetName", m_closeTrackChi2SetName = {"def"});
+ declareProperty("CloseTrackCorrChi2" , m_closeTrackCorrChi2 = {0});
+ declareProperty("CloseTrackMinDCAin3D" , m_minDCAin3D = {true});
+ declareProperty("CloseTrackMaxLogChi2" , m_closeTrackMaxLogChi2 = {-1.});
+ declareProperty("NCloseTrackMaxLogChi2", m_nCloseTrackMaxLogChi2 = {-1.});
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BVertexClosestTrackTool::initializeHook() {
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initializeHook() -- begin");
+
+ // check job options
+ if ( m_closeTrackChi2SetName.size() == 0 ) {
+ ATH_MSG_ERROR("No chi2 set names provided!");
+ }
+ if ( m_closeTrackCorrChi2.size() == 0 ) {
+ ATH_MSG_ERROR("No use of corrected chi2 settings provided!");
+ }
+ if ( m_minDCAin3D.size() == 0 ) {
+ ATH_MSG_ERROR("No use of min DCA in 3D settings provided!");
+ }
+ if ( m_closeTrackMaxLogChi2.size() == 0 ) {
+ ATH_MSG_ERROR("No cuts on max log chi2 for DOCA calculation provided!");
+ }
+ if ( m_nCloseTrackMaxLogChi2.size() == 0 ) {
+ ATH_MSG_ERROR("No cuts on max log chi2 for nClosetTracks calculation "
+ "provided!");
+ }
+ if ( m_closeTrackCorrChi2.size() != m_closeTrackChi2SetName.size() ||
+ m_minDCAin3D.size() != m_closeTrackChi2SetName.size() ||
+ m_closeTrackMaxLogChi2.size() != m_closeTrackChi2SetName.size() ||
+ m_nCloseTrackMaxLogChi2.size() != m_closeTrackChi2SetName.size() ) {
+ ATH_MSG_ERROR("Size mismatch of CloseTrackChi2SetName ("
+ << m_closeTrackChi2SetName.size() << "), "
+ << "CloseTrackCorrChi2 ("
+ << m_closeTrackCorrChi2 << "), "
+ << "CloseTrackMinDCAin3D ("
+ << m_minDCAin3D.size() << "), "
+ << "CloseTrackMaxLogChi2 ("
+ << m_closeTrackMaxLogChi2.size() << ") and/or "
+ << "NCloseTrackMaxLogChi2 ("
+ << m_nCloseTrackMaxLogChi2.size() << ")");
+ }
+
+ // initialize results array
+ initResults();
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initializeHook() -- end");
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BVertexClosestTrackTool::finalizeHook() {
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::finalizeHook()");
+
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexClosestTrackTool::addBranchesVCSetupHook(size_t ivc) const {
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::addBranchesVCLoopHook() -- begin");
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::addBranchesVCSetupHook: "
+ << "Vertex container index " << ivc
+ << " for collection " << m_vertexContainerNames[ivc]
+ << " with prefix " << m_branchPrefixes[ivc]);
+
+ setResultsPrefix(m_branchPrefixes[ivc]);
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::addBranchesVCSetupHook() -- end");
+
+ // nothing to do here
+ return StatusCode::SUCCESS;
+ }
+
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexClosestTrackTool::addBranchesSVLoopHook(const xAOD::Vertex* vtx) const {
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::addBranchesSVLoopHook() -- begin");
+
+ // calculate closest track values
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::addBranchesSVLoopHook(): "
+ "calculate closest track ...");
+ CHECK(calculateValues(vtx));
+
+ // save the closest track values
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::addBranchesSVLoopHook(): "
+ "save closest track ...");
+ CHECK(saveClosestTrack(vtx));
+
+ // dump close track item debugging information
+ if (m_debugTracksInThisEvent) {
+ CHECK(logCloseTracksDebugInfo());
+ }
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::addBranchesSVLoopHook() -- end");
+
+ // nothing to do here
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Calculate closest track variables -- method called from caching loop
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexClosestTrackTool::calcValuesHook(const xAOD::Vertex* vtx,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const {
+
+ ATH_MSG_DEBUG("calcValuesHook: ipv: " << ipv
+ << ", its: " << its << ", itt: " << itt);
+
+ // candidate tracks and momentum
+ xAOD::BPhysHelper cand(vtx);
+
+ // tracks to be considered
+ TrackBag tracks = selectTracks(m_tracks, cand, ipv, its, itt);
+
+ // loop over chi2 setting sets
+ unsigned int nChi2Sets = m_closeTrackChi2SetName.size();
+ for (unsigned int ics = 0; ics < nChi2Sets; ++ics) {
+
+ CtItem& cti = m_results[its][ipv][itt][ics];
+
+ // presets
+ cti.resetVals();
+
+ double closestTrkDCA = 9999.;
+ int closestTrkIdx(-1);
+ unsigned int trkIdx(0);
+ for (TrackBag::const_iterator trkItr = tracks.begin();
+ trkItr != tracks.end(); ++trkItr, ++trkIdx) {
+
+ //
+ // track selection bit pattern:
+ // bit 0 : included in number of close tracks
+ // bit 1 : chosen as closest track
+ //
+ unsigned short selpat(0);
+
+ // Returned vector components:
+ // 0: d0, 1: d0Err, 2: z0, 3: z0Err, 4: logChi2, 5: dca, 6: okFlag
+ // 7: vtxErrPart2, 8: trkErrPart2, 9: phi0Used
+ std::vector<double> vtap =
+ getTrackLogChi2DCA(*trkItr, cand.vtx(),
+ m_minDCAin3D[ics], m_closeTrackCorrChi2[ics]);
+ ATH_MSG_DEBUG("calcValuesHook: track: " << *trkItr
+ << ", logChi2: " << vtap[4] << ", dca: " << vtap[5]);
+
+ // track values at perigee found?
+ if ( vtap[6] >= 0. ) {
+ ATH_MSG_DEBUG("calcValuesHook: checking track count for "
+ "m_nCloseTrackMaxLogChi2[ics] = "
+ << m_nCloseTrackMaxLogChi2[ics]);
+ // count tracks
+ if ( vtap[4] < m_nCloseTrackMaxLogChi2[ics] ) {
+ cti.nTrksChi2++;
+ selpat |= 1;
+ ATH_MSG_DEBUG("calcValuesHook: nTrksChi2++ for track " << *trkItr);
+ }
+ // find closest track
+ ATH_MSG_DEBUG("calcValuesHook: log(chi2) check: "
+ "m_closeTrackMaxLogChi2[ics]: "
+ << m_closeTrackMaxLogChi2[ics]
+ << ", logChi2: " << vtap[4]
+ << ", closestTrkDCA: " << closestTrkDCA
+ << ", dca: " << fabs(vtap[5]));
+ if ( fabs(vtap[5]) < closestTrkDCA &&
+ vtap[4] < m_closeTrackMaxLogChi2[ics] ) {
+ closestTrkDCA = fabs(vtap[5]);
+ cti.dca = vtap[0];
+ cti.dcaErr = vtap[1];
+ cti.zca = vtap[2];
+ cti.zcaErr = vtap[3];
+ cti.vtxNDErr2 = vtap[7];
+ cti.trkNDErr2 = vtap[8];
+ cti.phi0Used = vtap[9];
+ cti.closeTrack = *trkItr;
+ closestTrkIdx = trkIdx;
+ ATH_MSG_DEBUG("calcValuesHook: closestTrkDCA now: "
+ << closestTrkDCA
+ << " for track " << *trkItr);
+ }
+ } // if ok
+ cti.tracks.push_back(*trkItr);
+ cti.vtap.push_back(vtap);
+ cti.selpat.push_back(selpat);
+ } // for tracks
+ // mark closest track
+ if (closestTrkIdx > -1 && closestTrkIdx < (int)cti.selpat.size()) {
+ cti.selpat[closestTrkIdx] |= 2;
+ }
+ } // for ics
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Fill closest track values from cache if found
+ //--------------------------------------------------------------------------
+ bool BVertexClosestTrackTool::fastFillHook(const xAOD::Vertex* vtx,
+ const int ipv) const {
+
+ ATH_MSG_DEBUG("fastFillHook: ipv: " << ipv);
+
+ bool found(false);
+
+ StringIntMap_t::iterator itpv =
+ m_pvAssocResMap.find(buildPvAssocCacheName(vtx, ipv));
+ if ( itpv != m_pvAssocResMap.end() ) {
+ found = true;
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+ unsigned int nChi2Sets = m_closeTrackChi2SetName.size();
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ for (unsigned int ics = 0; ics < nChi2Sets; ++ics) {
+ m_results[its][ipv][itt][ics]
+ .copyVals(m_results[its][itpv->second][itt][ics]);
+ } // for ics
+ } // for its
+ } // for itt
+ } // if found
+
+ ATH_MSG_DEBUG("fastFillHook: cache index: "
+ << buildPvAssocCacheName(vtx, ipv)
+ << ", found ? " << found
+ << ", ipv_ref: "
+ << (found ? itpv->second : -1));
+
+ return found;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexClosestTrackTool::saveClosestTrack(const xAOD::Vertex* vtx) const {
+
+ typedef ElementLink< xAOD::TrackParticleContainer > TrackParticleLink_t;
+
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+ unsigned int nChi2Sets = m_closeTrackChi2SetName.size();
+
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ for (unsigned int ics = 0; ics < nChi2Sets; ++ics) {
+ CtItem result = m_results[its][ipv][itt][ics];
+ SG::AuxElement::Decorator< float >
+ d_dca_value(result.dcaName());
+ SG::AuxElement::Decorator< float >
+ d_dcaErr_value(result.dcaErrName());
+ SG::AuxElement::Decorator< float >
+ d_zca_value(result.zcaName());
+ SG::AuxElement::Decorator< float >
+ d_zcaErr_value(result.zcaErrName());
+ SG::AuxElement::Decorator< int >
+ d_nTrksChi2_value(result.nTrksChi2Name());
+ d_dca_value(*vtx) = result.dca;
+ d_dcaErr_value(*vtx) = result.dcaErr;
+ d_zca_value(*vtx) = result.zca;
+ d_zcaErr_value(*vtx) = result.zcaErr;
+ d_nTrksChi2_value(*vtx) = result.nTrksChi2;
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::saveClosestTrack() "
+ << "-- dca: " << result.dcaName()
+ << ", dcaErr: " << result.dcaErrName()
+ << ", zca: " << result.zcaName()
+ << ", zcaErr: " << result.zcaErrName()
+ << ", nTrksChi2: " << result.nTrksChi2Name());
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::saveClosestTrack() "
+ << "-- vertex: ("
+ << vtx->x() << ", "
+ << vtx->y() << ", "
+ << vtx->z() << ")"
+ << ", dca: " << result.dca
+ << ", dcaErr: " << result.dcaErr
+ << ", zca: " << result.zca
+ << ", zcaErr: " << result.zcaErr
+ << ", nTrksChi2: " << result.nTrksChi2);
+ // add ElementLink to closest track
+ std::string linkName = result.closeTrackName();
+ SG::AuxElement::Decorator<TrackParticleLink_t>
+ tpLinkDecor(linkName);
+ TrackParticleLink_t tpLink;
+ if ( result.closeTrack != NULL ) {
+ tpLink.toContainedElement( *m_tracks, result.closeTrack );
+ }
+ ATH_MSG_DEBUG("saveClosestTrack: Decorate vtx "
+ << vtx << " with " << linkName
+ << ", closeTrkPtr: " << result.closeTrack);
+ tpLinkDecor(*vtx) = tpLink;
+ if ( tpLink.isValid() ) {
+ ATH_MSG_DEBUG("saveClosestTrack: Decorated vtx "
+ << vtx << " with " << linkName
+ << ", closeTrkPtr: " << result.closeTrack);
+ } else {
+ ATH_MSG_VERBOSE("saveClosestTrack: Failed to decorate vtx "
+ << vtx << " with " << linkName
+ << ", closeTrkPtr: "
+ << result.closeTrack << " !");
+ }
+ // if valid
+ } // for ics
+ } // for itt
+ } // for ipv
+ } // for its
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ void BVertexClosestTrackTool::setResultsPrefix(std::string prefix) const {
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::setResultsPrefix -- begin");
+
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+ unsigned int nChi2Sets = m_closeTrackChi2SetName.size();
+
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ for (unsigned int ics = 0; ics < nChi2Sets; ++ics) {
+ m_results[its][ipv][itt][ics].setPrefix(prefix);
+ } // for ics
+ } // for itt
+ } // for ipv
+ } // for its
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::setResultsPrefix -- end");
+ }
+ //--------------------------------------------------------------------------
+ void BVertexClosestTrackTool::initResults() {
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults -- begin");
+
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+ unsigned int nChi2Sets = m_closeTrackChi2SetName.size();
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults : nTrackSels = "
+ << nTrackSels);
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults : nPvAssocs = "
+ << nPvAssocs);
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults : nTrackTypes = "
+ << nTrackTypes);
+ m_results.resize(boost::extents[nTrackSels][nPvAssocs][nTrackTypes][nChi2Sets]);
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults -- its = " << its);
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults -- ipv = " << ipv);
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults -- itt = "
+ << itt);
+ for (unsigned int ics = 0; ics < nChi2Sets; ++ics) {
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults -- ics = "
+ << ics);
+ std::string csname = m_closeTrackChi2SetName[ics];
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults : "
+ << m_branchBaseName << ", "
+ << buildBranchBaseName(its, ipv, itt, csname));
+ m_results[its][ipv][itt][ics].setup(buildBranchBaseName(its, ipv,
+ itt,
+ csname),
+ m_branchBaseName);
+ } // for ics
+ } // for itt
+ } // for ipv
+ } // for its
+
+ ATH_MSG_DEBUG("BVertexClosestTrackTool::initResults -- end");
+ }
+ //--------------------------------------------------------------------------
+ // Dump CloseTracks debug information to log file
+ //--------------------------------------------------------------------------
+ StatusCode BVertexClosestTrackTool::logCloseTracksDebugInfo() const {
+
+ // Count candidates
+ if (m_runNumber != m_lastRunNumber || m_evtNumber != m_lastEvtNumber) {
+ m_lastRunNumber = m_runNumber;
+ m_lastEvtNumber = m_evtNumber;
+ m_svIdx = 0;
+ } else {
+ m_svIdx++;
+ }
+
+ std::string str(">>>>> logCloseTracksDebugInfo:\n");
+ boost::format f("Run %d Event %d SV %d\n");
+ f % m_runNumber % m_evtNumber % m_svIdx;
+ str.append(f.str());
+
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+ unsigned int nChi2Sets = m_closeTrackChi2SetName.size();
+
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ for (unsigned int ics = 0; ics < nChi2Sets; ++ics) {
+ boost::format f1("its: %d ipv: %d itt: %d ics: %d\n");
+ f1 % its % ipv % itt % its;
+ str.append(f1.str());
+ CtItem result = m_results[its][ipv][itt][ics];
+ str.append(result.toString()+"\n");
+ } // for ics
+ } // for itt
+ } // for ipv
+ } // for its
+
+ str.append("<<<<< logCloseTracksDebugInfo");
+ ATH_MSG_INFO(str);
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BVertexTrackIsoTool.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BVertexTrackIsoTool.cxx
new file mode 100644
index 00000000000..6bb527ea80e
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BVertexTrackIsoTool.cxx
@@ -0,0 +1,511 @@
+/*
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// BVertexTrackIsoTool.cxx
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Add B vertex track isolation information for different configurations,
+// different track selections and different PV-to-SV association methods.
+//
+// For an usage example see BPHY8.py .
+//
+// Job options provided by this class:
+// - IsolationConeSizes -- List of isolation cone sizes
+// - IsoTrkImpLogChi2Max -- List of maximum log(chi2) cuts for
+// association of tracks to the primary
+// vertex picked.
+// - IsoDoTrkImpLogChi2Cut -- apply log(chi2) cuts
+// 0 : don't apply log(chi2) cuts
+// 1 : apply log(chi2) cuts
+// 2 : apply log(chi2) cuts [former version]
+// (The last two job options must
+// contain the same number of elements
+// as the IsolationConeSizes list.)
+// - UseOptimizedAlgo -- Use the speed-optimized algorithm.
+//
+//============================================================================
+//
+#include "DerivationFrameworkBPhys/BVertexTrackIsoTool.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
+#include "EventPrimitives/EventPrimitivesHelpers.h"
+
+#include "boost/format.hpp"
+#include "TVector3.h"
+#include <algorithm>
+#include <sstream>
+
+namespace DerivationFramework {
+
+ //-------------------------------------------------------------------------
+ //
+ // helper class
+ BVertexTrackIsoTool::IsoItem::IsoItem(std::string Name,
+ std::string Bname,
+ std::string Prefix,
+ double IsoValue,
+ int NTracks) :
+ BaseItem(Name, Bname, Prefix), isoValue(IsoValue), nTracks(NTracks) {
+ }
+
+ BVertexTrackIsoTool::IsoItem::~IsoItem() {
+ }
+
+ void BVertexTrackIsoTool::IsoItem::setup(std::string Name,
+ std::string Bname,
+ std::string Prefix) {
+ BaseItem::setup(Name, Bname, Prefix);
+ isoValue = -1.;
+ nTracks = 0;
+ }
+
+ void BVertexTrackIsoTool::IsoItem::setup(std::string Name,
+ std::string Bname,
+ std::string Prefix,
+ double IsoValue,
+ int NTracks) {
+ BaseItem::setup(Name, Bname, Prefix);
+ isoValue = IsoValue;
+ nTracks = NTracks;
+ }
+
+ void BVertexTrackIsoTool::IsoItem::resetVals() {
+ isoValue = -2.;
+ nTracks = -1;
+ }
+
+ void BVertexTrackIsoTool::IsoItem::copyVals(const BaseItem& item) {
+ copyVals((const IsoItem&)item);
+ }
+
+ void BVertexTrackIsoTool::IsoItem::copyVals(const IsoItem& item) {
+ isoValue = item.isoValue;
+ nTracks = item.nTracks;
+ }
+
+ std::string BVertexTrackIsoTool::IsoItem::isoName() {
+ return buildName();
+ }
+
+ std::string BVertexTrackIsoTool::IsoItem::nTracksName() {
+ return buildName("Ntracks");
+ }
+
+ //--------------------------------------------------------------------------
+ BVertexTrackIsoTool::BVertexTrackIsoTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p)
+ : BPhysVertexTrackBase(t,n,p) {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ declareProperty("IsolationConeSizes" , m_isoConeSizes);
+ declareProperty("IsoTrkImpLogChi2Max" , m_isoTrkImpLogChi2Max);
+ declareProperty("IsoDoTrkImpLogChi2Cut" , m_isoDoTrkImpLogChi2Cut);
+ declareProperty("UseOptimizedAlgo" , m_useOptimizedAlgo = true);
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BVertexTrackIsoTool::initializeHook() {
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initializeHook() -- begin");
+
+ // check like-sized arrays
+ if ( m_isoConeSizes.size() != m_isoTrkImpLogChi2Max.size() ||
+ m_isoConeSizes.size() != m_isoDoTrkImpLogChi2Cut.size() ) {
+ ATH_MSG_ERROR("Size mismatch of IsolationConeSizes ("
+ << m_isoConeSizes.size()
+ << "), IsoTrkImpChi2Max ("
+ << m_isoTrkImpLogChi2Max.size()
+ << ") and IsoDoTrkImpChi2Cut ("
+ << m_isoDoTrkImpLogChi2Cut.size() << ") lists!");
+ }
+
+ // initialize results array
+ initResults();
+
+ // info output
+ ATH_MSG_INFO("calculateIsolation: using "
+ << (m_useOptimizedAlgo ?
+ "optimized (faster)" : "regular (slower)")
+ << "track isolation calculation methd.");
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initializeHook() -- end");
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode BVertexTrackIsoTool::finalizeHook() {
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::finalizeHook()");
+
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexTrackIsoTool::addBranchesVCSetupHook(size_t ivc) const {
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::addBranchesVCLoopHook() -- begin");
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::addBranchesVCSetupHook: "
+ << "Vertex container index " << ivc
+ << " for collection " << m_vertexContainerNames[ivc]
+ << " with prefix " << m_branchPrefixes[ivc]);
+
+ setResultsPrefix(m_branchPrefixes[ivc]);
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::addBranchesVCSetupHook() -- end");
+
+ // nothing to do here
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexTrackIsoTool::addBranchesSVLoopHook(const xAOD::Vertex* vtx) const {
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::addBranchesSVLoopHook() -- begin");
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::addBranchesSVLoopHook(): "
+ "calculate isolation ...");
+ if ( m_useOptimizedAlgo ) {
+ CHECK(calculateValues(vtx));
+ } else {
+ CHECK(calculateIsolation(vtx));
+ }
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::addBranchesSVLoopHook(): "
+ "save isolation ...");
+ // save the isolation values
+ CHECK(saveIsolation(vtx));
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::addBranchesSVLoopHook() -- end");
+
+ // nothing to do here
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Calculate track isolation variables -- faster method with caching
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexTrackIsoTool::calcValuesHook(const xAOD::Vertex* vtx,
+ const unsigned int ipv,
+ const unsigned int its,
+ const unsigned int itt) const {
+
+ ATH_MSG_DEBUG("calcValuesHook: ipv: " << ipv
+ << ", its: " << its << ", itt: " << itt);
+
+ // candidate tracks and momentum
+ xAOD::BPhysHelper cand(vtx);
+ TVector3 candP = cand.totalP();
+ const xAOD::Vertex* candRefPV = cand.pv(m_pvAssocTypes[ipv]);
+
+ TrackBag tracks = selectTracks(m_tracks, cand, ipv, its, itt);
+
+ // loop over isolation cones (pt and deltaR)
+ unsigned int nCones = m_isoConeSizes.size();
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+
+ IsoItem& iso = m_results[ic][its][ipv][itt];
+ const double& coneSize = m_isoConeSizes[ic];
+ const double& logChi2Max = m_isoTrkImpLogChi2Max[ic];
+ const int& doLogChi2 = m_isoDoTrkImpLogChi2Cut[ic];
+
+ // presets
+ iso.resetVals();
+
+ double nTracksInCone = 0;
+ double ptSumInCone = 0.;
+
+ // make sure candRefPV exists
+ if ( candRefPV != NULL ) {
+
+ for (TrackBag::const_iterator trkItr = tracks.begin();
+ trkItr != tracks.end(); ++trkItr) {
+ double deltaR = candP.DeltaR((*trkItr)->p4().Vect());
+ if ( deltaR < coneSize ) {
+ double logChi2 = (doLogChi2 > 0) ?
+ getTrackCandPVLogChi2(*trkItr, candRefPV) : -9999.;
+ // next line needed exactly as is for backward validation
+ if ( doLogChi2 == 2 ) logChi2 = abs(logChi2);
+ if ( doLogChi2 == 0 || logChi2 < logChi2Max ) {
+ nTracksInCone++;
+ ptSumInCone += (*trkItr)->pt();
+ } // logChi2
+ } // deltaR
+ }
+ // calculate result
+ if ( ptSumInCone + candP.Pt() > 0. ) {
+ iso.isoValue = candP.Pt() / ( ptSumInCone + candP.Pt() );
+ } else {
+ iso.isoValue = -5.;
+ }
+
+ } else {
+ iso.isoValue = -10.;
+ } // if candRefPV != NULL
+
+ iso.nTracks = nTracksInCone;
+ } // for ic
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Fill track isolation values from cache if found
+ //--------------------------------------------------------------------------
+ bool BVertexTrackIsoTool::fastFillHook(const xAOD::Vertex* vtx,
+ const int ipv) const {
+
+ ATH_MSG_DEBUG("fastFillHook: ipv: " << ipv);
+
+ bool found(false);
+
+ StringIntMap_t::iterator itpv =
+ m_pvAssocResMap.find(buildPvAssocCacheName(vtx, ipv));
+ if ( itpv != m_pvAssocResMap.end() ) {
+ found = true;
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ m_results[ic][its][ipv][itt]
+ .copyVals(m_results[ic][its][itpv->second][itt]);
+ } // for its
+ } // for ic
+ } // for itt
+ } // if found
+
+ ATH_MSG_DEBUG("fastFillHook: cache index: "
+ << buildPvAssocCacheName(vtx, ipv)
+ << ", found ? " << found
+ << ", ipv_ref: "
+ << (found ? itpv->second : -1));
+
+ return found;
+ }
+ //--------------------------------------------------------------------------
+ // Track isolation calculation loops -- slower method
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexTrackIsoTool::calculateIsolation(const xAOD::Vertex* vtx) const {
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::calculateIsolation -- begin");
+
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ CHECK(calcIsolation(m_results[ic][its][ipv][itt], vtx,
+ m_isoConeSizes[ic], m_isoTrkImpLogChi2Max[ic],
+ m_isoDoTrkImpLogChi2Cut[ic],
+ m_trackSelectionTools[its],
+ m_pvAssocTypes[ipv], m_useTrackTypes[itt]));
+ } // for itt
+ } // for ic
+ } // for ipv
+ } // for its
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Calculate track isolation variables -- slower method
+ //--------------------------------------------------------------------------
+ StatusCode BVertexTrackIsoTool::
+ calcIsolation(const IsoItem& iso,
+ const xAOD::Vertex* vtx,
+ const double coneSize,
+ const double logChi2Max,
+ const int doLogChi2,
+ const ToolHandle<TrkSelTool>& tSelTool,
+ const xAOD::BPhysHelper::pv_type pvAssocType,
+ const int trackTypes ) const {
+
+ // preset
+ iso.nTracks = -1;
+ iso.isoValue = -2.;
+
+ // candidate tracks and momentum
+ xAOD::BPhysHelper cand(vtx);
+ TrackBag candTracks = findAllTracksInDecay(cand);
+ TVector3 candP = cand.totalP();
+ const xAOD::Vertex* candRefPV = cand.pv(pvAssocType);
+ const xAOD::Vertex* candPV = cand.origPv(pvAssocType);
+
+ // tracks to be considered
+ TrackBag tracks;
+ for (xAOD::TrackParticleContainer::const_iterator trkItr =
+ m_tracks->begin(); trkItr != m_tracks->end(); ++trkItr) {
+ const xAOD::TrackParticle* track = *trkItr;
+ // track selection check
+ if ( ! tSelTool->accept(*track, candRefPV) ) continue;
+ // track type check
+ if ( ! ((unsigned int)trackTypes == ttall() ||
+ (unsigned int)trackTypes == ttallMin() ||
+ (detTrackTypes(track, candPV, candRefPV)
+ & trackTypes) > 0x0) ) continue;
+ // track not in SV
+ if ( std::find(candTracks.begin(), candTracks.end(), track)
+ != candTracks.end() ) continue;
+ // tracks that survived so far
+ tracks.push_back(track);
+ }
+
+ double nTracksInCone = 0;
+ double ptSumInCone = 0.;
+ for (TrackBag::const_iterator trkItr = tracks.begin();
+ trkItr != tracks.end(); ++trkItr) {
+ double deltaR = candP.DeltaR((*trkItr)->p4().Vect());
+ if ( deltaR < coneSize ) {
+ double logChi2 = (doLogChi2 > 0) ?
+ getTrackCandPVLogChi2(*trkItr, candRefPV) : -9999.;
+ // next line needed exactly as is for backward validation
+ if ( doLogChi2 == 2 ) logChi2 = abs(logChi2);
+ if ( doLogChi2 == 0 || logChi2 < logChi2Max ) {
+ nTracksInCone++;
+ ptSumInCone += (*trkItr)->pt();
+ }
+ } // deltaR
+ }
+ // calculate result
+ if ( ptSumInCone + candP.Pt() > 0. ) {
+ iso.isoValue = candP.Pt() / ( ptSumInCone + candP.Pt() );
+ } else {
+ iso.isoValue = -5;
+ }
+ iso.nTracks = nTracksInCone;
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ StatusCode
+ BVertexTrackIsoTool::saveIsolation(const xAOD::Vertex* vtx) const {
+
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ IsoItem result = m_results[ic][its][ipv][itt];
+ SG::AuxElement::Decorator< float >
+ d_iso_value(result.isoName());
+ SG::AuxElement::Decorator< int >
+ d_iso_ntracks(result.nTracksName());
+ d_iso_value(*vtx) = result.isoValue;
+ d_iso_ntracks(*vtx) = result.nTracks;
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::saveIsolation() -- isobn: "
+ << result.isoName() << ", ntbn: "
+ << result.nTracksName());
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::saveIsolation() -- vertex: ("
+ << vtx->x() << ", "
+ << vtx->y() << ", "
+ << vtx->z() << "), iso: "
+ << result.isoValue << ", nTracks: "
+ << result.nTracks);
+ } // for itt
+ } // for ic
+ } // for ipv
+ } // for its
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ void BVertexTrackIsoTool::setResultsPrefix(std::string prefix) const {
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::setResultsPrefix -- begin");
+
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ m_results[ic][its][ipv][itt].setPrefix(prefix);
+ } // for itt
+ } // for ic
+ } // for ipv
+ } // for its
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::setResultsPrefix -- end");
+ }
+ //--------------------------------------------------------------------------
+ void BVertexTrackIsoTool::initResults() {
+
+ unsigned int nCones = m_isoConeSizes.size();
+ unsigned int nTrackSels = m_trackSelectionTools.size();
+ unsigned int nPvAssocs = m_pvAssocTypes.size();
+ unsigned int nTrackTypes = m_useTrackTypes.size();
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults -- begin");
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults : nCones = " << nCones);
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults : nTrackSels = "
+ << nTrackSels);
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults : nPvAssocs = "
+ << nPvAssocs);
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults : nTrackTypes = "
+ << nTrackTypes);
+ m_results.resize(boost::extents[nCones][nTrackSels][nPvAssocs][nTrackTypes]);
+ for (unsigned int its = 0; its < nTrackSels; ++its) {
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults -- its = " << its);
+ for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults -- ipv = " << ipv);
+ for (unsigned int ic = 0; ic < nCones; ++ic) {
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults -- ic = " << ic);
+ for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults -- itt = " << itt);
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults :"
+ << m_branchBaseName << buildBranchName(ic, its,
+ ipv, itt));
+
+ m_results[ic][its][ipv][itt].setup(buildBranchName(ic, its,
+ ipv, itt),
+ m_branchBaseName);
+ } // for itt
+ } // for ic
+ } // for ipv
+ } // for its
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::initResults -- end");
+ }
+ //--------------------------------------------------------------------------
+ std::string BVertexTrackIsoTool::buildBranchName(unsigned int ic,
+ unsigned int its,
+ unsigned int ipv,
+ unsigned int itt) const {
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::buildBranchName -- begin");
+
+ double coneSize = m_isoConeSizes[ic];
+ double logChi2Max = m_isoTrkImpLogChi2Max[ic];
+ int doLogChi2 = m_isoDoTrkImpLogChi2Cut[ic];
+
+ // format it nicely
+ boost::format f("%02d_LC%02dd%1d_%s");
+ f % (int)(coneSize*10.) % (int)(logChi2Max*10.) % doLogChi2
+ % buildBranchBaseName(its, ipv, itt);
+
+ ATH_MSG_DEBUG("BVertexTrackIsoTool::buildBranchName: " << f.str());
+
+ return f.str();
+ }
+ //--------------------------------------------------------------------------
+}
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BmumuThinningTool.cxx_NoCompile b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BmumuThinningTool.cxx_NoCompile
new file mode 100644
index 00000000000..c8a539972c6
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/BmumuThinningTool.cxx_NoCompile
@@ -0,0 +1,1167 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file BmumuThinningTool.cxx
+ * @author Wolfgang Walkowiak <wolfgang.walkowiak@cern.ch>
+ *
+ */
+
+#include "DerivationFrameworkBPhys/BmumuThinningTool.h"
+#include "AthenaKernel/IThinningSvc.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODBase/IParticleHelpers.h"
+#include "AthContainers/AuxElement.h"
+#include "AthContainers/AuxTypeRegistry.h"
+
+#include <string>
+#include <sstream>
+#include <istream>
+#include <vector>
+#include <iomanip>
+#include <algorithm>
+#include <numeric>
+#include <regex>
+#include <boost/algorithm/string.hpp>
+
+namespace DerivationFramework {
+
+ // static members
+ // Note: may later be migrated to xAODBPhys/BPhysHelper
+ std::map<xAOD::BPhysHelper::pv_type, std::string>
+ BmumuThinningTool::PvTypeToVarNameMap =
+ { {xAOD::BPhysHelper::PV_MAX_SUM_PT2, "MaxSumPt2"},
+ {xAOD::BPhysHelper::PV_MIN_A0 , "MinA0" },
+ {xAOD::BPhysHelper::PV_MIN_Z0 , "MinZ0" },
+ {xAOD::BPhysHelper::PV_MIN_Z0_BA , "MinZ0BA" } };
+
+ //--------------------------------------------------------------------------
+ // Constructor
+ //--------------------------------------------------------------------------
+ BmumuThinningTool::BmumuThinningTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ CfAthAlgTool(t, n, p),
+ m_thinningSvc("ThinningSvc", n),
+ m_doCloseTracks(false),
+ m_doPVs(false),
+ m_doRefPVs(false),
+ m_doMuons(false),
+ m_doCalMuons(false),
+ m_doTracks(false) {
+
+ declareInterface<DerivationFramework::IThinningTool>(this);
+
+ // thinning service
+ declareProperty("ThinningService" , m_thinningSvc);
+ // TrackParticle container name
+ declareProperty("TrackParticleContainerName",
+ m_trkPartContName = "InDetTrackParticles");
+ // list of secondary vertex container names
+ declareProperty("VertexContainerNames" , m_vtxContNames);
+ // list of pass flags for the seconary vertices
+ // empty list lets all vertices pass
+ // list length needs to be identical to length of
+ // VertexContainerNames list if AlignPassToVertexList is True
+ declareProperty("VertexPassFlags" , m_vtxPassFlags);
+ // align VertexPassFlags to VertexContainerNames list?
+ // This option causes a 1:1 correlation between the two lists,
+ // i.e. a flag is only applied to the corresponding container
+ // if this option is set to True. (default: false)
+ declareProperty("AlignPassToVertexList",
+ m_alignPassToVertexList = false);
+ // Primary vertex container name
+ declareProperty("PVContainerName" , m_PVContName);
+ // Refitted primary vertex container names
+ // This list must be of same length and order as the m_vtxContNames list
+ // (or empty => no thinning of refitted primary vertex containers)
+ declareProperty("RefPVContainerNames" , m_refPVContNames);
+ // name of the used muon container
+ declareProperty("MuonContainerName" , m_muonContName = "");
+ // name of the calibrated muons container
+ declareProperty("CalibMuonContainerName" , m_calMuonContName = "");
+ // closest track branch base name
+ declareProperty("CloseTrackBranchBaseName", m_ctBranchBaseName);
+ // closest track branch prefixes
+ declareProperty("CloseTrackBranchPrefixes", m_ctBranchPrefixes);
+ // keep tracks for selected (refitted) primary vertices
+ declareProperty("KeepTracksForSelectedPVs", m_keepPVTracks = false);
+ // match vertex muons with calibrated muons
+ declareProperty("MatchCalibratedMuons" , m_matchCalMuons = false);
+ // mark orginal muons for matched calibrated muons as well
+ // (only makes sense if MatchCalibratedMuons = True)
+ declareProperty("MarkMatchedMuons" , m_markMuons = false);
+ // mark calibrated muons for matched original muons as well
+ // (only makes sense if MatchCalibratedMuons = False)
+ declareProperty("MarkMatchedCalMuons" , m_markCalMuons = false);
+ // sync marked muons both ways (forces it)
+ declareProperty("SyncMatchedMuonsBothWays", m_syncMuonsBothWays = false);
+ // allow fast sync of myon masks
+ // (Set to 'False' to force in-depth synchronization of muon masks.)
+ declareProperty("AllowFastMuonMaskSync" , m_allowFastMuonMaskSync = true);
+ // keep tracks for closest tracks
+ declareProperty("KeepCloseTracks" , m_keepCloseTracks = false);
+ // keep tracks for selected muons
+ declareProperty("KeepTracksForMuons" , m_keepSelMuonTracks = false);
+ // keep tracks for selected calibrated muons
+ declareProperty("KeepTracksForCalMuons" , m_keepSelCalMuonTracks = false);
+ // keep (original) muons for selected tracks
+ declareProperty("KeepMuonsForTracks" , m_keepSelTrackMuons = false);
+ // keep calibrated muons for selected tracks
+ declareProperty("KeepCalMuonsForTracks" , m_keepSelTrackCalMuons = false);
+ // apply AND for mask matching for vertices (default: false)
+ declareProperty("ApplyAndForVertices" , m_vertexAnd = false);
+ // apply AND for mask matching for tracks (default: false)
+ declareProperty("ApplyAndForTracks" , m_trackAnd = false);
+ // apply AND for mask matching for muons (default: false)
+ declareProperty("ApplyAndForMuons" , m_muonAnd = false);
+ // thin primary vertex collection
+ declareProperty("ThinPVs" , m_thinPVs = true);
+ // thin refittd primary vertex collections
+ declareProperty("ThinRefittedPVs" , m_thinRefPVs = true);
+ // thin ID track collection
+ declareProperty("ThinTracks" , m_thinTracks = true);
+ // thin muon collections
+ declareProperty("ThinMuons" , m_thinMuons = true);
+ }
+ //--------------------------------------------------------------------------
+ // Destructor
+ //--------------------------------------------------------------------------
+ BmumuThinningTool::~BmumuThinningTool() {
+ }
+ //--------------------------------------------------------------------------
+ // initialization
+ //--------------------------------------------------------------------------
+ StatusCode BmumuThinningTool::initialize() {
+
+ ATH_MSG_INFO("BmumuThinningTool::initialize()");
+
+ // check TrackParticle container name
+ if ( m_trkPartContName == "" ) {
+ ATH_MSG_INFO("No ID track collection provided for thinning.");
+ } else {
+ ATH_MSG_INFO("Using " << m_trkPartContName
+ << " as the source collection for ID track particles.");
+ m_doTracks = true;
+ }
+
+ // check secondary vertex container names
+ if ( m_vtxContNames.empty() ) {
+ ATH_MSG_FATAL("No secondary vertex collections provided for thinning.");
+ return StatusCode::FAILURE;
+ } else {
+ for (std::vector<std::string>::iterator it = m_vtxContNames.begin();
+ it != m_vtxContNames.end(); ++it) {
+ ATH_MSG_INFO("Using " << *it
+ << " as a source collection for secondary vertices.");
+ }
+ }
+
+ // check vertex pass flags
+ if ( m_alignPassToVertexList ) {
+ if ( m_vtxPassFlags.size() != m_vtxContNames.size() ) {
+ ATH_MSG_FATAL("Size mismatch of VertexContainerNames ("
+ << m_vtxContNames.size()
+ << ") and VertexPassFlags ("
+ << m_vtxPassFlags.size() << ")");
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_INFO(std::left << std::setw(35) << "VertexContainerNames"
+ << " : " << "VertexPassFlags");
+ ATH_MSG_INFO(std::setfill('-') << std::setw(70) << ""
+ << std::setfill(' '));
+ for (size_t i=0; i<m_vtxContNames.size(); ++i) {
+ ATH_MSG_INFO(std::left << std::setw(35) << m_vtxContNames[i]
+ << " : " << m_vtxPassFlags[i]);
+ }
+ }
+ } else {
+ if ( m_vtxPassFlags.empty() ) {
+ ATH_MSG_INFO("No VertexPassFlags: all secondary vertices will be "
+ << "accepted.");
+ } else {
+ std::string str;
+ for (size_t i=0; i < m_vtxPassFlags.size(); ++i) {
+ if (i > 0) str += ", ";
+ str += m_vtxPassFlags[i];
+ }
+ ATH_MSG_INFO("VertexPassFlags applied to all vertices:");
+ ATH_MSG_INFO(str);
+ }
+ }
+
+ // check primary vertex container name
+ if ( m_PVContName == "" ) {
+ ATH_MSG_FATAL("No primary vertex collection provided for thinning.");
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_INFO("Using " << m_PVContName
+ << " as the source collection for primary vertices.");
+ m_doPVs = true;
+ }
+
+ // check refitted primary vertex container names
+ if ( m_refPVContNames.empty() ) {
+ ATH_MSG_INFO("No refitted PV collections provided for thinning.");
+ } else {
+ if ( m_refPVContNames.size() != m_vtxContNames.size() ) {
+ ATH_MSG_FATAL("Size mismatch of VertexContainerNames ("
+ << m_vtxContNames.size()
+ << ") and RefPVContainerNames ("
+ << m_refPVContNames.size() << ")");
+ return StatusCode::FAILURE;
+ } else {
+ for (std::vector<std::string>::iterator it = m_refPVContNames.begin();
+ it != m_refPVContNames.end(); ++it) {
+ ATH_MSG_INFO("Using " << *it
+ << " as a source collection for refitted PVs.");
+ }
+ m_doRefPVs = true;
+ }
+ }
+
+ // check muon container name
+ if ( m_muonContName == "" ) {
+ ATH_MSG_INFO("No (orginal) muon collection provided for thinning.");
+ } else {
+ ATH_MSG_INFO("Using " << m_muonContName
+ << " as a source collection for (original) muons.");
+ m_doMuons = true;
+ }
+
+ // check calibrated muons container name
+ if ( m_calMuonContName == "" ) {
+ ATH_MSG_INFO("No calibrated muons collection provided for thinning.");
+ } else {
+ ATH_MSG_INFO("Using " << m_calMuonContName
+ << " as a source collection for calibrated muons.");
+ m_doCalMuons = true;
+ }
+
+ // check muon thinning settings
+ if ( m_thinMuons ) {
+ if ( (m_matchCalMuons || m_markCalMuons) && !m_doCalMuons ) {
+ ATH_MSG_ERROR("No container for calibrated muons given!");
+ }
+ if ( (!m_matchCalMuons || m_markMuons) && !m_doMuons ) {
+ ATH_MSG_ERROR("No container for (original) muons given!");
+ }
+ if ( m_matchCalMuons && m_markCalMuons ) {
+ ATH_MSG_WARNING("Configuration issue: both MatchWithCalMuons and "
+ << "MarkMatchedCalMuons set to true! "
+ << "Ignoring the second setting.");
+ }
+ if ( !m_matchCalMuons && m_markMuons ) {
+ ATH_MSG_WARNING("Configuration issue: MatchWithCalMuons set to "
+ << "false and "
+ << "MarkMatchedMuons set to true! "
+ << "Ignoring the second setting.");
+ }
+ ATH_MSG_INFO("MatchWithCalMuons: " << m_matchCalMuons
+ << ", MarkMatchedMuons: " << m_markMuons
+ << ", MarkMatchedCalMuons: " << m_markCalMuons);
+ }
+
+ // check closest track settings
+ m_doCloseTracks = (m_ctBranchBaseName != "" && !m_ctBranchPrefixes.empty());
+ if ( m_doCloseTracks ) {
+ for (std::vector<std::string>::iterator it = m_ctBranchPrefixes.begin();
+ it != m_ctBranchPrefixes.end(); ++it) {
+
+ ATH_MSG_INFO("Keeping tracks for "
+ << *it << "_" << m_ctBranchBaseName << "_*");
+ }
+ } else {
+ ATH_MSG_INFO("Not keeping anything for closest tracks in thinning.");
+ }
+
+ // check track container for combination of track and muon thinning
+ if ( (m_thinTracks || m_thinMuons) && !m_doTracks) {
+ ATH_MSG_FATAL("Requested track or muon thinning but required "
+ "track container not provided");
+ return StatusCode::FAILURE;
+ }
+
+ // Output of options
+ ATH_MSG_INFO("=== Option settings - begin ===");
+ ATH_MSG_INFO("KeepTracksForSelectedPVs : " << m_keepPVTracks);
+ ATH_MSG_INFO("MatchCalibratedMuons : " << m_matchCalMuons);
+ ATH_MSG_INFO("MarkMatchedMuons : " << m_markMuons);
+ ATH_MSG_INFO("MarkMatchedCalMuons : " << m_markCalMuons);
+ ATH_MSG_INFO("SyncMatchedMuonsBothWays : " << m_syncMuonsBothWays);
+ ATH_MSG_INFO("AllowFastMuonMaskSync : " << m_allowFastMuonMaskSync);
+ ATH_MSG_INFO("KeepCloseTracks : " << m_keepCloseTracks);
+ ATH_MSG_INFO("KeepTracksForMuons : " << m_keepSelMuonTracks);
+ ATH_MSG_INFO("KeepTracksForCalMuons : " << m_keepSelCalMuonTracks);
+ ATH_MSG_INFO("KeepMuonsForTracks : " << m_keepSelTrackMuons);
+ ATH_MSG_INFO("KeepCalMuonsForTracks : " << m_keepSelTrackCalMuons);
+ ATH_MSG_INFO("ApplyAndForVertices : " << m_vertexAnd);
+ ATH_MSG_INFO("ApplyAndForTracks : " << m_trackAnd);
+ ATH_MSG_INFO("ApplyAndForMuons : " << m_muonAnd);
+ ATH_MSG_INFO("ThinPVs : " << m_thinPVs);
+ ATH_MSG_INFO("ThinRefittedPVs : " << m_thinRefPVs);
+ ATH_MSG_INFO("ThinTracks : " << m_thinTracks);
+ ATH_MSG_INFO("ThinMuons : " << m_thinMuons);
+ ATH_MSG_INFO("=== Option settings - end ===");
+
+
+ // initialize cache vector-of-vectors (one per vertex container)
+ for (size_t ivcname=0; ivcname < m_vtxContNames.size(); ++ivcname) {
+ m_vvOrigPVLinkNames.push_back(std::vector<std::string>());
+ m_vvOrigPVLinkTypes.push_back(std::vector<pv_type>());
+ m_vvRefPVLinkNames.push_back(std::vector<std::string>());
+ m_vvRefPVLinkTypes.push_back(std::vector<pv_type>());
+ m_vvCtLinkNames.push_back(std::vector<std::string>());
+ m_vvCtLinkTypes.push_back(std::vector<pv_type>());
+ } // for ivcname
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // finalization
+ //--------------------------------------------------------------------------
+ StatusCode BmumuThinningTool::finalize() {
+
+ ATH_MSG_INFO("BmumuThinningTool::finalize()");
+
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // apply thinning
+ //--------------------------------------------------------------------------
+ StatusCode BmumuThinningTool::doThinning() const {
+
+ ATH_MSG_DEBUG("BmumuThinningTool::doThinning()");
+
+ // retrieve TrackParticle container
+ const xAOD::TrackParticleContainer* trkPartCont = nullptr;
+ std::vector<bool> trkMask;
+ if ( m_doTracks && (m_thinTracks || m_thinMuons) ) {
+ CHECK( evtStore()->retrieve(trkPartCont, m_trkPartContName) );
+ // default: keep no track
+ trkMask.assign(trkPartCont->size(), false);
+ }
+
+ // retrieve PV container
+ const xAOD::VertexContainer* pvCont = nullptr;
+ std::vector<bool> pvMask;
+ if ( m_doPVs && (m_thinPVs || m_keepPVTracks) ) {
+ CHECK( evtStore()->retrieve(pvCont, m_PVContName) );
+ // default: keep no PV
+ pvMask.assign(pvCont->size(), false);
+ }
+ // retrieve refitted PV container
+ std::vector<const xAOD::VertexContainer*> vRefPvCont =
+ std::vector<const xAOD::VertexContainer*>(m_refPVContNames.size(),
+ nullptr);
+ std::vector<std::vector<bool> > vRefPvMasks;
+ if ( m_thinRefPVs && m_doRefPVs ) {
+ for (size_t irpv = 0; irpv < m_refPVContNames.size(); ++irpv) {
+ CHECK( evtStore()->retrieve(vRefPvCont[irpv], m_refPVContNames[irpv]) );
+ // default: keep no refitted PV
+ vRefPvMasks.push_back(std::vector<bool>(vRefPvCont[irpv]->size(),
+ false));
+ }
+ }
+
+ // retrieve container of (original) muons
+ const xAOD::MuonContainer* muonCont = nullptr;
+ std::vector<bool> muonMask;
+ if ( m_thinMuons && m_doMuons && (!m_matchCalMuons || m_markMuons) ) {
+ CHECK( evtStore()->retrieve(muonCont, m_muonContName) );
+ // default: keep no muon
+ muonMask.assign(muonCont->size(), false);
+ }
+
+ // retrieve container of calibrated muons
+ const xAOD::MuonContainer* calMuonCont = nullptr;
+ std::vector<bool> calMuonMask;
+ if ( m_thinMuons && m_doCalMuons && (m_matchCalMuons || m_markCalMuons) ) {
+ CHECK( evtStore()->retrieve(calMuonCont, m_calMuonContName) );
+ // default: keep no muon
+ calMuonMask.assign(calMuonCont->size(), false);
+ }
+
+ // retrieve vertex containers
+ for (size_t ivcname=0; ivcname < m_vtxContNames.size(); ++ivcname) {
+ auto &vtxContName = m_vtxContNames[ivcname];
+ ATH_MSG_DEBUG("doThinning(): vtxContName: " << vtxContName);
+ const xAOD::VertexContainer* vtxCont = nullptr;
+ const xAOD::VertexAuxContainer* vtxAuxCont = nullptr;
+ CHECK( evtStore()->retrieve(vtxCont , vtxContName) );
+ CHECK( evtStore()->retrieve(vtxAuxCont, vtxContName+"Aux.") );
+ size_t vtxContSize = vtxCont->size();
+ std::vector<bool> vtxMask;
+ // default: keep no vertex
+ vtxMask.assign(vtxContSize, false);
+ ATH_MSG_DEBUG("doThinning(): vtxContSize: " << vtxContSize);
+ // loop over vertices
+ for (size_t ivtx = 0; ivtx < vtxContSize; ++ivtx) {
+ xAOD::BPhysHelper vtx(vtxCont->at(ivtx));
+ bool vtxPassed = false;
+ addToCounter(vtxContName+"_allVertices");
+ ATH_MSG_DEBUG("doThinning(): ivtx = " << ivtx);
+ if ( m_alignPassToVertexList ) {
+ ATH_MSG_DEBUG("doThinning(): 1: passFlag(" << ivcname << ") = "
+ << m_vtxPassFlags[ivcname]);
+ vtxPassed = pass(*vtx.vtx(), m_vtxPassFlags[ivcname]);
+ } else {
+ for (size_t ipass = 0; ipass < m_vtxPassFlags.size(); ++ipass) {
+ ATH_MSG_DEBUG("doThinning(): 2: passFlag(" << ipass << ") = "
+ << m_vtxPassFlags[ipass]);
+ if ( pass(*vtx.vtx(), m_vtxPassFlags[ipass]) ) {
+ vtxPassed = true;
+ break;
+ }
+ } // for ipass
+ }
+ if ( vtxPassed ) {
+ //
+ // vertex passed selection
+ //
+ ATH_MSG_DEBUG("doThinning(): ivtx " << ivtx << " passed selection");
+ vtxMask[ivtx] = true;
+ addToCounter(vtxContName+"_passedVertices");
+
+ // keep tracks from secondary vertices
+ if ( m_doTracks && (m_thinTracks || m_thinMuons) ) {
+ for (size_t itrk=0; itrk < trkPartCont->size(); ++itrk) {
+ // only consider if not yet kept
+ if ( !trkMask[itrk] ) {
+ for (size_t ivt=0; ivt < vtx.vtx()->nTrackParticles(); ++ivt) {
+ if ( vtx.vtx()->trackParticle(ivt)
+ == trkPartCont->at(itrk) ) {
+ trkMask[itrk] = true;
+ addToCounter(vtxContName+"_accTracks");
+ }
+ } // for trk
+ }
+ } // for itrk
+ } // if m_doTracks
+
+ // find aux variable names for closest tracks
+ if ( (m_thinTracks || m_thinMuons) && m_keepCloseTracks
+ && m_doCloseTracks && m_vvCtLinkNames[ivcname].empty() ) {
+ std::string prefix =
+ m_vtxContNames[ivcname]+"_"+m_ctBranchBaseName;
+ ATH_MSG_DEBUG("doThinning(): CT basename: " << prefix);
+ selectAuxElements(vtxAuxCont, m_vvCtLinkNames[ivcname],
+ m_ctBranchPrefixes,
+ m_vvCtLinkTypes[ivcname],
+ "_"+m_ctBranchBaseName+".*._Link");
+ if ( msgLvl(MSG::INFO) ) {
+ std::string sAuxVars =
+ dumpVS(m_vvCtLinkNames[ivcname],
+ "doThinning(): "+vtxContName+": CT aux vars: ("
+ +std::to_string(m_vvCtLinkNames[ivcname].size())+")",
+ 4);
+ logWrappedMsg(sAuxVars, MSG::INFO);
+ }
+ }
+
+ // keep tracks identified as closest tracks
+ if ( (m_thinTracks || m_thinMuons) && m_doTracks && m_keepCloseTracks
+ && m_doCloseTracks ) {
+ for (size_t i = 0; i < m_vvCtLinkNames[ivcname].size(); ++i) {
+ const xAOD::TrackParticle* closeTrack =
+ getTrackParticle(vtx.vtx(), m_vvCtLinkNames[ivcname][i]);
+ if ( closeTrack == nullptr ) continue;
+ auto tpit = std::find(trkPartCont->begin(), trkPartCont->end(),
+ closeTrack);
+ if ( tpit == trkPartCont->end() ) {
+ ATH_MSG_WARNING("ClosestTrack not found in "
+ << m_trkPartContName
+ << " for " << m_vvCtLinkNames[ivcname][i]);
+ continue;
+ }
+ size_t x = std::distance(trkPartCont->begin(), tpit);
+ if ( !trkMask.at(x) ) {
+ trkMask.at(x) = true;
+ addToCounter(vtxContName+"_addTracksByCT");
+ }
+ } // for i (CT link names)
+ } // if
+
+ // find aux variable names for original PVs
+ if ( m_thinPVs && m_vvOrigPVLinkNames[ivcname].empty() ) {
+ selectAuxElements(vtxAuxCont, m_vvOrigPVLinkNames[ivcname],
+ m_vvOrigPVLinkTypes[ivcname], "OrigPv.*.Link");
+ if ( msgLvl(MSG::INFO) ) {
+ std::string sAuxVars =
+ dumpVS(m_vvOrigPVLinkNames[ivcname],
+ "doThinning(): "+vtxContName+": OrigPV aux vars: ("
+ +std::to_string(m_vvOrigPVLinkNames[ivcname].size())+")",
+ 4);
+ logWrappedMsg(sAuxVars, MSG::INFO);
+ }
+ }
+ // find aux variable names for refitted PVs
+ if ( m_thinRefPVs && m_vvRefPVLinkNames[ivcname].empty() ) {
+ selectAuxElements(vtxAuxCont, m_vvRefPVLinkNames[ivcname],
+ m_vvRefPVLinkTypes[ivcname], "Pv.*.Link");
+ if ( msgLvl(MSG::INFO) ) {
+ std::string sAuxVars =
+ dumpVS(m_vvRefPVLinkNames[ivcname],
+ "doThinning() :"+vtxContName+": RefPV aux vars: ("
+ +std::to_string(m_vvRefPVLinkNames[ivcname].size())+")",
+ 4);
+ logWrappedMsg(sAuxVars, MSG::INFO);
+ }
+ }
+
+ // debug stuff
+ if ( msgLvl(MSG::VERBOSE) ) {
+ std::vector<std::string> auxVars =
+ filterAuxElements(vtxAuxCont, ".*Link");
+ std::string sAuxVars =
+ dumpVS(auxVars,
+ "doThinning(): "+vtxContName+": vtxAuxContVarNames:", 4);
+ logWrappedMsg(sAuxVars, MSG::DEBUG);
+ }
+
+ // now mark associated PVs
+ if ( m_thinPVs && m_doPVs ) {
+ for (size_t i = 0; i < m_vvOrigPVLinkTypes[ivcname].size(); ++i) {
+ const xAOD::Vertex* origPv =
+ vtx.origPv(m_vvOrigPVLinkTypes[ivcname][i]);
+ if ( origPv == nullptr ) continue;
+ auto pvit = std::find(pvCont->begin(), pvCont->end(), origPv);
+ if ( pvit == pvCont->end() ) {
+ ATH_MSG_WARNING("PV not found in " << m_PVContName
+ << " for " << m_vvOrigPVLinkNames[ivcname][i]);
+ continue;
+ }
+ size_t x = std::distance(pvCont->begin(), pvit);
+ if ( !pvMask.at(x) ) {
+ pvMask.at(x) = true;
+ addToCounter(vtxContName+"_accAssocPVs");
+ }
+ // keep tracks for selected PVs
+ if ( (m_thinTracks || m_thinMuons) && m_doTracks && m_keepPVTracks ) {
+ for (size_t ipvt=0; ipvt < (*pvit)->nTrackParticles();
+ ++ipvt) {
+ const xAOD::TrackParticle* tp = (*pvit)->trackParticle(ipvt);
+ if ( tp == nullptr ) continue;
+ auto tpit = std::find(trkPartCont->begin(),
+ trkPartCont->end(), tp);
+ if ( tpit == trkPartCont->end() ) {
+ ATH_MSG_WARNING("PV track not found in "
+ << m_trkPartContName << " for PV from "
+ << m_PVContName);
+ continue;
+ }
+ size_t x = std::distance(trkPartCont->begin(), tpit);
+ if ( !trkMask.at(x) ) {
+ trkMask.at(x) = true;
+ addToCounter(vtxContName+"_addTracksBySelPVs");
+ }
+ } // for ipvt
+ } // if m_keepPVTracks
+ } // for i (PVs)
+ } // if m_thinPVs && m_doPVs
+
+ // now mark associated refittedPVs
+ if ( m_thinRefPVs && m_doRefPVs ) {
+ for (size_t i = 0; i < m_vvRefPVLinkTypes[ivcname].size(); ++i) {
+ const xAOD::Vertex* refPv =
+ vtx.pv(m_vvRefPVLinkTypes[ivcname][i]);
+ if ( refPv == nullptr ) continue;
+ auto pvit = std::find(vRefPvCont[ivcname]->begin(),
+ vRefPvCont[ivcname]->end(), refPv);
+ if ( pvit == vRefPvCont[ivcname]->end() ) {
+ ATH_MSG_WARNING("PV not found in " << m_refPVContNames[ivcname]
+ << " for " << m_vvRefPVLinkNames[ivcname][i]);
+ continue;
+ }
+ size_t x = std::distance(vRefPvCont[ivcname]->begin(), pvit);
+ if ( !vRefPvMasks[ivcname].at(x) ) {
+ vRefPvMasks[ivcname].at(x) = true;
+ addToCounter(vtxContName+"_accAssocRefPVs");
+ }
+ // keep tracks for associated refitted PVs
+ if ( (m_thinTracks || m_thinMuons) && m_doTracks
+ && m_keepPVTracks ) {
+ for (size_t ipvt=0; ipvt < (*pvit)->nTrackParticles();
+ ++ipvt) {
+ const xAOD::TrackParticle* tp = (*pvit)->trackParticle(ipvt);
+ if ( tp == nullptr ) continue;
+ auto tpit = std::find(trkPartCont->begin(),
+ trkPartCont->end(), tp);
+ if ( tpit == trkPartCont->end() ) {
+ ATH_MSG_WARNING("Refitted PV track not found in "
+ << m_trkPartContName
+ << " for refitted PV from "
+ << m_refPVContNames[ivcname][i]);
+ continue;
+ }
+ size_t x = std::distance(trkPartCont->begin(), tpit);
+ if ( !trkMask.at(x) ) {
+ trkMask.at(x) = true;
+ addToCounter(vtxContName+"_addTracksByAssocRefPVs");
+ }
+ } // for ipvt
+ } // if (m_thinTracks || m_thinMuons) && m_doTracks
+ // && m_keepPVTracks
+ } // for i (refPVs)
+ } // if m_thinRefPVs && m_doRefPVs
+
+ // keep muons from secondary vertices
+ if ( m_thinMuons ) {
+ if ( m_matchCalMuons ) { // calibrated muons collection
+ if ( m_doCalMuons ) {
+ addToCounter(vtxContName+"_accCalMuons_calls");
+ CHECK( matchMuons(calMuonCont, calMuonMask, vtx,
+ vtxContName+"_accCalMuons") );
+ }
+ } else { // original muons collection
+ if ( m_doMuons ) {
+ addToCounter(vtxContName+"_accMuons_calls");
+ CHECK( matchMuons(muonCont, muonMask, vtx,
+ vtxContName+"_accMuons") );
+ }
+ } // if m_matchCalMuons
+ } // if m_thinMuons
+ } else {
+ ATH_MSG_DEBUG("doThinning(): ivtx " << ivtx
+ << " did not pass selection");
+ }
+ } // for ivtx (B vertex)
+
+ // Apply the thinning service based on vtxMask
+ CHECK( applyThinMask(vtxCont, vtxMask, m_vertexAnd, vtxContName) );
+
+ } // for m_vtxContNames
+
+ // Keep tracks for all PVs (i.e. if all PVs are kept)
+ if ( (m_thinTracks || m_thinMuons) && m_doTracks && m_keepPVTracks &&
+ !m_thinPVs && m_doPVs ) {
+ for (auto &pv : *pvCont) {
+ for (size_t ipvt=0; ipvt < pv->nTrackParticles(); ++ipvt) {
+ const xAOD::TrackParticle* tp = pv->trackParticle(ipvt);
+ if ( tp == nullptr ) continue;
+ auto tpit = std::find(trkPartCont->begin(), trkPartCont->end(), tp);
+ if ( tpit == trkPartCont->end() ) {
+ ATH_MSG_WARNING("PV track not found in "
+ << m_trkPartContName << " for PV from "
+ << m_PVContName);
+ continue;
+ }
+ size_t x = std::distance(trkPartCont->begin(), tpit);
+ if ( !trkMask.at(x) ) {
+ trkMask.at(x) = true;
+ addToCounter("addTracksByAllPVs");
+ }
+ } // for ipvt
+ } // for pv
+ } // if m_keepPVTracks && m_doTracks && m_keepPVTracks && !m_thinPVs
+
+ // Keep (original) muons for selected ID tracks
+ if (m_keepSelTrackMuons && m_thinMuons && m_doMuons && m_doTracks) {
+ CHECK( markMuonsForSelTracks(trkPartCont, trkMask, muonCont, muonMask,
+ "addMuonsBySelTracks") );
+ }
+
+ // Keep (original) muons for selected ID tracks
+ if (m_keepSelTrackCalMuons && m_thinMuons && m_doCalMuons && m_doTracks) {
+ CHECK( markMuonsForSelTracks(trkPartCont, trkMask, calMuonCont,
+ calMuonMask, "addCalMuonsBySelTracks") );
+ }
+
+ // mark 'other' muon container elements if requested
+ if ( m_thinMuons ) {
+ if ( m_syncMuonsBothWays || m_matchCalMuons ) {
+ // calibrated muons -> original muons
+ if ( (m_markMuons || m_syncMuonsBothWays)
+ && m_doMuons && m_doCalMuons) {
+ CHECK( markOrigMuons(muonCont, calMuonCont, muonMask, calMuonMask,
+ "addMarkedMuons", m_allowFastMuonMaskSync) );
+ }
+ } // if m_syncMuonsBothWays || m_matchCalMuons ) {
+ if ( m_syncMuonsBothWays || !m_matchCalMuons ) {
+ // 'orignal' muons -> calibrated muons
+ if ( (m_markCalMuons || m_syncMuonsBothWays)
+ && m_doCalMuons && m_doMuons ) {
+ CHECK( markCalibMuons(muonCont, calMuonCont, muonMask, calMuonMask,
+ "addMarkedCalMuons", m_allowFastMuonMaskSync) );
+ }
+ } // if m_syncMuonsBothWays || !m_matchCalMuons ) {
+ } // if m_thinMuons
+
+ // Keep tracks for selected (original) muons
+ if ( (m_thinTracks || m_thinMuons) && m_doTracks && m_keepSelMuonTracks
+ && m_doMuons ) {
+ CHECK( markTrksForSelMuons(trkPartCont, trkMask, muonCont, muonMask,
+ "addTracksBySelMuons") );
+ } // if (m_thinTracks || m_thinMuons) && m_doTracks && m_keepSelMuonTracks
+ // && m_doMuons
+
+ // Keep tracks for selected (calibrated) muons
+ if ( (m_thinTracks || m_thinMuons) && m_doTracks && m_keepSelCalMuonTracks
+ && m_doCalMuons ) {
+ CHECK( markTrksForSelMuons(trkPartCont, trkMask, calMuonCont,
+ calMuonMask, "addTracksBySelCalMuons") );
+ } // if (m_thinTracks || m_thinMuons) && m_doTracks
+ // && m_keepSelCalMuonTracks && m_doCalMuons
+
+ // debug: check muon masks' consistency
+ if ( msgLvl(MSG::DEBUG) ) {
+ std::string msg =
+ checkMaskConsistency(muonMask, calMuonMask,
+ m_muonContName+"Mask",
+ m_calMuonContName+"Mask",
+ "Muon mask consistency check:");
+ logWrappedMsg(msg, MSG::DEBUG);
+ }
+
+ // Apply the thinning service for TrackParticles based on trkMask
+ if ( m_thinTracks && m_doTracks ) {
+ addToCounter(m_trkPartContName+"_allTracks", trkPartCont->size());
+ addToCounter(m_trkPartContName+"_passedTracks",
+ std::accumulate(trkMask.begin(), trkMask.end(), 0));
+ CHECK( applyThinMask(trkPartCont, trkMask, m_trackAnd,
+ m_trkPartContName) );
+ } // if m_thinTracks && m_doTracks
+
+ // Apply the thinning service for PVs based on pvMask
+ if ( m_thinPVs && m_doPVs ) {
+ addToCounter(m_PVContName+"_allVertices", pvCont->size());
+ addToCounter(m_PVContName+"_passedVertices",
+ std::accumulate(pvMask.begin(), pvMask.end(), 0));
+ CHECK( applyThinMask(pvCont, pvMask, m_vertexAnd, m_PVContName) );
+ } // if m_doPVs
+
+ // Apply the thinning service for refPVs based on vRefPvMasks
+ if ( m_thinRefPVs && m_doRefPVs ) {
+ for (size_t irpv = 0; irpv < m_refPVContNames.size(); ++irpv) {
+ addToCounter(m_refPVContNames[irpv]+"_allVertices",
+ vRefPvCont[irpv]->size());
+ addToCounter(m_refPVContNames[irpv]+"_passedVertices",
+ std::accumulate(vRefPvMasks[irpv].begin(),
+ vRefPvMasks[irpv].end(), 0));
+ CHECK( applyThinMask(vRefPvCont[irpv], vRefPvMasks[irpv],
+ m_vertexAnd, m_refPVContNames[irpv]) );
+ } // for irpv
+ } // if m_doRefPVs
+
+ // Apply the thinning service for (original) Muons based on muonMask
+ if ( m_thinMuons && m_doMuons ) {
+ addToCounter(m_muonContName+"_allMuons", muonCont->size());
+ addToCounter(m_muonContName+"_passedMuons",
+ std::accumulate(muonMask.begin(), muonMask.end(), 0));
+ CHECK( applyThinMask(muonCont, muonMask, m_muonAnd,
+ m_muonContName) );
+ } // if m_thinMuons && m_doMuons
+
+ // Apply the thinning service for calibrated Muons based on calMuonMask
+ if ( m_thinMuons && m_doCalMuons ) {
+ addToCounter(m_calMuonContName+"_allMuons", calMuonCont->size());
+ addToCounter(m_calMuonContName+"_passedMuons",
+ std::accumulate(calMuonMask.begin(), calMuonMask.end(),
+ 0));
+ CHECK( applyThinMask(calMuonCont, calMuonMask, m_muonAnd,
+ m_calMuonContName) );
+ } // if m_thinMuons && m_doCalMuons
+
+ return StatusCode::SUCCESS;
+ }
+
+ //--------------------------------------------------------------------------
+ // Helper to apply thinning service mask -- for all Containers
+ //--------------------------------------------------------------------------
+ template<typename TYPE>
+ StatusCode
+ BmumuThinningTool::applyThinMask(SG::ThinningHandle<TYPE> &muCont,
+ const std::vector<bool>& muMask,
+ bool doAnd) const {
+
+ if (doAnd) {
+ ATH_MSG_DEBUG("doThinning(): apply thinning (AND) for " << muCont.key());
+ muCont.keep(muMask, SG::ThinningHandleBase::Op::And);
+ } else {
+ ATH_MSG_DEBUG("doThinning(): apply thinning (OR) for " << muCont.key());
+ muCont.keep(muMask, SG::ThinningHandleBase::Op::Or);
+ }
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Helper to check whether an element is marked as passing a specific
+ // hypothesis.
+ //--------------------------------------------------------------------------
+ bool BmumuThinningTool::pass(const SG::AuxElement& em, std::string hypo)
+ const {
+
+ if ( !boost::algorithm::starts_with(hypo, "passed_") )
+ hypo = "passed_" + hypo;
+ SG::AuxElement::Accessor<Char_t> flagAcc(hypo);
+ return flagAcc.isAvailable(em) && flagAcc(em) != 0;
+ }
+ //--------------------------------------------------------------------------
+ // Helper to get a TrackParticle link
+ //-------------------- ------------------------------------------------------
+ const xAOD::TrackParticle*
+ BmumuThinningTool::getTrackParticle(const xAOD::Vertex* vtx,
+ std::string name) const {
+ SG::AuxElement::Accessor<TrackParticleLink> tpLinkAcc(name);
+ if (!tpLinkAcc.isAvailable(*vtx)) {
+ return nullptr;
+ }
+ const TrackParticleLink& tpLink = tpLinkAcc(*vtx);
+ if (!tpLink.isValid()) {
+ return nullptr;
+ }
+ return *tpLink;
+ }
+ //--------------------------------------------------------------------------
+ // Helper to filter all names of auxillary elements of an aux container
+ // according to a certain pattern. The pattern must be a regular
+ // expression pattern.
+ //--------------------------------------------------------------------------
+ std::vector<std::string>
+ BmumuThinningTool::filterAuxElements(const xAOD::AuxContainerBase* auxCont,
+ std::string pattern) const {
+
+ SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
+
+ std::vector<std::string> vElNames;
+ std::regex re(pattern);
+
+ const SG::auxid_set_t& auxids = auxCont->getAuxIDs();
+ for ( SG::auxid_t auxid : auxids ) {
+ const std::string name = reg.getName(auxid);
+ if ( std::regex_match(name, re) ) {
+ vElNames.push_back(name);
+ }
+ } // for auxids
+
+ return vElNames;
+ }
+ //--------------------------------------------------------------------------
+ // Determine aux elements to be looked at -- for (refitted) PVs
+ //--------------------------------------------------------------------------
+ void
+ BmumuThinningTool::selectAuxElements(const xAOD::AuxContainerBase* auxCont,
+ std::vector<std::string>& vLinkNames,
+ std::vector<pv_type>& vLinkTypes,
+ std::string pattern) const {
+ // find aux element names matching pattern
+ std::vector<std::string> vAuxNames =
+ filterAuxElements(auxCont, pattern);
+
+ // select aux element names matching our PV-to-SV association types
+ for (auto &name : vAuxNames) {
+ for (size_t ipvt=0; ipvt < xAOD::BPhysHelper::n_pv_types; ++ipvt) {
+ if ( name.find(PvTypeToVarNameMap[(pv_type)ipvt]
+ +"Link") != std::string::npos) {
+ vLinkNames.push_back(name);
+ vLinkTypes.push_back((pv_type)ipvt);
+ }
+ } // for ipvt
+ } // for name
+ }
+ //--------------------------------------------------------------------------
+ // Determine aux elements to be looked at -- for closest tracks
+ //--------------------------------------------------------------------------
+ void
+ BmumuThinningTool::selectAuxElements(const xAOD::AuxContainerBase* auxCont,
+ std::vector<std::string>& vLinkNames,
+ std::vector<std::string> vPrefixes,
+ std::vector<pv_type>& vLinkTypes,
+ std::string pattern) const {
+ // find aux element names matching pattern
+ std::vector<std::string> vAuxNames;
+ for (auto &prefix : vPrefixes) {
+ std::string cpat = prefix+pattern;
+ std::vector<std::string> vMoreAuxNames =
+ filterAuxElements(auxCont, cpat);
+ vAuxNames.insert(vAuxNames.end(), vMoreAuxNames.begin(),
+ vMoreAuxNames.end());
+ } // for prefix
+
+ // select aux element names matching our PV-to-SV association types
+ for (auto &name : vAuxNames) {
+ for (size_t ipvt=0; ipvt < xAOD::BPhysHelper::n_pv_types; ++ipvt) {
+ std::regex re(".*"+xAOD::BPhysHelper::pv_type_str[ipvt]+".*_Link");
+ if ( std::regex_match(name, re) ) {
+ vLinkNames.push_back(name);
+ vLinkTypes.push_back((pv_type)ipvt);
+ }
+ } // for ipvt
+ } // for name
+ }
+ //--------------------------------------------------------------------------
+ // Mark muons matched to secondary vertices
+ //--------------------------------------------------------------------------
+ StatusCode
+ BmumuThinningTool::matchMuons(const xAOD::MuonContainer* muCont,
+ std::vector<bool>& muMask,
+ xAOD::BPhysHelper& vtx,
+ std::string counterName) const {
+
+ for (size_t imu=0; imu < muCont->size(); ++imu) {
+ // only consider if not yet kept
+ if ( !muMask[imu] ) {
+ for (int ivm=0; ivm < vtx.nMuons(); ++ivm) {
+ if ( vtx.muon(ivm) == muCont->at(imu) ) {
+ muMask[imu] = true;
+ addToCounter(counterName);
+ }
+ } // for ivm
+ }
+ } // for imu
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Mark original muons for accepted calibrated muons
+ //--------------------------------------------------------------------------
+ StatusCode
+ BmumuThinningTool::markOrigMuons(const xAOD::MuonContainer* muCont,
+ const xAOD::MuonContainer* cmuCont,
+ std::vector<bool>& muMask,
+ std::vector<bool>& cmuMask,
+ std::string counterName,
+ bool allowFastSync) const {
+
+ bool fastSync = allowFastSync;
+ // go to slow sync if muon mask sizes do not match
+ if ( muMask.size() != cmuMask.size() ) {
+ fastSync = false;
+ addToCounter(counterName+"_maskSizeMismatches");
+ }
+
+ for (size_t imu=0; imu < cmuMask.size(); ++imu) {
+ if ( cmuMask[imu] ) {
+ if ( fastSync ) {
+ if ( !muMask[imu] ) {
+ muMask[imu] = true;
+ addToCounter(counterName);
+ }
+ } else {
+ const xAOD::Muon* cMuon = cmuCont->at(imu);
+ if ( cMuon != nullptr ) {
+ const xAOD::Muon* oMuon =
+ (const xAOD::Muon*)xAOD::getOriginalObject(*cMuon);
+ if ( oMuon != nullptr ) {
+ auto muit = std::find(muCont->begin(), muCont->end(), oMuon);
+ if ( muit == muCont->end() ) {
+ ATH_MSG_WARNING("Muon not found in " << m_muonContName
+ << " for calibrated muon index " << imu);
+ } else {
+ size_t x = std::distance(muCont->begin(), muit);
+ if ( !muMask.at(x) ) {
+ muMask.at(x) = true;
+ addToCounter(counterName);
+ }
+ }
+ } else {
+ ATH_MSG_WARNING("No orignal muon for calibrated muon index "
+ << imu);
+ }
+ } else {
+ ATH_MSG_WARNING("No calibrated muon for index " << imu);
+ }
+ } // if fastSync
+ }
+ } // for imu
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Mark calibrated muons for accepted (original) muons
+ //--------------------------------------------------------------------------
+ StatusCode
+ BmumuThinningTool::markCalibMuons(const xAOD::MuonContainer* muCont,
+ const xAOD::MuonContainer* cmuCont,
+ std::vector<bool>& muMask,
+ std::vector<bool>& cmuMask,
+ std::string counterName,
+ bool allowFastSync) const {
+
+ bool fastSync = allowFastSync;
+ // go to slow sync if muon mask sizes do not match
+ if ( muMask.size() != cmuMask.size() ) {
+ fastSync = false;
+ addToCounter(counterName+"_maskSizeMismatches");
+ }
+
+ for (size_t imu=0; imu < muMask.size(); ++imu) {
+ if ( muMask[imu] ) {
+ if ( fastSync ) {
+ if ( !cmuMask[imu] ) {
+ cmuMask[imu] = true;
+ addToCounter(counterName);
+ }
+ } else {
+ const xAOD::Muon* oMuon = muCont->at(imu);
+ if ( oMuon != nullptr ) {
+ bool found = false;
+ for (size_t icmu = 0; icmu < cmuCont->size(); ++icmu) {
+ const xAOD::Muon* cMuon = cmuCont->at(icmu);
+ if ( cMuon != nullptr ) {
+ const xAOD::Muon* aMuon =
+ (const xAOD::Muon*)xAOD::getOriginalObject(*cMuon);
+ if ( aMuon == oMuon ) {
+ found = true;
+ if ( !cmuMask.at(icmu) ) {
+ cmuMask.at(icmu) = true;
+ addToCounter(counterName);
+ }
+ }
+ } else {
+ ATH_MSG_WARNING("No calibrated muon for calibrated "
+ << "muon index " << icmu);
+ }
+ } // for icmu
+ if ( !found ) {
+ ATH_MSG_WARNING("No calibrated muon found for orignal "
+ << "muon index " << imu);
+ }
+ } else {
+ ATH_MSG_WARNING("No (original) muon for index " << imu);
+ }
+ } // if fastSync
+ }
+ } // for imu
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Mark ID tracks of selected (original or calibrated) muons
+ //--------------------------------------------------------------------------
+ StatusCode
+ BmumuThinningTool::markTrksForSelMuons(const xAOD::TrackParticleContainer*
+ trkPartCont,
+ std::vector<bool>& trkMask,
+ const xAOD::MuonContainer* muCont,
+ std::vector<bool>& muMask,
+ std::string counterName) const {
+
+ for (size_t itrk=0; itrk < trkPartCont->size(); ++itrk) {
+ if ( trkMask[itrk] ) continue;
+ const xAOD::TrackParticle* tp = trkPartCont->at(itrk);
+ if ( tp == nullptr ) continue;
+ for (size_t imu=0; imu < muCont->size(); ++imu) {
+ if ( muMask[imu] ) {
+ const xAOD::Muon* muon = muCont->at(imu);
+ if ( muon != nullptr ) {
+ const xAOD::TrackParticle* mutp =
+ muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
+ if ( mutp == tp ) {
+ trkMask[itrk] = true;
+ addToCounter(counterName);
+ }
+ }
+ }
+ } // for imu
+ } // for itrk
+ return StatusCode::SUCCESS;
+ }
+ //--------------------------------------------------------------------------
+ // Mark muons for selected ID tracks
+ //--------------------------------------------------------------------------
+ StatusCode
+ BmumuThinningTool::markMuonsForSelTracks(const xAOD::TrackParticleContainer*
+ trkPartCont,
+ std::vector<bool>& trkMask,
+ const xAOD::MuonContainer* muCont,
+ std::vector<bool>& muMask,
+ std::string counterName) const {
+
+ for (size_t imu=0; imu < muCont->size(); ++imu) {
+ if ( muMask[imu] ) continue;
+ const xAOD::Muon* muon = muCont->at(imu);
+ if ( muon == nullptr ) continue;
+ const xAOD::TrackParticle* mutp =
+ muon->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
+ if ( mutp == nullptr) continue;
+ auto tpit = std::find(trkPartCont->begin(), trkPartCont->end(), mutp);
+ if ( tpit == trkPartCont->end() ) {
+ ATH_MSG_WARNING("Muon track not found in " << m_trkPartContName
+ << " for counter " << counterName);
+ addToCounter(counterName+"_missingTracksForMuons");
+ continue;
+ }
+ size_t x = std::distance(trkPartCont->begin(), tpit);
+ if ( trkMask.at(x) ) {
+ muMask[imu] = true;
+ addToCounter(counterName);
+ }
+ } // for imu
+ return StatusCode::SUCCESS;
+ }
+
+ //--------------------------------------------------------------------------
+ // Check two masks for consistency
+ //--------------------------------------------------------------------------
+ std::string
+ BmumuThinningTool::checkMaskConsistency(const std::vector<bool>& mask1,
+ const std::vector<bool>& mask2,
+ const std::string name1,
+ const std::string name2,
+ const std::string header) const {
+
+ bool sizesMatch = (mask1.size() == mask2.size());
+ int nTrueMask1 = std::accumulate(mask1.begin(), mask1.end(), 0);
+ int nTrueMask2 = std::accumulate(mask2.begin(), mask2.end(), 0);
+
+ std::string basecname = name1+"_"+name2;
+
+ int nEntryMismatches(0);
+ int nMoreTrueMask1(0);
+ int nMoreTrueMask2(0);
+ for (size_t i=0; i < std::min(mask1.size(), mask2.size()); ++i) {
+ if ( mask1[i] != mask2[i] ) nEntryMismatches++;
+ if ( mask1[i] && !mask2[i] ) nMoreTrueMask1++;
+ if ( !mask1[i] && mask2[i] ) nMoreTrueMask2++;
+ }
+
+ std::string str(header);
+ if ( str.length() > 0 ) str += "\n";
+ if ( sizesMatch && nTrueMask1 == nTrueMask2 && nEntryMismatches == 0 ) {
+ str += "Masks match OK: "+name1+" ("+mask1.size()+") : "
+ + name2+" ("+mask2.size()+")";
+ addToCounter(basecname+"_matchedOK");
+ } else {
+ str += "Masks do NOT match: "+name1+" ("+mask1.size()+") : "
+ + name2+" ("+mask2.size()+")";
+ str += "\nnTrueMask1: "+std::to_string(nTrueMask1)
+ +", nTrueMask2: "+std::to_string(nTrueMask2);
+ str += "\nnEntryMismatches: "+std::to_string(nEntryMismatches)
+ +"nMoreTrueMas1: "+std::to_string(nMoreTrueMask1)
+ +", nMoreTrueMask2: "+std::to_string(nMoreTrueMask2);
+ addToCounter(basecname+"_NOTmatched");
+ if (!sizesMatch) addToCounter(basecname+"_sizeMismatch");
+ addToCounter(basecname+"_nEntryMismatches", nEntryMismatches);
+ addToCounter(basecname+"_nMoreTrueMask1", nMoreTrueMask1);
+ addToCounter(basecname+"_nMoreTrueMask2", nMoreTrueMask2);
+ }
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Dump a vector<string> to string.
+ //--------------------------------------------------------------------------
+ std::string BmumuThinningTool::dumpVS(const std::vector<std::string>& vs,
+ const std::string header,
+ size_t nBlanks) const {
+ std::string str(header);
+ for (const std::string& s : vs) {
+ if ( str.length() > 0 ) str += "\n";
+ str += std::string(nBlanks, ' ') + s;
+ } // for s
+
+ return str;
+ }
+ //--------------------------------------------------------------------------
+ // Wrap string at line breaks and print with appropriate message level
+ //--------------------------------------------------------------------------
+ void BmumuThinningTool::logWrappedMsg(const std::string& str,
+ const MSG::Level lvl) const {
+ std::istringstream isstr(str);
+ std::string s;
+ while (std::getline(isstr, s)) {
+ msg(lvl) << s << endreq;
+ }
+ }
+ //--------------------------------------------------------------------------
+
+} // namespace DerivationFramework
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Bmumu_metadata.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Bmumu_metadata.cxx
new file mode 100644
index 00000000000..5d45a327e69
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Bmumu_metadata.cxx
@@ -0,0 +1,238 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file Bmumu_metadata.cxx
+ * @author Wolfgang Walkowiak <wolfgang.walkowiak@cern.ch>
+ */
+
+#include "DerivationFrameworkBPhys/Bmumu_metadata.h"
+
+namespace DerivationFramework {
+
+ //--------------------------------------------------------------------------
+ Bmumu_metadata::Bmumu_metadata(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p), BPhysMetadataBase(t,n,p) {
+
+ // configuration defaults etc.
+ recordPropertyI("verbose", 0);
+ recordPropertyB("isSimulation", false);
+ recordPropertyS("projectTag", "__NONE__");
+ recordPropertyB("isRelease21" , true);
+ recordPropertyS("mcCampaign", "__NONE__");
+ recordPropertyS("triggerStream", "__NONE__");
+
+ // MC dataset number lists
+ recordPropertyVI("mcBsmumu" , {});
+ recordPropertyVI("mcBplusJpsiKplus" , {});
+ recordPropertyVI("mcBsJpsiPhi" , {});
+ recordPropertyVI("mcBplusJpsiPiplus", {});
+ recordPropertyVI("mcBhh" , {});
+
+ // MC datasets without trigger information
+ recordPropertyVI("mcNoTrigger" , {});
+
+ // special data runs
+ recordPropertyVI("specDataRuns", {});
+
+ // special MC channels
+ recordPropertyVI("specMcChannels", {});
+
+ // blind search
+ recordPropertyB("doBmumuBlinding" , true);
+ recordPropertyB("doCutBlinded" , true);
+ recordPropertyB("blindOnlyAllMuonsTight", true);
+ recordPropertyS("BlindingKey" , "");
+ recordPropertyS("BlindedVars" , "");
+ recordPropertyS("BlindingFlag" , "");
+
+ // include trigger
+ recordPropertyB("doTriggerInfo" , true);
+
+ // include soft B tagging vertex containers
+ recordPropertyB("doAddSoftBVertices" , true);
+
+ // trigger navigation thinning
+ recordPropertyB("doTrigNavThinning", true);
+ recordPropertyVS("TrigNavThinList" , {});
+
+ // wide mumu mass range
+ recordPropertyB("doUseWideMuMuMassRange", false);
+
+ // use mass calculated using the combined muon track information in cuts?
+ recordPropertyB("useMuCalcMass", true);
+
+ // use calibrated muons instead of the original ones
+ recordPropertyI("useCalibratedMuons", 0);
+
+ // adjust primary track to muon kinematics for MUCALC mass
+ recordPropertyB("adjustMucalcKinematics", false);
+
+ // add MUCALC mass from non-modified muons for debugging
+ recordPropertyB("addMucalcMassForDebug", false);
+
+ // primary vertex types to consider for MinChi2ToAnyPV
+ recordPropertyVI("MinChi2ToAnyPVTypes", {1, 3});
+
+ // JpsiFinder: muAndMu or TrackAndTrack option?
+ recordPropertyB("JfTwoMuons" , true );
+ recordPropertyB("JfTwoTracks", false);
+
+ // JpsiFinder: TrackThresholdPt
+ recordPropertyD("JfTrackThresholdPt", 0.);
+
+ // muon calibration and smearing tool configuration
+ recordPropertyS("McstYear" , "Data16");
+ recordPropertyS("McstRelease" , "_NONE_");
+ recordPropertyB("McstStatComb" , true);
+ recordPropertyB("McstSagittaCorr" , true);
+ recordPropertyS("McstSagittaRelease" , "_NONE_");
+ recordPropertyB("McstDoSagittaMCDistortion", false);
+ recordPropertyB("McstSagittaCorrPhaseSpace", true);
+
+ // muon collections
+ recordPropertyS("MuonCollection" , "Muons");
+ recordPropertyS("CalMuonCollection" , "Muons");
+ recordPropertyS("UsedMuonCollection" , "Muons");
+ recordPropertyVS("AllMuonCollections", {} );
+
+ // Global mass values (in MeV, from PDG 2015)
+ recordPropertyD("GlobalMuonMass" , 105.6584);
+ recordPropertyD("GlobalPionMass" , 139.57061);
+ recordPropertyD("GlobalKaonMass" , 493.677 );
+ recordPropertyD("GlobalJpsiMass" , 3096.92 );
+ recordPropertyD("GlobalBplusMass", 5279.29 );
+ recordPropertyD("GlobalB0Mass" , 5279.61 );
+ recordPropertyD("GlobalBsMass" , 5366.79 );
+
+ // mass ranges
+ recordPropertyD("GlobalBMassUpperCut" , 7000.);
+ recordPropertyD("GlobalBMassLowerCut" , 3500.);
+ recordPropertyD("GlobalDiMuonMassUpperCut", 7000.);
+ recordPropertyD("GlobalDiMuonMassLowerCut", 2000.);
+ recordPropertyD("GlobalJpsiMassUpperCut" , 7000.);
+ recordPropertyD("GlobalJpsiMassLowerCut" , 2000.);
+ recordPropertyD("GlobalBlindUpperCut" , 5166.);
+ recordPropertyD("GlobalBlindLowerCut" , 5526.);
+ recordPropertyD("GlobalTrksMassUpperCut" , 7500.);
+ recordPropertyD("GlobalTrksMassLowerCut" , 3000.);
+
+ // Global chi2 cut for vertexing
+ recordPropertyD("GlobalChi2CutBase", 15.0);
+ // Different chi2 cuts for 2-, 3- and 4-prong vertices
+ recordPropertyD("Chi2Cut2Prong" , 30.0);
+ recordPropertyD("Chi2Cut3Prong" , 45.0);
+ recordPropertyD("Chi2Cut4Prong" , 60.0);
+
+ // Cut values for kaon candidates
+ recordPropertyD("GlobalKaonPtCut" , 1000.); // MeV
+ recordPropertyD("GlobalKaonEtaCut", 2.5 );
+
+ // MCP cuts for JpsiFinder
+ recordPropertyB("useJpsiFinderMCPCuts", false);
+
+ // reject muons in JpsiPlus1Track or JpsiPlus2Track finders
+ recordPropertyS("GlobalMuonsUsedInJpsi", "NONE"); // turn off by default
+
+ // run number
+ recordPropertyI("runNumber", -1);
+
+ // MC channel number
+ recordPropertyI("mcChNumber", -1);
+
+ // channels to be processed
+ recordPropertyVS("doChannels", {});
+
+ // vertex types to be done
+ recordPropertyI("doVertexType", 7);
+
+ // minimum number of tracks in PV considered for PV association
+ recordPropertyI("minNTracksInPV", 0);
+
+ // mode of minLogChi2ToAnyPV calculation
+ recordPropertyI("AddMinChi2ToAnyPVMode", 0);
+
+ // record 3-dimensional proper time in addition
+ recordPropertyB("do3dProperTime", false);
+
+ // thinning level
+ recordPropertyI("thinLevel", 0);
+
+ // selection expression
+ recordPropertyS("SelExpression", "");
+
+ // MC truth decay parents
+ recordPropertyVI("TruthDecayParents", {});
+
+ // vertex isolation properties
+ recordPropertyVS("IsoTrackCategoryName" , {});
+ recordPropertyVS("IsoTrackCutLevel" , {});
+ recordPropertyVD("IsoTrackPtCut" , {});
+ recordPropertyVD("IsoTrackEtaCut" , {});
+ recordPropertyVI("IsoTrackPixelHits" , {});
+ recordPropertyVI("IsoTrackSCTHits" , {});
+ recordPropertyVI("IsoTrackbLayerHits" , {});
+ recordPropertyVI("IsoTrackIBLHits" , {});
+ recordPropertyVD("IsolationConeSizes" , {});
+ recordPropertyVD("IsoTrkImpLogChi2Max" , {});
+ recordPropertyVI("IsoDoTrkImpLogChi2Cut", {});
+ recordPropertyVL("useIsoTrackTypes" , {});
+ recordPropertyB("IsoUseOptimizedAlgo" , true);
+ recordPropertyS("IsoTvaWorkingPoint" , "Nominal");
+ recordPropertyVS("IsoIncludes" , {});
+
+
+ // muon isolation properties (muons of B candidate)
+ recordPropertyVS("MuIsoTrackCategoryName" , {});
+ recordPropertyVS("MuIsoTrackCutLevel" , {});
+ recordPropertyVD("MuIsoTrackPtCut" , {});
+ recordPropertyVD("MuIsoTrackEtaCut" , {});
+ recordPropertyVI("MuIsoTrackPixelHits" , {});
+ recordPropertyVI("MuIsoTrackSCTHits" , {});
+ recordPropertyVI("MuIsoTrackbLayerHits" , {});
+ recordPropertyVI("MuIsoTrackIBLHits" , {});
+ recordPropertyVD("MuIsolationConeSizes" , {});
+ recordPropertyVD("MuIsoTrkImpLogChi2Max" , {});
+ recordPropertyVI("MuIsoDoTrkImpLogChi2Cut", {});
+ recordPropertyVL("useMuIsoTrackTypes" , {});
+ recordPropertyS("MuIsoTvaWorkingPoint" , "Nominal");
+ recordPropertyVS("MuIsoIncludes" , {});
+
+ // closest track properties
+ recordPropertyVS("CloseTrackCategoryName" , {});
+ recordPropertyVS("CloseTrackCutLevel" , {});
+ recordPropertyVD("CloseTrackPtCut" , {});
+ recordPropertyVD("CloseTrackEtaCut" , {});
+ recordPropertyVI("CloseTrackPixelHits" , {});
+ recordPropertyVI("CloseTrackSCTHits" , {});
+ recordPropertyVI("CloseTrackbLayerHits" , {});
+ recordPropertyVI("CloseTrackIBLHits" , {});
+ recordPropertyVL("useCloseTrackTypes" , {});
+ recordPropertyVS("CloseTrackChi2SetName" , {});
+ recordPropertyVI("CloseTrackCorrChi2" , {});
+ recordPropertyVB("CloseTrackMinDCAin3D" , {});
+ recordPropertyVD("CloseTrackMaxLogChi2" , {});
+ recordPropertyVD("NCloseTrackMaxLogChi2" , {});
+ recordPropertyS("CloseTrackTvaWorkingPoint", "Nominal");
+ recordPropertyVS("CloseTrackIncludes" , {});
+
+ // debug track types for isolation and closest track tools
+ recordPropertyI("DebugTrackTypes", 0);
+
+ // track-to-vertex association check tool
+ recordPropertyI("DebugTrkToVtxMaxEvents" , 0);
+
+ // output containers and branch prefixes
+ // (mostly used for isolation tools)
+ recordPropertyS("TrkPartContName", "InDetTrackParticles");
+ recordPropertyS("PVContName" , "PrimaryVertices");
+ recordPropertyVS("VtxContNames" , {} );
+ recordPropertyVS("RefPVContNames", {} );
+ recordPropertyVS("BranchPrefixes", {} );
+
+ }
+ //--------------------------------------------------------------------------
+} // namespace
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Bmumu_reco_mumu.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Bmumu_reco_mumu.cxx
new file mode 100644
index 00000000000..a3c06874ffa
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Bmumu_reco_mumu.cxx
@@ -0,0 +1,177 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/////////////////////////////////////////////////////////////////
+// Bmumu_reco_mumu.cxx
+///////////////////////////////////////////////////////////////////
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Original author (Reco_mumu):
+// Daniel Scheirich <daniel.scheirich@cern.ch>
+//
+// Changes:
+// Basic dimuon reconstruction for the derivation framework.
+// This class inherits from CfAthAlgTool instead of AthAlgTool in order
+// to have access to the CutFlowSvc instance.
+//
+//============================================================================
+//
+
+#include "DerivationFrameworkBPhys/Bmumu_reco_mumu.h"
+
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+#include "DerivationFrameworkBPhys/BPhysPVTools.h"
+
+
+namespace DerivationFramework {
+
+ Bmumu_reco_mumu::Bmumu_reco_mumu(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ CfAthAlgTool(t,n,p),
+ m_v0Tools("Trk::V0Tools"),
+ m_jpsiFinder("Analysis::JpsiFinder"),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter")
+ {
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare tools
+ declareProperty("V0Tools" , m_v0Tools);
+ declareProperty("JpsiFinder", m_jpsiFinder);
+ declareProperty("PVRefitter", m_pvRefitter);
+
+ // Declare user-defined properties
+ declareProperty("OutputVtxContainerName", m_outputVtxContainerName = "OniaCandidates");
+ declareProperty("PVContainerName" , m_pvContainerName = "PrimaryVertices");
+ declareProperty("RefPVContainerName" , m_refPVContainerName = "RefittedPrimaryVertices");
+ declareProperty("RefitPV" , m_refitPV = false);
+ declareProperty("MaxPVrefit" , m_PV_max = 1);
+ declareProperty("DoVertexType" , m_DoVertexType = 1);
+ // minimum number of tracks for PV to be considered for PV association
+ declareProperty("MinNTracksInPV" , m_PV_minNTracks = 0);
+ declareProperty("Do3d" , m_do3d = false);
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Bmumu_reco_mumu::initialize()
+ {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // retrieve V0 tools
+ CHECK( m_v0Tools.retrieve() );
+
+ // get the JpsiFinder tool
+ CHECK( m_jpsiFinder.retrieve() );
+
+ // get the PrimaryVertexRefitter tool
+ CHECK( m_pvRefitter.retrieve() );
+
+ // Get the beam spot service
+ CHECK( m_beamSpotKey.initialize() );
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Bmumu_reco_mumu::finalize()
+ {
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Bmumu_reco_mumu::addBranches() const
+ {
+ // Jpsi container and its auxilliary store
+ xAOD::VertexContainer* vtxContainer = NULL;
+ xAOD::VertexAuxContainer* vtxAuxContainer = NULL;
+
+ //----------------------------------------------------
+ // call Jpsi finder
+ //----------------------------------------------------
+ if( !m_jpsiFinder->performSearch(vtxContainer, vtxAuxContainer).isSuccess() ) {
+ ATH_MSG_FATAL("Jpsi finder (" << m_jpsiFinder << ") failed.");
+ return StatusCode::FAILURE;
+ }
+
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+ const xAOD::VertexContainer* pvContainer = NULL;
+ CHECK( evtStore()->retrieve(pvContainer, m_pvContainerName) );
+
+ //----------------------------------------------------
+ // Try to retrieve refitted primary vertices
+ //----------------------------------------------------
+ bool refPvExists = false;
+ xAOD::VertexContainer* refPvContainer = NULL;
+ xAOD::VertexAuxContainer* refPvAuxContainer = NULL;
+ if(m_refitPV) {
+ if(evtStore()->contains<xAOD::VertexContainer>(m_refPVContainerName)) {
+ // refitted PV container exists. Get it from the store gate
+ CHECK( evtStore()->retrieve(refPvContainer, m_refPVContainerName) );
+ CHECK( evtStore()->retrieve(refPvAuxContainer, m_refPVContainerName+"Aux.") );
+ refPvExists = true;
+ } else {
+ // refitted PV container does not exist. Create a new one.
+ refPvContainer = new xAOD::VertexContainer;
+ refPvAuxContainer = new xAOD::VertexAuxContainer;
+ refPvContainer->setStore(refPvAuxContainer);
+ }
+ }
+
+ // Give the helper class the ptr to v0tools and beamSpotsSvc to use
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVTools helper(&(*m_v0Tools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(m_PV_minNTracks);
+ helper.SetSave3d(m_do3d);
+
+ if(m_refitPV){
+ if(vtxContainer->size() >0){
+ StatusCode SC = helper.FillCandwithRefittedVertices(vtxContainer, pvContainer, refPvContainer, &(*m_pvRefitter) , m_PV_max, m_DoVertexType);
+ if(SC.isFailure()){
+ ATH_MSG_FATAL("refitting failed - check the vertices you passed");
+ return SC;
+ }
+ }
+ }else{
+ if(vtxContainer->size() >0)CHECK(helper.FillCandExistingVertices(vtxContainer, pvContainer, m_DoVertexType));
+ }
+
+
+ //----------------------------------------------------
+ // save in the StoreGate
+ //----------------------------------------------------
+ if (!evtStore()->contains<xAOD::VertexContainer>(m_outputVtxContainerName))
+ CHECK(evtStore()->record(vtxContainer, m_outputVtxContainerName));
+
+ if (!evtStore()->contains<xAOD::VertexAuxContainer>(m_outputVtxContainerName+"Aux."))
+ CHECK(evtStore()->record(vtxAuxContainer, m_outputVtxContainerName+"Aux."));
+
+ if(!refPvExists && m_refitPV) {
+ CHECK(evtStore()->record(refPvContainer , m_refPVContainerName));
+ CHECK(evtStore()->record(refPvAuxContainer, m_refPVContainerName+"Aux."));
+ }
+
+ // add counter for number of events seen
+ addEvent("dimuEvents");
+ // add counter for the number of events with >= 1 reco'd vertices
+ if ( vtxContainer->size() > 0 ) {
+ addEvent("dimuWithVertexCand");
+ }
+ // add counter for the number of vertices
+ addToCounter("dimuNumVertices", vtxContainer->size());
+
+ return StatusCode::SUCCESS;
+ }
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Cascade3Plus1.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Cascade3Plus1.cxx
new file mode 100644
index 00000000000..fbc231d3666
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Cascade3Plus1.cxx
@@ -0,0 +1,524 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+/////////////////////////////////////////////////////////////////
+// Cascade3Plus1.cxx, (c) ATLAS Detector software
+/////////////////////////////////////////////////////////////////
+#include "DerivationFrameworkBPhys/Cascade3Plus1.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "TrkToolInterfaces/ITrackSelectorTool.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "DerivationFrameworkBPhys/BPhysPVCascadeTools.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "DerivationFrameworkBPhys/BPhysPVTools.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "Math/Vector4D.h"
+
+namespace DerivationFramework {
+typedef ElementLink<xAOD::VertexContainer> VertexLink;
+typedef std::vector<VertexLink> VertexLinkVector;
+typedef std::vector<const xAOD::TrackParticle*> TrackBag;
+/// Base 4 Momentum type for TrackParticle
+typedef ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<double> > GenVecFourMom_t;
+
+template<size_t N>
+struct Candidate {
+ std::array<const xAOD::TrackParticle*, N> tracks;
+};
+
+struct VertexCand : Candidate<4> {
+ std::unique_ptr<Trk::VxCascadeInfo> cascVertex;
+};
+
+template<size_t N>
+GenVecFourMom_t SumVector(const std::array<GenVecFourMom_t, N> &vectors) {
+ GenVecFourMom_t total = vectors[0];
+ for(size_t i =1; i<N; i++) total+= vectors[i];
+ return total;
+}
+
+Cascade3Plus1::Cascade3Plus1(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
+ m_trkSelector("InDet::TrackSelectorTool"),
+ m_iVertexFitter("Trk::TrkVKalVrtFitter"),
+ m_V0Tools("Trk::V0Tools"),
+ m_CascadeTools("DerivationFramework::CascadeTools"),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter"),
+ m_cascadeOutputsKeys{ "CascadeVtx1", "CascadeVtx2" }
+{
+
+ declareProperty("TrackMassHyp", m_trackMasses);
+ declareProperty("CascadeVertexCollections", m_cascadeOutputsKeys);
+ declareProperty("TwoTrackMassMin", m_2trackmassMin);
+ declareProperty("TwoTrackMassMax", m_2trackmassMax);
+ declareProperty("ThreeTrackMassMin", m_3trackmassMin);
+ declareProperty("ThreeTrackMassMax", m_3trackmassMax);
+ declareProperty("FourTrackMassMin", m_4trackmassMin);
+ declareProperty("FourTrackMassMax", m_4trackmassMax);
+ declareProperty("TwoTracksMass", m_2tracksMass);
+ declareProperty("ThreeTracksMass", m_3tracksMass);
+ declareProperty("FourTracksMass", m_4tracksMass);
+ declareProperty("TrackSelectorTool",m_trkSelector);
+ declareProperty("CascadeTools", m_CascadeTools);
+ declareProperty("MinNTracksInPV", m_PV_minNTracks = 0);
+ declareProperty("HypothesisName", m_hypoName = "Bs");
+ declareProperty("Track3Name", m_3TrackName = "Ds");
+ declareProperty("MaxnPV", m_PV_max = 999);
+ declareProperty("DoVertexType", m_DoVertexType = 7);
+ declareProperty("RefitPV", m_refitPV = true);
+ declareProperty("RefPVContainerName", m_refPVContainerName = "RefittedPrimaryVertices");
+ declareProperty("PVRefitter", m_pvRefitter);
+ declareProperty("TrkVertexFitterTool", m_iVertexFitter);
+ declareProperty("PVContainerName", m_VxPrimaryCandidateName);
+ declareProperty("ThreeTrackMassConstraint", m_3TrackMassConstraint);
+ declareProperty("TwoTrackMassConstraint", m_2TrackMassConstraint);
+ declareProperty("Chi2NDFCut", m_Chi2NDFCut);
+
+ declareProperty("FourTrackMassFinalMin", m_4trackmassFinalMin);
+ declareProperty("FourTrackMassFinalMax", m_4trackmassFinalMax);
+ declareProperty("FourTrackTauCut", m_tauCut);
+ declareProperty("UseMuonsForTracks", m_requireMuonsOnTrack);
+ declareProperty("ThreeVertexOutputContainer", m_3TrackVertexOutput);
+ declareProperty("VertexEstimator", m_vertexEstimator);
+ declareProperty("ThreeTrackChi2NDF", m_3TrackChi2NDFCut);
+ declareProperty("EliminateBad3Tracksfrom4Track", m_eliminateBad3Tracksfrom4Track);
+ declareProperty("CopyAllVertices", m_copyAllVertices);
+ declareProperty("PTCutPerTrack", m_ptCutPerTrack);
+ m_ptCutPerVertex.fill(0);
+ declareProperty("PTCutVertex1", m_ptCutPerVertex[0]);
+ declareProperty("PTCutVertex2", m_ptCutPerVertex[1]);
+ declareProperty("PTCutVertex3", m_ptCutPerVertex[2]);
+}
+
+StatusCode Cascade3Plus1::initialize() {
+ if(m_trackMasses.size()!=4) {
+ ATH_MSG_ERROR("4 mass hypotheses must be provided");
+ return StatusCode::FAILURE;
+ }
+ if(m_cascadeOutputsKeys.size() !=s_topoN) {
+ ATH_MSG_FATAL("Incorrect number of VtxContainers");
+ return StatusCode::FAILURE;
+ }
+ // retrieving vertex Fitter
+ ATH_CHECK( m_iVertexFitter.retrieve());
+
+ // retrieving the Cascade tools
+ ATH_CHECK( m_CascadeTools.retrieve());
+
+ // Get the beam spot service
+ CHECK( m_beamSpotKey.initialize() );
+
+ ATH_CHECK(m_vertexEstimator.retrieve());
+ if(m_eliminateBad3Tracksfrom4Track && m_3TrackChi2NDFCut<=0.0) {
+ ATH_MSG_FATAL("Invalid configuration");
+ return StatusCode::FAILURE;
+ }
+
+ if(m_ptCutPerTrack.size() == 1 || m_ptCutPerTrack.size() > 4){
+ ATH_MSG_FATAL("Invalid configuration");
+ return StatusCode::FAILURE;
+ }
+ if(m_ptCutPerTrack.size() >=2 && m_ptCutPerTrack[0] != m_ptCutPerTrack[1]){
+ ATH_MSG_FATAL("Invalid configuration");
+ return StatusCode::FAILURE;
+ }
+ m_muonTrackBit.reset();
+ for(int i : m_requireMuonsOnTrack) {
+ if(i>=4) {
+ ATH_MSG_FATAL("Invalid configuration" << " muon track " << i);
+ return StatusCode::FAILURE;
+ }
+ m_muonTrackBit[i] = true;
+ }
+ m_requireMuonsOnTrack.clear();
+ m_requireMuonsOnTrack.shrink_to_fit();
+
+ if(m_muonTrackBit[0] != m_muonTrackBit[1])
+ {
+ ATH_MSG_FATAL("Invalid configuration" << " variable is " << m_muonTrackBit.to_string());
+ return StatusCode::FAILURE;
+ }
+
+
+ return StatusCode::SUCCESS;
+}
+
+Cascade3Plus1::~Cascade3Plus1() { }
+
+
+const TrackBag& Cascade3Plus1::ApplyAdditionalCuts(const TrackBag& alltracks, const TrackBag& muonTracks, TrackBag& cuttracks, size_t track) const {
+ const TrackBag& tracks = m_muonTrackBit[track] ? muonTracks : alltracks;
+ if(track >= m_ptCutPerTrack.size()) return tracks;
+ double ptCut = m_ptCutPerTrack.at(track);
+ if(ptCut <=0.0) return tracks;
+ cuttracks.clear();//reset any previous selections
+ for(auto ptr : tracks){
+ if(ptr->pt() > ptCut) cuttracks.push_back(ptr);
+ }
+ return cuttracks;
+}
+
+StatusCode Cascade3Plus1::addBranches() const
+{
+ const xAOD::TrackParticleContainer *trackContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(trackContainer, "InDetTrackParticles" ));
+
+ //----------------------------------------------------
+ // Try to retrieve refitted primary vertices
+ //----------------------------------------------------
+ xAOD::VertexContainer* refPvContainer = nullptr;
+ xAOD::VertexAuxContainer* refPvAuxContainer = nullptr;
+ if (m_refitPV) {
+ if (evtStore()->contains<xAOD::VertexContainer>(m_refPVContainerName)) {
+ // refitted PV container exists. Get it from the store gate
+ ATH_CHECK(evtStore()->retrieve(refPvContainer, m_refPVContainerName ));
+ ATH_CHECK(evtStore()->retrieve(refPvAuxContainer, m_refPVContainerName + "Aux."));
+ } else {
+ // refitted PV container does not exist. Create a new one.
+ refPvContainer = new xAOD::VertexContainer;
+ refPvAuxContainer = new xAOD::VertexAuxContainer;
+ refPvContainer->setStore(refPvAuxContainer);
+ ATH_CHECK(evtStore()->record(refPvContainer, m_refPVContainerName));
+ ATH_CHECK(evtStore()->record(refPvAuxContainer, m_refPVContainerName+"Aux."));
+ }
+ }
+
+ std::array<xAOD::VertexContainer*, s_topoN> Vtxwritehandles;
+ std::array<xAOD::VertexAuxContainer*, s_topoN> Vtxwritehandlesaux;
+
+ for(int i =0; i<s_topoN; i++) {
+ Vtxwritehandles[i] = new xAOD::VertexContainer();
+ Vtxwritehandlesaux[i] = new xAOD::VertexAuxContainer();
+ Vtxwritehandles[i]->setStore(Vtxwritehandlesaux[i]);
+ ATH_CHECK(evtStore()->record(Vtxwritehandles[i], m_cascadeOutputsKeys[i] ));
+ ATH_CHECK(evtStore()->record(Vtxwritehandlesaux[i], m_cascadeOutputsKeys[i] + "Aux."));
+ }
+ xAOD::VertexContainer *v3container = nullptr;
+ if(!m_3TrackVertexOutput.empty()) {
+ v3container = new xAOD::VertexContainer();
+ auto vcontaineraux = new xAOD::VertexAuxContainer();
+ v3container->setStore(vcontaineraux);
+ ATH_CHECK(evtStore()->record(v3container, m_3TrackVertexOutput ));
+ ATH_CHECK(evtStore()->record(vcontaineraux, m_3TrackVertexOutput + "Aux."));
+ }
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+
+ const xAOD::Vertex * primaryVertex(nullptr);
+ const xAOD::VertexContainer *pvContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(pvContainer, m_VxPrimaryCandidateName));
+
+ if (pvContainer->size()==0) {
+ ATH_MSG_WARNING("You have no primary vertices: " << pvContainer->size());
+ return StatusCode::RECOVERABLE;
+ } else {
+ primaryVertex = (*pvContainer)[0];
+ }
+
+
+ TrackBag theIDTracksAfterSelection;
+ TrackBag theIDTracksAfterAdditionalSelection;
+ for(auto x : *trackContainer) {
+ if ( m_trkSelector->decision(*x, nullptr) ) theIDTracksAfterSelection.push_back(x);
+ }
+ ATH_MSG_DEBUG("Found good tracks N="<<theIDTracksAfterSelection.size());
+ TrackBag theMuonsAfterSelection;
+ if(m_muonTrackBit.any()) {
+ const xAOD::MuonContainer* importedMuonCollection(0);
+ ATH_CHECK(evtStore()->retrieve(importedMuonCollection, "Muons"));
+ for(auto muon : *importedMuonCollection) {
+ if(muon->muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) continue;
+ auto ptr = muon->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
+ if(ptr) theMuonsAfterSelection.push_back(ptr);
+ }
+ }
+
+ std::vector<Candidate<2>> Initialcandidates;
+ { //Isolate scope for safety
+ const TrackBag &Tracksfor2Vertex = ApplyAdditionalCuts(theIDTracksAfterSelection, theMuonsAfterSelection, theIDTracksAfterAdditionalSelection, 0);
+ for(auto track1itr = Tracksfor2Vertex.cbegin(); track1itr != Tracksfor2Vertex.cend(); ++track1itr) {
+ Candidate<2> cand;
+ std::array<GenVecFourMom_t, 2> vectors;
+ cand.tracks[0] = *track1itr;
+ vectors[0].SetCoordinates(cand.tracks[0]->pt(), cand.tracks[0]->eta(), cand.tracks[0]->phi(), m_trackMasses[0]);
+ for(auto track2itr = track1itr+1; track2itr != Tracksfor2Vertex.cend(); ++track2itr) {
+ cand.tracks[1] = *track2itr;
+ if(cand.tracks[0]->qOverP() * cand.tracks[1]->qOverP() >= 0.) continue; //Skip same signed
+ vectors[1].SetCoordinates(cand.tracks[1]->pt(), cand.tracks[1]->eta(), cand.tracks[1]->phi(), m_trackMasses[1]);
+ GenVecFourMom_t pair = SumVector(vectors);
+ if(pair.Pt() < m_ptCutPerVertex[0]) continue;
+ if(pair.M() >= m_2trackmassMin && pair.M() < m_2trackmassMax) {
+ ATH_MSG_VERBOSE("2 Track candidate found: " << pair.M() << " Within " << m_2trackmassMin << " and " << m_2trackmassMax);
+ Initialcandidates.push_back(cand);
+ }
+ }
+ }
+ }
+ ATH_MSG_DEBUG("2 Track candidates found: " << Initialcandidates.size());
+ if(Initialcandidates.empty()) {
+ //No work to do Leave method early
+ return StatusCode::SUCCESS;
+ }
+ std::vector<Candidate<3>> Candidates3;
+
+ {//isolate scope
+ const TrackBag &Tracksfor3Vertex = ApplyAdditionalCuts(theIDTracksAfterSelection, theMuonsAfterSelection, theIDTracksAfterAdditionalSelection, 2);
+ for(auto &c : Initialcandidates) {
+ Candidate<3> c3;
+ std::copy(c.tracks.begin(), c.tracks.end(), c3.tracks.begin());
+ std::array<GenVecFourMom_t, 3> vectors;
+ vectors[0].SetCoordinates(c.tracks[0]->pt(), c.tracks[0]->eta(), c.tracks[0]->phi(), m_trackMasses[0]);
+ vectors[1].SetCoordinates(c.tracks[1]->pt(), c.tracks[1]->eta(), c.tracks[1]->phi(), m_trackMasses[1]);
+ for(auto track3itr = Tracksfor3Vertex.cbegin(); track3itr != Tracksfor3Vertex.cend(); ++track3itr) {
+ if(std::find(c3.tracks.begin(), c3.tracks.end(), *track3itr) != c3.tracks.end()) continue;
+ c3.tracks[2] = *track3itr;
+ vectors[2].SetCoordinates(c3.tracks[2]->pt(), c3.tracks[2]->eta(), c3.tracks[2]->phi(), m_trackMasses[2]);
+ GenVecFourMom_t tripple = SumVector(vectors);
+ if(tripple.Pt() < m_ptCutPerVertex[1]) continue;
+ if(tripple.M() >= m_3trackmassMin && tripple.M() < m_3trackmassMax) {
+ ATH_MSG_VERBOSE("3 Track candidate found: " << tripple.M() << " Within " << m_3trackmassMin << " and " << m_3trackmassMax);
+ Candidates3.push_back(c3);
+ }
+ }
+ }
+ }
+ Initialcandidates.clear();
+ Initialcandidates.shrink_to_fit();
+
+ ATH_MSG_DEBUG("3 Track candidates found: " << Candidates3.size());
+ std::map<const std::array<const xAOD::TrackParticle*, 3>, xAOD::Vertex* > threeVertexMap;
+
+ if(!m_3TrackVertexOutput.empty()) {
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVTools helper(&(*m_V0Tools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(0);
+ helper.SetSave3d(false);
+ std::vector<const xAOD::TrackParticle*> tracksforfit;
+ std::vector<Candidate<3>> Candidates3PassCuts;
+ if(m_eliminateBad3Tracksfrom4Track) Candidates3PassCuts.reserve(Candidates3.size());
+ for(const auto &c3 : Candidates3) {
+ tracksforfit.assign(c3.tracks.begin(), c3.tracks.end());
+ auto v = StandardFit(tracksforfit, trackContainer);
+ if(v==nullptr) {
+ ATH_MSG_DEBUG("3Vertex fit returned null");
+ continue;
+ }
+ if(m_3TrackChi2NDFCut > 0. && v->chiSquared() / v->numberDoF() > m_3TrackChi2NDFCut) {
+ ATH_MSG_DEBUG("Rejecting 3 track vertex because Chi " << v->chiSquared() / v->numberDoF() << " > " << m_3TrackChi2NDFCut);
+ continue;
+ }
+ if(m_eliminateBad3Tracksfrom4Track) Candidates3PassCuts.push_back(c3);
+ threeVertexMap[c3.tracks] = v.get();
+ xAOD::BPhysHelper bHelper(v.get());//"get" does not "release" still automatically deleted
+ bHelper.setRefTrks();
+ v3container->push_back(v.release());
+ }
+
+ if(v3container->size() >0) ATH_CHECK(helper.FillCandExistingVertices(v3container, pvContainer, 1));
+
+ if(m_eliminateBad3Tracksfrom4Track) {
+ ATH_MSG_DEBUG("Swapping container to N = "<< Candidates3PassCuts.size() << " from " << Candidates3.size());
+ Candidates3PassCuts.swap(Candidates3);//Swap old container with one that passed cuts
+ }
+
+ }
+ std::vector<VertexCand> Candidates4;
+ {//isolate scope
+ const TrackBag &Tracksfor4Vertex = ApplyAdditionalCuts(theIDTracksAfterSelection, theMuonsAfterSelection, theIDTracksAfterAdditionalSelection, 3);
+ for(auto &c : Candidates3) {
+ VertexCand c4;
+ std::copy(c.tracks.begin(), c.tracks.end(), c4.tracks.begin());
+ std::array<GenVecFourMom_t, 4> vectors;
+ vectors[0].SetCoordinates(c.tracks[0]->pt(), c.tracks[0]->eta(), c.tracks[0]->phi(), m_trackMasses[0]);
+ vectors[1].SetCoordinates(c.tracks[1]->pt(), c.tracks[1]->eta(), c.tracks[1]->phi(), m_trackMasses[1]);
+ vectors[2].SetCoordinates(c.tracks[2]->pt(), c.tracks[2]->eta(), c.tracks[2]->phi(), m_trackMasses[2]);
+ for(auto track4itr = Tracksfor4Vertex.cbegin(); track4itr != Tracksfor4Vertex.cend(); ++track4itr) {
+ if(std::find(c4.tracks.begin(), c4.tracks.end(), *track4itr) != c4.tracks.end()) continue;
+ c4.tracks[3] = *track4itr;
+ if(c4.tracks[2]->qOverP() * c4.tracks[3]->qOverP() >= 0.) continue; //Skip same signed
+ vectors[3].SetCoordinates(c4.tracks[3]->pt(), c4.tracks[3]->eta(), c4.tracks[3]->phi(), m_trackMasses[3]);
+ GenVecFourMom_t fourtrack = SumVector(vectors);
+ if(fourtrack.Pt() < m_ptCutPerVertex[2]) continue;
+ if(fourtrack.M() >= m_4trackmassMin && fourtrack.M() < m_4trackmassMax) {
+ ATH_MSG_VERBOSE("3 Track candidate found: " << fourtrack.M() << " Within " << m_4trackmassMin << " and " << m_4trackmassMax);
+ Candidates4.push_back(std::move(c4));
+ }
+ }
+ }
+ }
+ Candidates3.clear();
+ Candidates3.shrink_to_fit();
+
+ ATH_MSG_DEBUG("4 Track candidates found: " << Candidates4.size() << " running cascade");
+ for(auto &c : Candidates4) {
+ c.cascVertex = CascadeFit(c.tracks);
+ if(c.cascVertex!=nullptr) {
+ c.cascVertex->setSVOwnership(true);
+ }
+ }
+
+ SG::AuxElement::Decorator<VertexLinkVector> CascadeLinksDecor("CascadeVertexLinks");
+ SG::AuxElement::Decorator<VertexLink> Vertex3Decor(m_3TrackName+ "_VertexLink");
+ SG::AuxElement::Decorator<float> chi2_decor("ChiSquared");
+ SG::AuxElement::Decorator<float> ndof_decor("NumberDoF");
+// SG::AuxElement::Decorator<float> TotalProb_decor("TotalProb");
+ SG::AuxElement::Decorator<float> Pt_decor("Pt");
+ SG::AuxElement::Decorator<float> PtErr_decor("PtErr");
+ SG::AuxElement::Decorator<float> Mass_svdecor(m_3TrackName+ "_mass");
+ SG::AuxElement::Decorator<float> MassErr_svdecor(m_3TrackName+"_massErr");
+ SG::AuxElement::Decorator<float> Pt_svdecor(m_3TrackName+"_Pt");
+ SG::AuxElement::Decorator<float> PtErr_svdecor(m_3TrackName+"_PtErr");
+ SG::AuxElement::Decorator<float> Lxy_svdecor(m_3TrackName+"_Lxy");
+ SG::AuxElement::Decorator<float> LxyErr_svdecor(m_3TrackName+"_LxyErr");
+ SG::AuxElement::Decorator<float> Tau_svdecor(m_3TrackName+"_Tau");
+ SG::AuxElement::Decorator<float> TauErr_svdecor(m_3TrackName+"_TauErr");
+
+
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVCascadeTools helper(&(*m_CascadeTools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(m_PV_minNTracks);
+ helper.m_copyAllVertices = this->m_copyAllVertices;
+
+
+
+ int totalnotnull=0;
+ for(auto &c : Candidates4) {
+ if(c.cascVertex==nullptr) {
+ totalnotnull++;
+ continue;
+ }
+ auto x = c.cascVertex.get();
+ const std::vector<xAOD::Vertex*> &cascadeVertices = x->vertices();
+ if(cascadeVertices.size()!=s_topoN) {
+ ATH_MSG_ERROR("Incorrect number of vertices");
+ continue;
+ }
+ if(cascadeVertices[0] == nullptr || cascadeVertices[1] == nullptr) {
+ ATH_MSG_ERROR("Error null vertex");
+ continue;
+ }
+ if( m_Chi2NDFCut > 0.0 && (x->fitChi2() / x->nDoF()) > m_Chi2NDFCut) {
+ continue;
+ }
+ BPhysPVCascadeTools::PrepareVertexLinks(c.cascVertex.get(), trackContainer);
+ const std::vector< std::vector<TLorentzVector> > &moms = x->getParticleMoms();
+ double mass1 = m_CascadeTools->invariantMass(moms[1]);
+ if(m_4trackmassFinalMin > 0. && mass1 < m_4trackmassFinalMin) continue;
+ if(m_4trackmassFinalMax > 0. && mass1 > m_4trackmassFinalMax) continue;
+ double tau = m_CascadeTools->tau(moms[1],cascadeVertices[1],primaryVertex);
+ if(tau < m_tauCut) continue;
+// ATH_MSG_INFO("Total chi " << x->fitChi2()<< " sum chi2 " << cascadeVertices[0]->chiSquared() + cascadeVertices[1]->chiSquared() );
+ // Keep vertices (bear in mind that they come in reverse order!)
+ for(int i =0; i<s_topoN; i++) Vtxwritehandles[i]->push_back(cascadeVertices[i]);
+ x->setSVOwnership(false); // Prevent Container from deleting vertices
+ const auto mainVertex = cascadeVertices[1]; // this is the B vertex
+
+ // Set links to cascade vertices
+ std::vector<const xAOD::Vertex*> verticestoLink;
+ verticestoLink.push_back(cascadeVertices[0]);
+ if(!BPhysPVCascadeTools::LinkVertices(CascadeLinksDecor, verticestoLink, Vtxwritehandles[0], cascadeVertices[1])) {
+ ATH_MSG_ERROR("Error decorating with cascade vertices");
+ }
+
+ // loop over candidates -- Don't apply PV_minNTracks requirement here
+ // because it may result in exclusion of the high-pt PV.
+ // get good PVs
+
+ xAOD::BPhysHypoHelper vtx(m_hypoName, mainVertex);
+
+ // Get refitted track momenta from all vertices, charged tracks only
+ BPhysPVCascadeTools::SetVectorInfo(vtx, x);
+
+ // Decorate main vertex
+ //
+ // 1.a) mass, mass error
+
+ BPHYS_CHECK( vtx.setMass(m_CascadeTools->invariantMass(moms[1])) );
+ BPHYS_CHECK( vtx.setMassErr(m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1])) );
+ // 1.b) pt and pT error (the default pt of mainVertex is != the pt of the full cascade fit!)
+ Pt_decor(*mainVertex) = m_CascadeTools->pT(moms[1]);
+ PtErr_decor(*mainVertex) = m_CascadeTools->pTError(moms[1],x->getCovariance()[1]);
+ // 1.c) chi2 and ndof (the default chi2 of mainVertex is != the chi2 of the full cascade fit!)
+ chi2_decor(*mainVertex) = x->fitChi2();
+ ndof_decor(*mainVertex) = x->nDoF();
+ ATH_CHECK(helper.FillCandwithRefittedVertices(m_refitPV, pvContainer,
+ refPvContainer, &(*m_pvRefitter), m_PV_max, m_DoVertexType, x, 1, m_4tracksMass, vtx));
+ // 4) decorate the main vertex with D0 vertex mass, pt, lifetime and lxy values (plus errors)
+ // D0 points to the main vertex, so lifetime and lxy are w.r.t the main vertex
+ Mass_svdecor(*mainVertex) = m_CascadeTools->invariantMass(moms[0]);
+ MassErr_svdecor(*mainVertex) = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ Pt_svdecor(*mainVertex) = m_CascadeTools->pT(moms[0]);
+ PtErr_svdecor(*mainVertex) = m_CascadeTools->pTError(moms[0],x->getCovariance()[0]);
+ Lxy_svdecor(*mainVertex) = m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
+ LxyErr_svdecor(*mainVertex) = m_CascadeTools->lxyError(moms[0],x->getCovariance()[0], cascadeVertices[0],cascadeVertices[1]);
+ Tau_svdecor(*mainVertex) = m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1]);
+ TauErr_svdecor(*mainVertex) = m_CascadeTools->tauError(moms[0],x->getCovariance()[0], cascadeVertices[0],cascadeVertices[1]);
+ if(!threeVertexMap.empty()) {
+ std::array<const xAOD::TrackParticle*, 3> lookuparray;
+ std::copy(c.tracks.begin(), c.tracks.begin()+3, lookuparray.begin());
+ auto ptr = threeVertexMap[lookuparray];
+ if(ptr == nullptr) ATH_MSG_WARNING("3Vertex lookup found null");
+ Vertex3Decor(*mainVertex) = ptr ? VertexLink(ptr, *v3container) : VertexLink();
+ }
+ }
+
+
+ ATH_MSG_DEBUG("Found " << Vtxwritehandles[0]->size() << " candidates " << totalnotnull << " were null");
+ if(Vtxwritehandles[0]->size() > 200) ATH_MSG_WARNING("A lot of candidates N=" << Vtxwritehandles[0]->size());
+ return StatusCode::SUCCESS;
+}
+
+std::unique_ptr<Trk::VxCascadeInfo> Cascade3Plus1::CascadeFit(std::array<const xAOD::TrackParticle*, 4> &Track) const {
+// ATH_MSG_DEBUG("Running Cascade Fit");
+ std::vector<const xAOD::TrackParticle*> tracksDs(Track.begin(), Track.begin()+3);
+ std::vector<const xAOD::TrackParticle*> tracksBs(1, Track[3]);
+
+ std::vector<double> massesDs(m_trackMasses.begin(), m_trackMasses.begin()+3);
+ std::vector<double> massesBs(1, m_trackMasses[3]);
+
+ std::unique_ptr<Trk::IVKalState> state = m_iVertexFitter->makeState();
+ int robustness = 0;
+ m_iVertexFitter->setRobustness(robustness, *state);
+// if(tracksDs.size() != massesDs.size()) ATH_MSG_ERROR("Track sizes do not match");
+// for(int i =0;i < tracksDs.size();i++) ATH_MSG_DEBUG("Num " << i << " track " << tracksDs[i] << " mass " << massesDs[i]);
+ // Vertex list
+ std::vector<Trk::VertexID> vrtList;
+ // Ds vertex
+ auto vID = m_iVertexFitter->startVertex(tracksDs, massesDs, *state, m_3TrackMassConstraint ? m_3tracksMass : 0.0);
+ std::vector<Trk::VertexID> cnstV;
+ if (m_2TrackMassConstraint && !m_iVertexFitter->addMassConstraint(vID, tracksDs, cnstV, *state, m_2tracksMass).isSuccess() ) {
+ ATH_MSG_WARNING("addMassConstraint failed");
+ }
+ vrtList.push_back(vID);
+ // Bs vertex
+ m_iVertexFitter->nextVertex(tracksBs,massesBs,vrtList, *state);
+ // Do the work
+ auto x = std::unique_ptr<Trk::VxCascadeInfo> (m_iVertexFitter->fitCascade(*state));
+ if(x==nullptr) ATH_MSG_VERBOSE("Cascade returned null");
+ return x;
+}
+
+std::unique_ptr<xAOD::Vertex> Cascade3Plus1::StandardFit(const std::vector<const xAOD::TrackParticle*> &inputTracks, const xAOD::TrackParticleContainer* importedTrackCollection) const {
+ assert(inputTracks.size() >=2);
+ const Trk::Perigee& aPerigee1 = inputTracks[0]->perigeeParameters();
+ const Trk::Perigee& aPerigee2 = inputTracks[1]->perigeeParameters();
+ int sflag = 0;
+ int errorcode = 0;
+ Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&aPerigee1,&aPerigee2,sflag,errorcode);
+ if (errorcode != 0) {
+ startingPoint(0) = 0.0;
+ startingPoint(1) = 0.0;
+ startingPoint(2) = 0.0;
+ }
+ std::unique_ptr<Trk::IVKalState> state = m_iVertexFitter->makeState();
+ auto theResult = std::unique_ptr<xAOD::Vertex>( m_iVertexFitter->fit(inputTracks, startingPoint, *state));
+ if(theResult) BPhysPVTools::PrepareVertexLinks(theResult.get(), importedTrackCollection);
+ return theResult;
+}
+
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/CascadeTools.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/CascadeTools.cxx
new file mode 100644
index 00000000000..7721d36d9ee
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/CascadeTools.cxx
@@ -0,0 +1,608 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+/////////////////////////////////////////////////////////////////
+// CascadeTools.cxx, (c) ATLAS Detector software
+/////////////////////////////////////////////////////////////////
+#include "DerivationFrameworkBPhys/CascadeTools.h"
+#include "CLHEP/GenericFunctions/CumulativeChiSquare.hh"
+
+
+namespace DerivationFramework {
+
+
+CascadeTools::CascadeTools(const std::string& t, const std::string& n, const IInterface* p) :
+ AthAlgTool(t,n,p)
+{
+ declareInterface<CascadeTools>(this);
+}
+
+CascadeTools::~CascadeTools() {}
+
+//Light speed constant for various calculations
+constexpr double s_CONST = 1000./299.792;
+
+double CascadeTools::invariantMass(const std::vector<TLorentzVector> &particleMom) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ TLorentzVector totalMom;
+ unsigned int NTrk = particleMom.size();
+ for( unsigned int it=0; it<NTrk; it++) totalMom += particleMom[it];
+ return totalMom.M();
+}
+
+double CascadeTools::invariantMass(const std::vector<TLorentzVector> &particleMom2, const std::vector<double> &masses) const
+{
+ if(particleMom2.size() == 0) return -999999.;
+ TLorentzVector totalMom;
+ unsigned int NTrk = particleMom2.size();
+ if (masses.size() != NTrk) {
+ ATH_MSG_DEBUG("The provided number of masses does not match the number of tracks in the vertex");
+ return -999999.;
+ }
+ TLorentzVector temp;
+ for( unsigned int it=0; it<NTrk; it++) {
+ double esq = particleMom2[it].Px()*particleMom2[it].Px() + particleMom2[it].Py()*particleMom2[it].Py() +
+ particleMom2[it].Pz()*particleMom2[it].Pz() + masses[it]*masses[it];
+ double e = (esq>0.) ? sqrt(esq) : 0.;
+
+ temp.SetPxPyPzE(particleMom2[it].Px(),particleMom2[it].Py(),particleMom2[it].Pz(),e);
+ totalMom += temp;
+ }
+ return totalMom.M();
+}
+
+double CascadeTools::invariantMassError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ unsigned int NTrk = particleMom.size();
+ TLorentzVector totalMom;
+ for( unsigned int it=0; it<NTrk; it++) totalMom += particleMom[it];
+
+ Amg::MatrixX D_vec(3*NTrk+3,1); D_vec.setZero();
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = 2.*(totalMom.E()*particleMom[it].Px()/particleMom[it].E()-totalMom.Px());
+ D_vec(3*it+4) = 2.*(totalMom.E()*particleMom[it].Py()/particleMom[it].E()-totalMom.Py());
+ D_vec(3*it+5) = 2.*(totalMom.E()*particleMom[it].Pz()/particleMom[it].E()-totalMom.Pz());
+ }
+ Amg::MatrixX merr = D_vec.transpose() * cov * D_vec;
+ double massVarsq = merr(0,0);
+ if (massVarsq <= 0.) ATH_MSG_DEBUG("massError: negative sqrt massVarsq " << massVarsq);
+ double massVar = (massVarsq>0.) ? sqrt(massVarsq) : 0.;
+ double massErr = massVar/(2.*totalMom.M());
+ return massErr;
+}
+
+double CascadeTools::invariantMassError(const std::vector<TLorentzVector> &particleMom2, const Amg::MatrixX& cov, const std::vector<double> &masses) const
+{
+ if(particleMom2.size() == 0) return -999999.;
+ unsigned int NTrk = particleMom2.size();
+ if (masses.size() != NTrk) {
+ ATH_MSG_DEBUG("The provided number of masses does not match the number of tracks in the vertex");
+ return -999999.;
+ }
+ std::vector<TLorentzVector> particleMom(NTrk); particleMom.clear();
+ for( unsigned int it=0; it<NTrk; it++) {
+ double esq = particleMom2[it].Px()*particleMom2[it].Px() + particleMom2[it].Py()*particleMom2[it].Py() +
+ particleMom2[it].Pz()*particleMom2[it].Pz() + masses[it]*masses[it];
+ double e = (esq>0.) ? sqrt(esq) : 0.;
+ particleMom[it].SetPxPyPzE(particleMom2[it].Px(),particleMom2[it].Py(),particleMom2[it].Pz(),e);
+ }
+ TLorentzVector totalMom;
+ for( unsigned int it=0; it<NTrk; it++) totalMom += particleMom[it];
+
+ std::vector<double>dm2dpx(NTrk), dm2dpy(NTrk), dm2dpz(NTrk);
+ for( unsigned int it=0; it<NTrk; it++) {
+ dm2dpx[it] = 2.*(totalMom.E()*particleMom[it].Px()/particleMom[it].E()-totalMom.Px());
+ dm2dpy[it] = 2.*(totalMom.E()*particleMom[it].Py()/particleMom[it].E()-totalMom.Py());
+ dm2dpz[it] = 2.*(totalMom.E()*particleMom[it].Pz()/particleMom[it].E()-totalMom.Pz());
+ }
+ Amg::MatrixX D_vec(3*NTrk+3,1); D_vec.setZero();
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = dm2dpx[it];
+ D_vec(3*it+4) = dm2dpy[it];
+ D_vec(3*it+5) = dm2dpz[it];
+ }
+ Amg::MatrixX merr = D_vec.transpose() * cov * D_vec;
+ double massVarsq = merr(0,0);
+ if (massVarsq <= 0.) ATH_MSG_DEBUG("massError: negative sqrt massVarsq " << massVarsq);
+ double massVar = (massVarsq>0.) ? sqrt(massVarsq) : 0.;
+ double massErr = massVar/(2.*totalMom.M());
+ return massErr;
+}
+
+double CascadeTools::pT(const std::vector<TLorentzVector> &particleMom) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ Amg::Vector3D P = momentum(particleMom);;
+ return P.perp();
+}
+
+double CascadeTools::pTError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ Amg::Vector3D P = momentum(particleMom);;
+ double Px = P.x();
+ double Py = P.y();
+ double PT = P.perp();
+
+ unsigned int NTrk = particleMom.size();
+ Amg::MatrixX D_vec(3*NTrk+3,1); D_vec.setZero();
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = Px/PT;
+ D_vec(3*it+4) = Py/PT;
+ D_vec(3*it+5) = 0.;
+ }
+ Amg::MatrixX PtErrSq = D_vec.transpose() * cov * D_vec;
+ double PtErrsq = PtErrSq(0,0);
+ if (PtErrsq <= 0.) ATH_MSG_DEBUG("ptError: negative sqrt PtErrsq " << PtErrsq);
+ return (PtErrsq>0.) ? sqrt(PtErrsq) : 0.;
+}
+
+double CascadeTools::lxy(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ auto vert = SV->position() - PV->position();
+ double dx = vert.x();
+ double dy = vert.y();
+ Amg::Vector3D P = momentum(particleMom);;
+ double dxy = (P.x()*dx + P.y()*dy)/P.perp();
+ return dxy;
+}
+
+double CascadeTools::lxyError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ auto vert = SV->position() - PV->position();
+ double dx = vert.x();
+ double dy = vert.y();
+ Amg::Vector3D P = momentum(particleMom);;
+ double Px = P.x();
+ double Py = P.y();
+ double PT = P.perp();
+ double LXYoverPT = (Px*dx+Py*dy)/(PT*PT);
+
+ unsigned int NTrk = particleMom.size();
+
+ double dLxydx = Px/PT;
+ double dLxydy = Py/PT;
+ double dLxydx0 = -dLxydx;
+ double dLxydy0 = -dLxydy;
+
+ Amg::MatrixX D_vec(3*NTrk+6,1); D_vec.setZero();
+ D_vec(0) = dLxydx;
+ D_vec(1) = dLxydy;
+ D_vec(2) = 0.;
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = (dx - LXYoverPT*Px)/PT;
+ D_vec(3*it+4) = (dy - LXYoverPT*Py)/PT;
+ D_vec(3*it+5) = 0.;
+ }
+ D_vec(3*NTrk+3) = dLxydx0;
+ D_vec(3*NTrk+4) = dLxydy0;
+ D_vec(3*NTrk+5) = 0.;
+
+ unsigned int ndim = 3*NTrk+3;
+ Amg::MatrixX W_mat(3*NTrk+6,3*NTrk+6); W_mat.setZero();
+ W_mat.block(0,0,ndim,ndim) = cov;
+ W_mat.block(3*NTrk+3,3*NTrk+3,3,3) = PV->covariancePosition();
+ Amg::MatrixX V_err = D_vec.transpose() * W_mat * D_vec;
+
+ double LxyErrsq = V_err(0,0);
+ if (LxyErrsq <= 0.) ATH_MSG_DEBUG("lxyError: negative sqrt LxyErrsq " << LxyErrsq);
+ return (LxyErrsq>0.) ? sqrt(LxyErrsq) : 0.;
+}
+
+double CascadeTools::tau(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ double M = invariantMass(particleMom);
+ double LXY = lxy(particleMom,SV,PV);
+ double PT = pT(particleMom);
+ return s_CONST*M*LXY/PT;
+}
+
+double CascadeTools::tauError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ double M = invariantMass(particleMom);
+ auto vert = SV->position() - PV->position();
+ double dx = vert.x();
+ double dy = vert.y();
+ Amg::Vector3D P = momentum(particleMom);;
+ double Px = P.x();
+ double Py = P.y();
+ double PT = P.perp();
+ double LXY = Px*dx+Py*dy;
+
+ unsigned int NTrk = particleMom.size();
+ TLorentzVector totalMom;
+ for( unsigned int it=0; it<NTrk; it++) totalMom += particleMom[it];
+
+ double dTaudx = (M*Px)/(PT*PT);
+ double dTaudy = (M*Py)/(PT*PT);
+ double dTaudx0 = -dTaudx;
+ double dTaudy0 = -dTaudy;
+
+ Amg::MatrixX D_vec(3*NTrk+6,1); D_vec.setZero();
+ D_vec(0) = dTaudx;
+ D_vec(1) = dTaudy;
+ D_vec(2) = 0.;
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = (((totalMom.E()*particleMom[it].Px()*LXY)/(M*particleMom[it].E()))-Px*LXY/M+M*dx)/(PT*PT) - 2.*M*LXY*Px/(PT*PT*PT*PT);
+ D_vec(3*it+4) = (((totalMom.E()*particleMom[it].Py()*LXY)/(M*particleMom[it].E()))-Py*LXY/M+M*dy)/(PT*PT) - 2.*M*LXY*Py/(PT*PT*PT*PT);
+ D_vec(3*it+5) = 0.;
+ }
+ D_vec(3*NTrk+3) = dTaudx0;
+ D_vec(3*NTrk+4) = dTaudy0;
+ D_vec(3*NTrk+5) = 0.;
+
+ unsigned int ndim = 3*NTrk+3;
+ Amg::MatrixX W_mat(3*NTrk+6,3*NTrk+6); W_mat.setZero();
+ W_mat.block(0,0,ndim,ndim) = cov;
+ W_mat.block(3*NTrk+3,3*NTrk+3,3,3) = PV->covariancePosition();
+ Amg::MatrixX V_err = D_vec.transpose() * W_mat * D_vec;
+
+ double tauErrsq = V_err(0,0);
+ if (tauErrsq <= 0.) ATH_MSG_DEBUG("tauError: negative sqrt tauErrsq " << tauErrsq);
+ double tauErr = (tauErrsq>0.) ? sqrt(tauErrsq) : 0.;
+ return s_CONST*tauErr;
+}
+
+double CascadeTools::tau(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV, double M) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ double LXY = lxy(particleMom,SV,PV);
+ double PT = pT(particleMom);
+ return s_CONST*M*LXY/PT;
+}
+
+double CascadeTools::tauError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV, double M) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ auto vert = SV->position() - PV->position();
+ double dx = vert.x();
+ double dy = vert.y();
+ Amg::Vector3D P = momentum(particleMom);;
+ double Px = P.x();
+ double Py = P.y();
+ double PT = P.perp();
+ double LXY = Px*dx+Py*dy;
+
+ unsigned int NTrk = particleMom.size();
+ TLorentzVector totalMom;
+ for( unsigned int it=0; it<NTrk; it++) totalMom += particleMom[it];
+
+ double dTaudx = (M*Px)/(PT*PT);
+ double dTaudy = (M*Py)/(PT*PT);
+ double dTaudx0 = -dTaudx;
+ double dTaudy0 = -dTaudy;
+
+ Amg::MatrixX D_vec(3*NTrk+6,1); D_vec.setZero();
+ D_vec(0) = dTaudx;
+ D_vec(1) = dTaudy;
+ D_vec(2) = 0.;
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = (M*dx)/(PT*PT) - 2.*M*LXY*Px/(PT*PT*PT*PT);
+ D_vec(3*it+4) = (M*dy)/(PT*PT) - 2.*M*LXY*Py/(PT*PT*PT*PT);
+ D_vec(3*it+5) = 0.;
+ }
+ D_vec(3*NTrk+3) = dTaudx0;
+ D_vec(3*NTrk+4) = dTaudy0;
+ D_vec(3*NTrk+5) = 0.;
+
+ unsigned int ndim = 3*NTrk+3;
+ Amg::MatrixX W_mat(3*NTrk+6,3*NTrk+6); W_mat.setZero();
+ W_mat.block(0,0,ndim,ndim) = cov;
+ W_mat.block(3*NTrk+3,3*NTrk+3,3,3) = PV->covariancePosition();
+ Amg::MatrixX V_err = D_vec.transpose() * W_mat * D_vec;
+
+ double tauErrsq = V_err(0,0);
+ if (tauErrsq <= 0.) ATH_MSG_DEBUG("tauError: negative sqrt tauErrsq " << tauErrsq);
+ double tauErr = (tauErrsq>0.) ? sqrt(tauErrsq) : 0.;
+ return s_CONST*tauErr;
+}
+
+Amg::Vector3D CascadeTools::pca(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) {
+ Amg::Vector3D p; p.setZero();
+ return p;
+ }
+ Amg::Vector3D pv = PV->position();
+ Amg::Vector3D sv = SV->position();
+ Amg::Vector3D P = momentum(particleMom);;
+ double p2 = P.mag2();
+ double pdr = P.dot((sv - pv));
+ return sv - P*pdr/p2;
+}
+
+double CascadeTools::cosTheta(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ Amg::Vector3D P = momentum(particleMom);;
+ Amg::Vector3D vtx = SV->position();
+ vtx -= PV->position();
+ return (P.dot(vtx))/(P.mag()*vtx.mag());
+}
+
+double CascadeTools::cosTheta_xy(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ Amg::Vector3D P = momentum(particleMom);;
+ Amg::Vector3D vtx = SV->position();
+ vtx -= PV->position();
+ double pT = P.perp();
+ return (P.x()*vtx.x()+P.y()*vtx.y())/(pT*vtx.perp());
+}
+
+double CascadeTools::a0z(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ Amg::Vector3D pv = PV->position();
+ Amg::Vector3D ca_point = pca(particleMom,SV,PV);
+ Amg::Vector3D a0_vec = pv - ca_point;
+ return a0_vec.z();
+}
+
+double CascadeTools::a0zError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ auto vert = SV->position() - PV->position();
+ double dx = vert.x();
+ double dy = vert.y();
+ double dz = vert.z();
+ Amg::Vector3D P = momentum(particleMom);;
+ double Px = P.x();
+ double Py = P.y();
+ double Pz = P.z();
+ double P2 = P.mag2();
+ double L = Px*dx+Py*dy+Pz*dz;
+
+ unsigned int NTrk = particleMom.size();
+
+
+ double da0zdx = (Px*Pz)/P2;
+ double da0zdy = (Py*Pz)/P2;
+ double da0zdz = (Pz*Pz)/P2 - 1.;
+ double da0zdx0 = -da0zdx;
+ double da0zdy0 = -da0zdy;
+ double da0zdz0 = -da0zdz;
+
+ Amg::MatrixX D_vec(3*NTrk+6,1); D_vec.setZero();
+ D_vec(0) = da0zdx;
+ D_vec(1) = da0zdy;
+ D_vec(2) = da0zdz;
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = (Pz*(P2*dx-2.*L*Px))/(P2*P2);
+ D_vec(3*it+4) = (Pz*(P2*dy-2.*L*Py))/(P2*P2);
+ D_vec(3*it+5) = (Pz*(P2*dz-2.*L*Pz))/(P2*P2)+L/P2;
+ }
+ D_vec(3*NTrk+3) = da0zdx0;
+ D_vec(3*NTrk+4) = da0zdy0;
+ D_vec(3*NTrk+5) = da0zdz0;
+
+ unsigned int ndim = 3*NTrk+3;
+ Amg::MatrixX W_mat(3*NTrk+6,3*NTrk+6); W_mat.setZero();
+ W_mat.block(0,0,ndim,ndim) = cov;
+ W_mat.block(3*NTrk+3,3*NTrk+3,3,3) = PV->covariancePosition();
+ Amg::MatrixX V_err = D_vec.transpose() * W_mat * D_vec;
+
+ double a0zErrsq = V_err(0,0);
+ if (a0zErrsq <= 0.) ATH_MSG_DEBUG("a0zError: negative sqrt a0zErrsq " << a0zErrsq);
+ return (a0zErrsq>0.) ? sqrt(a0zErrsq) : 0.;
+}
+
+double CascadeTools::a0xy(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ double cosineTheta_xy = cosTheta_xy(particleMom,SV,PV);
+ double sinTheta_xy = ((1.-cosineTheta_xy*cosineTheta_xy)>0.) ? sqrt((1.-cosineTheta_xy*cosineTheta_xy)) : 0.;
+ return (SV->position()-PV->position()).perp() * sinTheta_xy;
+}
+
+double CascadeTools::a0xyError(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ auto vert = SV->position() - PV->position();
+ double dx = vert.x();
+ double dy = vert.y();
+ Amg::Vector3D P = momentum(particleMom);;
+ double Px = P.x();
+ double Py = P.y();
+ double P2 = P.perp()*P.perp();
+ double L = Px*dx+Py*dy;
+ double dR2 = vert.perp()*vert.perp();
+ double d = sqrt((P2*dR2-L*L)/P2);
+
+ unsigned int NTrk = particleMom.size();
+
+ double da0dx = (P2*dx-L*Px)/(P2*d);
+ double da0dy = (P2*dy-L*Py)/(P2*d);
+ double da0dx0 = -da0dx;
+ double da0dy0 = -da0dy;
+
+ Amg::MatrixX D_vec(3*NTrk+6,1); D_vec.setZero();
+ D_vec(0) = da0dx;
+ D_vec(1) = da0dy;
+ D_vec(2) = 0.;
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = (L*(L*Px-P2*dx))/(P2*P2*d);
+ D_vec(3*it+4) = (L*(L*Py-P2*dy))/(P2*P2*d);
+ D_vec(3*it+5) = 0.;
+ }
+ D_vec(3*NTrk+3) = da0dx0;
+ D_vec(3*NTrk+4) = da0dy0;
+ D_vec(3*NTrk+5) = 0.;
+
+ unsigned int ndim = 3*NTrk+3;
+ Amg::MatrixX W_mat(3*NTrk+6,3*NTrk+6); W_mat.setZero();
+ W_mat.block(0,0,ndim,ndim) = cov;
+ W_mat.block(3*NTrk+3,3*NTrk+3,3,3) = PV->covariancePosition();
+ Amg::MatrixX V_err = D_vec.transpose() * W_mat * D_vec;
+
+ double a0xyErrsq = V_err(0,0);
+ if (a0xyErrsq <= 0.) ATH_MSG_DEBUG("a0xyError: negative sqrt a0xyErrsq " << a0xyErrsq);
+ return (a0xyErrsq>0.) ? sqrt(a0xyErrsq) : 0.;
+}
+
+double CascadeTools::a0(const std::vector<TLorentzVector> &particleMom, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ double cosineTheta = cosTheta(particleMom,SV,PV);
+ double sinTheta = ((1.-cosineTheta*cosineTheta)>0.) ? sqrt((1.-cosineTheta*cosineTheta)) : 0.;
+ return (SV->position()-PV->position()).mag() * sinTheta;
+}
+
+double CascadeTools::a0Error(const std::vector<TLorentzVector> &particleMom, const Amg::MatrixX& cov, const xAOD::Vertex* SV, const xAOD::Vertex* PV) const
+{
+ if(particleMom.size() == 0) return -999999.;
+ auto vert = SV->position() - PV->position();
+ double dx = vert.x();
+ double dy = vert.y();
+ double dz = vert.z();
+ Amg::Vector3D P = momentum(particleMom);;
+ double Px = P.x();
+ double Py = P.y();
+ double Pz = P.z();
+ double P2 = P.mag2();
+ double L = Px*dx+Py*dy+Pz*dz;
+ double dR2 = vert.mag2();
+ double d = sqrt((P2*dR2-L*L)/P2);
+
+ unsigned int NTrk = particleMom.size();
+
+ double da0dx = (P2*dx-L*Px)/(P2*d);
+ double da0dy = (P2*dy-L*Py)/(P2*d);
+ double da0dz = (P2*dz-L*Pz)/(P2*d);
+ double da0dx0 = -da0dx;
+ double da0dy0 = -da0dy;
+ double da0dz0 = -da0dz;
+
+ Amg::MatrixX D_vec(3*NTrk+6,1); D_vec.setZero();
+ D_vec(0) = da0dx;
+ D_vec(1) = da0dy;
+ D_vec(2) = da0dz;
+ for( unsigned int it=0; it<NTrk; it++) {
+ D_vec(3*it+3) = (L*(L*Px-P2*dx))/(P2*P2*d);
+ D_vec(3*it+4) = (L*(L*Py-P2*dy))/(P2*P2*d);
+ D_vec(3*it+5) = (L*(L*Pz-P2*dz))/(P2*P2*d);
+ }
+ D_vec(3*NTrk+3) = da0dx0;
+ D_vec(3*NTrk+4) = da0dy0;
+ D_vec(3*NTrk+5) = da0dz0;
+
+ unsigned int ndim = 3*NTrk+3;
+ Amg::MatrixX W_mat(3*NTrk+6,3*NTrk+6); W_mat.setZero();
+ W_mat.block(0,0,ndim,ndim) = cov;
+ W_mat.block(3*NTrk+3,3*NTrk+3,3,3) = PV->covariancePosition();
+ Amg::MatrixX V_err = D_vec.transpose() * W_mat * D_vec;
+
+ double a0Errsq = V_err(0,0);
+ if (a0Errsq <= 0.) ATH_MSG_DEBUG("a0Error: negative sqrt a0Errsq " << a0Errsq);
+ return (a0Errsq>0.) ? sqrt(a0Errsq) : 0.;
+}
+
+Amg::Vector3D CascadeTools::momentum(const std::vector<TLorentzVector> &particleMom) const
+{
+ if(particleMom.size() == 0) {
+ Amg::Vector3D p; p.setZero();
+ return p;
+ }
+ TLorentzVector totalMom;
+ unsigned int NTrk = particleMom.size();
+ for( unsigned int it=0; it<NTrk; it++) totalMom += particleMom[it];
+ TVector3 P3 = totalMom.Vect();
+ Amg::Vector3D mom(P3.Px(),P3.Py(),P3.Pz());
+ return mom;
+}
+
+double CascadeTools::massProbability(double V0Mass, double mass, double massErr) const
+{
+ if(massErr > 0.) {
+ double chi2 = (V0Mass - mass)*(V0Mass - mass)/(massErr*massErr);
+ int ndf = 1;
+ Genfun::CumulativeChiSquare myCumulativeChiSquare(ndf);
+ if (chi2 > 0.) {
+ double achi2prob = 1.-myCumulativeChiSquare(chi2);
+ return achi2prob;
+ } else {
+ ATH_MSG_DEBUG("chi2 <= 0");
+ return -1.;
+ }
+ } else {
+ return -1.;
+ }
+}
+
+double CascadeTools::vertexProbability(int ndf, double chi2) const
+{
+ if (ndf > 0.) {
+ Genfun::CumulativeChiSquare myCumulativeChiSquare(ndf);
+ if (chi2 > 0.) {
+ double chi2prob = 1.-myCumulativeChiSquare(chi2);
+ return chi2prob;
+ } else {
+ ATH_MSG_DEBUG("chi2 <= 0");
+ return -1.;
+ }
+ } else {
+ ATH_MSG_DEBUG("ndf <= 0");
+ return -1.;
+ }
+}
+
+
+Amg::MatrixX * CascadeTools::convertCovMatrix(const xAOD::Vertex * vxCandidate) const
+{
+ unsigned int NTrk = vxCandidate->nTrackParticles();
+ std::vector<float> matrix = vxCandidate->covariance();
+
+ int ndim = 0;
+
+ if ( matrix.size() == (3*NTrk+3)*(3*NTrk+3+1)/2) {
+ ndim = 3*NTrk+3;
+ } else if (matrix.size() == (5*NTrk+3)*(5*NTrk+3+1)/2) {
+ ndim = 5*NTrk+3;
+ } else {
+ return nullptr;
+ }
+
+ Amg::MatrixX* mtx = new Amg::MatrixX(ndim,ndim);
+
+ long int ij=0;
+ for (int i=1; i<= ndim; i++) {
+ for (int j=1; j<=i; j++){
+ if (i==j) {
+ (*mtx)(i-1,j-1)=matrix[ij];
+ } else {
+ (*mtx).fillSymmetric(i-1,j-1,matrix[ij]);
+ }
+ ij++;
+ }
+ }
+ // NOTE: mtx is a pointer! Take care of deleting it after you do not need it anymore!!!
+
+ return mtx;
+}
+
+Amg::MatrixX CascadeTools::SetFullMatrix(int NTrk, const std::vector<float> & Matrix) const
+{
+
+ Amg::MatrixX mtx(3+3*NTrk,3+3*NTrk); // Create identity matrix of needed size
+
+ int ij=0;
+
+ for(int i=0; i<(3+3*NTrk); i++){
+ for(int j=0; j<=i; j++){
+ mtx(i,j)=Matrix[ij];
+ if(i!=j) mtx(j,i)=Matrix[ij];
+ ij++;
+ }
+ }
+
+ return mtx;
+}
+
+} //end of namespace definitions
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/CfAthAlgTool.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/CfAthAlgTool.cxx
new file mode 100644
index 00000000000..299340b7b3a
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/CfAthAlgTool.cxx
@@ -0,0 +1,178 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// CfAthAlgTool.h
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Wrapper around AthAlgTool to provide easy access to CutFlowSvc
+// and some utility methods for it.
+// Methods for accessing the CutFlowSvc are modelled after
+// AthFilterAlgorithm's implementation.
+//
+// This class inherits from AthAlgTool. It should be inherited from.
+//
+//-----------------------------------------------------------------------------
+//
+// Usage information
+//
+// Example:
+//
+// // Bmumu_reco_mumu.h:
+// class Bmumu_reco_mumu : public CfAthAlgTool, public IAugmentationTool {
+// public:
+// Bmumu_reco_mumu(const std::string& t, const std::string& n,
+// const IInterface* p);
+// ...
+//
+// // Bmumu_reco_mumu.cxx:
+// Bmumu_reco_mumu::Bmumu_reco_mumu(const std::string& t,
+// const std::string& n,
+// const IInterface* p) :
+// CfAthAlgTool(t,n,p),
+// ...
+//
+// // inside a method like Bmumu_reco_mumu::addBranches():
+// ...
+// // add counter for number of events seen
+// addEvent("dimuEvents");
+// // add counter for the number of events with >= 1 reco'd vertices
+// if ( vtxContainer->size() > 0 ) {
+// addEvent("dimuWithVertexCand");
+// }
+// // add counter for the number of vertices
+// addToCounter("dimuNumVertices", vtxContainer->size());
+// ...
+//
+// Please note that a line for
+// addEvent(nameString, weight=1.);
+// or
+// addToCounter(nameString, counts=1, weight=1.);
+// is sufficient.
+// In a case a counter with that name does not exist yet, it will be
+// initialized automatically.
+//
+//============================================================================
+//
+#include "DerivationFrameworkBPhys/CfAthAlgTool.h"
+
+namespace DerivationFramework {
+
+ //--------------------------------------------------------------------------
+ // Constructor
+ CfAthAlgTool::CfAthAlgTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_cutFlowSvc("CutFlowSvc/CutFlowSvc", n),
+ m_ctbasename(n),
+ m_bid(0), m_bidisset(false) {
+
+ ATH_MSG_DEBUG("Calling constructor with parameters");
+
+ // Declare counters base name
+ declareProperty("CountersBaseName", m_ctbasename);
+
+ // clean-up counter base name
+ std::string fstr("ToolSvc.");
+ std::string::size_type ind = m_ctbasename.find(fstr);
+ if (ind != std::string::npos) m_ctbasename.erase(ind, fstr.length());
+
+ }
+ //--------------------------------------------------------------------------
+ // Destructor
+ CfAthAlgTool::~CfAthAlgTool() {
+
+ ATH_MSG_DEBUG("Calling destructor");
+ }
+ //--------------------------------------------------------------------------
+ // return a handle to an ICutFlowSvc instance
+ ServiceHandle<ICutFlowSvc>& CfAthAlgTool::cutFlowSvc() const {
+
+ return m_cutFlowSvc;
+ }
+ //--------------------------------------------------------------------------
+ // Initialization method invoked by the framework.
+ StatusCode CfAthAlgTool::sysInitialize() {
+
+ // retrieve CutFlowSvc instance
+ CHECK( cutFlowSvc().retrieve() );
+
+ // re-direct to base class...
+ return AthAlgTool::sysInitialize();
+ }
+ //--------------------------------------------------------------------------
+ // add one event to a named counter -- returns true on success
+ bool CfAthAlgTool::addEvent(const std::string &name, double weight) const {
+
+ CutIdentifier id = getCounter(name);
+ if ( id > 0 ) {
+ cutFlowSvc()->addEvent(id, weight);
+ }
+ return (id > 0);
+ }
+ //--------------------------------------------------------------------------
+ // add to a named counter -- returns true on success
+ // if counts > 1 : same weight is added multiple times
+ bool CfAthAlgTool::addToCounter(const std::string &name, uint64_t counts,
+ double weight) const {
+
+ CutIdentifier id = getCounter(name);
+ if ( id > 0 ) {
+ for (uint64_t i=0; i<counts; ++i) {
+ cutFlowSvc()->addEvent(id, weight);
+ }
+ }
+ return (id > 0);
+ }
+ //--------------------------------------------------------------------------
+ // add a counter by name -- simply returns id if counter already exists
+ CutIdentifier CfAthAlgTool::getCounter(const std::string &name) const {
+
+ CutIdentifier id = getCounterIdByName(name);
+ if ( id < 1 ) {
+ std::string fullname = m_ctbasename + "_" + name;
+ if ( ! m_bidisset ) {
+ throw std::runtime_error("cutFlowSvc()->registerFilter is no longer supported. code an alternative here");
+ //id = cutFlowSvc()->registerFilter(fullname, "N/A");
+ m_bid = id;
+ } else {
+ throw std::runtime_error("cutFlowSvc()->registerCut is no longer supported. code an alternative here");
+ //id = cutFlowSvc()->registerCut(fullname, "N/A", m_bid);
+ }
+ m_mctn[name] = id;
+ }
+ return id;
+ }
+ //--------------------------------------------------------------------------
+ // returns counter name by id
+ std::string CfAthAlgTool::getCounterNameById(CutIdentifier id) const {
+
+ std::string res = "__NOT_FOUND__";
+
+ for (NameIdMap_t::iterator it = m_mctn.begin(); it != m_mctn.end(); ++it) {
+ if ( it->second == id ) {
+ res = it->first;
+ break;
+ }
+ }
+ return res;
+ }
+ //--------------------------------------------------------------------------
+ // returns counter id by name
+ CutIdentifier CfAthAlgTool::getCounterIdByName(const std::string &name) const {
+
+ CutIdentifier id = 0;
+
+ NameIdMap_t::const_iterator it = m_mctn.find(name);
+ if ( it != m_mctn.end() ) {
+ id = it->second;
+ }
+ return id;
+ }
+ //--------------------------------------------------------------------------
+} // namespace
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/FourMuonTool.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/FourMuonTool.cxx
new file mode 100644
index 00000000000..bdf1acabf9e
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/FourMuonTool.cxx
@@ -0,0 +1,449 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// ****************************************************************************
+// ----------------------------------------------------------------------------
+// FourMuonTool
+// James Catmore <James.Catmore@cern.ch>
+// Evelina Bouhova-Thacker <e.bouhova@cern.ch>
+// ----------------------------------------------------------------------------
+// ****************************************************************************
+
+#include "DerivationFrameworkBPhys/FourMuonTool.h"
+#include "DerivationFrameworkBPhys/BPhysPVTools.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "TrkVertexFitterInterfaces/IVertexFitter.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "TrkV0Fitter/TrkV0VertexFitter.h"
+#include "InDetConversionFinderTools/ConversionFinderUtils.h"
+#include "InDetConversionFinderTools/VertexPointEstimator.h"
+#include "TrkToolInterfaces/ITrackSelectorTool.h"
+#include "AthLinks/ElementLink.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+
+#include "xAODTracking/Vertex.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODTracking/TrackParticle.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "StoreGate/WriteDecorHandle.h"
+
+#include <algorithm>
+
+namespace DerivationFramework {
+
+ StatusCode FourMuonTool::initialize() {
+
+ // retrieving vertex Fitter
+ if ( m_iVertexFitter.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_iVertexFitter);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Retrieved tool " << m_iVertexFitter);
+ }
+
+ // retrieving V0 Fitter
+ if ( m_iV0VertexFitter.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_iV0VertexFitter);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Retrieved tool " << m_iV0VertexFitter);
+ }
+
+ // Get the track selector tool from ToolSvc
+ if ( m_trkSelector.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_trkSelector);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Retrieved tool " << m_trkSelector);
+ }
+
+ // uploading the V0 tools
+ if ( m_V0Tools.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_V0Tools);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Retrieved tool " << m_V0Tools);
+ }
+
+ // Get the vertex point estimator tool from ToolSvc
+ if ( m_vertexEstimator.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_vertexEstimator);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Retrieved tool " << m_vertexEstimator);
+ }
+
+ // Get the beam spot service
+ CHECK( m_beamSpotKey.initialize() );
+
+ m_muonIndex = m_muonCollectionKey.key() + ".BPHY4MuonIndex";
+ ATH_CHECK(m_muonIndex.initialize());
+ ATH_MSG_DEBUG("Initialize successful");
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ FourMuonTool::FourMuonTool(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
+ m_ptCut(0.0),
+ m_etaCut(0.0),
+ m_useV0Fitter(false),
+ m_muonCollectionKey("Muons"),
+ m_TrkParticleCollection("TrackParticleCandidate"),
+ m_iVertexFitter("Trk::TrkVKalVrtFitter"),
+ m_iV0VertexFitter("Trk::V0VertexFitter"),
+ m_V0Tools("Trk::V0Tools"),
+ m_trkSelector("InDet::TrackSelectorTool"),
+ m_vertexEstimator("InDet::VertexPointEstimator")
+ {
+ declareInterface<FourMuonTool>(this);
+ declareProperty("ptCut",m_ptCut);
+ declareProperty("etaCut",m_etaCut);
+ declareProperty("useV0Fitter",m_useV0Fitter);
+ declareProperty("muonCollectionKey",m_muonCollectionKey);
+ declareProperty("TrackParticleCollection",m_TrkParticleCollection);
+ declareProperty("TrkVertexFitterTool",m_iVertexFitter);
+ declareProperty("V0VertexFitterTool",m_iV0VertexFitter);
+ declareProperty("V0Tools",m_V0Tools);
+ declareProperty("TrackSelectorTool",m_trkSelector);
+ declareProperty("VertexPointEstimator",m_vertexEstimator);
+ }
+
+ FourMuonTool::~FourMuonTool() { }
+
+ //-------------------------------------------------------------------------------------
+ // Find the candidates
+ //-------------------------------------------------------------------------------------
+ StatusCode FourMuonTool::performSearch(xAOD::VertexContainer*& pairVxContainer, xAOD::VertexAuxContainer*& pairVxAuxContainer,
+ xAOD::VertexContainer*& quadVxContainer, xAOD::VertexAuxContainer*& quadVxAuxContainer, bool &selectEvent) const
+ {
+ ATH_MSG_DEBUG( "FourMuonTool::performSearch" );
+ selectEvent = false;
+
+ // pairs
+ pairVxContainer = new xAOD::VertexContainer;
+ pairVxAuxContainer = new xAOD::VertexAuxContainer;
+ pairVxContainer->setStore(pairVxAuxContainer);
+ // quads
+ quadVxContainer = new xAOD::VertexContainer;
+ quadVxAuxContainer = new xAOD::VertexAuxContainer;
+ quadVxContainer->setStore(quadVxAuxContainer);
+
+
+ // Get the muons from StoreGate
+ SG::ReadHandle<xAOD::MuonContainer> importedMuonCollection(m_muonCollectionKey);
+ ATH_CHECK(importedMuonCollection.isValid());
+ ATH_MSG_DEBUG("Muon container size "<<importedMuonCollection->size());
+
+ // Get ID tracks
+ SG::ReadHandle<xAOD::TrackParticleContainer> importedTrackCollection(m_TrkParticleCollection);
+ ATH_CHECK(importedTrackCollection.isValid());
+ ATH_MSG_DEBUG("ID TrackParticle container size "<< importedTrackCollection->size());
+
+ // Select the muons
+ std::vector<const xAOD::Muon*> theMuonsAfterSelection;
+ SG::WriteDecorHandle<xAOD::MuonContainer, int> muonDecorator(m_muonIndex);
+ unsigned int nCombMuons = 0;
+ unsigned int nSegmentTaggedMuons = 0;
+
+ for (auto muItr=importedMuonCollection->begin(); muItr!=importedMuonCollection->end(); ++muItr) {
+ if ( *muItr == NULL ) continue;
+ muonDecorator(**muItr) = -1; // all muons must be decorated
+ if ( ((*muItr)->muonType() != xAOD::Muon::Combined ) && ((*muItr)->muonType() != xAOD::Muon::SegmentTagged ) ) continue;
+ if (!(*muItr)->inDetTrackParticleLink().isValid()) continue; // No muons without ID tracks
+ auto& link = (*muItr)->inDetTrackParticleLink();
+ const xAOD::TrackParticle* muonTrk = *link;
+ if ( muonTrk==NULL) continue;
+ const xAOD::Vertex* vx = nullptr;
+ if ( !m_trkSelector->decision(*muonTrk, vx) ) continue; // all ID tracks must pass basic tracking cuts
+ if ( fabs(muonTrk->pt())<m_ptCut ) continue; // pt cut
+ if ( fabs(muonTrk->eta())>m_etaCut ) continue; // eta cut
+ if ( (*muItr)->muonType() == xAOD::Muon::Combined ) ++nCombMuons;
+ if ( (*muItr)->muonType() == xAOD::Muon::SegmentTagged ) ++nSegmentTaggedMuons;
+ theMuonsAfterSelection.push_back(*muItr);
+ }
+ unsigned int nSelectedMuons = theMuonsAfterSelection.size();
+ ATH_MSG_DEBUG("Number of muons after selection: " << nSelectedMuons);
+ ATH_MSG_DEBUG("of which " << nCombMuons << " are combined");
+ ATH_MSG_DEBUG("and " << nSegmentTaggedMuons << " are segment tagged");
+ if ( (nSelectedMuons < 4) || (nCombMuons < 1) ) {
+ ATH_MSG_DEBUG("Muon criteria not met. Skipping event.");
+ return StatusCode::SUCCESS;
+ }
+ selectEvent = true; // if we got this far we should definitively accept the event
+
+ // Decorators
+ SG::AuxElement::Decorator< std::string > indexDecorator("CombinationCode");
+ SG::AuxElement::Decorator< std::string > chargeDecorator("ChargeCode");
+ //SG::AuxElement::Decorator< double > acdcDecorator("ACminusDC");
+ //SG::AuxElement::Decorator< double > ssdcDecorator("SSminusDC");
+
+ // Order by pT
+ std::sort(theMuonsAfterSelection.begin(), theMuonsAfterSelection.end(), [](const xAOD::Muon *a, const xAOD::Muon *b) {
+ return b->pt() < a->pt();
+ });
+
+ // Decorate the selected muons (now pT ordered) with their index
+ unsigned int muonIndex(0);
+ for (auto selMuon : theMuonsAfterSelection) {
+ muonDecorator(*selMuon) = muonIndex;
+ ++muonIndex;
+ }
+
+ // Quadruplet combinatorics
+ std::vector<Combination> quadruplets;
+ std::vector<Combination> pairs;
+ buildCombinations(theMuonsAfterSelection,pairs,quadruplets,nSelectedMuons);
+ if (quadruplets.size()==0) {
+ ATH_MSG_DEBUG("No acceptable quadruplets");
+ return StatusCode::SUCCESS;
+ }
+
+ // Get the beam spot (for the vertexing starting point)
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ const Amg::Vector3D &beamSpot = beamSpotHandle->beamPos();
+
+ // fit pairs
+ ATH_MSG_DEBUG("Successful pairs.....");
+ for (std::vector<Combination>::iterator pairItr = pairs.begin(); pairItr!=pairs.end(); ++pairItr) {
+ std::vector<const xAOD::TrackParticle*> theTracks = (*pairItr).trackParticles("pair1");
+ xAOD::Vertex* pairVxCandidate = fit(theTracks,importedTrackCollection.get(),beamSpot); // This line actually does the fitting and object making
+ if (pairVxCandidate != 0) {
+ // decorate the candidate with its codes
+ indexDecorator(*pairVxCandidate) = (*pairItr).combinationIndices();
+ chargeDecorator(*pairVxCandidate) = (*pairItr).combinationCharges();
+ // decorate the candidate with refitted tracks and muons via the BPhysHelper
+ xAOD::BPhysHelper helper(pairVxCandidate);
+ helper.setRefTrks();
+ std::vector<const xAOD::Muon*> theStoredMuons;
+ theStoredMuons = (*pairItr).muons;
+ helper.setMuons(theStoredMuons,importedMuonCollection.get());
+ // Retain the vertex
+ pairVxContainer->push_back(pairVxCandidate);
+ ATH_MSG_DEBUG("..... indices: " << (*pairItr).combinationIndices() <<
+ " charges: " << (*pairItr).combinationCharges() <<
+ " chi2: " << pairVxCandidate->chiSquared());
+ } else { // fit failed
+ ATH_MSG_DEBUG("Fitter failed!");
+ }
+ }
+ ATH_MSG_DEBUG("pairContainer size " << pairVxContainer->size());
+
+ // fit quadruplets
+ ATH_MSG_DEBUG("Successful quadruplets.....");
+ for (std::vector<Combination>::iterator quadItr = quadruplets.begin(); quadItr!=quadruplets.end(); ++quadItr) {
+ std::vector<const xAOD::TrackParticle*> theDCTracks; theDCTracks.clear();
+ //std::vector<const xAOD::TrackParticle*> theACTracks; theACTracks.clear();
+ //std::vector<const xAOD::TrackParticle*> theSSTracks; theSSTracks.clear();
+ theDCTracks = (*quadItr).trackParticles("DC");
+ //theACTracks = (*quadItr).trackParticles("AC");
+ //theSSTracks = (*quadItr).trackParticles("SS");
+ xAOD::Vertex* dcVxCandidate = fit(theDCTracks,importedTrackCollection.get(), beamSpot);
+ //xAOD::Vertex* acVxCandidate = fit(theACTracks,importedTrackCollection, beamSpot);
+ //xAOD::Vertex* ssVxCandidate = fit(theSSTracks,importedTrackCollection, beamSpot);
+ // Get the chi2 for each one
+ //double acChi2(0.0);
+ //double ssChi2(0.0);
+ //if (acVxCandidate != 0) {acChi2 = acVxCandidate->chiSquared();}
+ //if (ssVxCandidate != 0) {ssChi2 = ssVxCandidate->chiSquared();}
+ if (dcVxCandidate != 0) {
+ // decorate the candidate with its codes
+ indexDecorator(*dcVxCandidate) = (*quadItr).combinationIndices();
+ chargeDecorator(*dcVxCandidate) = (*quadItr).combinationCharges();
+ // Decorate the DC candidate with the differences between its chi2 and the other
+ double dcChi2 = dcVxCandidate->chiSquared();
+ //acdcDecorator(*dcVxCandidate) = acChi2 - dcChi2;
+ //ssdcDecorator(*dcVxCandidate) = ssChi2 - dcChi2;
+ // decorate the candidate with refitted tracks and muons via the BPhysHelper
+ xAOD::BPhysHelper helper(dcVxCandidate);
+ helper.setRefTrks();
+ const std::vector<const xAOD::Muon*> &theStoredMuons = (*quadItr).muons;
+ helper.setMuons(theStoredMuons,importedMuonCollection.get());
+ // Retain the vertex
+ quadVxContainer->push_back(dcVxCandidate);
+ ATH_MSG_DEBUG("..... indices: " << (*quadItr).combinationIndices() <<
+ " charges: " << (*quadItr).combinationCharges() <<
+ " chi2(DC): " << dcChi2);
+ //" chi2(AC): " << acChi2 <<
+ //" chi2(SS): " << ssChi2);
+ } else { // fit failed
+ ATH_MSG_DEBUG("Fitter failed!");
+ }
+ }
+ ATH_MSG_DEBUG("quadruplet container size " << quadVxContainer->size());
+
+ return StatusCode::SUCCESS;;
+ }
+
+ // *********************************************************************************
+
+ // ---------------------------------------------------------------------------------
+ // fit - does the fit
+ // ---------------------------------------------------------------------------------
+
+ xAOD::Vertex* FourMuonTool::fit(const std::vector<const xAOD::TrackParticle*> &inputTracks,
+ const xAOD::TrackParticleContainer* importedTrackCollection,
+ const Amg::Vector3D &beamSpot) const {
+
+ const Trk::TrkV0VertexFitter* concreteVertexFitter=0;
+ if (m_useV0Fitter) {
+ // making a concrete fitter for the V0Fitter
+ concreteVertexFitter = dynamic_cast<const Trk::TrkV0VertexFitter * >(&(*m_iV0VertexFitter));
+ if(concreteVertexFitter == 0) {
+ ATH_MSG_FATAL("The vertex fitter passed is not a V0 Vertex Fitter");
+ return NULL;
+ }
+ }
+
+ //int sflag = 0;
+ //int errorcode = 0;
+ //Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&aPerigee1,&aPerigee2,sflag,errorcode);
+ //startingPoint(0) = 0.0; startingPoint(1) = 0.0; startingPoint(2) = 0.0;}
+ //Trk::Vertex vertex(beamSpot);
+
+ xAOD::Vertex* myVxCandidate = nullptr;
+ if (m_useV0Fitter) {
+ myVxCandidate = concreteVertexFitter->fit(inputTracks, beamSpot /*vertex startingPoint*/ );
+ } else {
+ myVxCandidate = m_iVertexFitter->fit(inputTracks, beamSpot /*vertex startingPoint*/ );
+ }
+
+ if(myVxCandidate) BPhysPVTools::PrepareVertexLinks(myVxCandidate, importedTrackCollection);
+
+ return myVxCandidate;
+
+ } // End of fit method
+
+
+ // *********************************************************************************
+
+ // ---------------------------------------------------------------------------------
+ // getQuadIndices: forms up index lists
+ // ---------------------------------------------------------------------------------
+
+ std::vector<std::vector<unsigned int> > FourMuonTool::getQuadIndices(unsigned int length) {
+
+ std::vector<std::vector<unsigned int> > quadIndices = mFromN(4,length);
+ return(quadIndices);
+ }
+
+
+ // *********************************************************************************
+
+ // ---------------------------------------------------------------------------------
+ // mFromN and combinatorics
+ // ---------------------------------------------------------------------------------
+ std::vector<std::vector<unsigned int> > FourMuonTool::mFromN(unsigned int m, unsigned int N) {
+
+ std::vector<std::vector<unsigned int> > allCombinations;
+ std::vector<unsigned int> mainList;
+ std::vector<unsigned int> combination;
+ for (unsigned int i=0; i<N; ++i) mainList.push_back(i);
+ combinatorics(0,m,combination,mainList,allCombinations);
+ return allCombinations;
+ }
+
+ void FourMuonTool::combinatorics(unsigned int offset,
+ unsigned int k,
+ std::vector<unsigned int> &combination,
+ std::vector<unsigned int> &mainList,
+ std::vector<std::vector<unsigned int> > &allCombinations) {
+ if (k==0) {
+ allCombinations.push_back(combination);
+ return;
+ }
+ if (k>0) {
+ for (unsigned int i=offset; i<=mainList.size()-k; ++i) {
+ combination.push_back(mainList[i]);
+ combinatorics(i+1,k-1,combination,mainList,allCombinations);
+ combination.pop_back();
+ }
+ }
+ }
+
+ // ---------------------------------------------------------------------------------
+ // getPairIndices
+ // ---------------------------------------------------------------------------------
+
+ std::vector<std::pair<unsigned int, unsigned int> > FourMuonTool::getPairIndices(unsigned int length){
+
+ std::vector<std::pair<unsigned int, unsigned int> > uniquePairs;
+ std::vector<std::vector<unsigned int> > doublets = mFromN(2,length);
+ for (std::vector<std::vector<unsigned int> >::iterator it=doublets.begin(); it!=doublets.end(); ++it) {
+ std::pair<unsigned int, unsigned int> tmpPair = std::make_pair((*it).at(0),(*it).at(1));
+ uniquePairs.push_back(tmpPair);
+ }
+
+ return(uniquePairs);
+ }
+
+
+
+ // *********************************************************************************
+
+ // ---------------------------------------------------------------------------------
+ // buildCombinations: forms up the quadruplet of muons/tracks
+ // ---------------------------------------------------------------------------------
+
+ void FourMuonTool::buildCombinations(const std::vector<const xAOD::Muon*> &muonsIn,
+ std::vector<Combination> &pairs,
+ std::vector<Combination> &quadruplets,
+ unsigned int nSelectedMuons) {
+
+ std::vector<std::vector<unsigned int> > quadrupletIndices = getQuadIndices(nSelectedMuons);
+ std::vector<std::pair<unsigned int, unsigned int> > pairIndices = getPairIndices(nSelectedMuons);
+
+ // Quadruplets
+ std::vector<std::vector<unsigned int> >::iterator quadItr;
+ for (quadItr=quadrupletIndices.begin(); quadItr!=quadrupletIndices.end(); ++quadItr) {
+ const std::vector<unsigned int> &quad = (*quadItr);
+ std::vector<const xAOD::Muon*> theMuons = {muonsIn[quad[0]],muonsIn[quad[1]],muonsIn[quad[2]],muonsIn[quad[3]]};
+ if (!passesQuadSelection(theMuons)) continue;
+ Combination tmpQuad;
+ tmpQuad.muons = std::move(theMuons);
+ tmpQuad.quadIndices = quad;
+ quadruplets.emplace_back(std::move(tmpQuad));
+ }
+ if (quadruplets.size() == 0) return;
+
+ // pairs
+ std::vector<std::pair<unsigned int, unsigned int> >::iterator pairItr;
+ for (pairItr=pairIndices.begin(); pairItr!=pairIndices.end(); ++pairItr) {
+ std::pair<unsigned int, unsigned int> pair = (*pairItr);
+ Combination tmpPair;
+ std::vector<const xAOD::Muon*> theMuons = {muonsIn[pair.first],muonsIn[pair.second]};
+ tmpPair.muons = std::move(theMuons);
+ tmpPair.pairIndices = pair;
+ pairs.emplace_back(std::move(tmpPair));
+ }
+
+ return;
+
+ }
+
+ // *********************************************************************************
+
+ // ---------------------------------------------------------------------------------
+ // passesQuadSelection: 4-muon selection
+ // ---------------------------------------------------------------------------------
+
+ bool FourMuonTool::passesQuadSelection(const std::vector<const xAOD::Muon*> &muons) {
+ bool accept(false);
+ bool charges(true);
+ bool quality(false);
+ //unsigned int sumCharges = abs(mu0->charge() + mu1->charge() + mu2->charge() + mu3->charge());
+ //if (sumCharges<4) charges = true;
+ if (( muons.at(0)->muonType() == xAOD::Muon::Combined ) ||
+ ( muons.at(1)->muonType() == xAOD::Muon::Combined ) ||
+ ( muons.at(2)->muonType() == xAOD::Muon::Combined ) ||
+ ( muons.at(3)->muonType() == xAOD::Muon::Combined )
+ ) quality = true;
+ if (charges && quality) accept = true;
+ return accept;
+ }
+
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDpstCascade.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDpstCascade.cxx
new file mode 100644
index 00000000000..04f187bf3d8
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDpstCascade.cxx
@@ -0,0 +1,724 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+/////////////////////////////////////////////////////////////////
+// JpsiPlusDpstCascade.cxx, (c) ATLAS Detector software
+/////////////////////////////////////////////////////////////////
+#include "DerivationFrameworkBPhys/JpsiPlusDpstCascade.h"
+#include "TrkVertexFitterInterfaces/IVertexFitter.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "GaudiKernel/IPartPropSvc.h"
+#include "DerivationFrameworkBPhys/CascadeTools.h"
+#include "DerivationFrameworkBPhys/BPhysPVCascadeTools.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include <algorithm>
+#include "xAODTracking/VertexContainer.h"
+#include "DerivationFrameworkBPhys/LocalVector.h"
+#include "HepPDT/ParticleDataTable.hh"
+
+namespace DerivationFramework {
+ typedef ElementLink<xAOD::VertexContainer> VertexLink;
+ typedef std::vector<VertexLink> VertexLinkVector;
+ typedef std::vector<const xAOD::TrackParticle*> TrackBag;
+
+
+ StatusCode JpsiPlusDpstCascade::initialize() {
+
+ // retrieving vertex Fitter
+ ATH_CHECK( m_iVertexFitter.retrieve());
+
+ // retrieving the V0 tools
+ ATH_CHECK( m_V0Tools.retrieve());
+
+ // retrieving the Cascade tools
+ ATH_CHECK( m_CascadeTools.retrieve());
+
+ // Get the beam spot service
+ ATH_CHECK(m_beamSpotKey.initialize());
+
+ IPartPropSvc* partPropSvc = nullptr;
+ ATH_CHECK( service("PartPropSvc", partPropSvc, true) );
+ auto pdt = partPropSvc->PDT();
+
+ // retrieve particle masses
+ if(m_mass_jpsi < 0. ) m_mass_jpsi = BPhysPVCascadeTools::getParticleMass(pdt, PDG::J_psi);
+ if(m_vtx0MassHypo < 0.) m_vtx0MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::B_c_plus);
+ if(m_vtx1MassHypo < 0.) m_vtx1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::D0);
+
+ if(m_vtx0Daug1MassHypo < 0.) m_vtx0Daug1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::mu_minus);
+ if(m_vtx0Daug2MassHypo < 0.) m_vtx0Daug2MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::mu_minus);
+ if(m_vtx0Daug3MassHypo < 0.) m_vtx0Daug3MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::pi_plus);
+ if(m_vtx1Daug1MassHypo < 0.) m_vtx1Daug1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::pi_plus);
+ if(m_vtx1Daug2MassHypo < 0.) m_vtx1Daug2MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::K_plus);
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ StatusCode JpsiPlusDpstCascade::addBranches() const
+ {
+ std::vector<Trk::VxCascadeInfo*> cascadeinfoContainer;
+ constexpr int topoN = 2;
+ std::array<xAOD::VertexContainer*, topoN> Vtxwritehandles;
+ std::array<xAOD::VertexAuxContainer*, topoN> Vtxwritehandlesaux;
+ if(m_cascadeOutputsKeys.size() !=topoN) { ATH_MSG_FATAL("Incorrect number of VtxContainers"); return StatusCode::FAILURE; }
+
+ for(int i =0; i<topoN;i++){
+ Vtxwritehandles[i] = new xAOD::VertexContainer();
+ Vtxwritehandlesaux[i] = new xAOD::VertexAuxContainer();
+ Vtxwritehandles[i]->setStore(Vtxwritehandlesaux[i]);
+ ATH_CHECK(evtStore()->record(Vtxwritehandles[i] , m_cascadeOutputsKeys[i] ));
+ ATH_CHECK(evtStore()->record(Vtxwritehandlesaux[i], m_cascadeOutputsKeys[i] + "Aux."));
+ }
+
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+ const xAOD::Vertex * primaryVertex(nullptr);
+ const xAOD::VertexContainer *pvContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(pvContainer, m_VxPrimaryCandidateName));
+ ATH_MSG_DEBUG("Found " << m_VxPrimaryCandidateName << " in StoreGate!");
+
+ if (pvContainer->size()==0){
+ ATH_MSG_WARNING("You have no primary vertices: " << pvContainer->size());
+ return StatusCode::RECOVERABLE;
+ } else {
+ primaryVertex = (*pvContainer)[0];
+ }
+
+ //----------------------------------------------------
+ // Try to retrieve refitted primary vertices
+ //----------------------------------------------------
+ xAOD::VertexContainer* refPvContainer = nullptr;
+ xAOD::VertexAuxContainer* refPvAuxContainer = nullptr;
+ if (m_refitPV) {
+ if (evtStore()->contains<xAOD::VertexContainer>(m_refPVContainerName)) {
+ // refitted PV container exists. Get it from the store gate
+ ATH_CHECK(evtStore()->retrieve(refPvContainer , m_refPVContainerName ));
+ ATH_CHECK(evtStore()->retrieve(refPvAuxContainer, m_refPVContainerName + "Aux."));
+ } else {
+ // refitted PV container does not exist. Create a new one.
+ refPvContainer = new xAOD::VertexContainer;
+ refPvAuxContainer = new xAOD::VertexAuxContainer;
+ refPvContainer->setStore(refPvAuxContainer);
+ ATH_CHECK(evtStore()->record(refPvContainer , m_refPVContainerName));
+ ATH_CHECK(evtStore()->record(refPvAuxContainer, m_refPVContainerName+"Aux."));
+ }
+ }
+
+ ATH_CHECK(performSearch(&cascadeinfoContainer));
+
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVCascadeTools helper(&(*m_CascadeTools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(m_PV_minNTracks);
+
+ // Decorators for the main vertex: chi2, ndf, pt and pt error, plus the D0 vertex variables
+ SG::AuxElement::Decorator<VertexLinkVector> CascadeLinksDecor("CascadeVertexLinks");
+ SG::AuxElement::Decorator<VertexLinkVector> JpsipiLinksDecor("JpsipiVertexLinks");
+ SG::AuxElement::Decorator<VertexLinkVector> D0LinksDecor("D0VertexLinks");
+ SG::AuxElement::Decorator<float> chi2_decor("ChiSquared");
+ SG::AuxElement::Decorator<float> ndof_decor("NumberDoF");
+ SG::AuxElement::Decorator<float> Pt_decor("Pt");
+ SG::AuxElement::Decorator<float> PtErr_decor("PtErr");
+ SG::AuxElement::Decorator<float> Mass_svdecor("D0_mass");
+ SG::AuxElement::Decorator<float> MassErr_svdecor("D0_massErr");
+ SG::AuxElement::Decorator<float> Pt_svdecor("D0_Pt");
+ SG::AuxElement::Decorator<float> PtErr_svdecor("D0_PtErr");
+ SG::AuxElement::Decorator<float> Lxy_svdecor("D0_Lxy");
+ SG::AuxElement::Decorator<float> LxyErr_svdecor("D0_LxyErr");
+ SG::AuxElement::Decorator<float> Tau_svdecor("D0_Tau");
+ SG::AuxElement::Decorator<float> TauErr_svdecor("D0_TauErr");
+
+ SG::AuxElement::Decorator<float> MassMumu_decor("Mumu_mass");
+ SG::AuxElement::Decorator<float> MassKpi_svdecor("Kpi_mass");
+ SG::AuxElement::Decorator<float> MassJpsi_decor("Jpsi_mass");
+ SG::AuxElement::Decorator<float> MassPiD0_decor("PiD0_mass");
+
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer.size());
+
+ // Get Jpsi+pi container and identify the input Jpsi+pi
+ const xAOD::VertexContainer *jpsipiContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(jpsipiContainer , m_vertexContainerKey ));
+ const xAOD::VertexContainer *d0Container(nullptr);
+ ATH_CHECK(evtStore()->retrieve(d0Container , m_vertexD0ContainerKey ));
+
+ for (Trk::VxCascadeInfo* x : cascadeinfoContainer) {
+ if(x==nullptr) ATH_MSG_ERROR("cascadeinfoContainer is null");
+
+ // the cascade fitter returns:
+ // std::vector<xAOD::Vertex*>, each xAOD::Vertex contains the refitted track parameters (perigee at the vertex position)
+ // vertices[iv] the links to the original TPs and a covariance of size 3+5*NTRK; the chi2 of the total fit
+ // is split between the cascade vertices as per track contribution
+ // std::vector< std::vector<TLorentzVector> >, each std::vector<TLorentzVector> contains the refitted momenta (TLorentzVector)
+ // momenta[iv][...] of all tracks in the corresponding vertex, including any pseudotracks (from cascade vertices)
+ // originating in this vertex; the masses are as assigned in the cascade fit
+ // std::vector<Amg::MatrixX>, the corresponding covariance matrices in momentum space
+ // covariance[iv]
+ // int nDoF, double Chi2
+ //
+ // the invariant mass, pt, lifetime etc. errors should be calculated using the covariance matrices in momentum space as these
+ // take into account the full track-track and track-vertex correlations
+ //
+ // in the case of Jpsi+V0: vertices[0] is the V0 vertex, vertices[1] is the B/Lambda_b(bar) vertex, containing the 2 Jpsi tracks.
+ // The covariance terms between the two vertices are not stored. In momentum space momenta[0] contains the 2 V0 tracks,
+ // their momenta add up to the momentum of the 3rd track in momenta[1], the first two being the Jpsi tracks
+
+ const std::vector<xAOD::Vertex*> &cascadeVertices = x->vertices();
+ if(cascadeVertices.size()!=topoN)
+ ATH_MSG_ERROR("Incorrect number of vertices");
+ if(cascadeVertices[0] == nullptr || cascadeVertices[1] == nullptr) ATH_MSG_ERROR("Error null vertex");
+ // Keep vertices (bear in mind that they come in reverse order!)
+ for(int i =0;i<topoN;i++) Vtxwritehandles[i]->push_back(cascadeVertices[i]);
+
+ x->setSVOwnership(false); // Prevent Container from deleting vertices
+ const auto mainVertex = cascadeVertices[1]; // this is the B_c+/- vertex
+ const std::vector< std::vector<TLorentzVector> > &moms = x->getParticleMoms();
+
+ // Set links to cascade vertices
+ std::vector<const xAOD::Vertex*> verticestoLink;
+ verticestoLink.push_back(cascadeVertices[0]);
+ if(Vtxwritehandles[1] == nullptr) ATH_MSG_ERROR("Vtxwritehandles[1] is null");
+ if(!BPhysPVCascadeTools::LinkVertices(CascadeLinksDecor, verticestoLink, Vtxwritehandles[0], cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with cascade vertices");
+
+ // Identify the input Jpsi+pi
+ const xAOD::Vertex* jpsipiVertex = BPhysPVCascadeTools::FindVertex<3>(jpsipiContainer, cascadeVertices[1]);
+ ATH_MSG_DEBUG("1 pt Jpsi+pi tracks " << cascadeVertices[1]->trackParticle(0)->pt() << ", " << cascadeVertices[1]->trackParticle(1)->pt() << ", " << cascadeVertices[1]->trackParticle(2)->pt());
+ if (jpsipiVertex) ATH_MSG_DEBUG("2 pt Jpsi+pi tracks " << jpsipiVertex->trackParticle(0)->pt() << ", " << jpsipiVertex->trackParticle(1)->pt() << ", " << jpsipiVertex->trackParticle(2)->pt());
+
+ // Identify the input D0
+ const xAOD::Vertex* d0Vertex = BPhysPVCascadeTools::FindVertex<2>(d0Container, cascadeVertices[0]);;
+ ATH_MSG_DEBUG("1 pt D0 tracks " << cascadeVertices[0]->trackParticle(0)->pt() << ", " << cascadeVertices[0]->trackParticle(1)->pt());
+ if (d0Vertex) ATH_MSG_DEBUG("2 pt D0 tracks " << d0Vertex->trackParticle(0)->pt() << ", " << d0Vertex->trackParticle(1)->pt());
+
+ // Set links to input vertices
+ std::vector<const xAOD::Vertex*> jpsipiVerticestoLink;
+ if (jpsipiVertex) jpsipiVerticestoLink.push_back(jpsipiVertex);
+ else ATH_MSG_WARNING("Could not find linking Jpsi+pi");
+ if(!BPhysPVCascadeTools::LinkVertices(JpsipiLinksDecor, jpsipiVerticestoLink, jpsipiContainer, cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with Jpsi+pi vertices");
+
+ std::vector<const xAOD::Vertex*> d0VerticestoLink;
+ if (d0Vertex) d0VerticestoLink.push_back(d0Vertex);
+ else ATH_MSG_WARNING("Could not find linking D0");
+ if(!BPhysPVCascadeTools::LinkVertices(D0LinksDecor, d0VerticestoLink, d0Container, cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with D0 vertices");
+
+ bool tagD0(true);
+ if (jpsipiVertex){
+ if(abs(m_Dx_pid)==421 && (jpsipiVertex->trackParticle(2)->charge()==-1)) tagD0 = false;
+ }
+
+ double mass_b = m_vtx0MassHypo;
+ double mass_d0 = m_vtx1MassHypo;
+ std::vector<double> massesJpsipi;
+ massesJpsipi.push_back(m_vtx0Daug1MassHypo);
+ massesJpsipi.push_back(m_vtx0Daug2MassHypo);
+ massesJpsipi.push_back(m_vtx0Daug3MassHypo);
+ std::vector<double> massesD0;
+ if(tagD0){
+ massesD0.push_back(m_vtx1Daug1MassHypo);
+ massesD0.push_back(m_vtx1Daug2MassHypo);
+ }else{ // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
+ massesD0.push_back(m_vtx1Daug2MassHypo);
+ massesD0.push_back(m_vtx1Daug1MassHypo);
+ }
+ std::vector<double> Masses;
+ Masses.push_back(m_vtx0Daug1MassHypo);
+ Masses.push_back(m_vtx0Daug2MassHypo);
+ Masses.push_back(m_vtx0Daug3MassHypo);
+ Masses.push_back(m_vtx1MassHypo);
+
+ // loop over candidates -- Don't apply PV_minNTracks requirement here
+ // because it may result in exclusion of the high-pt PV.
+ // get good PVs
+
+ xAOD::BPhysHypoHelper vtx(m_hypoName, mainVertex);
+
+ // Get refitted track momenta from all vertices, charged tracks only
+ BPhysPVCascadeTools::SetVectorInfo(vtx, x);
+
+ // Decorate main vertex
+ //
+ // 1.a) mass, mass error
+ BPHYS_CHECK( vtx.setMass(m_CascadeTools->invariantMass(moms[1])) );
+ BPHYS_CHECK( vtx.setMassErr(m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1])) );
+ // 1.b) pt and pT error (the default pt of mainVertex is != the pt of the full cascade fit!)
+ Pt_decor(*mainVertex) = m_CascadeTools->pT(moms[1]);
+ PtErr_decor(*mainVertex) = m_CascadeTools->pTError(moms[1],x->getCovariance()[1]);
+ // 1.c) chi2 and ndof (the default chi2 of mainVertex is != the chi2 of the full cascade fit!)
+ chi2_decor(*mainVertex) = x->fitChi2();
+ ndof_decor(*mainVertex) = x->nDoF();
+
+ float massMumu = 0.;
+ if (jpsipiVertex) {
+ TLorentzVector p4_mu1, p4_mu2;
+ p4_mu1.SetPtEtaPhiM(jpsipiVertex->trackParticle(0)->pt(),
+ jpsipiVertex->trackParticle(0)->eta(),
+ jpsipiVertex->trackParticle(0)->phi(), m_vtx0Daug1MassHypo);
+ p4_mu2.SetPtEtaPhiM(jpsipiVertex->trackParticle(1)->pt(),
+ jpsipiVertex->trackParticle(1)->eta(),
+ jpsipiVertex->trackParticle(1)->phi(), m_vtx0Daug2MassHypo);
+ massMumu = (p4_mu1 + p4_mu2).M();
+ }
+ MassMumu_decor(*mainVertex) = massMumu;
+
+ float massKpi = 0.;
+ if (d0Vertex) {
+ TLorentzVector p4_ka, p4_pi;
+ if(tagD0){
+ p4_pi.SetPtEtaPhiM(d0Vertex->trackParticle(0)->pt(),
+ d0Vertex->trackParticle(0)->eta(),
+ d0Vertex->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
+ p4_ka.SetPtEtaPhiM(d0Vertex->trackParticle(1)->pt(),
+ d0Vertex->trackParticle(1)->eta(),
+ d0Vertex->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
+ }else{ // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
+ p4_pi.SetPtEtaPhiM(d0Vertex->trackParticle(1)->pt(),
+ d0Vertex->trackParticle(1)->eta(),
+ d0Vertex->trackParticle(1)->phi(), m_vtx1Daug1MassHypo);
+ p4_ka.SetPtEtaPhiM(d0Vertex->trackParticle(0)->pt(),
+ d0Vertex->trackParticle(0)->eta(),
+ d0Vertex->trackParticle(0)->phi(), m_vtx1Daug2MassHypo);
+ }
+ massKpi = (p4_ka + p4_pi).M();
+ }
+ MassKpi_svdecor(*mainVertex) = massKpi;
+ MassJpsi_decor(*mainVertex) = (moms[1][0] + moms[1][1]).M();
+ MassPiD0_decor(*mainVertex) = (moms[1][2] + moms[1][3]).M();
+
+
+ ATH_CHECK(helper.FillCandwithRefittedVertices(m_refitPV, pvContainer,
+ refPvContainer, &(*m_pvRefitter), m_PV_max, m_DoVertexType, x, 1, mass_b, vtx));
+
+ // 4) decorate the main vertex with D0 vertex mass, pt, lifetime and lxy values (plus errors)
+ // D0 points to the main vertex, so lifetime and lxy are w.r.t the main vertex
+ Mass_svdecor(*mainVertex) = m_CascadeTools->invariantMass(moms[0]);
+ MassErr_svdecor(*mainVertex) = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ Pt_svdecor(*mainVertex) = m_CascadeTools->pT(moms[0]);
+ PtErr_svdecor(*mainVertex) = m_CascadeTools->pTError(moms[0],x->getCovariance()[0]);
+ Lxy_svdecor(*mainVertex) = m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
+ LxyErr_svdecor(*mainVertex) = m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1]);
+ Tau_svdecor(*mainVertex) = m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1]);
+ TauErr_svdecor(*mainVertex) = m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1]);
+
+ // Some checks in DEBUG mode
+ ATH_MSG_DEBUG("chi2 " << x->fitChi2()
+ << " chi2_1 " << m_V0Tools->chisq(cascadeVertices[0])
+ << " chi2_2 " << m_V0Tools->chisq(cascadeVertices[1])
+ << " vprob " << m_CascadeTools->vertexProbability(x->nDoF(),x->fitChi2()));
+ ATH_MSG_DEBUG("ndf " << x->nDoF() << " ndf_1 " << m_V0Tools->ndof(cascadeVertices[0]) << " ndf_2 " << m_V0Tools->ndof(cascadeVertices[1]));
+ ATH_MSG_DEBUG("V0Tools mass_d0 " << m_V0Tools->invariantMass(cascadeVertices[0],massesD0)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[0],massesD0)
+ << " mass_J " << m_V0Tools->invariantMass(cascadeVertices[1],massesJpsipi)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[1],massesJpsipi));
+ // masses and errors, using track masses assigned in the fit
+ double Mass_B = m_CascadeTools->invariantMass(moms[1]);
+ double Mass_D0 = m_CascadeTools->invariantMass(moms[0]);
+ double Mass_B_err = m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1]);
+ double Mass_D0_err = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ ATH_MSG_DEBUG("Mass_B " << Mass_B << " Mass_D0 " << Mass_D0);
+ ATH_MSG_DEBUG("Mass_B_err " << Mass_B_err << " Mass_D0_err " << Mass_D0_err);
+ double mprob_B = m_CascadeTools->massProbability(mass_b,Mass_B,Mass_B_err);
+ double mprob_D0 = m_CascadeTools->massProbability(mass_d0,Mass_D0,Mass_D0_err);
+ ATH_MSG_DEBUG("mprob_B " << mprob_B << " mprob_D0 " << mprob_D0);
+ // masses and errors, assigning user defined track masses
+ ATH_MSG_DEBUG("Mass_b " << m_CascadeTools->invariantMass(moms[1],Masses)
+ << " Mass_d0 " << m_CascadeTools->invariantMass(moms[0],massesD0));
+ ATH_MSG_DEBUG("Mass_b_err " << m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1],Masses)
+ << " Mass_d0_err " << m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0],massesD0));
+ ATH_MSG_DEBUG("pt_b " << m_CascadeTools->pT(moms[1])
+ << " pt_d " << m_CascadeTools->pT(moms[0])
+ << " pt_d0 " << m_V0Tools->pT(cascadeVertices[0]));
+ ATH_MSG_DEBUG("ptErr_b " << m_CascadeTools->pTError(moms[1],x->getCovariance()[1])
+ << " ptErr_d " << m_CascadeTools->pTError(moms[0],x->getCovariance()[0])
+ << " ptErr_d0 " << m_V0Tools->pTError(cascadeVertices[0]));
+ ATH_MSG_DEBUG("lxy_B " << m_V0Tools->lxy(cascadeVertices[1],primaryVertex) << " lxy_D " << m_V0Tools->lxy(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("lxy_b " << m_CascadeTools->lxy(moms[1],cascadeVertices[1],primaryVertex) << " lxy_d " << m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("lxyErr_b " << m_CascadeTools->lxyError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << " lxyErr_d " << m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << " lxyErr_d0 " << m_V0Tools->lxyError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("tau_B " << m_CascadeTools->tau(moms[1],cascadeVertices[1],primaryVertex,mass_b)
+ << " tau_d0 " << m_V0Tools->tau(cascadeVertices[0],cascadeVertices[1],massesD0));
+ ATH_MSG_DEBUG("tau_b " << m_CascadeTools->tau(moms[1],cascadeVertices[1],primaryVertex)
+ << " tau_d " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << " tau_D " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1],mass_d0));
+ ATH_MSG_DEBUG("tauErr_b " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << " tauErr_d " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << " tauErr_d0 " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[1],massesD0));
+ ATH_MSG_DEBUG("TauErr_b " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex,mass_b)
+ << " TauErr_d " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1],mass_d0)
+ << " TauErr_d0 " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[1],massesD0,mass_d0));
+
+ ATH_MSG_DEBUG("CascadeTools main vert wrt PV " << " CascadeTools SV " << " V0Tools SV");
+ ATH_MSG_DEBUG("a0z " << m_CascadeTools->a0z(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0z(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0z(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0zErr " << m_CascadeTools->a0zError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0zError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0zError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0xy " << m_CascadeTools->a0xy(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0xy(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0xy(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0xyErr " << m_CascadeTools->a0xyError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0xyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0xyError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0 " << m_CascadeTools->a0(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0Err " << m_CascadeTools->a0Error(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0Error(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0Error(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("x0 " << m_V0Tools->vtx(cascadeVertices[0]).x() << " y0 " << m_V0Tools->vtx(cascadeVertices[0]).y() << " z0 " << m_V0Tools->vtx(cascadeVertices[0]).z());
+ ATH_MSG_DEBUG("x1 " << m_V0Tools->vtx(cascadeVertices[1]).x() << " y1 " << m_V0Tools->vtx(cascadeVertices[1]).y() << " z1 " << m_V0Tools->vtx(cascadeVertices[1]).z());
+ ATH_MSG_DEBUG("X0 " << primaryVertex->x() << " Y0 " << primaryVertex->y() << " Z0 " << primaryVertex->z());
+ ATH_MSG_DEBUG("rxy0 " << m_V0Tools->rxy(cascadeVertices[0]) << " rxyErr0 " << m_V0Tools->rxyError(cascadeVertices[0]));
+ ATH_MSG_DEBUG("rxy1 " << m_V0Tools->rxy(cascadeVertices[1]) << " rxyErr1 " << m_V0Tools->rxyError(cascadeVertices[1]));
+ ATH_MSG_DEBUG("Rxy0 wrt PV " << m_V0Tools->rxy(cascadeVertices[0],primaryVertex) << " RxyErr0 wrt PV " << m_V0Tools->rxyError(cascadeVertices[0],primaryVertex));
+ ATH_MSG_DEBUG("Rxy1 wrt PV " << m_V0Tools->rxy(cascadeVertices[1],primaryVertex) << " RxyErr1 wrt PV " << m_V0Tools->rxyError(cascadeVertices[1],primaryVertex));
+ ATH_MSG_DEBUG("number of covariance matrices " << (x->getCovariance()).size());
+ } // loop over cascadeinfoContainer
+
+ // Deleting cascadeinfo since this won't be stored.
+ // Vertices have been kept in m_cascadeOutputs and should be owned by their container
+ for (auto x : cascadeinfoContainer) delete x;
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ JpsiPlusDpstCascade::JpsiPlusDpstCascade(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
+ m_vertexContainerKey(""),
+ m_vertexD0ContainerKey(""),
+ m_cascadeOutputsKeys{ "JpsiPlusDpstCascadeVtx1", "JpsiPlusDpstCascadeVtx2" },
+ m_VxPrimaryCandidateName("PrimaryVertices"),
+ m_jpsiMassLower(0.0),
+ m_jpsiMassUpper(10000.0),
+ m_jpsipiMassLower(0.0),
+ m_jpsipiMassUpper(10000.0),
+ m_D0MassLower(0.0),
+ m_D0MassUpper(10000.0),
+ m_DstMassLower(0.0),
+ m_DstMassUpper(10000.0),
+ m_MassLower(0.0),
+ m_MassUpper(20000.0),
+ m_vtx0MassHypo(-1),
+ m_vtx1MassHypo(-1),
+ m_vtx0Daug1MassHypo(-1),
+ m_vtx0Daug2MassHypo(-1),
+ m_vtx0Daug3MassHypo(-1),
+ m_vtx1Daug1MassHypo(-1),
+ m_vtx1Daug2MassHypo(-1),
+ m_mass_jpsi(-1),
+ m_Dx_pid(421),
+ m_constrD0(true),
+ m_constrJpsi(true),
+ m_chi2cut(-1.0),
+ m_iVertexFitter("Trk::TrkVKalVrtFitter"),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter"),
+ m_V0Tools("Trk::V0Tools"),
+ m_CascadeTools("DerivationFramework::CascadeTools")
+ {
+ declareProperty("JpsipiVertices", m_vertexContainerKey);
+ declareProperty("D0Vertices", m_vertexD0ContainerKey);
+ declareProperty("VxPrimaryCandidateName", m_VxPrimaryCandidateName);
+ declareProperty("RefPVContainerName", m_refPVContainerName = "RefittedPrimaryVertices");
+ declareProperty("JpsiMassLowerCut", m_jpsiMassLower);
+ declareProperty("JpsiMassUpperCut", m_jpsiMassUpper);
+ declareProperty("JpsipiMassLowerCut", m_jpsipiMassLower);
+ declareProperty("JpsipiMassUpperCut", m_jpsipiMassUpper);
+ declareProperty("D0MassLowerCut", m_D0MassLower);
+ declareProperty("D0MassUpperCut", m_D0MassUpper);
+ declareProperty("DstMassLowerCut", m_DstMassLower);
+ declareProperty("DstMassUpperCut", m_DstMassUpper);
+ declareProperty("MassLowerCut", m_MassLower);
+ declareProperty("MassUpperCut", m_MassUpper);
+ declareProperty("HypothesisName", m_hypoName = "Bc");
+ declareProperty("Vtx0MassHypo", m_vtx0MassHypo);
+ declareProperty("Vtx1MassHypo", m_vtx1MassHypo);
+ declareProperty("Vtx0Daug1MassHypo", m_vtx0Daug1MassHypo);
+ declareProperty("Vtx0Daug2MassHypo", m_vtx0Daug2MassHypo);
+ declareProperty("Vtx0Daug3MassHypo", m_vtx0Daug3MassHypo);
+ declareProperty("Vtx1Daug1MassHypo", m_vtx1Daug1MassHypo);
+ declareProperty("Vtx1Daug2MassHypo", m_vtx1Daug2MassHypo);
+ declareProperty("JpsiMass", m_mass_jpsi);
+ declareProperty("DxHypothesis", m_Dx_pid);
+ declareProperty("ApplyD0MassConstraint", m_constrD0);
+ declareProperty("ApplyJpsiMassConstraint", m_constrJpsi);
+ declareProperty("Chi2Cut", m_chi2cut);
+ declareProperty("RefitPV", m_refitPV = true);
+ declareProperty("MaxnPV", m_PV_max = 999);
+ declareProperty("MinNTracksInPV", m_PV_minNTracks = 0);
+ declareProperty("DoVertexType", m_DoVertexType = 7);
+ declareProperty("TrkVertexFitterTool", m_iVertexFitter);
+ declareProperty("PVRefitter", m_pvRefitter);
+ declareProperty("V0Tools", m_V0Tools);
+ declareProperty("CascadeTools", m_CascadeTools);
+ declareProperty("CascadeVertexCollections", m_cascadeOutputsKeys);
+ }
+
+ JpsiPlusDpstCascade::~JpsiPlusDpstCascade(){ }
+
+ StatusCode JpsiPlusDpstCascade::performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer) const
+ {
+ ATH_MSG_DEBUG( "JpsiPlusDpstCascade::performSearch" );
+ assert(cascadeinfoContainer!=nullptr);
+
+ // Get TrackParticle container (for setting links to the original tracks)
+ const xAOD::TrackParticleContainer *trackContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(trackContainer , "InDetTrackParticles" ));
+
+ // Get Jpsi+pi container
+ const xAOD::VertexContainer *jpsipiContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(jpsipiContainer , m_vertexContainerKey ));
+
+ // Get D0 container
+ const xAOD::VertexContainer *d0Container(nullptr);
+ ATH_CHECK(evtStore()->retrieve(d0Container , m_vertexD0ContainerKey ));
+
+ double mass_d0 = m_vtx1MassHypo;
+ std::vector<const xAOD::TrackParticle*> tracksJpsipi;
+ std::vector<const xAOD::TrackParticle*> tracksJpsi;
+ std::vector<const xAOD::TrackParticle*> tracksD0;
+ std::vector<const xAOD::TrackParticle*> tracksBc;
+ std::vector<double> massesJpsipi;
+ massesJpsipi.push_back(m_vtx0Daug1MassHypo);
+ massesJpsipi.push_back(m_vtx0Daug2MassHypo);
+ massesJpsipi.push_back(m_vtx0Daug3MassHypo);
+ std::vector<double> massesD0;
+ massesD0.push_back(m_vtx1Daug1MassHypo);
+ massesD0.push_back(m_vtx1Daug2MassHypo);
+ std::vector<double> massesD0b; // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
+ massesD0b.push_back(m_vtx1Daug2MassHypo);
+ massesD0b.push_back(m_vtx1Daug1MassHypo);
+ std::vector<double> Masses;
+ Masses.push_back(m_vtx0Daug1MassHypo);
+ Masses.push_back(m_vtx0Daug2MassHypo);
+ Masses.push_back(m_vtx0Daug3MassHypo);
+ Masses.push_back(m_vtx1MassHypo);
+
+ // Select J/psi pi+ candidates before calling cascade fit
+ std::vector<const xAOD::Vertex*> selectedJpsipiCandidates;
+ for(auto vxcItr=jpsipiContainer->cbegin(); vxcItr!=jpsipiContainer->cend(); ++vxcItr) {
+
+ // Check the passed flag first
+ const xAOD::Vertex* vtx = *vxcItr;
+ SG::AuxElement::Accessor<Char_t> flagAcc1("passed_Jpsipi");
+ if(flagAcc1.isAvailable(*vtx)){
+ if(!flagAcc1(*vtx)) continue;
+ }
+
+ // Check J/psi candidate invariant mass and skip if need be
+ TLorentzVector p4Mup_in, p4Mum_in;
+ p4Mup_in.SetPtEtaPhiM((*vxcItr)->trackParticle(0)->pt(),
+ (*vxcItr)->trackParticle(0)->eta(),
+ (*vxcItr)->trackParticle(0)->phi(), m_vtx0Daug1MassHypo);
+ p4Mum_in.SetPtEtaPhiM((*vxcItr)->trackParticle(1)->pt(),
+ (*vxcItr)->trackParticle(1)->eta(),
+ (*vxcItr)->trackParticle(1)->phi(), m_vtx0Daug2MassHypo);
+ double mass_Jpsi = (p4Mup_in + p4Mum_in).M();
+ ATH_MSG_DEBUG("Jpsi mass " << mass_Jpsi);
+ if (mass_Jpsi < m_jpsiMassLower || mass_Jpsi > m_jpsiMassUpper) {
+ ATH_MSG_DEBUG(" Original Jpsi candidate rejected by the mass cut: mass = "
+ << mass_Jpsi << " != (" << m_jpsiMassLower << ", " << m_jpsiMassUpper << ")" );
+ continue;
+ }
+
+ // Check J/psi pi+ candidate invariant mass and skip if need be
+ double mass_Jpsipi = m_V0Tools->invariantMass(*vxcItr, massesJpsipi);
+ ATH_MSG_DEBUG("Jpsipi mass " << mass_Jpsipi);
+ if (mass_Jpsipi < m_jpsipiMassLower || mass_Jpsipi > m_jpsipiMassUpper) {
+ ATH_MSG_DEBUG(" Original Jpsipi candidate rejected by the mass cut: mass = "
+ << mass_Jpsipi << " != (" << m_jpsipiMassLower << ", " << m_jpsipiMassUpper << ")" );
+ continue;
+ }
+
+ selectedJpsipiCandidates.push_back(*vxcItr);
+ }
+ if(selectedJpsipiCandidates.size()<1) return StatusCode::SUCCESS;
+
+ // Select the D0/D0b candidates before calling cascade fit
+ std::vector<const xAOD::Vertex*> selectedD0Candidates;
+ for(auto vxcItr=d0Container->cbegin(); vxcItr!=d0Container->cend(); ++vxcItr) {
+
+ // Check the passed flag first
+ const xAOD::Vertex* vtx = *vxcItr;
+ SG::AuxElement::Accessor<Char_t> flagAcc1("passed_D0");
+ SG::AuxElement::Accessor<Char_t> flagAcc2("passed_D0b");
+ bool isD0(true);
+ bool isD0b(true);
+ if(flagAcc1.isAvailable(*vtx)){
+ if(!flagAcc1(*vtx)) isD0 = false;
+ }
+ if(flagAcc2.isAvailable(*vtx)){
+ if(!flagAcc2(*vtx)) isD0b = false;
+ }
+ if(!(isD0||isD0b)) continue;
+
+ // Ensure the total charge is correct
+ if ((*vxcItr)->trackParticle(0)->charge() != 1 || (*vxcItr)->trackParticle(1)->charge() != -1) {
+ ATH_MSG_DEBUG(" Original D0/D0-bar candidate rejected by the charge requirement: "
+ << (*vxcItr)->trackParticle(0)->charge() << ", " << (*vxcItr)->trackParticle(1)->charge() );
+ continue;
+ }
+
+ // Check D0/D0bar candidate invariant mass and skip if need be
+ double mass_D0 = m_V0Tools->invariantMass(*vxcItr,massesD0);
+ double mass_D0b = m_V0Tools->invariantMass(*vxcItr,massesD0b);
+ ATH_MSG_DEBUG("D0 mass " << mass_D0 << ", D0b mass "<<mass_D0b);
+ if ((mass_D0 < m_D0MassLower || mass_D0 > m_D0MassUpper) && (mass_D0b < m_D0MassLower || mass_D0b > m_D0MassUpper)) {
+ ATH_MSG_DEBUG(" Original D0 candidate rejected by the mass cut: mass = "
+ << mass_D0 << " != (" << m_D0MassLower << ", " << m_D0MassUpper << ") "
+ << mass_D0b << " != (" << m_D0MassLower << ", " << m_D0MassUpper << ") " );
+ continue;
+ }
+
+ selectedD0Candidates.push_back(*vxcItr);
+ }
+ if(selectedD0Candidates.size()<1) return StatusCode::SUCCESS;
+
+ // Select J/psi D*+ candidates
+ // Iterate over Jpsi+pi vertices
+ for(auto jpsipiItr=selectedJpsipiCandidates.cbegin(); jpsipiItr!=selectedJpsipiCandidates.cend(); ++jpsipiItr) {
+
+ size_t jpsipiTrkNum = (*jpsipiItr)->nTrackParticles();
+ tracksJpsipi.clear();
+ tracksJpsi.clear();
+ for( unsigned int it=0; it<jpsipiTrkNum; it++) tracksJpsipi.push_back((*jpsipiItr)->trackParticle(it));
+ for( unsigned int it=0; it<jpsipiTrkNum-1; it++) tracksJpsi.push_back((*jpsipiItr)->trackParticle(it));
+
+ if (tracksJpsipi.size() != 3 || massesJpsipi.size() != 3 ) {
+ ATH_MSG_INFO("problems with Jpsi+pi input");
+ }
+
+ bool tagD0(true);
+ if(abs(m_Dx_pid)==421 && (*jpsipiItr)->trackParticle(2)->charge()==-1) tagD0 = false;
+
+ TLorentzVector p4_pi1; // Momentum of soft pion
+ p4_pi1.SetPtEtaPhiM((*jpsipiItr)->trackParticle(2)->pt(),
+ (*jpsipiItr)->trackParticle(2)->eta(),
+ (*jpsipiItr)->trackParticle(2)->phi(), m_vtx0Daug3MassHypo);
+
+ // Iterate over D0/D0bar vertices
+ for(auto d0Itr=selectedD0Candidates.cbegin(); d0Itr!=selectedD0Candidates.cend(); ++d0Itr) {
+
+ // Check identical tracks in input
+ if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*d0Itr)->trackParticle(0)) != tracksJpsipi.cend()) continue;
+ if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*d0Itr)->trackParticle(1)) != tracksJpsipi.cend()) continue;
+
+
+ TLorentzVector p4_ka, p4_pi2;
+ if(tagD0){ // for D*+
+ p4_pi2.SetPtEtaPhiM((*d0Itr)->trackParticle(0)->pt(),
+ (*d0Itr)->trackParticle(0)->eta(),
+ (*d0Itr)->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
+ p4_ka.SetPtEtaPhiM( (*d0Itr)->trackParticle(1)->pt(),
+ (*d0Itr)->trackParticle(1)->eta(),
+ (*d0Itr)->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
+ }else{ // change the order in the case of D*-
+ p4_pi2.SetPtEtaPhiM((*d0Itr)->trackParticle(1)->pt(),
+ (*d0Itr)->trackParticle(1)->eta(),
+ (*d0Itr)->trackParticle(1)->phi(), m_vtx1Daug1MassHypo);
+ p4_ka.SetPtEtaPhiM( (*d0Itr)->trackParticle(0)->pt(),
+ (*d0Itr)->trackParticle(0)->eta(),
+ (*d0Itr)->trackParticle(0)->phi(), m_vtx1Daug2MassHypo);
+ }
+ // Check D*+/- candidate invariant mass and skip if need be
+ double mass_Dst= (p4_pi1 + p4_ka + p4_pi2).M();
+ ATH_MSG_DEBUG("D*+/- mass " << mass_Dst);
+ if (mass_Dst < m_DstMassLower || mass_Dst > m_DstMassUpper) {
+ ATH_MSG_DEBUG(" Original D*+/- candidate rejected by the mass cut: mass = "
+ << mass_Dst << " != (" << m_DstMassLower << ", " << m_DstMassUpper << ")" );
+ continue;
+ }
+
+ size_t d0TrkNum = (*d0Itr)->nTrackParticles();
+ tracksD0.clear();
+ for( unsigned int it=0; it<d0TrkNum; it++) tracksD0.push_back((*d0Itr)->trackParticle(it));
+ if (tracksD0.size() != 2 || massesD0.size() != 2 ) {
+ ATH_MSG_INFO("problems with D0 input");
+ }
+
+ ATH_MSG_DEBUG("using tracks" << tracksJpsipi[0] << ", " << tracksJpsipi[1] << ", " << tracksJpsipi[2] << ", " << tracksD0[0] << ", " << tracksD0[1]);
+ ATH_MSG_DEBUG("Charge of Jpsi+pi tracks: "<<(*jpsipiItr)->trackParticle(0)->charge()<<", "<<(*jpsipiItr)->trackParticle(1)->charge()<<", "<<(*jpsipiItr)->trackParticle(2)->charge());
+ ATH_MSG_DEBUG("Charge of D0 tracks: "<<(*d0Itr)->trackParticle(0)->charge()<<", "<<(*d0Itr)->trackParticle(1)->charge());
+
+ tracksBc.clear();
+ for( unsigned int it=0; it<jpsipiTrkNum; it++) tracksBc.push_back((*jpsipiItr)->trackParticle(it));
+ for( unsigned int it=0; it<d0TrkNum; it++) tracksBc.push_back((*d0Itr)->trackParticle(it));
+
+
+ // Apply the user's settings to the fitter
+ // Reset
+ std::unique_ptr<Trk::IVKalState> state (m_iVertexFitter->makeState());
+ // Robustness
+ int robustness = 0;
+ m_iVertexFitter->setRobustness(robustness, *state);
+ // Build up the topology
+ // Vertex list
+ std::vector<Trk::VertexID> vrtList;
+ // D0 vertex
+ Trk::VertexID vID;
+ if (m_constrD0) {
+ if(tagD0) vID = m_iVertexFitter->startVertex(tracksD0,massesD0,*state,mass_d0);
+ else vID = m_iVertexFitter->startVertex(tracksD0,massesD0b,*state,mass_d0);
+ } else {
+ if(tagD0) vID = m_iVertexFitter->startVertex(tracksD0,massesD0,*state);
+ else vID = m_iVertexFitter->startVertex(tracksD0,massesD0b,*state);
+ }
+ vrtList.push_back(vID);
+ // B vertex including Jpsi+pi
+ Trk::VertexID vID2 = m_iVertexFitter->nextVertex(tracksJpsipi,massesJpsipi,vrtList,*state);
+ if (m_constrJpsi) {
+ std::vector<Trk::VertexID> cnstV;
+ cnstV.clear();
+ if ( !m_iVertexFitter->addMassConstraint(vID2,tracksJpsi,cnstV,*state,m_mass_jpsi).isSuccess() ) {
+ ATH_MSG_WARNING("addMassConstraint failed");
+ //return StatusCode::FAILURE;
+ }
+ }
+ // Do the work
+ std::unique_ptr<Trk::VxCascadeInfo> result(m_iVertexFitter->fitCascade(*state));
+
+ if (result != nullptr) {
+
+ // reset links to original tracks
+ BPhysPVCascadeTools::PrepareVertexLinks(result.get(), trackContainer);
+ ATH_MSG_DEBUG("storing tracks " << ((result->vertices())[0])->trackParticle(0) << ", "
+ << ((result->vertices())[0])->trackParticle(1) << ", "
+ << ((result->vertices())[1])->trackParticle(0) << ", "
+ << ((result->vertices())[1])->trackParticle(1) << ", "
+ << ((result->vertices())[1])->trackParticle(2));
+ // necessary to prevent memory leak
+ result->setSVOwnership(true);
+
+ // Chi2/DOF cut
+ double bChi2DOF = result->fitChi2()/result->nDoF();
+ ATH_MSG_DEBUG("Candidate chi2/DOF is " << bChi2DOF);
+ bool chi2CutPassed = (m_chi2cut <= 0.0 || bChi2DOF < m_chi2cut);
+
+ const std::vector< std::vector<TLorentzVector> > &moms = result->getParticleMoms();
+ double mass = m_CascadeTools->invariantMass(moms[1]);
+ if(chi2CutPassed) {
+ if (mass >= m_MassLower && mass <= m_MassUpper) {
+ cascadeinfoContainer->push_back(result.release());
+ } else {
+ ATH_MSG_DEBUG("Candidate rejected by the mass cut: mass = "
+ << mass << " != (" << m_MassLower << ", " << m_MassUpper << ")" );
+ }
+ }
+ }
+
+ } //Iterate over D0 vertices
+
+ } //Iterate over Jpsi+pi vertices
+
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer->size());
+
+ return StatusCode::SUCCESS;
+ }
+
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDs1Cascade.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDs1Cascade.cxx
new file mode 100644
index 00000000000..e49a95911bc
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDs1Cascade.cxx
@@ -0,0 +1,905 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+/////////////////////////////////////////////////////////////////
+// JpsiPlusDs1Cascade.cxx, (c) ATLAS Detector software
+/////////////////////////////////////////////////////////////////
+#include "DerivationFrameworkBPhys/JpsiPlusDs1Cascade.h"
+#include "TrkVertexFitterInterfaces/IVertexFitter.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "GaudiKernel/IPartPropSvc.h"
+#include "DerivationFrameworkBPhys/CascadeTools.h"
+#include "DerivationFrameworkBPhys/BPhysPVCascadeTools.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include <algorithm>
+#include "xAODTracking/VertexContainer.h"
+#include "DerivationFrameworkBPhys/LocalVector.h"
+
+namespace DerivationFramework {
+ typedef ElementLink<xAOD::VertexContainer> VertexLink;
+ typedef std::vector<VertexLink> VertexLinkVector;
+ typedef std::vector<const xAOD::TrackParticle*> TrackBag;
+
+ double JpsiPlusDs1Cascade::getParticleMass(int pdgcode) const{
+ auto ptr = m_particleDataTable->particle( pdgcode );
+ return ptr ? ptr->mass() : 0.;
+ }
+
+ StatusCode JpsiPlusDs1Cascade::initialize() {
+
+ // retrieving vertex Fitter
+ ATH_CHECK( m_iVertexFitter.retrieve());
+
+ // retrieving the V0 tools
+ ATH_CHECK( m_V0Tools.retrieve());
+
+ // retrieving the Cascade tools
+ ATH_CHECK( m_CascadeTools.retrieve());
+
+ // Get the beam spot service
+ ATH_CHECK(m_beamSpotKey.initialize());
+
+ IPartPropSvc* partPropSvc = nullptr;
+ ATH_CHECK( service("PartPropSvc", partPropSvc, true) );
+ m_particleDataTable = partPropSvc->PDT();
+
+ // retrieve particle masses
+ if(m_mass_jpsi < 0. ) m_mass_jpsi = getParticleMass(PDG::J_psi);
+ if(m_vtx0MassHypo < 0.) m_vtx0MassHypo = getParticleMass(PDG::B_c_plus);
+ if(m_vtx1MassHypo < 0.) m_vtx1MassHypo = getParticleMass(PDG::D0);
+ if(m_vtx2MassHypo < 0.) m_vtx2MassHypo = getParticleMass(PDG::K_S0);
+
+ if(m_vtx0Daug1MassHypo < 0.) m_vtx0Daug1MassHypo = getParticleMass(PDG::mu_minus);
+ if(m_vtx0Daug2MassHypo < 0.) m_vtx0Daug2MassHypo = getParticleMass(PDG::mu_minus);
+ if(m_vtx0Daug3MassHypo < 0.) m_vtx0Daug3MassHypo = getParticleMass(PDG::pi_plus);
+ if(m_vtx1Daug1MassHypo < 0.) m_vtx1Daug1MassHypo = getParticleMass(PDG::pi_plus);
+ if(m_vtx1Daug2MassHypo < 0.) m_vtx1Daug2MassHypo = getParticleMass(PDG::K_plus);
+ if(m_vtx2Daug1MassHypo < 0.) m_vtx2Daug1MassHypo = getParticleMass(PDG::pi_plus);
+ if(m_vtx2Daug2MassHypo < 0.) m_vtx2Daug2MassHypo = getParticleMass(PDG::pi_plus);
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ StatusCode JpsiPlusDs1Cascade::addBranches() const
+ {
+ std::vector<Trk::VxCascadeInfo*> cascadeinfoContainer;
+ constexpr int topoN = 3;
+ std::array<xAOD::VertexContainer*, topoN> Vtxwritehandles;
+ std::array<xAOD::VertexAuxContainer*, topoN> Vtxwritehandlesaux;
+ if(m_cascadeOutputsKeys.size() !=topoN) { ATH_MSG_FATAL("Incorrect number of VtxContainers"); return StatusCode::FAILURE; }
+
+ for(int i =0; i<topoN;i++){
+ Vtxwritehandles[i] = new xAOD::VertexContainer();
+ Vtxwritehandlesaux[i] = new xAOD::VertexAuxContainer();
+ Vtxwritehandles[i]->setStore(Vtxwritehandlesaux[i]);
+ ATH_CHECK(evtStore()->record(Vtxwritehandles[i] , m_cascadeOutputsKeys[i] ));
+ ATH_CHECK(evtStore()->record(Vtxwritehandlesaux[i], m_cascadeOutputsKeys[i] + "Aux."));
+ }
+
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+ const xAOD::Vertex * primaryVertex(nullptr);
+ const xAOD::VertexContainer *pvContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(pvContainer, m_VxPrimaryCandidateName));
+ ATH_MSG_DEBUG("Found " << m_VxPrimaryCandidateName << " in StoreGate!");
+
+ if (pvContainer->size()==0){
+ ATH_MSG_WARNING("You have no primary vertices: " << pvContainer->size());
+ return StatusCode::RECOVERABLE;
+ } else {
+ primaryVertex = (*pvContainer)[0];
+ }
+
+ //----------------------------------------------------
+ // Try to retrieve refitted primary vertices
+ //----------------------------------------------------
+ xAOD::VertexContainer* refPvContainer = nullptr;
+ xAOD::VertexAuxContainer* refPvAuxContainer = nullptr;
+ if (m_refitPV) {
+ if (evtStore()->contains<xAOD::VertexContainer>(m_refPVContainerName)) {
+ // refitted PV container exists. Get it from the store gate
+ ATH_CHECK(evtStore()->retrieve(refPvContainer , m_refPVContainerName ));
+ ATH_CHECK(evtStore()->retrieve(refPvAuxContainer, m_refPVContainerName + "Aux."));
+ } else {
+ // refitted PV container does not exist. Create a new one.
+ refPvContainer = new xAOD::VertexContainer;
+ refPvAuxContainer = new xAOD::VertexAuxContainer;
+ refPvContainer->setStore(refPvAuxContainer);
+ ATH_CHECK(evtStore()->record(refPvContainer , m_refPVContainerName));
+ ATH_CHECK(evtStore()->record(refPvAuxContainer, m_refPVContainerName+"Aux."));
+ }
+ }
+
+ ATH_CHECK(performSearch(&cascadeinfoContainer));
+
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVCascadeTools helper(&(*m_CascadeTools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(m_PV_minNTracks);
+
+ // Decorators for the main vertex: chi2, ndf, pt and pt error, plus the D0, K0 vertex variables
+ SG::AuxElement::Decorator<VertexLinkVector> CascadeV1LinksDecor("CascadeVertex1Links");
+ SG::AuxElement::Decorator<VertexLinkVector> CascadeV2LinksDecor("CascadeVertex2Links");
+ SG::AuxElement::Decorator<VertexLinkVector> JpsipiLinksDecor("JpsipiVertexLinks");
+ SG::AuxElement::Decorator<VertexLinkVector> D0LinksDecor("D0VertexLinks");
+ SG::AuxElement::Decorator<VertexLinkVector> K0LinksDecor("K0VertexLinks");
+ SG::AuxElement::Decorator<float> chi2_decor("ChiSquared");
+ SG::AuxElement::Decorator<float> ndof_decor("NumberDoF");
+ SG::AuxElement::Decorator<float> Pt_decor("Pt");
+ SG::AuxElement::Decorator<float> PtErr_decor("PtErr");
+ SG::AuxElement::Decorator<float> Mass_svdecor("D0_mass");
+ SG::AuxElement::Decorator<float> MassErr_svdecor("D0_massErr");
+ SG::AuxElement::Decorator<float> Pt_svdecor("D0_Pt");
+ SG::AuxElement::Decorator<float> PtErr_svdecor("D0_PtErr");
+ SG::AuxElement::Decorator<float> Lxy_svdecor("D0_Lxy");
+ SG::AuxElement::Decorator<float> LxyErr_svdecor("D0_LxyErr");
+ SG::AuxElement::Decorator<float> Tau_svdecor("D0_Tau");
+ SG::AuxElement::Decorator<float> TauErr_svdecor("D0_TauErr");
+
+ SG::AuxElement::Decorator<float> Mass_sv2decor("K0_mass");
+ SG::AuxElement::Decorator<float> MassErr_sv2decor("K0_massErr");
+ SG::AuxElement::Decorator<float> Pt_sv2decor("K0_Pt");
+ SG::AuxElement::Decorator<float> PtErr_sv2decor("K0_PtErr");
+ SG::AuxElement::Decorator<float> Lxy_sv2decor("K0_Lxy");
+ SG::AuxElement::Decorator<float> LxyErr_sv2decor("K0_LxyErr");
+ SG::AuxElement::Decorator<float> Tau_sv2decor("K0_Tau");
+ SG::AuxElement::Decorator<float> TauErr_sv2decor("K0_TauErr");
+
+ SG::AuxElement::Decorator<float> MassJpsi_decor("Jpsi_mass");
+ SG::AuxElement::Decorator<float> MassPiD0_decor("PiD0_mass");
+ SG::AuxElement::Decorator<float> MassPiD0K0_decor("PiD0K0_mass");
+
+ SG::AuxElement::Decorator<float> MassMumu_decor("Mumu_mass");
+ SG::AuxElement::Decorator<float> MassKpi_svdecor("Kpi_mass");
+ SG::AuxElement::Decorator<float> MassPipi_sv2decor("Pipi_mass");
+
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer.size());
+
+ // Get Jpsi+pi container and identify the input Jpsi+pi
+ const xAOD::VertexContainer *jpsipiContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(jpsipiContainer , m_vertexContainerKey ));
+ // Get D0 container and identify the input D0
+ const xAOD::VertexContainer *d0Container(nullptr);
+ ATH_CHECK(evtStore()->retrieve(d0Container , m_vertexD0ContainerKey ));
+ // Get K0 container and identify the input K0
+ const xAOD::VertexContainer *k0Container(nullptr);
+ ATH_CHECK(evtStore()->retrieve(k0Container , m_vertexK0ContainerKey ));
+
+ for (Trk::VxCascadeInfo* x : cascadeinfoContainer) {
+ if(x==nullptr) ATH_MSG_ERROR("cascadeinfoContainer is null");
+
+ // the cascade fitter returns:
+ // std::vector<xAOD::Vertex*>, each xAOD::Vertex contains the refitted track parameters (perigee at the vertex position)
+ // vertices[iv] the links to the original TPs and a covariance of size 3+5*NTRK; the chi2 of the total fit
+ // is split between the cascade vertices as per track contribution
+ // std::vector< std::vector<TLorentzVector> >, each std::vector<TLorentzVector> contains the refitted momenta (TLorentzVector)
+ // momenta[iv][...] of all tracks in the corresponding vertex, including any pseudotracks (from cascade vertices)
+ // originating in this vertex; the masses are as assigned in the cascade fit
+ // std::vector<Amg::MatrixX>, the corresponding covariance matrices in momentum space
+ // covariance[iv]
+ // int nDoF, double Chi2
+ //
+ // the invariant mass, pt, lifetime etc. errors should be calculated using the covariance matrices in momentum space as these
+ // take into account the full track-track and track-vertex correlations
+ //
+ // in the case of Jpsi+V0: vertices[0] is the V0 vertex, vertices[1] is the B/Lambda_b(bar) vertex, containing the 2 Jpsi tracks.
+ // The covariance terms between the two vertices are not stored. In momentum space momenta[0] contains the 2 V0 tracks,
+ // their momenta add up to the momentum of the 3rd track in momenta[1], the first two being the Jpsi tracks
+
+ const std::vector<xAOD::Vertex*> &cascadeVertices = x->vertices();
+ if(cascadeVertices.size()!=topoN)
+ ATH_MSG_ERROR("Incorrect number of vertices");
+ if(cascadeVertices[0] == nullptr || cascadeVertices[1] == nullptr || cascadeVertices[2] == nullptr) ATH_MSG_ERROR("Error null vertex");
+ // Keep vertices (bear in mind that they come in reverse order!)
+ for(int i =0;i<topoN;i++) Vtxwritehandles[i]->push_back(cascadeVertices[i]);
+
+ x->setSVOwnership(false); // Prevent Container from deleting vertices
+ const auto mainVertex = cascadeVertices[2]; // this is the B_c+/- vertex
+ const std::vector< std::vector<TLorentzVector> > &moms = x->getParticleMoms();
+
+ // Set links to cascade vertices
+ std::vector<const xAOD::Vertex*> verticestoLink;
+ verticestoLink.push_back(cascadeVertices[0]);
+ //if(Vtxwritehandles[1] == nullptr) ATH_MSG_ERROR("Vtxwritehandles[1] is null");
+ if(Vtxwritehandles[2] == nullptr) ATH_MSG_ERROR("Vtxwritehandles[2] is null");
+ if(!BPhysPVCascadeTools::LinkVertices(CascadeV1LinksDecor, verticestoLink, Vtxwritehandles[0], cascadeVertices[2]))
+ ATH_MSG_ERROR("Error decorating with cascade vertices");
+
+ verticestoLink.clear();
+ verticestoLink.push_back(cascadeVertices[1]);
+ if(!BPhysPVCascadeTools::LinkVertices(CascadeV2LinksDecor, verticestoLink, Vtxwritehandles[1], cascadeVertices[2]))
+ ATH_MSG_ERROR("Error decorating with cascade vertices");
+
+ // Identify the input Jpsi+pi
+ const xAOD::Vertex* jpsipiVertex = BPhysPVCascadeTools::FindVertex<3>(jpsipiContainer, cascadeVertices[2]);
+ ATH_MSG_DEBUG("1 pt Jpsi+pi tracks " << cascadeVertices[2]->trackParticle(0)->pt() << ", " << cascadeVertices[2]->trackParticle(1)->pt() << ", " << cascadeVertices[2]->trackParticle(2)->pt());
+ if (jpsipiVertex) ATH_MSG_DEBUG("2 pt Jpsi+pi tracks " << jpsipiVertex->trackParticle(0)->pt() << ", " << jpsipiVertex->trackParticle(1)->pt() << ", " << jpsipiVertex->trackParticle(2)->pt());
+
+ // Identify the input D0
+ const xAOD::Vertex* d0Vertex = BPhysPVCascadeTools::FindVertex<2>(d0Container, cascadeVertices[1]);;
+ ATH_MSG_DEBUG("1 pt D0 tracks " << cascadeVertices[1]->trackParticle(0)->pt() << ", " << cascadeVertices[1]->trackParticle(1)->pt());
+ if (d0Vertex) ATH_MSG_DEBUG("2 pt D0 tracks " << d0Vertex->trackParticle(0)->pt() << ", " << d0Vertex->trackParticle(1)->pt());
+
+ // Identify the input K_S0
+ const xAOD::Vertex* k0Vertex = BPhysPVCascadeTools::FindVertex<2>(k0Container, cascadeVertices[0]);;
+ ATH_MSG_DEBUG("1 pt K_S0 tracks " << cascadeVertices[0]->trackParticle(0)->pt() << ", " << cascadeVertices[0]->trackParticle(1)->pt());
+ if (k0Vertex) ATH_MSG_DEBUG("2 pt K_S0 tracks " << k0Vertex->trackParticle(0)->pt() << ", " << k0Vertex->trackParticle(1)->pt());
+
+ // Set links to input vertices
+ std::vector<const xAOD::Vertex*> jpsipiVerticestoLink;
+ if (jpsipiVertex) jpsipiVerticestoLink.push_back(jpsipiVertex);
+ else ATH_MSG_WARNING("Could not find linking Jpsi+pi");
+ if(!BPhysPVCascadeTools::LinkVertices(JpsipiLinksDecor, jpsipiVerticestoLink, jpsipiContainer, cascadeVertices[2]))
+ ATH_MSG_ERROR("Error decorating with Jpsi+pi vertices");
+
+ std::vector<const xAOD::Vertex*> d0VerticestoLink;
+ if (d0Vertex) d0VerticestoLink.push_back(d0Vertex);
+ else ATH_MSG_WARNING("Could not find linking D0");
+ if(!BPhysPVCascadeTools::LinkVertices(D0LinksDecor, d0VerticestoLink, d0Container, cascadeVertices[2]))
+ ATH_MSG_ERROR("Error decorating with D0 vertices");
+
+ std::vector<const xAOD::Vertex*> k0VerticestoLink;
+ if (k0Vertex) k0VerticestoLink.push_back(k0Vertex);
+ else ATH_MSG_WARNING("Could not find linking K_S0");
+ if(!BPhysPVCascadeTools::LinkVertices(K0LinksDecor, k0VerticestoLink, k0Container, cascadeVertices[2]))
+ ATH_MSG_ERROR("Error decorating with K_S0 vertices");
+
+ bool tagD0(true);
+ if (jpsipiVertex){
+ if(abs(m_Dx_pid)==421 && (jpsipiVertex->trackParticle(2)->charge()==-1)) tagD0 = false;
+ }
+
+ double mass_b = m_vtx0MassHypo;
+ double mass_d0 = m_vtx1MassHypo;
+ double mass_k0 = m_vtx2MassHypo;
+ std::vector<double> massesJpsipi;
+ massesJpsipi.push_back(m_vtx0Daug1MassHypo);
+ massesJpsipi.push_back(m_vtx0Daug2MassHypo);
+ massesJpsipi.push_back(m_vtx0Daug3MassHypo);
+ std::vector<double> massesD0;
+ if(tagD0){
+ massesD0.push_back(m_vtx1Daug1MassHypo);
+ massesD0.push_back(m_vtx1Daug2MassHypo);
+ }else{ // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
+ massesD0.push_back(m_vtx1Daug2MassHypo);
+ massesD0.push_back(m_vtx1Daug1MassHypo);
+ }
+ std::vector<double> massesK0;
+ massesK0.push_back(m_vtx2Daug1MassHypo);
+ massesK0.push_back(m_vtx2Daug2MassHypo);
+ std::vector<double> Masses;
+ Masses.push_back(m_vtx0Daug1MassHypo);
+ Masses.push_back(m_vtx0Daug2MassHypo);
+ Masses.push_back(m_vtx0Daug3MassHypo);
+ Masses.push_back(m_vtx1MassHypo);
+ Masses.push_back(m_vtx2MassHypo);
+
+ // loop over candidates -- Don't apply PV_minNTracks requirement here
+ // because it may result in exclusion of the high-pt PV.
+ // get good PVs
+
+ xAOD::BPhysHypoHelper vtx(m_hypoName, mainVertex);
+
+ BPhysPVCascadeTools::SetVectorInfo(vtx, x);
+
+ // Decorate main vertex
+ //
+ // 1.a) mass, mass error
+ BPHYS_CHECK( vtx.setMass(m_CascadeTools->invariantMass(moms[2])) );
+ BPHYS_CHECK( vtx.setMassErr(m_CascadeTools->invariantMassError(moms[2],x->getCovariance()[2])) );
+ // 1.b) pt and pT error (the default pt of mainVertex is != the pt of the full cascade fit!)
+ Pt_decor(*mainVertex) = m_CascadeTools->pT(moms[2]);
+ PtErr_decor(*mainVertex) = m_CascadeTools->pTError(moms[2],x->getCovariance()[2]);
+ // 1.c) chi2 and ndof (the default chi2 of mainVertex is != the chi2 of the full cascade fit!)
+ chi2_decor(*mainVertex) = x->fitChi2();
+ ndof_decor(*mainVertex) = x->nDoF();
+
+ float massMumu = 0.;
+ if (jpsipiVertex) {
+ TLorentzVector p4_mu1, p4_mu2;
+ p4_mu1.SetPtEtaPhiM(jpsipiVertex->trackParticle(0)->pt(),
+ jpsipiVertex->trackParticle(0)->eta(),
+ jpsipiVertex->trackParticle(0)->phi(), m_vtx0Daug1MassHypo);
+ p4_mu2.SetPtEtaPhiM(jpsipiVertex->trackParticle(1)->pt(),
+ jpsipiVertex->trackParticle(1)->eta(),
+ jpsipiVertex->trackParticle(1)->phi(), m_vtx0Daug2MassHypo);
+ massMumu = (p4_mu1 + p4_mu2).M();
+ }
+ MassMumu_decor(*mainVertex) = massMumu;
+
+ float massKpi = 0.;
+ if (d0Vertex) {
+ TLorentzVector p4_ka, p4_pi;
+ if(tagD0){
+ p4_pi.SetPtEtaPhiM(d0Vertex->trackParticle(0)->pt(),
+ d0Vertex->trackParticle(0)->eta(),
+ d0Vertex->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
+ p4_ka.SetPtEtaPhiM(d0Vertex->trackParticle(1)->pt(),
+ d0Vertex->trackParticle(1)->eta(),
+ d0Vertex->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
+ }else{ // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
+ p4_pi.SetPtEtaPhiM(d0Vertex->trackParticle(1)->pt(),
+ d0Vertex->trackParticle(1)->eta(),
+ d0Vertex->trackParticle(1)->phi(), m_vtx1Daug1MassHypo);
+ p4_ka.SetPtEtaPhiM(d0Vertex->trackParticle(0)->pt(),
+ d0Vertex->trackParticle(0)->eta(),
+ d0Vertex->trackParticle(0)->phi(), m_vtx1Daug2MassHypo);
+ }
+ massKpi = (p4_ka + p4_pi).M();
+ }
+ MassKpi_svdecor(*mainVertex) = massKpi;
+
+ float massPipi = 0.;
+ if (k0Vertex) {
+ TLorentzVector p4_pip, p4_pim;
+ p4_pip.SetPtEtaPhiM(k0Vertex->trackParticle(0)->pt(),
+ k0Vertex->trackParticle(0)->eta(),
+ k0Vertex->trackParticle(0)->phi(), m_vtx2Daug1MassHypo);
+ p4_pim.SetPtEtaPhiM(k0Vertex->trackParticle(1)->pt(),
+ k0Vertex->trackParticle(1)->eta(),
+ k0Vertex->trackParticle(1)->phi(), m_vtx2Daug2MassHypo);
+ massPipi = (p4_pip + p4_pim).M();
+ }
+ MassPipi_sv2decor(*mainVertex) = massPipi;
+
+ MassJpsi_decor(*mainVertex) = (moms[2][0] + moms[2][1]).M();
+ MassPiD0_decor(*mainVertex) = (moms[2][2] + moms[2][4]).M();
+ MassPiD0K0_decor(*mainVertex) = (moms[2][2] + moms[2][4] + moms[2][3]).M();
+
+ ATH_CHECK(helper.FillCandwithRefittedVertices(m_refitPV, pvContainer,
+ refPvContainer, &(*m_pvRefitter), m_PV_max, m_DoVertexType, x, 2, mass_b, vtx));
+
+ // 4) decorate the main vertex with D0 vertex mass, pt, lifetime and lxy values (plus errors)
+ // D0 points to the main vertex, so lifetime and lxy are w.r.t the main vertex
+ Mass_svdecor(*mainVertex) = m_CascadeTools->invariantMass(moms[1]);
+ MassErr_svdecor(*mainVertex) = m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1]);
+ Pt_svdecor(*mainVertex) = m_CascadeTools->pT(moms[1]);
+ PtErr_svdecor(*mainVertex) = m_CascadeTools->pTError(moms[1],x->getCovariance()[1]);
+ Lxy_svdecor(*mainVertex) = m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[2]);
+ LxyErr_svdecor(*mainVertex) = m_CascadeTools->lxyError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2]);
+ Tau_svdecor(*mainVertex) = m_CascadeTools->tau(moms[1],cascadeVertices[1],cascadeVertices[2]);
+ TauErr_svdecor(*mainVertex) = m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2]);
+
+ // 5) decorate the main vertex with K_S0 vertex mass, pt, lifetime and lxy values (plus errors)
+ // K_S0 points to the main vertex, so lifetime and lxy are w.r.t the main vertex
+ Mass_sv2decor(*mainVertex) = m_CascadeTools->invariantMass(moms[0]);
+ MassErr_sv2decor(*mainVertex) = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ Pt_sv2decor(*mainVertex) = m_CascadeTools->pT(moms[0]);
+ PtErr_sv2decor(*mainVertex) = m_CascadeTools->pTError(moms[0],x->getCovariance()[0]);
+ Lxy_sv2decor(*mainVertex) = m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[2]);
+ LxyErr_sv2decor(*mainVertex) = m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2]);
+ Tau_sv2decor(*mainVertex) = m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[2]);
+ TauErr_sv2decor(*mainVertex) = m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2]);
+
+ // Some checks in DEBUG mode
+ ATH_MSG_DEBUG("chi2 " << x->fitChi2()
+ << " chi2_1 " << m_V0Tools->chisq(cascadeVertices[0])
+ << " chi2_2 " << m_V0Tools->chisq(cascadeVertices[1])
+ << " chi2_3 " << m_V0Tools->chisq(cascadeVertices[2])
+ << " vprob " << m_CascadeTools->vertexProbability(x->nDoF(),x->fitChi2()));
+ ATH_MSG_DEBUG("ndf " << x->nDoF() << " ndf_1 " << m_V0Tools->ndof(cascadeVertices[0]) << " ndf_2 " << m_V0Tools->ndof(cascadeVertices[1]) << " ndf_3 " << m_V0Tools->ndof(cascadeVertices[2]));
+ ATH_MSG_DEBUG("V0Tools mass_k0 " << m_V0Tools->invariantMass(cascadeVertices[0],massesK0)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[0],massesK0)
+ << " mass_d0 " << m_V0Tools->invariantMass(cascadeVertices[1],massesD0)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[1],massesD0)
+ << " mass_J " << m_V0Tools->invariantMass(cascadeVertices[2],massesJpsipi)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[2],massesJpsipi));
+ // masses and errors, using track masses assigned in the fit
+ double Mass_B = m_CascadeTools->invariantMass(moms[2]);
+ double Mass_D0 = m_CascadeTools->invariantMass(moms[1]);
+ double Mass_K0 = m_CascadeTools->invariantMass(moms[0]);
+ double Mass_B_err = m_CascadeTools->invariantMassError(moms[2],x->getCovariance()[2]);
+ double Mass_D0_err = m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1]);
+ double Mass_K0_err = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ ATH_MSG_DEBUG("Mass_B " << Mass_B << " Mass_D0 " << Mass_D0 << " Mass_K0 " << Mass_K0);
+ ATH_MSG_DEBUG("Mass_B_err " << Mass_B_err << " Mass_D0_err " << Mass_D0_err << " Mass_K0_err " << Mass_K0_err);
+ double mprob_B = m_CascadeTools->massProbability(mass_b,Mass_B,Mass_B_err);
+ double mprob_D0 = m_CascadeTools->massProbability(mass_d0,Mass_D0,Mass_D0_err);
+ double mprob_K0 = m_CascadeTools->massProbability(mass_k0,Mass_K0,Mass_K0_err);
+ ATH_MSG_DEBUG("mprob_B " << mprob_B << " mprob_D0 " << mprob_D0 << " mprob_K0 " << mprob_K0);
+ // masses and errors, assigning user defined track masses
+ ATH_MSG_DEBUG("Mass_b " << m_CascadeTools->invariantMass(moms[2],Masses)
+ << " Mass_d0 " << m_CascadeTools->invariantMass(moms[1],massesD0)
+ << " Mass_k0 " << m_CascadeTools->invariantMass(moms[0],massesD0));
+ ATH_MSG_DEBUG("Mass_b_err " << m_CascadeTools->invariantMassError(moms[2],x->getCovariance()[2],Masses)
+ << " Mass_d0_err " << m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1],massesD0)
+ << " Mass_k0_err " << m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0],massesK0));
+ ATH_MSG_DEBUG("pt_b " << m_CascadeTools->pT(moms[2])
+ << " pt_d " << m_CascadeTools->pT(moms[1])
+ << " pt_d0 " << m_V0Tools->pT(cascadeVertices[1])
+ << " pt_k " << m_CascadeTools->pT(moms[0])
+ << " pt_k0 " << m_V0Tools->pT(cascadeVertices[0]));
+ ATH_MSG_DEBUG("ptErr_b " << m_CascadeTools->pTError(moms[2],x->getCovariance()[2])
+ << " ptErr_d " << m_CascadeTools->pTError(moms[1],x->getCovariance()[1])
+ << " ptErr_d0 " << m_V0Tools->pTError(cascadeVertices[1])
+ << " ptErr_k " << m_CascadeTools->pTError(moms[0],x->getCovariance()[0])
+ << " ptErr_k0 " << m_V0Tools->pTError(cascadeVertices[0]));
+ ATH_MSG_DEBUG("lxy_B " << m_V0Tools->lxy(cascadeVertices[2],primaryVertex) << " lxy_D " << m_V0Tools->lxy(cascadeVertices[1],cascadeVertices[2]) << " lxy_K " << m_V0Tools->lxy(cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("lxy_b " << m_CascadeTools->lxy(moms[2],cascadeVertices[2],primaryVertex) << " lxy_d " << m_CascadeTools->lxy(moms[1],cascadeVertices[1],cascadeVertices[2]) << " lxy_k " << m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("lxyErr_b " << m_CascadeTools->lxyError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
+ << " lxyErr_d " << m_CascadeTools->lxyError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
+ << " lxyErr_d0 " << m_V0Tools->lxyError(cascadeVertices[1],cascadeVertices[2])
+ << " lxyErr_k " << m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
+ << " lxyErr_k0 " << m_V0Tools->lxyError(cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("tau_B " << m_CascadeTools->tau(moms[2],cascadeVertices[2],primaryVertex,mass_b)
+ << " tau_d0 " << m_V0Tools->tau(cascadeVertices[1],cascadeVertices[2],massesD0)
+ << " tau_k0 " << m_V0Tools->tau(cascadeVertices[0],cascadeVertices[2],massesK0));
+ ATH_MSG_DEBUG("tau_b " << m_CascadeTools->tau(moms[2],cascadeVertices[2],primaryVertex)
+ << " tau_d " << m_CascadeTools->tau(moms[1],cascadeVertices[1],cascadeVertices[2])
+ << " tau_D " << m_CascadeTools->tau(moms[1],cascadeVertices[1],cascadeVertices[2],mass_d0)
+ << " tau_k " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[2])
+ << " tau_K " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[2],mass_k0));
+ ATH_MSG_DEBUG("tauErr_b " << m_CascadeTools->tauError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
+ << " tauErr_d " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
+ << " tauErr_d0 " << m_V0Tools->tauError(cascadeVertices[1],cascadeVertices[2],massesD0)
+ << " tauErr_k " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
+ << " tauErr_k0 " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[2],massesK0));
+ ATH_MSG_DEBUG("TauErr_b " << m_CascadeTools->tauError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex,mass_b)
+ << " TauErr_d " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2],mass_d0)
+ << " TauErr_d0 " << m_V0Tools->tauError(cascadeVertices[1],cascadeVertices[2],massesD0,mass_d0)
+ << " TauErr_k " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2],mass_k0)
+ << " TauErr_k0 " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[2],massesD0,mass_k0));
+
+ ATH_MSG_DEBUG("CascadeTools main vert wrt PV " << " CascadeTools SV " << " V0Tools SV");
+ ATH_MSG_DEBUG("a0z " << m_CascadeTools->a0z(moms[2],cascadeVertices[2],primaryVertex)
+ << ", " << m_CascadeTools->a0z(moms[1],cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_CascadeTools->a0z(moms[0],cascadeVertices[0],cascadeVertices[2])
+ << ", " << m_V0Tools->a0z(cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_V0Tools->a0z(cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("a0zErr " << m_CascadeTools->a0zError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
+ << ", " << m_CascadeTools->a0zError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_CascadeTools->a0zError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
+ << ", " << m_V0Tools->a0zError(cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_V0Tools->a0zError(cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("a0xy " << m_CascadeTools->a0xy(moms[2],cascadeVertices[2],primaryVertex)
+ << ", " << m_CascadeTools->a0xy(moms[1],cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_CascadeTools->a0xy(moms[0],cascadeVertices[0],cascadeVertices[2])
+ << ", " << m_V0Tools->a0xy(cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_V0Tools->a0xy(cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("a0xyErr " << m_CascadeTools->a0xyError(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
+ << ", " << m_CascadeTools->a0xyError(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_CascadeTools->a0xyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
+ << ", " << m_V0Tools->a0xyError(cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_V0Tools->a0xyError(cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("a0 " << m_CascadeTools->a0(moms[2],cascadeVertices[2],primaryVertex)
+ << ", " << m_CascadeTools->a0(moms[1],cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_CascadeTools->a0(moms[0],cascadeVertices[0],cascadeVertices[2])
+ << ", " << m_V0Tools->a0(cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_V0Tools->a0(cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("a0Err " << m_CascadeTools->a0Error(moms[2],x->getCovariance()[2],cascadeVertices[2],primaryVertex)
+ << ", " << m_CascadeTools->a0Error(moms[1],x->getCovariance()[1],cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_CascadeTools->a0Error(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[2])
+ << ", " << m_V0Tools->a0Error(cascadeVertices[1],cascadeVertices[2])
+ << ", " << m_V0Tools->a0Error(cascadeVertices[0],cascadeVertices[2]));
+ ATH_MSG_DEBUG("x0 " << m_V0Tools->vtx(cascadeVertices[0]).x() << " y0 " << m_V0Tools->vtx(cascadeVertices[0]).y() << " z0 " << m_V0Tools->vtx(cascadeVertices[0]).z());
+ ATH_MSG_DEBUG("x1 " << m_V0Tools->vtx(cascadeVertices[1]).x() << " y1 " << m_V0Tools->vtx(cascadeVertices[1]).y() << " z1 " << m_V0Tools->vtx(cascadeVertices[1]).z());
+ ATH_MSG_DEBUG("x2 " << m_V0Tools->vtx(cascadeVertices[2]).x() << " y2 " << m_V0Tools->vtx(cascadeVertices[2]).y() << " z2 " << m_V0Tools->vtx(cascadeVertices[2]).z());
+ ATH_MSG_DEBUG("X0 " << primaryVertex->x() << " Y0 " << primaryVertex->y() << " Z0 " << primaryVertex->z());
+ ATH_MSG_DEBUG("rxy0 " << m_V0Tools->rxy(cascadeVertices[0]) << " rxyErr0 " << m_V0Tools->rxyError(cascadeVertices[0]));
+ ATH_MSG_DEBUG("rxy1 " << m_V0Tools->rxy(cascadeVertices[1]) << " rxyErr1 " << m_V0Tools->rxyError(cascadeVertices[1]));
+ ATH_MSG_DEBUG("rxy2 " << m_V0Tools->rxy(cascadeVertices[2]) << " rxyErr2 " << m_V0Tools->rxyError(cascadeVertices[2]));
+ ATH_MSG_DEBUG("Rxy0 wrt PV " << m_V0Tools->rxy(cascadeVertices[0],primaryVertex) << " RxyErr0 wrt PV " << m_V0Tools->rxyError(cascadeVertices[0],primaryVertex));
+ ATH_MSG_DEBUG("Rxy1 wrt PV " << m_V0Tools->rxy(cascadeVertices[1],primaryVertex) << " RxyErr1 wrt PV " << m_V0Tools->rxyError(cascadeVertices[1],primaryVertex));
+ ATH_MSG_DEBUG("Rxy2 wrt PV " << m_V0Tools->rxy(cascadeVertices[2],primaryVertex) << " RxyErr2 wrt PV " << m_V0Tools->rxyError(cascadeVertices[2],primaryVertex));
+ ATH_MSG_DEBUG("number of covariance matrices " << (x->getCovariance()).size());
+ } // loop over cascadeinfoContainer
+
+ // Deleting cascadeinfo since this won't be stored.
+ // Vertices have been kept in m_cascadeOutputs and should be owned by their container
+ for (auto x : cascadeinfoContainer) delete x;
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ JpsiPlusDs1Cascade::JpsiPlusDs1Cascade(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
+ m_vertexContainerKey(""),
+ m_vertexD0ContainerKey(""),
+ m_vertexK0ContainerKey(""),
+ m_cascadeOutputsKeys{ "JpsiPlusDs1CascadeVtx1", "JpsiPlusDs1CascadeVtx2", "JpsiPlusDs1CascadeVtx3" },
+ m_VxPrimaryCandidateName("PrimaryVertices"),
+ m_jpsiMassLower(0.0),
+ m_jpsiMassUpper(10000.0),
+ m_jpsipiMassLower(0.0),
+ m_jpsipiMassUpper(10000.0),
+ m_D0MassLower(0.0),
+ m_D0MassUpper(10000.0),
+ m_K0MassLower(0.0),
+ m_K0MassUpper(10000.0),
+ m_DstMassLower(0.0),
+ m_DstMassUpper(10000.0),
+ m_MassLower(0.0),
+ m_MassUpper(20000.0),
+ m_vtx0MassHypo(-1),
+ m_vtx1MassHypo(-1),
+ m_vtx2MassHypo(-1),
+ m_vtx0Daug1MassHypo(-1),
+ m_vtx0Daug2MassHypo(-1),
+ m_vtx0Daug3MassHypo(-1),
+ m_vtx1Daug1MassHypo(-1),
+ m_vtx1Daug2MassHypo(-1),
+ m_vtx2Daug1MassHypo(-1),
+ m_vtx2Daug2MassHypo(-1),
+ m_particleDataTable(nullptr),
+ m_mass_jpsi(-1),
+ m_Dx_pid(421),
+ m_constrD0(true),
+ m_constrK0(true),
+ m_constrJpsi(true),
+ m_chi2cut(-1.0),
+ m_iVertexFitter("Trk::TrkVKalVrtFitter"),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter"),
+ m_V0Tools("Trk::V0Tools"),
+ m_CascadeTools("DerivationFramework::CascadeTools")
+ {
+ declareProperty("JpsipiVertices", m_vertexContainerKey);
+ declareProperty("D0Vertices", m_vertexD0ContainerKey);
+ declareProperty("K0Vertices", m_vertexK0ContainerKey);
+ declareProperty("VxPrimaryCandidateName", m_VxPrimaryCandidateName);
+ declareProperty("RefPVContainerName", m_refPVContainerName = "RefittedPrimaryVertices");
+ declareProperty("JpsiMassLowerCut", m_jpsiMassLower);
+ declareProperty("JpsiMassUpperCut", m_jpsiMassUpper);
+ declareProperty("JpsipiMassLowerCut", m_jpsipiMassLower);
+ declareProperty("JpsipiMassUpperCut", m_jpsipiMassUpper);
+ declareProperty("D0MassLowerCut", m_D0MassLower);
+ declareProperty("D0MassUpperCut", m_D0MassUpper);
+ declareProperty("K0MassLowerCut", m_K0MassLower);
+ declareProperty("K0MassUpperCut", m_K0MassUpper);
+ declareProperty("DstMassLowerCut", m_DstMassLower);
+ declareProperty("DstMassUpperCut", m_DstMassUpper);
+ declareProperty("MassLowerCut", m_MassLower);
+ declareProperty("MassUpperCut", m_MassUpper);
+ declareProperty("HypothesisName", m_hypoName = "Bc");
+ declareProperty("Vtx0MassHypo", m_vtx0MassHypo);
+ declareProperty("Vtx1MassHypo", m_vtx1MassHypo);
+ declareProperty("Vtx2MassHypo", m_vtx2MassHypo);
+ declareProperty("Vtx0Daug1MassHypo", m_vtx0Daug1MassHypo);
+ declareProperty("Vtx0Daug2MassHypo", m_vtx0Daug2MassHypo);
+ declareProperty("Vtx0Daug3MassHypo", m_vtx0Daug3MassHypo);
+ declareProperty("Vtx1Daug1MassHypo", m_vtx1Daug1MassHypo);
+ declareProperty("Vtx1Daug2MassHypo", m_vtx1Daug2MassHypo);
+ declareProperty("Vtx2Daug1MassHypo", m_vtx2Daug1MassHypo);
+ declareProperty("Vtx2Daug2MassHypo", m_vtx2Daug2MassHypo);
+ declareProperty("JpsiMass", m_mass_jpsi);
+ declareProperty("DxHypothesis", m_Dx_pid);
+ declareProperty("ApplyD0MassConstraint", m_constrD0);
+ declareProperty("ApplyK0MassConstraint", m_constrK0);
+ declareProperty("ApplyJpsiMassConstraint", m_constrJpsi);
+ declareProperty("Chi2Cut", m_chi2cut);
+ declareProperty("RefitPV", m_refitPV = true);
+ declareProperty("MaxnPV", m_PV_max = 999);
+ declareProperty("MinNTracksInPV", m_PV_minNTracks = 0);
+ declareProperty("DoVertexType", m_DoVertexType = 7);
+ declareProperty("TrkVertexFitterTool", m_iVertexFitter);
+ declareProperty("PVRefitter", m_pvRefitter);
+ declareProperty("V0Tools", m_V0Tools);
+ declareProperty("CascadeTools", m_CascadeTools);
+ declareProperty("CascadeVertexCollections", m_cascadeOutputsKeys);
+ }
+
+ JpsiPlusDs1Cascade::~JpsiPlusDs1Cascade(){ }
+
+ StatusCode JpsiPlusDs1Cascade::performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer) const
+ {
+ ATH_MSG_DEBUG( "JpsiPlusDs1Cascade::performSearch" );
+ assert(cascadeinfoContainer!=nullptr);
+
+ // Get TrackParticle container (for setting links to the original tracks)
+ const xAOD::TrackParticleContainer *trackContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(trackContainer , "InDetTrackParticles" ));
+
+ // Get Jpsi+pi container
+ const xAOD::VertexContainer *jpsipiContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(jpsipiContainer , m_vertexContainerKey ));
+
+ // Get D0 container
+ const xAOD::VertexContainer *d0Container(nullptr);
+ ATH_CHECK(evtStore()->retrieve(d0Container , m_vertexD0ContainerKey ));
+
+ // Get K_S0 container
+ const xAOD::VertexContainer *k0Container(nullptr);
+ ATH_CHECK(evtStore()->retrieve(k0Container , m_vertexK0ContainerKey ));
+
+ double mass_d0 = m_vtx1MassHypo;
+ double mass_k0 = m_vtx2MassHypo;
+ std::vector<const xAOD::TrackParticle*> tracksJpsipi;
+ std::vector<const xAOD::TrackParticle*> tracksJpsi;
+ std::vector<const xAOD::TrackParticle*> tracksD0;
+ std::vector<const xAOD::TrackParticle*> tracksK0;
+ std::vector<const xAOD::TrackParticle*> tracksBc;
+ std::vector<double> massesJpsipi;
+ massesJpsipi.push_back(m_vtx0Daug1MassHypo);
+ massesJpsipi.push_back(m_vtx0Daug2MassHypo);
+ massesJpsipi.push_back(m_vtx0Daug3MassHypo);
+ std::vector<double> massesD0;
+ massesD0.push_back(m_vtx1Daug1MassHypo);
+ massesD0.push_back(m_vtx1Daug2MassHypo);
+ std::vector<double> massesD0b; // Change the oreder of masses for D*-->D0bar pi-, D0bar->K+pi-
+ massesD0b.push_back(m_vtx1Daug2MassHypo);
+ massesD0b.push_back(m_vtx1Daug1MassHypo);
+ std::vector<double> massesK0;
+ massesK0.push_back(m_vtx2Daug1MassHypo);
+ massesK0.push_back(m_vtx2Daug2MassHypo);
+ std::vector<double> Masses;
+ Masses.push_back(m_vtx0Daug1MassHypo);
+ Masses.push_back(m_vtx0Daug2MassHypo);
+ Masses.push_back(m_vtx0Daug3MassHypo);
+ Masses.push_back(m_vtx1MassHypo);
+ Masses.push_back(m_vtx2MassHypo);
+
+ // Select J/psi pi+ candidates before calling cascade fit
+ std::vector<const xAOD::Vertex*> selectedJpsipiCandidates;
+ for(auto vxcItr=jpsipiContainer->cbegin(); vxcItr!=jpsipiContainer->cend(); ++vxcItr) {
+
+ // Check the passed flag first
+ const xAOD::Vertex* vtx = *vxcItr;
+ SG::AuxElement::Accessor<Char_t> flagAcc1("passed_Jpsipi");
+ if(flagAcc1.isAvailable(*vtx)){
+ if(!flagAcc1(*vtx)) continue;
+ }
+
+ // Check J/psi candidate invariant mass and skip if need be
+ TLorentzVector p4Mup_in, p4Mum_in;
+ p4Mup_in.SetPtEtaPhiM((*vxcItr)->trackParticle(0)->pt(),
+ (*vxcItr)->trackParticle(0)->eta(),
+ (*vxcItr)->trackParticle(0)->phi(), m_vtx0Daug1MassHypo);
+ p4Mum_in.SetPtEtaPhiM((*vxcItr)->trackParticle(1)->pt(),
+ (*vxcItr)->trackParticle(1)->eta(),
+ (*vxcItr)->trackParticle(1)->phi(), m_vtx0Daug2MassHypo);
+ double mass_Jpsi = (p4Mup_in + p4Mum_in).M();
+ ATH_MSG_DEBUG("Jpsi mass " << mass_Jpsi);
+ if (mass_Jpsi < m_jpsiMassLower || mass_Jpsi > m_jpsiMassUpper) {
+ ATH_MSG_DEBUG(" Original Jpsi candidate rejected by the mass cut: mass = "
+ << mass_Jpsi << " != (" << m_jpsiMassLower << ", " << m_jpsiMassUpper << ")" );
+ continue;
+ }
+
+ // Check J/psi pi+ candidate invariant mass and skip if need be
+ double mass_Jpsipi = m_V0Tools->invariantMass(*vxcItr, massesJpsipi);
+ ATH_MSG_DEBUG("Jpsipi mass " << mass_Jpsipi);
+ if (mass_Jpsipi < m_jpsipiMassLower || mass_Jpsipi > m_jpsipiMassUpper) {
+ ATH_MSG_DEBUG(" Original Jpsipi candidate rejected by the mass cut: mass = "
+ << mass_Jpsipi << " != (" << m_jpsipiMassLower << ", " << m_jpsipiMassUpper << ")" );
+ continue;
+ }
+
+ selectedJpsipiCandidates.push_back(*vxcItr);
+ }
+ if(selectedJpsipiCandidates.size()<1) return StatusCode::SUCCESS;
+
+ // Select the D0/D0b candidates before calling cascade fit
+ std::vector<const xAOD::Vertex*> selectedD0Candidates;
+ for(auto vxcItr=d0Container->cbegin(); vxcItr!=d0Container->cend(); ++vxcItr) {
+
+ // Check the passed flag first
+ const xAOD::Vertex* vtx = *vxcItr;
+ SG::AuxElement::Accessor<Char_t> flagAcc1("passed_D0");
+ SG::AuxElement::Accessor<Char_t> flagAcc2("passed_D0b");
+ bool isD0(true);
+ bool isD0b(true);
+ if(flagAcc1.isAvailable(*vtx)){
+ if(!flagAcc1(*vtx)) isD0 = false;
+ }
+ if(flagAcc2.isAvailable(*vtx)){
+ if(!flagAcc2(*vtx)) isD0b = false;
+ }
+ if(!(isD0||isD0b)) continue;
+
+ // Ensure the total charge is correct
+ if ((*vxcItr)->trackParticle(0)->charge() != 1 || (*vxcItr)->trackParticle(1)->charge() != -1) {
+ ATH_MSG_DEBUG(" Original D0/D0-bar candidate rejected by the charge requirement: "
+ << (*vxcItr)->trackParticle(0)->charge() << ", " << (*vxcItr)->trackParticle(1)->charge() );
+ continue;
+ }
+
+ // Check D0/D0bar candidate invariant mass and skip if need be
+ double mass_D0 = m_V0Tools->invariantMass(*vxcItr,massesD0);
+ double mass_D0b = m_V0Tools->invariantMass(*vxcItr,massesD0b);
+ ATH_MSG_DEBUG("D0 mass " << mass_D0 << ", D0b mass "<<mass_D0b);
+ if ((mass_D0 < m_D0MassLower || mass_D0 > m_D0MassUpper) && (mass_D0b < m_D0MassLower || mass_D0b > m_D0MassUpper)) {
+ ATH_MSG_DEBUG(" Original D0 candidate rejected by the mass cut: mass = "
+ << mass_D0 << " != (" << m_D0MassLower << ", " << m_D0MassUpper << ") "
+ << mass_D0b << " != (" << m_D0MassLower << ", " << m_D0MassUpper << ") " );
+ continue;
+ }
+
+ selectedD0Candidates.push_back(*vxcItr);
+ }
+ if(selectedD0Candidates.size()<1) return StatusCode::SUCCESS;
+
+ // Select the D0/D0b candidates before calling cascade fit
+ std::vector<const xAOD::Vertex*> selectedK0Candidates;
+ for(auto vxcItr=k0Container->cbegin(); vxcItr!=k0Container->cend(); ++vxcItr) {
+
+ // Check the passed flag first
+ const xAOD::Vertex* vtx = *vxcItr;
+ SG::AuxElement::Accessor<Char_t> flagAcc1("passed_K0");
+ if(flagAcc1.isAvailable(*vtx)){
+ if(!flagAcc1(*vtx)) continue;
+ }
+
+ // Check K_S0 candidate invariant mass and skip if need be
+ double mass_K0 = m_V0Tools->invariantMass(*vxcItr, massesK0);
+ ATH_MSG_DEBUG("K_S0 mass " << mass_K0);
+ if (mass_K0 < m_K0MassLower || mass_K0 > m_K0MassUpper) {
+ ATH_MSG_DEBUG(" Original K_S0 candidate rejected by the mass cut: mass = "
+ << mass_K0 << " != (" << m_K0MassLower << ", " << m_K0MassUpper << ")" );
+ continue;
+ }
+
+ selectedK0Candidates.push_back(*vxcItr);
+ }
+ if(selectedK0Candidates.size()<1) return StatusCode::SUCCESS;
+
+ // Select J/psi D*+ candidates
+ // Iterate over Jpsi+pi vertices
+ for(auto jpsipiItr=selectedJpsipiCandidates.cbegin(); jpsipiItr!=selectedJpsipiCandidates.cend(); ++jpsipiItr) {
+
+ size_t jpsipiTrkNum = (*jpsipiItr)->nTrackParticles();
+ tracksJpsipi.clear();
+ tracksJpsi.clear();
+ for( unsigned int it=0; it<jpsipiTrkNum; it++) tracksJpsipi.push_back((*jpsipiItr)->trackParticle(it));
+ for( unsigned int it=0; it<jpsipiTrkNum-1; it++) tracksJpsi.push_back((*jpsipiItr)->trackParticle(it));
+
+ if (tracksJpsipi.size() != 3 || massesJpsipi.size() != 3 ) {
+ ATH_MSG_INFO("problems with Jpsi+pi input");
+ }
+
+ bool tagD0(true);
+ if(abs(m_Dx_pid)==421 && (*jpsipiItr)->trackParticle(2)->charge()==-1) tagD0 = false;
+
+ TLorentzVector p4_pi1; // Momentum of soft pion
+ p4_pi1.SetPtEtaPhiM((*jpsipiItr)->trackParticle(2)->pt(),
+ (*jpsipiItr)->trackParticle(2)->eta(),
+ (*jpsipiItr)->trackParticle(2)->phi(), m_vtx0Daug3MassHypo);
+
+ // Iterate over D0/D0bar vertices
+ for(auto d0Itr=selectedD0Candidates.cbegin(); d0Itr!=selectedD0Candidates.cend(); ++d0Itr) {
+
+ // Check identical tracks in input
+ if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*d0Itr)->trackParticle(0)) != tracksJpsipi.cend()) continue;
+ if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*d0Itr)->trackParticle(1)) != tracksJpsipi.cend()) continue;
+
+ TLorentzVector p4_ka, p4_pi2;
+ if(tagD0){ // for D*+
+ p4_pi2.SetPtEtaPhiM((*d0Itr)->trackParticle(0)->pt(),
+ (*d0Itr)->trackParticle(0)->eta(),
+ (*d0Itr)->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
+ p4_ka.SetPtEtaPhiM( (*d0Itr)->trackParticle(1)->pt(),
+ (*d0Itr)->trackParticle(1)->eta(),
+ (*d0Itr)->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
+ }else{ // change the order in the case of D*-
+ p4_pi2.SetPtEtaPhiM((*d0Itr)->trackParticle(1)->pt(),
+ (*d0Itr)->trackParticle(1)->eta(),
+ (*d0Itr)->trackParticle(1)->phi(), m_vtx1Daug1MassHypo);
+ p4_ka.SetPtEtaPhiM( (*d0Itr)->trackParticle(0)->pt(),
+ (*d0Itr)->trackParticle(0)->eta(),
+ (*d0Itr)->trackParticle(0)->phi(), m_vtx1Daug2MassHypo);
+ }
+ // Check D*+/- candidate invariant mass and skip if need be
+ double mass_Dst= (p4_pi1 + p4_ka + p4_pi2).M();
+ ATH_MSG_DEBUG("D*+/- mass " << mass_Dst);
+ if (mass_Dst < m_DstMassLower || mass_Dst > m_DstMassUpper) {
+ ATH_MSG_DEBUG(" Original D*+/- candidate rejected by the mass cut: mass = "
+ << mass_Dst << " != (" << m_DstMassLower << ", " << m_DstMassUpper << ")" );
+ continue;
+ }
+
+ size_t d0TrkNum = (*d0Itr)->nTrackParticles();
+ tracksD0.clear();
+ for( unsigned int it=0; it<d0TrkNum; it++) tracksD0.push_back((*d0Itr)->trackParticle(it));
+ if (tracksD0.size() != 2 || massesD0.size() != 2 ) {
+ ATH_MSG_INFO("problems with D0 input");
+ }
+
+ // Iterate over K0 vertices
+ for(auto k0Itr=selectedK0Candidates.cbegin(); k0Itr!=selectedK0Candidates.cend(); ++k0Itr) {
+
+ // Check identical tracks in input
+ if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*k0Itr)->trackParticle(0)) != tracksJpsipi.cend()) continue;
+ if(std::find(tracksJpsipi.cbegin(), tracksJpsipi.cend(), (*k0Itr)->trackParticle(1)) != tracksJpsipi.cend()) continue;
+ if(std::find(tracksD0.cbegin(), tracksD0.cend(), (*k0Itr)->trackParticle(0)) != tracksD0.cend()) continue;
+ if(std::find(tracksD0.cbegin(), tracksD0.cend(), (*k0Itr)->trackParticle(1)) != tracksD0.cend()) continue;
+
+ size_t k0TrkNum = (*k0Itr)->nTrackParticles();
+ tracksK0.clear();
+ for( unsigned int it=0; it<k0TrkNum; it++) tracksK0.push_back((*k0Itr)->trackParticle(it));
+ if (tracksK0.size() != 2 || massesK0.size() != 2 ) {
+ ATH_MSG_INFO("problems with K0 input");
+ }
+
+ ATH_MSG_DEBUG("using tracks" << tracksJpsipi[0] << ", " << tracksJpsipi[1] << ", " << tracksJpsipi[2] << ", " << tracksD0[0] << ", " << tracksD0[1] << ", " << tracksK0[0] << ", " << tracksK0[1]);
+
+ tracksBc.clear();
+ for( unsigned int it=0; it<jpsipiTrkNum; it++) tracksBc.push_back((*jpsipiItr)->trackParticle(it));
+ for( unsigned int it=0; it<d0TrkNum; it++) tracksBc.push_back((*d0Itr)->trackParticle(it));
+ for( unsigned int it=0; it<k0TrkNum; it++) tracksBc.push_back((*k0Itr)->trackParticle(it));
+
+
+ // Apply the user's settings to the fitter
+ // Reset
+ std::unique_ptr<Trk::IVKalState> state (m_iVertexFitter->makeState());
+ // Robustness
+ int robustness = 0;
+ m_iVertexFitter->setRobustness(robustness, *state);
+ // Build up the topology
+ // Vertex list
+ std::vector<Trk::VertexID> vrtList;
+ // K_S0 vertex
+ Trk::VertexID vK0ID;
+ if (m_constrK0) {
+ vK0ID = m_iVertexFitter->startVertex(tracksK0,massesK0, *state, mass_k0);
+ } else {
+ vK0ID = m_iVertexFitter->startVertex(tracksK0,massesK0, *state);
+ }
+ vrtList.push_back(vK0ID);
+ // D0 vertex
+ Trk::VertexID vD0ID;
+ if (m_constrD0) {
+ if(tagD0) vD0ID = m_iVertexFitter->nextVertex(tracksD0,massesD0, *state, mass_d0);
+ else vD0ID = m_iVertexFitter->nextVertex(tracksD0,massesD0b, *state, mass_d0);
+ } else {
+ if(tagD0) vD0ID = m_iVertexFitter->nextVertex(tracksD0,massesD0, *state);
+ else vD0ID = m_iVertexFitter->nextVertex(tracksD0,massesD0b, *state);
+ }
+ vrtList.push_back(vD0ID);
+ // B vertex including Jpsi+pi
+ Trk::VertexID vBcID = m_iVertexFitter->nextVertex(tracksJpsipi,massesJpsipi,vrtList, *state);
+ if (m_constrJpsi) {
+ std::vector<Trk::VertexID> cnstV;
+ cnstV.clear();
+ if ( !m_iVertexFitter->addMassConstraint(vBcID,tracksJpsi,cnstV, *state, m_mass_jpsi).isSuccess() ) {
+ ATH_MSG_WARNING("addMassConstraint failed");
+ //return StatusCode::FAILURE;
+ }
+ }
+ // Do the work
+ std::unique_ptr<Trk::VxCascadeInfo> result(m_iVertexFitter->fitCascade(*state));
+
+ if (result != nullptr) {
+
+ // reset links to original tracks
+ BPhysPVCascadeTools::PrepareVertexLinks(result.get(), trackContainer);
+ ATH_MSG_DEBUG("storing tracks " << ((result->vertices())[0])->trackParticle(0) << ", "
+ << ((result->vertices())[0])->trackParticle(1) << ", "
+ << ((result->vertices())[1])->trackParticle(0) << ", "
+ << ((result->vertices())[1])->trackParticle(1) << ", "
+ << ((result->vertices())[2])->trackParticle(0) << ", "
+ << ((result->vertices())[2])->trackParticle(1) << ", "
+ << ((result->vertices())[2])->trackParticle(2));
+ // necessary to prevent memory leak
+ result->setSVOwnership(true);
+
+ // Chi2/DOF cut
+ double bChi2DOF = result->fitChi2()/result->nDoF();
+ ATH_MSG_DEBUG("Candidate chi2/DOF is " << bChi2DOF);
+ bool chi2CutPassed = (m_chi2cut <= 0.0 || bChi2DOF < m_chi2cut);
+
+ const std::vector< std::vector<TLorentzVector> > &moms = result->getParticleMoms();
+ double mass = m_CascadeTools->invariantMass(moms[2]);
+ if(chi2CutPassed) {
+ if (mass >= m_MassLower && mass <= m_MassUpper) {
+ cascadeinfoContainer->push_back(result.release());
+ } else {
+ ATH_MSG_DEBUG("Candidate rejected by the mass cut: mass = "
+ << mass << " != (" << m_MassLower << ", " << m_MassUpper << ")" );
+ }
+ }
+ }
+
+ } //Iterate over K0 vertices
+
+ } //Iterate over D0 vertices
+
+ } //Iterate over Jpsi+pi vertices
+
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer->size());
+
+ return StatusCode::SUCCESS;
+ }
+
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDsCascade.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDsCascade.cxx
new file mode 100644
index 00000000000..f7d485b75f7
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusDsCascade.cxx
@@ -0,0 +1,702 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+/////////////////////////////////////////////////////////////////
+// JpsiPlusDsCascade.cxx, (c) ATLAS Detector software
+/////////////////////////////////////////////////////////////////
+#include "DerivationFrameworkBPhys/JpsiPlusDsCascade.h"
+#include "TrkVertexFitterInterfaces/IVertexFitter.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "GaudiKernel/IPartPropSvc.h"
+#include "DerivationFrameworkBPhys/CascadeTools.h"
+#include "DerivationFrameworkBPhys/BPhysPVCascadeTools.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include <algorithm>
+#include "xAODTracking/VertexContainer.h"
+#include "DerivationFrameworkBPhys/LocalVector.h"
+#include "HepPDT/ParticleDataTable.hh"
+
+namespace DerivationFramework {
+ typedef ElementLink<xAOD::VertexContainer> VertexLink;
+ typedef std::vector<VertexLink> VertexLinkVector;
+ typedef std::vector<const xAOD::TrackParticle*> TrackBag;
+
+ StatusCode JpsiPlusDsCascade::initialize() {
+
+ // retrieving vertex Fitter
+ ATH_CHECK( m_iVertexFitter.retrieve());
+
+ // retrieving the V0 tools
+ ATH_CHECK( m_V0Tools.retrieve());
+
+ // retrieving the Cascade tools
+ ATH_CHECK( m_CascadeTools.retrieve());
+
+ // Get the beam spot service
+ ATH_CHECK( m_beamSpotKey.initialize() );
+
+ IPartPropSvc* partPropSvc = nullptr;
+ ATH_CHECK( service("PartPropSvc", partPropSvc, true) );
+ auto pdt = partPropSvc->PDT();
+
+ // retrieve particle masses
+ if(m_mass_jpsi < 0. ) m_mass_jpsi = BPhysPVCascadeTools::getParticleMass(pdt, PDG::J_psi);
+ if(m_vtx0MassHypo < 0.)
+ m_vtx0MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::B_c_plus);
+ if(m_vtx1MassHypo < 0.) {
+ if(abs(m_Dx_pid) == 411) m_vtx1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::D_plus);
+ else m_vtx1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::D_s_plus);
+ }
+
+ if(m_vtx0Daug1MassHypo < 0.) m_vtx0Daug1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::mu_minus);
+ if(m_vtx0Daug2MassHypo < 0.) m_vtx0Daug2MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::mu_minus);
+ if(m_vtx1Daug1MassHypo < 0.) {
+ if(abs(m_Dx_pid) == 411) m_vtx1Daug1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::pi_plus);
+ else m_vtx1Daug1MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::K_plus);
+ }
+ if(m_vtx1Daug2MassHypo < 0.) m_vtx1Daug2MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::K_plus);
+ if(m_vtx1Daug3MassHypo < 0.) m_vtx1Daug3MassHypo = BPhysPVCascadeTools::getParticleMass(pdt, PDG::pi_plus);
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ StatusCode JpsiPlusDsCascade::addBranches() const
+ {
+ std::vector<Trk::VxCascadeInfo*> cascadeinfoContainer;
+ constexpr int topoN = 2;
+ std::array<xAOD::VertexContainer*, topoN> Vtxwritehandles;
+ std::array<xAOD::VertexAuxContainer*, topoN> Vtxwritehandlesaux;
+ if(m_cascadeOutputsKeys.size() !=topoN) { ATH_MSG_FATAL("Incorrect number of VtxContainers"); return StatusCode::FAILURE; }
+
+ for(int i =0; i<topoN;i++){
+ Vtxwritehandles[i] = new xAOD::VertexContainer();
+ Vtxwritehandlesaux[i] = new xAOD::VertexAuxContainer();
+ Vtxwritehandles[i]->setStore(Vtxwritehandlesaux[i]);
+ ATH_CHECK(evtStore()->record(Vtxwritehandles[i] , m_cascadeOutputsKeys[i] ));
+ ATH_CHECK(evtStore()->record(Vtxwritehandlesaux[i], m_cascadeOutputsKeys[i] + "Aux."));
+ }
+
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+ const xAOD::Vertex * primaryVertex(nullptr);
+ const xAOD::VertexContainer *pvContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(pvContainer, m_VxPrimaryCandidateName));
+ ATH_MSG_DEBUG("Found " << m_VxPrimaryCandidateName << " in StoreGate!");
+
+ if (pvContainer->size()==0){
+ ATH_MSG_WARNING("You have no primary vertices: " << pvContainer->size());
+ return StatusCode::RECOVERABLE;
+ } else {
+ primaryVertex = (*pvContainer)[0];
+ }
+
+ //----------------------------------------------------
+ // Try to retrieve refitted primary vertices
+ //----------------------------------------------------
+ xAOD::VertexContainer* refPvContainer = nullptr;
+ xAOD::VertexAuxContainer* refPvAuxContainer = nullptr;
+ if (m_refitPV) {
+ if (evtStore()->contains<xAOD::VertexContainer>(m_refPVContainerName)) {
+ // refitted PV container exists. Get it from the store gate
+ ATH_CHECK(evtStore()->retrieve(refPvContainer , m_refPVContainerName ));
+ ATH_CHECK(evtStore()->retrieve(refPvAuxContainer, m_refPVContainerName + "Aux."));
+ } else {
+ // refitted PV container does not exist. Create a new one.
+ refPvContainer = new xAOD::VertexContainer;
+ refPvAuxContainer = new xAOD::VertexAuxContainer;
+ refPvContainer->setStore(refPvAuxContainer);
+ ATH_CHECK(evtStore()->record(refPvContainer , m_refPVContainerName));
+ ATH_CHECK(evtStore()->record(refPvAuxContainer, m_refPVContainerName+"Aux."));
+ }
+ }
+
+ ATH_CHECK(performSearch(&cascadeinfoContainer));
+
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVCascadeTools helper(&(*m_CascadeTools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(m_PV_minNTracks);
+
+ // Decorators for the main vertex: chi2, ndf, pt and pt error, plus the V0 vertex variables
+ SG::AuxElement::Decorator<VertexLinkVector> CascadeLinksDecor("CascadeVertexLinks");
+ SG::AuxElement::Decorator<VertexLinkVector> JpsiLinksDecor("JpsiVertexLinks");
+ SG::AuxElement::Decorator<VertexLinkVector> DxLinksDecor("DxVertexLinks");
+ SG::AuxElement::Decorator<float> chi2_decor("ChiSquared");
+ SG::AuxElement::Decorator<float> ndof_decor("NumberDoF");
+ SG::AuxElement::Decorator<float> Pt_decor("Pt");
+ SG::AuxElement::Decorator<float> PtErr_decor("PtErr");
+ SG::AuxElement::Decorator<float> Mass_svdecor("Dx_mass");
+ SG::AuxElement::Decorator<float> MassErr_svdecor("Dx_massErr");
+ SG::AuxElement::Decorator<float> Pt_svdecor("Dx_Pt");
+ SG::AuxElement::Decorator<float> PtErr_svdecor("Dx_PtErr");
+ SG::AuxElement::Decorator<float> Lxy_svdecor("Dx_Lxy");
+ SG::AuxElement::Decorator<float> LxyErr_svdecor("Dx_LxyErr");
+ SG::AuxElement::Decorator<float> Tau_svdecor("Dx_Tau");
+ SG::AuxElement::Decorator<float> TauErr_svdecor("Dx_TauErr");
+
+ SG::AuxElement::Decorator<float> MassMumu_decor("Mumu_mass");
+ SG::AuxElement::Decorator<float> MassKX_svdecor("KX_mass");
+ SG::AuxElement::Decorator<float> MassKXpi_svdecor("KXpi_mass");
+
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer.size());
+
+ // Get Jpsi container and identify the input Jpsi
+ const xAOD::VertexContainer *jpsiContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(jpsiContainer , m_vertexContainerKey ));
+ const xAOD::VertexContainer *dxContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(dxContainer , m_vertexDxContainerKey ));
+
+ for (Trk::VxCascadeInfo* x : cascadeinfoContainer) {
+ if(x==nullptr) ATH_MSG_ERROR("cascadeinfoContainer is null");
+
+ // the cascade fitter returns:
+ // std::vector<xAOD::Vertex*>, each xAOD::Vertex contains the refitted track parameters (perigee at the vertex position)
+ // vertices[iv] the links to the original TPs and a covariance of size 3+5*NTRK; the chi2 of the total fit
+ // is split between the cascade vertices as per track contribution
+ // std::vector< std::vector<TLorentzVector> >, each std::vector<TLorentzVector> contains the refitted momenta (TLorentzVector)
+ // momenta[iv][...] of all tracks in the corresponding vertex, including any pseudotracks (from cascade vertices)
+ // originating in this vertex; the masses are as assigned in the cascade fit
+ // std::vector<Amg::MatrixX>, the corresponding covariance matrices in momentum space
+ // covariance[iv]
+ // int nDoF, double Chi2
+ //
+ // the invariant mass, pt, lifetime etc. errors should be calculated using the covariance matrices in momentum space as these
+ // take into account the full track-track and track-vertex correlations
+ //
+ // in the case of Jpsi+V0: vertices[0] is the V0 vertex, vertices[1] is the B/Lambda_b(bar) vertex, containing the 2 Jpsi tracks.
+ // The covariance terms between the two vertices are not stored. In momentum space momenta[0] contains the 2 V0 tracks,
+ // their momenta add up to the momentum of the 3rd track in momenta[1], the first two being the Jpsi tracks
+
+ const std::vector<xAOD::Vertex*> &cascadeVertices = x->vertices();
+ if(cascadeVertices.size()!=topoN)
+ ATH_MSG_ERROR("Incorrect number of vertices");
+ if(cascadeVertices[0] == nullptr || cascadeVertices[1] == nullptr) ATH_MSG_ERROR("Error null vertex");
+ // Keep vertices (bear in mind that they come in reverse order!)
+ for(int i =0;i<topoN;i++) Vtxwritehandles[i]->push_back(cascadeVertices[i]);
+
+ x->setSVOwnership(false); // Prevent Container from deleting vertices
+ const auto mainVertex = cascadeVertices[1]; // this is the B_c+/- vertex
+ const std::vector< std::vector<TLorentzVector> > &moms = x->getParticleMoms();
+
+ // Set links to cascade vertices
+ std::vector<const xAOD::Vertex*> verticestoLink;
+ verticestoLink.push_back(cascadeVertices[0]);
+ if(Vtxwritehandles[1] == nullptr) ATH_MSG_ERROR("Vtxwritehandles[1] is null");
+ if(!BPhysPVCascadeTools::LinkVertices(CascadeLinksDecor, verticestoLink, Vtxwritehandles[0], cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with cascade vertices");
+
+ // Identify the input Jpsi
+ const xAOD::Vertex* jpsiVertex = BPhysPVCascadeTools::FindVertex<2>(jpsiContainer, cascadeVertices[1]);
+ ATH_MSG_DEBUG("1 pt Jpsi tracks " << cascadeVertices[1]->trackParticle(0)->pt() << ", " << cascadeVertices[1]->trackParticle(1)->pt());
+ if (jpsiVertex) ATH_MSG_DEBUG("2 pt Jpsi tracks " << jpsiVertex->trackParticle(0)->pt() << ", " << jpsiVertex->trackParticle(1)->pt());
+
+ // Identify the input D_(s)+
+ const xAOD::Vertex* dxVertex = BPhysPVCascadeTools::FindVertex<3>(dxContainer, cascadeVertices[0]);;
+ ATH_MSG_DEBUG("1 pt D_(s)+ tracks " << cascadeVertices[0]->trackParticle(0)->pt() << ", " << cascadeVertices[0]->trackParticle(1)->pt() << ", " << cascadeVertices[0]->trackParticle(2)->pt());
+ if (dxVertex) ATH_MSG_DEBUG("2 pt D_(s)+ tracks " << dxVertex->trackParticle(0)->pt() << ", " << dxVertex->trackParticle(1)->pt() << ", " << dxVertex->trackParticle(2)->pt());
+
+ // Set links to input vertices
+ std::vector<const xAOD::Vertex*> jpsiVerticestoLink;
+ if (jpsiVertex) jpsiVerticestoLink.push_back(jpsiVertex);
+ else ATH_MSG_WARNING("Could not find linking Jpsi");
+ if(!BPhysPVCascadeTools::LinkVertices(JpsiLinksDecor, jpsiVerticestoLink, jpsiContainer, cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with Jpsi vertices");
+
+ std::vector<const xAOD::Vertex*> dxVerticestoLink;
+ if (dxVertex) dxVerticestoLink.push_back(dxVertex);
+ else ATH_MSG_WARNING("Could not find linking D_(s)+");
+ if(!BPhysPVCascadeTools::LinkVertices(DxLinksDecor, dxVerticestoLink, dxContainer, cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with D_(s)+ vertices");
+
+ bool tagDp(true);
+ if (dxVertex) {
+ if(abs(m_Dx_pid)==411 && (dxVertex->trackParticle(2)->charge()==-1)) tagDp = false;
+ }
+
+ double mass_b = m_vtx0MassHypo;
+ double mass_d = m_vtx1MassHypo;
+ std::vector<double> massesJpsi;
+ massesJpsi.push_back(m_vtx0Daug1MassHypo);
+ massesJpsi.push_back(m_vtx0Daug2MassHypo);
+ std::vector<double> massesDx;
+ if(tagDp){
+ massesDx.push_back(m_vtx1Daug1MassHypo);
+ massesDx.push_back(m_vtx1Daug2MassHypo);
+ }else{ // Change the order for D-
+ massesDx.push_back(m_vtx1Daug2MassHypo);
+ massesDx.push_back(m_vtx1Daug1MassHypo);
+ }
+ massesDx.push_back(m_vtx1Daug3MassHypo);
+ std::vector<double> Masses;
+ Masses.push_back(m_vtx0Daug1MassHypo);
+ Masses.push_back(m_vtx0Daug2MassHypo);
+ Masses.push_back(m_vtx1MassHypo);
+
+ // loop over candidates -- Don't apply PV_minNTracks requirement here
+ // because it may result in exclusion of the high-pt PV.
+ // get good PVs
+
+
+ xAOD::BPhysHypoHelper vtx(m_hypoName, mainVertex);
+
+ // Get refitted track momenta from all vertices, charged tracks only
+ BPhysPVCascadeTools::SetVectorInfo(vtx, x);
+
+ // Decorate main vertex
+ //
+ // 1.a) mass, mass error
+ BPHYS_CHECK( vtx.setMass(m_CascadeTools->invariantMass(moms[1])) );
+ BPHYS_CHECK( vtx.setMassErr(m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1])) );
+ // 1.b) pt and pT error (the default pt of mainVertex is != the pt of the full cascade fit!)
+ Pt_decor(*mainVertex) = m_CascadeTools->pT(moms[1]);
+ PtErr_decor(*mainVertex) = m_CascadeTools->pTError(moms[1],x->getCovariance()[1]);
+ // 1.c) chi2 and ndof (the default chi2 of mainVertex is != the chi2 of the full cascade fit!)
+ chi2_decor(*mainVertex) = x->fitChi2();
+ ndof_decor(*mainVertex) = x->nDoF();
+
+ float massMumu = 0.;
+ if (jpsiVertex) {
+ TLorentzVector p4_mu1, p4_mu2;
+ p4_mu1.SetPtEtaPhiM(jpsiVertex->trackParticle(0)->pt(),
+ jpsiVertex->trackParticle(0)->eta(),
+ jpsiVertex->trackParticle(0)->phi(), m_vtx0Daug1MassHypo);
+ p4_mu2.SetPtEtaPhiM(jpsiVertex->trackParticle(1)->pt(),
+ jpsiVertex->trackParticle(1)->eta(),
+ jpsiVertex->trackParticle(1)->phi(), m_vtx0Daug2MassHypo);
+ massMumu = (p4_mu1 + p4_mu2).M();
+ }
+ MassMumu_decor(*mainVertex) = massMumu;
+
+ float massKX = 0., massKXpi = 0.;
+ if (dxVertex) {
+ TLorentzVector p4_h1, p4_h2, p4_h3;
+ if(tagDp){
+ p4_h1.SetPtEtaPhiM(dxVertex->trackParticle(0)->pt(),
+ dxVertex->trackParticle(0)->eta(),
+ dxVertex->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
+ p4_h2.SetPtEtaPhiM(dxVertex->trackParticle(1)->pt(),
+ dxVertex->trackParticle(1)->eta(),
+ dxVertex->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
+ }else{ // Change the order for D-
+ p4_h1.SetPtEtaPhiM(dxVertex->trackParticle(0)->pt(),
+ dxVertex->trackParticle(0)->eta(),
+ dxVertex->trackParticle(0)->phi(), m_vtx1Daug2MassHypo);
+ p4_h2.SetPtEtaPhiM(dxVertex->trackParticle(1)->pt(),
+ dxVertex->trackParticle(1)->eta(),
+ dxVertex->trackParticle(1)->phi(), m_vtx1Daug1MassHypo);
+ }
+ p4_h3.SetPtEtaPhiM(dxVertex->trackParticle(2)->pt(),
+ dxVertex->trackParticle(2)->eta(),
+ dxVertex->trackParticle(2)->phi(), m_vtx1Daug3MassHypo);
+ massKX = (p4_h1 + p4_h2).M();
+ massKXpi = (p4_h1 + p4_h2 + p4_h3).M();
+ }
+ MassKX_svdecor(*mainVertex) = massKX;
+ MassKXpi_svdecor(*mainVertex) = massKXpi;
+
+ ATH_CHECK(helper.FillCandwithRefittedVertices(m_refitPV, pvContainer,
+ refPvContainer, &(*m_pvRefitter), m_PV_max, m_DoVertexType, x, 1, mass_b, vtx));
+
+
+ // 4) decorate the main vertex with V0 vertex mass, pt, lifetime and lxy values (plus errors)
+ // V0 points to the main vertex, so lifetime and lxy are w.r.t the main vertex
+ Mass_svdecor(*mainVertex) = m_CascadeTools->invariantMass(moms[0]);
+ MassErr_svdecor(*mainVertex) = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ Pt_svdecor(*mainVertex) = m_CascadeTools->pT(moms[0]);
+ PtErr_svdecor(*mainVertex) = m_CascadeTools->pTError(moms[0],x->getCovariance()[0]);
+ Lxy_svdecor(*mainVertex) = m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
+ LxyErr_svdecor(*mainVertex) = m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1]);
+ Tau_svdecor(*mainVertex) = m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1]);
+ TauErr_svdecor(*mainVertex) = m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1]);
+
+ // Some checks in DEBUG mode
+ ATH_MSG_DEBUG("chi2 " << x->fitChi2()
+ << " chi2_1 " << m_V0Tools->chisq(cascadeVertices[0])
+ << " chi2_2 " << m_V0Tools->chisq(cascadeVertices[1])
+ << " vprob " << m_CascadeTools->vertexProbability(x->nDoF(),x->fitChi2()));
+ ATH_MSG_DEBUG("ndf " << x->nDoF() << " ndf_1 " << m_V0Tools->ndof(cascadeVertices[0]) << " ndf_2 " << m_V0Tools->ndof(cascadeVertices[1]));
+ ATH_MSG_DEBUG("V0Tools mass_d " << m_V0Tools->invariantMass(cascadeVertices[0],massesDx)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[0],massesDx)
+ << " mass_J " << m_V0Tools->invariantMass(cascadeVertices[1],massesJpsi)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[1],massesJpsi));
+ // masses and errors, using track masses assigned in the fit
+ double Mass_B = m_CascadeTools->invariantMass(moms[1]);
+ double Mass_D = m_CascadeTools->invariantMass(moms[0]);
+ double Mass_B_err = m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1]);
+ double Mass_D_err = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ ATH_MSG_DEBUG("Mass_B " << Mass_B << " Mass_D " << Mass_D);
+ ATH_MSG_DEBUG("Mass_B_err " << Mass_B_err << " Mass_D_err " << Mass_D_err);
+ double mprob_B = m_CascadeTools->massProbability(mass_b,Mass_B,Mass_B_err);
+ double mprob_D = m_CascadeTools->massProbability(mass_d,Mass_D,Mass_D_err);
+ ATH_MSG_DEBUG("mprob_B " << mprob_B << " mprob_D " << mprob_D);
+ // masses and errors, assigning user defined track masses
+ ATH_MSG_DEBUG("Mass_b " << m_CascadeTools->invariantMass(moms[1],Masses)
+ << " Mass_d " << m_CascadeTools->invariantMass(moms[0],massesDx));
+ ATH_MSG_DEBUG("Mass_b_err " << m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1],Masses)
+ << " Mass_d_err " << m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0],massesDx));
+ ATH_MSG_DEBUG("pt_b " << m_CascadeTools->pT(moms[1])
+ << " pt_d " << m_CascadeTools->pT(moms[0])
+ << " pt_dp " << m_V0Tools->pT(cascadeVertices[0]));
+ ATH_MSG_DEBUG("ptErr_b " << m_CascadeTools->pTError(moms[1],x->getCovariance()[1])
+ << " ptErr_d " << m_CascadeTools->pTError(moms[0],x->getCovariance()[0])
+ << " ptErr_dp " << m_V0Tools->pTError(cascadeVertices[0]));
+ ATH_MSG_DEBUG("lxy_B " << m_V0Tools->lxy(cascadeVertices[1],primaryVertex) << " lxy_D " << m_V0Tools->lxy(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("lxy_b " << m_CascadeTools->lxy(moms[1],cascadeVertices[1],primaryVertex) << " lxy_d " << m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("lxyErr_b " << m_CascadeTools->lxyError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << " lxyErr_d " << m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << " lxyErr_dp " << m_V0Tools->lxyError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("tau_B " << m_CascadeTools->tau(moms[1],cascadeVertices[1],primaryVertex,mass_b)
+ << " tau_dp " << m_V0Tools->tau(cascadeVertices[0],cascadeVertices[1],massesDx));
+ ATH_MSG_DEBUG("tau_b " << m_CascadeTools->tau(moms[1],cascadeVertices[1],primaryVertex)
+ << " tau_d " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << " tau_D " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1],mass_d));
+ ATH_MSG_DEBUG("tauErr_b " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << " tauErr_d " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << " tauErr_dp " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[1],massesDx));
+ ATH_MSG_DEBUG("TauErr_b " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex,mass_b)
+ << " TauErr_d " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1],mass_d)
+ << " TauErr_dp " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[1],massesDx,mass_d));
+
+ ATH_MSG_DEBUG("CascadeTools main vert wrt PV " << " CascadeTools SV " << " V0Tools SV");
+ ATH_MSG_DEBUG("a0z " << m_CascadeTools->a0z(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0z(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0z(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0zErr " << m_CascadeTools->a0zError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0zError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0zError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0xy " << m_CascadeTools->a0xy(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0xy(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0xy(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0xyErr " << m_CascadeTools->a0xyError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0xyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0xyError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0 " << m_CascadeTools->a0(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0Err " << m_CascadeTools->a0Error(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0Error(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0Error(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("x0 " << m_V0Tools->vtx(cascadeVertices[0]).x() << " y0 " << m_V0Tools->vtx(cascadeVertices[0]).y() << " z0 " << m_V0Tools->vtx(cascadeVertices[0]).z());
+ ATH_MSG_DEBUG("x1 " << m_V0Tools->vtx(cascadeVertices[1]).x() << " y1 " << m_V0Tools->vtx(cascadeVertices[1]).y() << " z1 " << m_V0Tools->vtx(cascadeVertices[1]).z());
+ ATH_MSG_DEBUG("X0 " << primaryVertex->x() << " Y0 " << primaryVertex->y() << " Z0 " << primaryVertex->z());
+ ATH_MSG_DEBUG("rxy0 " << m_V0Tools->rxy(cascadeVertices[0]) << " rxyErr0 " << m_V0Tools->rxyError(cascadeVertices[0]));
+ ATH_MSG_DEBUG("rxy1 " << m_V0Tools->rxy(cascadeVertices[1]) << " rxyErr1 " << m_V0Tools->rxyError(cascadeVertices[1]));
+ ATH_MSG_DEBUG("Rxy0 wrt PV " << m_V0Tools->rxy(cascadeVertices[0],primaryVertex) << " RxyErr0 wrt PV " << m_V0Tools->rxyError(cascadeVertices[0],primaryVertex));
+ ATH_MSG_DEBUG("Rxy1 wrt PV " << m_V0Tools->rxy(cascadeVertices[1],primaryVertex) << " RxyErr1 wrt PV " << m_V0Tools->rxyError(cascadeVertices[1],primaryVertex));
+ ATH_MSG_DEBUG("number of covariance matrices " << (x->getCovariance()).size());
+ } // loop over cascadeinfoContainer
+
+ // Deleting cascadeinfo since this won't be stored.
+ // Vertices have been kept in m_cascadeOutputs and should be owned by their container
+ for (auto x : cascadeinfoContainer) delete x;
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ JpsiPlusDsCascade::JpsiPlusDsCascade(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
+ m_vertexContainerKey(""),
+ m_vertexDxContainerKey(""),
+ m_cascadeOutputsKeys{ "JpsiPlusDsCascadeVtx1", "JpsiPlusDsCascadeVtx2" },
+ m_VxPrimaryCandidateName("PrimaryVertices"),
+ m_jpsiMassLower(0.0),
+ m_jpsiMassUpper(10000.0),
+ m_DxMassLower(0.0),
+ m_DxMassUpper(10000.0),
+ m_MassLower(0.0),
+ m_MassUpper(20000.0),
+ m_vtx0MassHypo(-1),
+ m_vtx1MassHypo(-1),
+ m_vtx0Daug1MassHypo(-1),
+ m_vtx0Daug2MassHypo(-1),
+ m_vtx1Daug1MassHypo(-1),
+ m_vtx1Daug2MassHypo(-1),
+ m_vtx1Daug3MassHypo(-1),
+ m_mass_jpsi(-1),
+ m_Dx_pid(431),
+ m_constrDx(true),
+ m_constrJpsi(true),
+ m_chi2cut(-1.0),
+ m_iVertexFitter("Trk::TrkVKalVrtFitter"),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter"),
+ m_V0Tools("Trk::V0Tools"),
+ m_CascadeTools("DerivationFramework::CascadeTools")
+ {
+ declareProperty("JpsiVertices", m_vertexContainerKey);
+ declareProperty("DxVertices", m_vertexDxContainerKey);
+ declareProperty("VxPrimaryCandidateName", m_VxPrimaryCandidateName);
+ declareProperty("RefPVContainerName", m_refPVContainerName = "RefittedPrimaryVertices");
+ declareProperty("JpsiMassLowerCut", m_jpsiMassLower);
+ declareProperty("JpsiMassUpperCut", m_jpsiMassUpper);
+ declareProperty("DxMassLowerCut", m_DxMassLower);
+ declareProperty("DxMassUpperCut", m_DxMassUpper);
+ declareProperty("MassLowerCut", m_MassLower);
+ declareProperty("MassUpperCut", m_MassUpper);
+ declareProperty("HypothesisName", m_hypoName = "Bc");
+ declareProperty("Vtx0MassHypo", m_vtx0MassHypo);
+ declareProperty("Vtx1MassHypo", m_vtx1MassHypo);
+ declareProperty("Vtx0Daug1MassHypo", m_vtx0Daug1MassHypo);
+ declareProperty("Vtx0Daug2MassHypo", m_vtx0Daug2MassHypo);
+ declareProperty("Vtx1Daug1MassHypo", m_vtx1Daug1MassHypo);
+ declareProperty("Vtx1Daug2MassHypo", m_vtx1Daug2MassHypo);
+ declareProperty("Vtx1Daug3MassHypo", m_vtx1Daug3MassHypo);
+ declareProperty("JpsiMass", m_mass_jpsi);
+ declareProperty("DxHypothesis", m_Dx_pid);
+ declareProperty("ApplyDxMassConstraint", m_constrDx);
+ declareProperty("ApplyJpsiMassConstraint", m_constrJpsi);
+ declareProperty("Chi2Cut", m_chi2cut);
+ declareProperty("RefitPV", m_refitPV = true);
+ declareProperty("MaxnPV", m_PV_max = 999);
+ declareProperty("MinNTracksInPV", m_PV_minNTracks = 0);
+ declareProperty("DoVertexType", m_DoVertexType = 7);
+ declareProperty("TrkVertexFitterTool", m_iVertexFitter);
+ declareProperty("PVRefitter", m_pvRefitter);
+ declareProperty("V0Tools", m_V0Tools);
+ declareProperty("CascadeTools", m_CascadeTools);
+ declareProperty("CascadeVertexCollections", m_cascadeOutputsKeys);
+ }
+
+ JpsiPlusDsCascade::~JpsiPlusDsCascade(){ }
+
+ StatusCode JpsiPlusDsCascade::performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer) const
+ {
+ ATH_MSG_DEBUG( "JpsiPlusDsCascade::performSearch" );
+ assert(cascadeinfoContainer!=nullptr);
+
+ // Get TrackParticle container (for setting links to the original tracks)
+ const xAOD::TrackParticleContainer *trackContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(trackContainer , "InDetTrackParticles" ));
+
+ // Get Jpsi container
+ const xAOD::VertexContainer *jpsiContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(jpsiContainer , m_vertexContainerKey ));
+
+ // Get V0 container
+ const xAOD::VertexContainer *dxContainer(nullptr);
+ ATH_CHECK(evtStore()->retrieve(dxContainer , m_vertexDxContainerKey ));
+
+
+
+ double mass_d = m_vtx1MassHypo;
+ std::vector<const xAOD::TrackParticle*> tracksJpsi;
+ std::vector<const xAOD::TrackParticle*> tracksDx;
+ std::vector<const xAOD::TrackParticle*> tracksBc;
+ std::vector<double> massesJpsi;
+ massesJpsi.push_back(m_vtx0Daug1MassHypo);
+ massesJpsi.push_back(m_vtx0Daug2MassHypo);
+ std::vector<double> massesDx;
+ massesDx.push_back(m_vtx1Daug1MassHypo);
+ massesDx.push_back(m_vtx1Daug2MassHypo);
+ massesDx.push_back(m_vtx1Daug3MassHypo);
+ std::vector<double> massesDm; // Alter the order of masses for D-
+ massesDm.push_back(m_vtx1Daug2MassHypo);
+ massesDm.push_back(m_vtx1Daug1MassHypo);
+ massesDm.push_back(m_vtx1Daug3MassHypo);
+ std::vector<double> Masses;
+ Masses.push_back(m_vtx0Daug1MassHypo);
+ Masses.push_back(m_vtx0Daug2MassHypo);
+ Masses.push_back(m_vtx1MassHypo);
+
+ // Select the J/psi candidates before calling cascade fit
+ std::vector<const xAOD::Vertex*> selectedJpsiCandidates;
+ for(auto vxcItr=jpsiContainer->cbegin(); vxcItr!=jpsiContainer->cend(); ++vxcItr) {
+
+ // Check the passed flag first
+ const xAOD::Vertex* vtx = *vxcItr;
+ SG::AuxElement::Accessor<Char_t> flagAcc1("passed_Jpsi");
+ if(flagAcc1.isAvailable(*vtx)){
+ if(!flagAcc1(*vtx)) continue;
+ }
+
+ // Check J/psi candidate invariant mass and skip if need be
+ double mass_Jpsi = m_V0Tools->invariantMass(*vxcItr, massesJpsi);
+ if (mass_Jpsi < m_jpsiMassLower || mass_Jpsi > m_jpsiMassUpper) {
+ ATH_MSG_DEBUG(" Original Jpsi candidate rejected by the mass cut: mass = "
+ << mass_Jpsi << " != (" << m_jpsiMassLower << ", " << m_jpsiMassUpper << ")" );
+ continue;
+ }
+ selectedJpsiCandidates.push_back(*vxcItr);
+ }
+ if(selectedJpsiCandidates.size()<1) return StatusCode::SUCCESS;
+
+ // Select the D_s+/D+ candidates before calling cascade fit
+ std::vector<const xAOD::Vertex*> selectedDxCandidates;
+ for(auto vxcItr=dxContainer->cbegin(); vxcItr!=dxContainer->cend(); ++vxcItr) {
+
+ // Check the passed flag first
+ const xAOD::Vertex* vtx = *vxcItr;
+ if(abs(m_Dx_pid)==431) { // D_s+/-
+ SG::AuxElement::Accessor<Char_t> flagAcc1("passed_Ds");
+ if(flagAcc1.isAvailable(*vtx)){
+ if(!flagAcc1(*vtx)) continue;
+ }
+ }
+
+ if(abs(m_Dx_pid==411)) { // D+/-
+ SG::AuxElement::Accessor<Char_t> flagAcc1("passed_Dp");
+ SG::AuxElement::Accessor<Char_t> flagAcc2("passed_Dm");
+ bool isDp(true);
+ bool isDm(true);
+ if(flagAcc1.isAvailable(*vtx)){
+ if(!flagAcc1(*vtx)) isDp = false;
+ }
+ if(flagAcc2.isAvailable(*vtx)){
+ if(!flagAcc2(*vtx)) isDm = false;
+ }
+ if(!(isDp||isDm)) continue;
+ }
+
+
+ // Ensure the total charge is correct
+ if(abs((*vxcItr)->trackParticle(0)->charge()+(*vxcItr)->trackParticle(1)->charge()+(*vxcItr)->trackParticle(2)->charge()) != 1){
+ ATH_MSG_DEBUG(" Original D+ candidate rejected by the charge requirement: "
+ << (*vxcItr)->trackParticle(0)->charge() << ", " << (*vxcItr)->trackParticle(1)->charge() << ", " << (*vxcItr)->trackParticle(2)->charge() );
+ continue;
+ }
+
+ // Check D_(s)+/- candidate invariant mass and skip if need be
+ double mass_D;
+ if(abs(m_Dx_pid)==411 && (*vxcItr)->trackParticle(2)->charge()<0) // D-
+ mass_D = m_V0Tools->invariantMass(*vxcItr,massesDm);
+ else // D+, D_s+/-
+ mass_D = m_V0Tools->invariantMass(*vxcItr,massesDx);
+ ATH_MSG_DEBUG("D_(s) mass " << mass_D);
+ if(mass_D < m_DxMassLower || mass_D > m_DxMassUpper) {
+ ATH_MSG_DEBUG(" Original D_(s) candidate rejected by the mass cut: mass = "
+ << mass_D << " != (" << m_DxMassLower << ", " << m_DxMassUpper << ")" );
+ continue;
+ }
+
+ // Add loose cut on K+k- mass for D_s->phi pi
+ if(m_Dx_pid==431){
+ TLorentzVector p4Kp_in, p4Km_in;
+ p4Kp_in.SetPtEtaPhiM( (*vxcItr)->trackParticle(0)->pt(),
+ (*vxcItr)->trackParticle(0)->eta(),
+ (*vxcItr)->trackParticle(0)->phi(), m_vtx1Daug1MassHypo);
+ p4Km_in.SetPtEtaPhiM( (*vxcItr)->trackParticle(1)->pt(),
+ (*vxcItr)->trackParticle(1)->eta(),
+ (*vxcItr)->trackParticle(1)->phi(), m_vtx1Daug2MassHypo);
+ double mass_phi = (p4Kp_in + p4Km_in).M();
+ ATH_MSG_DEBUG("phi mass " << mass_phi);
+ if(mass_phi > 1200) {
+ ATH_MSG_DEBUG(" Original phi candidate rejected by the mass cut: mass = " << mass_phi );
+ continue;
+ }
+ }
+ selectedDxCandidates.push_back(*vxcItr);
+ }
+ if(selectedDxCandidates.size()<1) return StatusCode::SUCCESS;
+
+ // Select J/psi D_(s)+ candidates
+ // Iterate over Jpsi vertices
+ for(auto jpsiItr=selectedJpsiCandidates.cbegin(); jpsiItr!=selectedJpsiCandidates.cend(); ++jpsiItr) {
+
+ size_t jpsiTrkNum = (*jpsiItr)->nTrackParticles();
+ tracksJpsi.clear();
+ for( unsigned int it=0; it<jpsiTrkNum; it++) tracksJpsi.push_back((*jpsiItr)->trackParticle(it));
+
+ if (tracksJpsi.size() != 2 || massesJpsi.size() != 2 ) {
+ ATH_MSG_INFO("problems with Jpsi input");
+ }
+
+ // Iterate over D_(s)+/- vertices
+ for(auto dxItr=selectedDxCandidates.cbegin(); dxItr!=selectedDxCandidates.cend(); ++dxItr) {
+
+ // Check identical tracks in input
+ if(std::find(tracksJpsi.cbegin(), tracksJpsi.cend(), (*dxItr)->trackParticle(0)) != tracksJpsi.cend()) continue;
+ if(std::find(tracksJpsi.cbegin(), tracksJpsi.cend(), (*dxItr)->trackParticle(1)) != tracksJpsi.cend()) continue;
+ if(std::find(tracksJpsi.cbegin(), tracksJpsi.cend(), (*dxItr)->trackParticle(2)) != tracksJpsi.cend()) continue;
+
+ size_t dxTrkNum = (*dxItr)->nTrackParticles();
+ tracksDx.clear();
+ for( unsigned int it=0; it<dxTrkNum; it++) tracksDx.push_back((*dxItr)->trackParticle(it));
+ if (tracksDx.size() != 3 || massesDx.size() != 3 ) {
+ ATH_MSG_INFO("problems with D_(s) input");
+ }
+
+ ATH_MSG_DEBUG("using tracks" << tracksJpsi[0] << ", " << tracksJpsi[1] << ", " << tracksDx[0] << ", " << tracksDx[1] << ", " << tracksDx[2]);
+ tracksBc.clear();
+ for( unsigned int it=0; it<jpsiTrkNum; it++) tracksBc.push_back((*jpsiItr)->trackParticle(it));
+ for( unsigned int it=0; it<dxTrkNum; it++) tracksBc.push_back((*dxItr)->trackParticle(it));
+
+ // Apply the user's settings to the fitter
+ // Reset
+ std::unique_ptr<Trk::IVKalState> state (m_iVertexFitter->makeState());
+ // Robustness
+ int robustness = 0;
+ m_iVertexFitter->setRobustness(robustness, *state);
+ // Build up the topology
+ // Vertex list
+ std::vector<Trk::VertexID> vrtList;
+ // D_(s)+/- vertex
+ Trk::VertexID vID;
+ if (m_constrDx) {
+ if(abs(m_Dx_pid)==411 && (*dxItr)->trackParticle(2)->charge()<0) // D-
+ vID = m_iVertexFitter->startVertex(tracksDx,massesDm,*state,mass_d);
+ else // D+, D_s+/-
+ vID = m_iVertexFitter->startVertex(tracksDx,massesDx,*state,mass_d);
+ } else {
+ if(abs(m_Dx_pid)==411 && (*dxItr)->trackParticle(2)->charge()<0) // D-
+ vID = m_iVertexFitter->startVertex(tracksDx,massesDm,*state);
+ else // D+, D_s+/-
+ vID = m_iVertexFitter->startVertex(tracksDx,massesDx,*state);
+ }
+ vrtList.push_back(vID);
+ // B vertex including Jpsi
+ Trk::VertexID vID2 = m_iVertexFitter->nextVertex(tracksJpsi,massesJpsi,vrtList,*state);
+ if (m_constrJpsi) {
+ std::vector<Trk::VertexID> cnstV;
+ cnstV.clear();
+ if ( !m_iVertexFitter->addMassConstraint(vID2,tracksJpsi,cnstV,*state,m_mass_jpsi).isSuccess() ) {
+ ATH_MSG_WARNING("addMassConstraint failed");
+ //return StatusCode::FAILURE;
+ }
+ }
+ // Do the work
+ std::unique_ptr<Trk::VxCascadeInfo> result(m_iVertexFitter->fitCascade(*state));
+
+ if (result != nullptr) {
+ // reset links to original tracks
+ BPhysPVCascadeTools::PrepareVertexLinks(result.get(), trackContainer);
+ ATH_MSG_DEBUG("storing tracks " << ((result->vertices())[0])->trackParticle(0) << ", "
+ << ((result->vertices())[0])->trackParticle(1) << ", "
+ << ((result->vertices())[0])->trackParticle(2) << ", "
+ << ((result->vertices())[1])->trackParticle(0) << ", "
+ << ((result->vertices())[1])->trackParticle(1));
+ // necessary to prevent memory leak
+ result->setSVOwnership(true);
+
+ // Chi2/DOF cut
+ double bChi2DOF = result->fitChi2()/result->nDoF();
+ ATH_MSG_DEBUG("Candidate chi2/DOF is " << bChi2DOF);
+ bool chi2CutPassed = (m_chi2cut <= 0.0 || bChi2DOF < m_chi2cut);
+
+ const std::vector< std::vector<TLorentzVector> > &moms = result->getParticleMoms();
+ double mass = m_CascadeTools->invariantMass(moms[1]);
+ if(chi2CutPassed) {
+ if (mass >= m_MassLower && mass <= m_MassUpper) {
+ cascadeinfoContainer->push_back(result.release());
+ } else {
+ ATH_MSG_DEBUG("Candidate rejected by the mass cut: mass = "
+ << mass << " != (" << m_MassLower << ", " << m_MassUpper << ")" );
+ }
+ }
+ }
+
+ } //Iterate over D_(s)+ vertices
+
+ } //Iterate over Jpsi vertices
+
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer->size());
+
+ return StatusCode::SUCCESS;
+ }
+
+}
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusV0Cascade.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusV0Cascade.cxx
new file mode 100644
index 00000000000..6f66478553a
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/JpsiPlusV0Cascade.cxx
@@ -0,0 +1,576 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+/////////////////////////////////////////////////////////////////
+// JpsiPlusV0Cascade.cxx, (c) ATLAS Detector software
+/////////////////////////////////////////////////////////////////
+#include "DerivationFrameworkBPhys/JpsiPlusV0Cascade.h"
+#include "TrkVertexFitterInterfaces/IVertexFitter.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "GaudiKernel/IPartPropSvc.h"
+#include "DerivationFrameworkBPhys/CascadeTools.h"
+#include "DerivationFrameworkBPhys/BPhysPVCascadeTools.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include <algorithm>
+#include "xAODTracking/VertexContainer.h"
+#include "DerivationFrameworkBPhys/LocalVector.h"
+#include "HepPDT/ParticleDataTable.hh"
+
+namespace DerivationFramework {
+ typedef ElementLink<xAOD::VertexContainer> VertexLink;
+ typedef std::vector<VertexLink> VertexLinkVector;
+ typedef std::vector<const xAOD::TrackParticle*> TrackBag;
+
+
+ StatusCode JpsiPlusV0Cascade::initialize() {
+
+ // retrieving vertex Fitter
+ if ( m_iVertexFitter.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_iVertexFitter);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Retrieved tool " << m_iVertexFitter);
+ }
+
+ // retrieving the V0 tools
+ if ( m_V0Tools.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_V0Tools);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_INFO("Retrieved tool " << m_V0Tools);
+ }
+
+ // retrieving the Cascade tools
+ if ( m_CascadeTools.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_CascadeTools);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_INFO("Retrieved tool " << m_CascadeTools);
+ }
+
+ ATH_CHECK(m_beamSpotKey.initialize());
+
+ IPartPropSvc* partPropSvc = 0;
+ StatusCode sc = service("PartPropSvc", partPropSvc, true);
+ if (sc.isFailure()) {
+ msg(MSG::ERROR) << "Could not initialize Particle Properties Service" << endmsg;
+ return StatusCode::FAILURE;
+ }
+ const HepPDT::ParticleDataTable* pdt = partPropSvc->PDT();
+
+ // retrieve particle masses
+ m_mass_muon = BPhysPVCascadeTools::getParticleMass(pdt, PDG::mu_minus);
+ m_mass_pion = BPhysPVCascadeTools::getParticleMass(pdt, PDG::pi_plus);
+ m_mass_proton = BPhysPVCascadeTools::getParticleMass(pdt, PDG::p_plus);
+ m_mass_lambda = BPhysPVCascadeTools::getParticleMass(pdt, PDG::Lambda0);
+ m_mass_ks = BPhysPVCascadeTools::getParticleMass(pdt, PDG::K_S0);
+ m_mass_jpsi = BPhysPVCascadeTools::getParticleMass(pdt, PDG::J_psi);
+ m_mass_b0 = BPhysPVCascadeTools::getParticleMass(pdt, PDG::B0);
+ m_mass_lambdaB = BPhysPVCascadeTools::getParticleMass(pdt, PDG::Lambda_b0);
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ StatusCode JpsiPlusV0Cascade::addBranches() const
+ {
+ std::vector<Trk::VxCascadeInfo*> cascadeinfoContainer;
+ constexpr int topoN = 2;
+ std::array<xAOD::VertexContainer*, topoN> Vtxwritehandles;
+ std::array<xAOD::VertexAuxContainer*, topoN> Vtxwritehandlesaux;
+ if(m_cascadeOutputsKeys.size() !=topoN) { ATH_MSG_FATAL("Incorrect number of VtxContainers"); return StatusCode::FAILURE; }
+
+ for(int i =0; i<topoN;i++){
+ Vtxwritehandles[i] = new xAOD::VertexContainer();
+ Vtxwritehandlesaux[i] = new xAOD::VertexAuxContainer();
+ Vtxwritehandles[i]->setStore(Vtxwritehandlesaux[i]);
+ CHECK(evtStore()->record(Vtxwritehandles[i] , m_cascadeOutputsKeys[i] ));
+ CHECK(evtStore()->record(Vtxwritehandlesaux[i], m_cascadeOutputsKeys[i] + "Aux."));
+ }
+
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+ const xAOD::Vertex * primaryVertex(nullptr);
+ const xAOD::VertexContainer *pvContainer(nullptr);
+ CHECK(evtStore()->retrieve(pvContainer, m_VxPrimaryCandidateName));
+ ATH_MSG_DEBUG("Found " << m_VxPrimaryCandidateName << " in StoreGate!");
+
+ if (pvContainer->size()==0){
+ ATH_MSG_WARNING("You have no primary vertices: " << pvContainer->size());
+ return StatusCode::RECOVERABLE;
+ } else {
+ primaryVertex = (*pvContainer)[0];
+ }
+
+ //----------------------------------------------------
+ // Try to retrieve refitted primary vertices
+ //----------------------------------------------------
+ xAOD::VertexContainer* refPvContainer = NULL;
+ xAOD::VertexAuxContainer* refPvAuxContainer = NULL;
+ if (m_refitPV) {
+ if (evtStore()->contains<xAOD::VertexContainer>(m_refPVContainerName)) {
+ // refitted PV container exists. Get it from the store gate
+ CHECK(evtStore()->retrieve(refPvContainer , m_refPVContainerName ));
+ CHECK(evtStore()->retrieve(refPvAuxContainer, m_refPVContainerName + "Aux."));
+ } else {
+ // refitted PV container does not exist. Create a new one.
+ refPvContainer = new xAOD::VertexContainer;
+ refPvAuxContainer = new xAOD::VertexAuxContainer;
+ refPvContainer->setStore(refPvAuxContainer);
+ CHECK(evtStore()->record(refPvContainer , m_refPVContainerName));
+ CHECK(evtStore()->record(refPvAuxContainer, m_refPVContainerName+"Aux."));
+ }
+ }
+
+ ATH_CHECK(performSearch(&cascadeinfoContainer));
+
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVCascadeTools helper(&(*m_CascadeTools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(m_PV_minNTracks);
+
+ // Decorators for the main vertex: chi2, ndf, pt and pt error, plus the V0 vertex variables
+ SG::AuxElement::Decorator<VertexLinkVector> CascadeLinksDecor("CascadeVertexLinks");
+ SG::AuxElement::Decorator<VertexLinkVector> JpsiLinksDecor("JpsiVertexLinks");
+ SG::AuxElement::Decorator<VertexLinkVector> V0LinksDecor("V0VertexLinks");
+ SG::AuxElement::Decorator<float> chi2_decor("ChiSquared");
+ SG::AuxElement::Decorator<float> ndof_decor("NumberDoF");
+ SG::AuxElement::Decorator<float> Pt_decor("Pt");
+ SG::AuxElement::Decorator<float> PtErr_decor("PtErr");
+ SG::AuxElement::Decorator<float> Mass_svdecor("V0_mass");
+ SG::AuxElement::Decorator<float> MassErr_svdecor("V0_massErr");
+ SG::AuxElement::Decorator<float> Pt_svdecor("V0_Pt");
+ SG::AuxElement::Decorator<float> PtErr_svdecor("V0_PtErr");
+ SG::AuxElement::Decorator<float> Lxy_svdecor("V0_Lxy");
+ SG::AuxElement::Decorator<float> LxyErr_svdecor("V0_LxyErr");
+ SG::AuxElement::Decorator<float> Tau_svdecor("V0_Tau");
+ SG::AuxElement::Decorator<float> TauErr_svdecor("V0_TauErr");
+
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer.size());
+
+ // Get Jpsi container and identify the input Jpsi
+ const xAOD::VertexContainer *jpsiContainer(nullptr);
+ CHECK(evtStore()->retrieve(jpsiContainer , m_vertexContainerKey ));
+ const xAOD::VertexContainer *v0Container(nullptr);
+ CHECK(evtStore()->retrieve(v0Container , m_vertexV0ContainerKey ));
+
+ for (Trk::VxCascadeInfo* x : cascadeinfoContainer) {
+ if(x==nullptr) ATH_MSG_ERROR("cascadeinfoContainer is null");
+
+ // the cascade fitter returns:
+ // std::vector<xAOD::Vertex*>, each xAOD::Vertex contains the refitted track parameters (perigee at the vertex position)
+ // vertices[iv] the links to the original TPs and a covariance of size 3+5*NTRK; the chi2 of the total fit
+ // is split between the cascade vertices as per track contribution
+ // std::vector< std::vector<TLorentzVector> >, each std::vector<TLorentzVector> contains the refitted momenta (TLorentzVector)
+ // momenta[iv][...] of all tracks in the corresponding vertex, including any pseudotracks (from cascade vertices)
+ // originating in this vertex; the masses are as assigned in the cascade fit
+ // std::vector<Amg::MatrixX>, the corresponding covariance matrices in momentum space
+ // covariance[iv]
+ // int nDoF, double Chi2
+ //
+ // the invariant mass, pt, lifetime etc. errors should be calculated using the covariance matrices in momentum space as these
+ // take into account the full track-track and track-vertex correlations
+ //
+ // in the case of Jpsi+V0: vertices[0] is the V0 vertex, vertices[1] is the B/Lambda_b(bar) vertex, containing the 2 Jpsi tracks.
+ // The covariance terms between the two vertices are not stored. In momentum space momenta[0] contains the 2 V0 tracks,
+ // their momenta add up to the momentum of the 3rd track in momenta[1], the first two being the Jpsi tracks
+
+ const std::vector<xAOD::Vertex*> &cascadeVertices = x->vertices();
+ if(cascadeVertices.size()!=topoN)
+ ATH_MSG_ERROR("Incorrect number of vertices");
+ if(cascadeVertices[0] == nullptr || cascadeVertices[1] == nullptr) ATH_MSG_ERROR("Error null vertex");
+ // Keep vertices (bear in mind that they come in reverse order!)
+ for(int i =0;i<topoN;i++) Vtxwritehandles[i]->push_back(cascadeVertices[i]);
+
+ x->setSVOwnership(false); // Prevent Container from deleting vertices
+ const auto mainVertex = cascadeVertices[1]; // this is the Bd (Bd, Lambda_b, Lambda_bbar) vertex
+ //const auto v0Vertex = cascadeVertices[0]; // this is the V0 (Kshort, Lambda, Lambdabar) vertex
+ const std::vector< std::vector<TLorentzVector> > &moms = x->getParticleMoms();
+
+ // Set links to cascade vertices
+ std::vector<const xAOD::Vertex*> verticestoLink;
+ verticestoLink.push_back(cascadeVertices[0]);
+ if(Vtxwritehandles[1] == nullptr) ATH_MSG_ERROR("Vtxwritehandles[1] is null");
+ if(!BPhysPVCascadeTools::LinkVertices(CascadeLinksDecor, verticestoLink, Vtxwritehandles[0], cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with cascade vertices");
+
+ // Identify the input Jpsi
+ const xAOD::Vertex* jpsiVertex = BPhysPVCascadeTools::FindVertex<2>(jpsiContainer, cascadeVertices[1]);
+ ATH_MSG_DEBUG("1 pt Jpsi tracks " << cascadeVertices[1]->trackParticle(0)->pt() << ", " << cascadeVertices[1]->trackParticle(1)->pt());
+ if (jpsiVertex) ATH_MSG_DEBUG("2 pt Jpsi tracks " << jpsiVertex->trackParticle(0)->pt() << ", " << jpsiVertex->trackParticle(1)->pt());
+
+ // Identify the input V0
+ const xAOD::Vertex* v0Vertex = BPhysPVCascadeTools::FindVertex<2>(v0Container, cascadeVertices[0]);;
+ ATH_MSG_DEBUG("1 pt V0 tracks " << cascadeVertices[0]->trackParticle(0)->pt() << ", " << cascadeVertices[0]->trackParticle(1)->pt());
+ if (v0Vertex) ATH_MSG_DEBUG("2 pt V0 tracks " << v0Vertex->trackParticle(0)->pt() << ", " << v0Vertex->trackParticle(1)->pt());
+
+ // Set links to input vertices
+ std::vector<const xAOD::Vertex*> jpsiVerticestoLink;
+ if (jpsiVertex) jpsiVerticestoLink.push_back(jpsiVertex);
+ else ATH_MSG_WARNING("Could not find linking Jpsi");
+ if(!BPhysPVCascadeTools::LinkVertices(JpsiLinksDecor, jpsiVerticestoLink, jpsiContainer, cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with Jpsi vertices");
+
+ std::vector<const xAOD::Vertex*> v0VerticestoLink;
+ if (v0Vertex) v0VerticestoLink.push_back(v0Vertex);
+ else ATH_MSG_WARNING("Could not find linking V0");
+ if(!BPhysPVCascadeTools::LinkVertices(V0LinksDecor, v0VerticestoLink, v0Container, cascadeVertices[1]))
+ ATH_MSG_ERROR("Error decorating with V0 vertices");
+
+ double mass_v0 = m_mass_ks;
+ double mass_b = m_mass_b0;
+ std::vector<double> massesJpsi(2, m_mass_muon);
+ std::vector<double> massesV0;
+ std::vector<double> Masses(2, m_mass_muon);
+ if (m_v0_pid == 310) {
+ massesV0.push_back(m_mass_pion);
+ massesV0.push_back(m_mass_pion);
+ Masses.push_back(m_mass_ks);
+ } else if (m_v0_pid == 3122) {
+ massesV0.push_back(m_mass_proton);
+ massesV0.push_back(m_mass_pion);
+ Masses.push_back(m_mass_lambda);
+ mass_v0 = m_mass_lambda;
+ mass_b = m_mass_lambdaB;
+ } else if (m_v0_pid == -3122) {
+ massesV0.push_back(m_mass_pion);
+ massesV0.push_back(m_mass_proton);
+ Masses.push_back(m_mass_lambda);
+ mass_v0 = m_mass_lambda;
+ mass_b = m_mass_lambdaB;
+ }
+
+ // loop over candidates -- Don't apply PV_minNTracks requirement here
+ // because it may result in exclusion of the high-pt PV.
+ // get good PVs
+
+ xAOD::BPhysHypoHelper vtx(m_hypoName, mainVertex);
+
+ BPhysPVCascadeTools::SetVectorInfo(vtx, x);
+
+
+ // Decorate main vertex
+ //
+ // 1.a) mass, mass error
+ BPHYS_CHECK( vtx.setMass(m_CascadeTools->invariantMass(moms[1])) );
+ BPHYS_CHECK( vtx.setMassErr(m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1])) );
+ // 1.b) pt and pT error (the default pt of mainVertex is != the pt of the full cascade fit!)
+ Pt_decor(*mainVertex) = m_CascadeTools->pT(moms[1]);
+ PtErr_decor(*mainVertex) = m_CascadeTools->pTError(moms[1],x->getCovariance()[1]);
+ // 1.c) chi2 and ndof (the default chi2 of mainVertex is != the chi2 of the full cascade fit!)
+ chi2_decor(*mainVertex) = x->fitChi2();
+ ndof_decor(*mainVertex) = x->nDoF();
+
+ ATH_CHECK(helper.FillCandwithRefittedVertices(m_refitPV, pvContainer,
+ refPvContainer, &(*m_pvRefitter), m_PV_max, m_DoVertexType, x, 1, mass_b, vtx));
+
+ // 4) decorate the main vertex with V0 vertex mass, pt, lifetime and lxy values (plus errors)
+ // V0 points to the main vertex, so lifetime and lxy are w.r.t the main vertex
+ Mass_svdecor(*mainVertex) = m_CascadeTools->invariantMass(moms[0]);
+ MassErr_svdecor(*mainVertex) = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ Pt_svdecor(*mainVertex) = m_CascadeTools->pT(moms[0]);
+ PtErr_svdecor(*mainVertex) = m_CascadeTools->pTError(moms[0],x->getCovariance()[0]);
+ Lxy_svdecor(*mainVertex) = m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]);
+ LxyErr_svdecor(*mainVertex) = m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1]);
+ Tau_svdecor(*mainVertex) = m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1]);
+ TauErr_svdecor(*mainVertex) = m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1]);
+
+ // Some checks in DEBUG mode
+ ATH_MSG_DEBUG("chi2 " << x->fitChi2()
+ << " chi2_1 " << m_V0Tools->chisq(cascadeVertices[0])
+ << " chi2_2 " << m_V0Tools->chisq(cascadeVertices[1])
+ << " vprob " << m_CascadeTools->vertexProbability(x->nDoF(),x->fitChi2()));
+ ATH_MSG_DEBUG("ndf " << x->nDoF() << " ndf_1 " << m_V0Tools->ndof(cascadeVertices[0]) << " ndf_2 " << m_V0Tools->ndof(cascadeVertices[1]));
+ ATH_MSG_DEBUG("V0Tools mass_v0 " << m_V0Tools->invariantMass(cascadeVertices[0],massesV0)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[0],massesV0)
+ << " mass_J " << m_V0Tools->invariantMass(cascadeVertices[1],massesJpsi)
+ << " error " << m_V0Tools->invariantMassError(cascadeVertices[1],massesJpsi));
+ // masses and errors, using track masses assigned in the fit
+ double Mass_B = m_CascadeTools->invariantMass(moms[1]);
+ double Mass_V0 = m_CascadeTools->invariantMass(moms[0]);
+ double Mass_B_err = m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1]);
+ double Mass_V0_err = m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0]);
+ ATH_MSG_DEBUG("Mass_B " << Mass_B << " Mass_V0 " << Mass_V0);
+ ATH_MSG_DEBUG("Mass_B_err " << Mass_B_err << " Mass_V0_err " << Mass_V0_err);
+ double mprob_B = m_CascadeTools->massProbability(mass_b,Mass_B,Mass_B_err);
+ double mprob_V0 = m_CascadeTools->massProbability(mass_v0,Mass_V0,Mass_V0_err);
+ ATH_MSG_DEBUG("mprob_B " << mprob_B << " mprob_V0 " << mprob_V0);
+ // masses and errors, assigning user defined track masses
+ ATH_MSG_DEBUG("Mass_b " << m_CascadeTools->invariantMass(moms[1],Masses)
+ << " Mass_v0 " << m_CascadeTools->invariantMass(moms[0],massesV0));
+ ATH_MSG_DEBUG("Mass_b_err " << m_CascadeTools->invariantMassError(moms[1],x->getCovariance()[1],Masses)
+ << " Mass_v0_err " << m_CascadeTools->invariantMassError(moms[0],x->getCovariance()[0],massesV0));
+ ATH_MSG_DEBUG("pt_b " << m_CascadeTools->pT(moms[1])
+ << " pt_v " << m_CascadeTools->pT(moms[0])
+ << " pt_v0 " << m_V0Tools->pT(cascadeVertices[0]));
+ ATH_MSG_DEBUG("ptErr_b " << m_CascadeTools->pTError(moms[1],x->getCovariance()[1])
+ << " ptErr_v " << m_CascadeTools->pTError(moms[0],x->getCovariance()[0])
+ << " ptErr_v0 " << m_V0Tools->pTError(cascadeVertices[0]));
+ ATH_MSG_DEBUG("lxy_B " << m_V0Tools->lxy(cascadeVertices[1],primaryVertex) << " lxy_V " << m_V0Tools->lxy(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("lxy_b " << m_CascadeTools->lxy(moms[1],cascadeVertices[1],primaryVertex) << " lxy_v " << m_CascadeTools->lxy(moms[0],cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("lxyErr_b " << m_CascadeTools->lxyError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << " lxyErr_v " << m_CascadeTools->lxyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << " lxyErr_v0 " << m_V0Tools->lxyError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("tau_B " << m_CascadeTools->tau(moms[1],cascadeVertices[1],primaryVertex,mass_b)
+ << " tau_v0 " << m_V0Tools->tau(cascadeVertices[0],cascadeVertices[1],massesV0));
+ ATH_MSG_DEBUG("tau_b " << m_CascadeTools->tau(moms[1],cascadeVertices[1],primaryVertex)
+ << " tau_v " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << " tau_V " << m_CascadeTools->tau(moms[0],cascadeVertices[0],cascadeVertices[1],mass_v0));
+ ATH_MSG_DEBUG("tauErr_b " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << " tauErr_v " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << " tauErr_v0 " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[1],massesV0));
+ ATH_MSG_DEBUG("TauErr_b " << m_CascadeTools->tauError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex,mass_b)
+ << " TauErr_v " << m_CascadeTools->tauError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1],mass_v0)
+ << " TauErr_v0 " << m_V0Tools->tauError(cascadeVertices[0],cascadeVertices[1],massesV0,mass_v0));
+
+ ATH_MSG_DEBUG("CascadeTools main vert wrt PV " << " CascadeTools SV " << " V0Tools SV");
+ ATH_MSG_DEBUG("a0z " << m_CascadeTools->a0z(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0z(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0z(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0zErr " << m_CascadeTools->a0zError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0zError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0zError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0xy " << m_CascadeTools->a0xy(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0xy(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0xy(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0xyErr " << m_CascadeTools->a0xyError(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0xyError(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0xyError(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0 " << m_CascadeTools->a0(moms[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0(moms[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("a0Err " << m_CascadeTools->a0Error(moms[1],x->getCovariance()[1],cascadeVertices[1],primaryVertex)
+ << ", " << m_CascadeTools->a0Error(moms[0],x->getCovariance()[0],cascadeVertices[0],cascadeVertices[1])
+ << ", " << m_V0Tools->a0Error(cascadeVertices[0],cascadeVertices[1]));
+ ATH_MSG_DEBUG("x0 " << m_V0Tools->vtx(cascadeVertices[0]).x() << " y0 " << m_V0Tools->vtx(cascadeVertices[0]).y() << " z0 " << m_V0Tools->vtx(cascadeVertices[0]).z());
+ ATH_MSG_DEBUG("x1 " << m_V0Tools->vtx(cascadeVertices[1]).x() << " y1 " << m_V0Tools->vtx(cascadeVertices[1]).y() << " z1 " << m_V0Tools->vtx(cascadeVertices[1]).z());
+ ATH_MSG_DEBUG("X0 " << primaryVertex->x() << " Y0 " << primaryVertex->y() << " Z0 " << primaryVertex->z());
+ ATH_MSG_DEBUG("rxy0 " << m_V0Tools->rxy(cascadeVertices[0]) << " rxyErr0 " << m_V0Tools->rxyError(cascadeVertices[0]));
+ ATH_MSG_DEBUG("rxy1 " << m_V0Tools->rxy(cascadeVertices[1]) << " rxyErr1 " << m_V0Tools->rxyError(cascadeVertices[1]));
+ ATH_MSG_DEBUG("Rxy0 wrt PV " << m_V0Tools->rxy(cascadeVertices[0],primaryVertex) << " RxyErr0 wrt PV " << m_V0Tools->rxyError(cascadeVertices[0],primaryVertex));
+ ATH_MSG_DEBUG("Rxy1 wrt PV " << m_V0Tools->rxy(cascadeVertices[1],primaryVertex) << " RxyErr1 wrt PV " << m_V0Tools->rxyError(cascadeVertices[1],primaryVertex));
+ ATH_MSG_DEBUG("number of covariance matrices " << (x->getCovariance()).size());
+ //const Amg::MatrixX& cov30 = (cascadeVertices[0])->covariancePosition();
+ //const Amg::MatrixX& cov31 = (cascadeVertices[1])->covariancePosition();
+ //ATH_MSG_DEBUG("cov30 " << cov30);
+ //ATH_MSG_DEBUG("cov31 " << cov31);
+
+
+ } // loop over cascadeinfoContainer
+
+ // Deleting cascadeinfo since this won't be stored.
+ // Vertices have been kept in m_cascadeOutputs and should be owned by their container
+ for (auto x : cascadeinfoContainer) delete x;
+
+ return StatusCode::SUCCESS;
+ }
+
+
+ JpsiPlusV0Cascade::JpsiPlusV0Cascade(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
+ m_vertexContainerKey(""),
+ m_vertexV0ContainerKey(""),
+ m_cascadeOutputsKeys{ "JpsiPlusV0CascadeVtx1", "JpsiPlusV0CascadeVtx2" },
+ m_VxPrimaryCandidateName("PrimaryVertices"),
+ m_jpsiMassLower(0.0),
+ m_jpsiMassUpper(10000.0),
+ m_V0MassLower(0.0),
+ m_V0MassUpper(10000.0),
+ m_MassLower(0.0),
+ m_MassUpper(20000.0),
+ m_mass_muon ( 0 ),
+ m_mass_pion ( 0 ),
+ m_mass_proton ( 0 ),
+ m_mass_lambda ( 0 ),
+ m_mass_ks ( 0 ),
+ m_mass_jpsi ( 0 ),
+ m_mass_b0 ( 0 ),
+ m_mass_lambdaB( 0 ),
+ m_v0_pid(310),
+ m_constrV0(true),
+ m_constrJpsi(true),
+ m_iVertexFitter("Trk::TrkVKalVrtFitter"),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter"),
+ m_V0Tools("Trk::V0Tools"),
+ m_CascadeTools("DerivationFramework::CascadeTools")
+ {
+ declareProperty("JpsiVertices", m_vertexContainerKey);
+ declareProperty("V0Vertices", m_vertexV0ContainerKey);
+ declareProperty("VxPrimaryCandidateName", m_VxPrimaryCandidateName);
+ declareProperty("RefPVContainerName", m_refPVContainerName = "RefittedPrimaryVertices");
+ declareProperty("JpsiMassLowerCut", m_jpsiMassLower);
+ declareProperty("JpsiMassUpperCut", m_jpsiMassUpper);
+ declareProperty("V0MassLowerCut", m_V0MassLower);
+ declareProperty("V0MassUpperCut", m_V0MassUpper);
+ declareProperty("MassLowerCut", m_MassLower);
+ declareProperty("MassUpperCut", m_MassUpper);
+ declareProperty("HypothesisName", m_hypoName = "Bd");
+ declareProperty("V0Hypothesis", m_v0_pid);
+ declareProperty("ApplyV0MassConstraint", m_constrV0);
+ declareProperty("ApplyJpsiMassConstraint", m_constrJpsi);
+ declareProperty("RefitPV", m_refitPV = true);
+ declareProperty("MaxnPV", m_PV_max = 999);
+ declareProperty("MinNTracksInPV", m_PV_minNTracks = 0);
+ declareProperty("DoVertexType", m_DoVertexType = 7);
+ declareProperty("TrkVertexFitterTool", m_iVertexFitter);
+ declareProperty("PVRefitter", m_pvRefitter);
+ declareProperty("V0Tools", m_V0Tools);
+ declareProperty("CascadeTools", m_CascadeTools);
+ declareProperty("CascadeVertexCollections", m_cascadeOutputsKeys);
+ }
+
+ JpsiPlusV0Cascade::~JpsiPlusV0Cascade(){ }
+
+ StatusCode JpsiPlusV0Cascade::performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer) const
+ {
+ ATH_MSG_DEBUG( "JpsiPlusV0Cascade::performSearch" );
+ assert(cascadeinfoContainer!=nullptr);
+
+ // Get TrackParticle container (for setting links to the original tracks)
+ const xAOD::TrackParticleContainer *trackContainer(nullptr);
+ CHECK(evtStore()->retrieve(trackContainer , "InDetTrackParticles" ));
+
+ // Get Jpsi container
+ const xAOD::VertexContainer *jpsiContainer(nullptr);
+ CHECK(evtStore()->retrieve(jpsiContainer , m_vertexContainerKey ));
+
+ // Get V0 container
+ const xAOD::VertexContainer *v0Container(nullptr);
+ CHECK(evtStore()->retrieve(v0Container , m_vertexV0ContainerKey ));
+
+ double mass_v0 = m_mass_ks;
+ std::vector<const xAOD::TrackParticle*> tracksJpsi;
+ std::vector<const xAOD::TrackParticle*> tracksV0;
+ std::vector<double> massesJpsi(2, m_mass_muon);
+ std::vector<double> massesV0;
+ std::vector<double> Masses(2, m_mass_muon);
+ if (m_v0_pid == 310) {
+ massesV0.push_back(m_mass_pion);
+ massesV0.push_back(m_mass_pion);
+ Masses.push_back(m_mass_ks);
+ } else if (m_v0_pid == 3122) {
+ massesV0.push_back(m_mass_proton);
+ massesV0.push_back(m_mass_pion);
+ mass_v0 = m_mass_lambda;
+ Masses.push_back(m_mass_lambda);
+ } else if (m_v0_pid == -3122) {
+ massesV0.push_back(m_mass_pion);
+ massesV0.push_back(m_mass_proton);
+ mass_v0 = m_mass_lambda;
+ Masses.push_back(m_mass_lambda);
+ }
+
+ for(auto jpsi : *jpsiContainer) { //Iterate over Jpsi vertices
+
+ size_t jpsiTrkNum = jpsi->nTrackParticles();
+ tracksJpsi.clear();
+ for( unsigned int it=0; it<jpsiTrkNum; it++) tracksJpsi.push_back(jpsi->trackParticle(it));
+
+ if (tracksJpsi.size() != 2 || massesJpsi.size() != 2 ) {
+ ATH_MSG_INFO("problems with Jpsi input");
+ }
+ double mass_Jpsi = m_V0Tools->invariantMass(jpsi,massesJpsi);
+ ATH_MSG_DEBUG("Jpsi mass " << mass_Jpsi);
+ if (mass_Jpsi < m_jpsiMassLower || mass_Jpsi > m_jpsiMassUpper) {
+ ATH_MSG_DEBUG(" Original Jpsi candidate rejected by the mass cut: mass = "
+ << mass_Jpsi << " != (" << m_jpsiMassLower << ", " << m_jpsiMassUpper << ")" );
+ continue;
+ }
+
+ for(auto v0 : *v0Container) { //Iterate over V0 vertices
+
+ size_t v0TrkNum = v0->nTrackParticles();
+ tracksV0.clear();
+ for( unsigned int it=0; it<v0TrkNum; it++) tracksV0.push_back(v0->trackParticle(it));
+ if (tracksV0.size() != 2 || massesV0.size() != 2 ) {
+ ATH_MSG_INFO("problems with V0 input");
+ }
+ double mass_V0 = m_V0Tools->invariantMass(v0,massesV0);
+ ATH_MSG_DEBUG("V0 mass " << mass_V0);
+ if (mass_V0 < m_V0MassLower || mass_V0 > m_V0MassUpper) {
+ ATH_MSG_DEBUG(" Original V0 candidate rejected by the mass cut: mass = "
+ << mass_V0 << " != (" << m_V0MassLower << ", " << m_V0MassUpper << ")" );
+ continue;
+ }
+ ATH_MSG_DEBUG("using tracks" << tracksJpsi[0] << ", " << tracksJpsi[1] << ", " << tracksV0[0] << ", " << tracksV0[1]);
+ if(!BPhysPVCascadeTools::uniqueCollection(tracksJpsi, tracksV0)) continue;
+
+
+ //if (std::find(trackContainer->begin(), trackContainer->end(), tracksJpsi[0]) == trackContainer->end()) {
+ // ATH_MSG_ERROR("Track is not in standard container");
+ //} else {
+ // ATH_MSG_DEBUG("Track " << tracksJpsi[0] << " is at position " << std::distance(trackContainer->begin(), std::find(trackContainer->begin(), trackContainer->end(), tracksJpsi[0])) );
+ //}
+ //ATH_MSG_DEBUG("using tracks " << tracksJpsi[0] << ", " << tracksJpsi[1] << ", " << tracksV0[0] << ", " << tracksV0[1]);
+
+ // Apply the user's settings to the fitter
+ // Reset
+ std::unique_ptr<Trk::IVKalState> state = m_iVertexFitter->makeState();
+ // Robustness
+ int robustness = 0;
+ m_iVertexFitter->setRobustness(robustness, *state);
+ // Build up the topology
+ // Vertex list
+ std::vector<Trk::VertexID> vrtList;
+ // V0 vertex
+ Trk::VertexID vID;
+ if (m_constrV0) {
+ vID = m_iVertexFitter->startVertex(tracksV0,massesV0,*state, mass_v0);
+ } else {
+ vID = m_iVertexFitter->startVertex(tracksV0,massesV0, *state);
+ }
+ vrtList.push_back(vID);
+ // B vertex including Jpsi
+ Trk::VertexID vID2 = m_iVertexFitter->nextVertex(tracksJpsi,massesJpsi,vrtList, *state);
+ if (m_constrJpsi) {
+ std::vector<Trk::VertexID> cnstV;
+ cnstV.clear();
+ if ( !m_iVertexFitter->addMassConstraint(vID2,tracksJpsi,cnstV,*state, m_mass_jpsi).isSuccess() ) {
+ ATH_MSG_WARNING("addMassConstraint failed");
+ //return StatusCode::FAILURE;
+ }
+ }
+ // Do the work
+ std::unique_ptr<Trk::VxCascadeInfo> result(m_iVertexFitter->fitCascade(*state));
+
+ if (result != NULL) {
+ // reset links to original tracks
+ BPhysPVCascadeTools::PrepareVertexLinks(result.get(), trackContainer);
+
+ ATH_MSG_DEBUG("storing tracks " << ((result->vertices())[0])->trackParticle(0) << ", "
+ << ((result->vertices())[0])->trackParticle(1) << ", "
+ << ((result->vertices())[1])->trackParticle(0) << ", "
+ << ((result->vertices())[1])->trackParticle(1));
+
+ // necessary to prevent memory leak
+ result->setSVOwnership(true);
+ const std::vector< std::vector<TLorentzVector> > &moms = result->getParticleMoms();
+ if(moms.size() < 2){
+ ATH_MSG_FATAL("Incorrect size " << __FILE__ << __LINE__ );
+ return StatusCode::FAILURE;
+ }
+ double mass = m_CascadeTools->invariantMass(moms[1]);
+ if (mass >= m_MassLower && mass <= m_MassUpper) {
+
+ cascadeinfoContainer->push_back(result.release());
+ } else {
+ ATH_MSG_DEBUG("Candidate rejected by the mass cut: mass = "
+ << mass << " != (" << m_MassLower << ", " << m_MassUpper << ")" );
+ }
+ }
+
+ } //Iterate over V0 vertices
+
+ } //Iterate over Jpsi vertices
+
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer->size());
+
+ return StatusCode::SUCCESS;
+ }
+
+}
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/MuonExtrapolationTool.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/MuonExtrapolationTool.cxx
new file mode 100644
index 00000000000..4a55beb9601
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/MuonExtrapolationTool.cxx
@@ -0,0 +1,182 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+// MuonExtrapolationTool.cxx
+#include "DerivationFrameworkBPhys/MuonExtrapolationTool.h"
+#include "xAODTruth/TruthParticleContainer.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "TrkSurfaces/DiscSurface.h"
+#include "TrkSurfaces/CylinderSurface.h"
+#include "TrkExInterfaces/IExtrapolator.h"
+#include "TVector2.h"
+#include "xAODMuon/MuonContainer.h"
+//**********************************************************************
+
+namespace DerivationFramework {
+
+MuonExtrapolationTool::MuonExtrapolationTool(const std::string &t, const std::string& n, const IInterface* p)
+ :
+ AthAlgTool(t, n, p),
+ m_extrapolator("Trk::Extrapolator/AtlasExtrapolator")
+{
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+ declareProperty("EndcapPivotPlaneZ", m_endcapPivotPlaneZ = 15525.);// z position of pivot plane in endcap region
+ declareProperty("EndcapPivotPlaneMinimumRadius", m_endcapPivotPlaneMinimumRadius = 0.);// minimum radius of pivot plane in endcap region
+ declareProperty("EndcapPivotPlaneMaximumRadius", m_endcapPivotPlaneMaximumRadius = 11977.); // maximum radius of pivot plane in endcap region
+ declareProperty("BarrelPivotPlaneRadius", m_barrelPivotPlaneRadius = 8000.);// radius of pivot plane in barrel region
+ declareProperty("BarrelPivotPlaneHalfLength", m_barrelPivotPlaneHalfLength = 9700.);// half length of pivot plane in barrel region
+ declareProperty("Extrapolator", m_extrapolator);
+ declareProperty("MuonCollection", m_muonContainerName = "Muons");
+}
+
+//**********************************************************************
+
+
+StatusCode MuonExtrapolationTool::initialize()
+{
+ ATH_CHECK(m_extrapolator.retrieve());
+ return StatusCode::SUCCESS;
+}
+
+
+//**********************************************************************
+
+bool MuonExtrapolationTool::extrapolateAndDecorateTrackParticle(const xAOD::TrackParticle* particle, float & eta, float & phi) const
+{
+
+ // decorators used to access or store the information
+ static SG::AuxElement::Decorator< char > Decorated ("DecoratedPivotEtaPhi");
+ static SG::AuxElement::Decorator< float > Eta ("EtaTriggerPivot");
+ static SG::AuxElement::Decorator< float > Phi ("PhiTriggerPivot");
+
+ if (! Decorated.isAvailable(*particle) || !Decorated(*particle)){
+ // in the athena release, we can run the extrapolation if needed
+ const Trk::TrackParameters* pTag = extrapolateToTriggerPivotPlane(*particle);
+ if(!pTag) {
+ Decorated(*particle) = false;
+ return false;
+ }
+ Eta(*particle) = pTag->position().eta();
+ Phi(*particle) = pTag->position().phi();
+ Decorated(*particle) = true;
+ delete pTag;
+ }
+ // if we get here, the decoration was either already present or just added by us
+ // so we can finally read the values
+ eta = Eta(*particle);
+ phi = Phi(*particle);
+ return true;
+}
+
+//**********************************************************************
+
+const xAOD::TrackParticle* MuonExtrapolationTool::getPreferredTrackParticle (const xAOD::IParticle* muon) const
+{
+ if (dynamic_cast<const xAOD::TruthParticle*>(muon)){
+ ATH_MSG_WARNING("Pivot plane extrapolation not supported for Truth muons!");
+ return 0;
+ }
+ const xAOD::TrackParticle* muonTrack = dynamic_cast<const xAOD::TrackParticle*>(muon);
+ if(!muonTrack && dynamic_cast<const xAOD::Muon*>(muon)) {
+ const xAOD::Muon* theMuon = dynamic_cast<const xAOD::Muon*>(muon);
+ muonTrack = theMuon->trackParticle( xAOD::Muon::MuonSpectrometerTrackParticle );
+ if(!muonTrack) {
+ muonTrack = theMuon->primaryTrackParticle();
+ if(!muonTrack) {
+ muonTrack = theMuon->trackParticle( xAOD::Muon::InnerDetectorTrackParticle );
+ }
+ }
+ }
+ if(!muonTrack){
+ ATH_MSG_WARNING("no valid track found for extrapolating the muon to the pivot plane!");
+ }
+ return muonTrack;
+
+}
+
+StatusCode MuonExtrapolationTool::addBranches() const
+{
+ const xAOD::MuonContainer* muons = NULL;
+ CHECK(evtStore()->retrieve(muons, m_muonContainerName));
+ for(auto muon : *muons){
+ const xAOD::TrackParticle* track = getPreferredTrackParticle(muon);
+ float eta, phi = 0;
+ if( !extrapolateAndDecorateTrackParticle( track, eta, phi )){
+ if( muon->pt() > 3500.){
+ //only complain if the muon has sufficient pT to actually reach the pivot plane
+ //extrapolation will often fail for muons with pT < 3500 MeV
+ ATH_MSG_WARNING("Failed to extrapolate+decorate muon with pivot plane coords - Muon params: pt "<<muon->pt()<<", eta "<< muon->eta()<<", phi "<< muon->phi());
+ }
+ }
+ }
+ return StatusCode::SUCCESS;
+}
+
+const Trk::TrackParameters* MuonExtrapolationTool::extrapolateToTriggerPivotPlane(const xAOD::TrackParticle& track) const
+{
+ // BARREL
+ const Trk::Perigee& perigee = track.perigeeParameters();
+
+ // create the barrel as a cylinder surface centered at 0,0,0
+ Amg::Vector3D barrelCentre(0., 0., 0.);
+ Amg::Transform3D* matrix = new Amg::Transform3D(Amg::RotationMatrix3D::Identity(), barrelCentre);
+
+ Trk::CylinderSurface* cylinder =
+ new Trk::CylinderSurface(matrix,
+ m_barrelPivotPlaneRadius,
+ m_barrelPivotPlaneHalfLength);
+ if (!cylinder) {
+ ATH_MSG_WARNING("extrapolateToTriggerPivotPlane :: new Trk::CylinderSurface failed.");
+ delete matrix;
+ matrix = 0;
+ return 0;
+ }
+ // and then attempt to extrapolate our track to this surface, checking for the boundaries of the barrel
+ bool boundaryCheck = true;
+ const Trk::Surface* surface = cylinder;
+ const Trk::TrackParameters* p = m_extrapolator->extrapolate(perigee,
+ *surface,
+ Trk::alongMomentum,
+ boundaryCheck,
+ Trk::muon);
+ delete cylinder;
+ // if the extrapolation worked out (so we are in the barrel) we are done and can return the
+ // track parameters at this surface.
+ if (p) return p;
+
+ // if we get here, the muon did not cross the barrel surface
+ // so we assume it is going into the endcap.
+ // ENDCAP
+
+ // After 2 years of using this code, we realised that ATLAS actually has endcaps on both sides ;-)
+ // So better make sure we place our endcap at the correct side of the detector!
+ // Hopefully no-one will ever read this comment...
+ float SignOfEta = track.eta() > 0 ? 1. : -1.;
+
+ Amg::Vector3D endcapCentre(0., 0., m_endcapPivotPlaneZ);
+ // much better!
+ matrix = new Amg::Transform3D(Amg::RotationMatrix3D::Identity(), SignOfEta * endcapCentre);
+
+ Trk::DiscSurface* disc =
+ new Trk::DiscSurface(matrix,
+ m_endcapPivotPlaneMinimumRadius,
+ m_endcapPivotPlaneMaximumRadius);
+ if (!disc) {
+ ATH_MSG_WARNING("extrapolateToTriggerPivotPlane :: new Trk::DiscSurface failed.");
+ delete matrix;
+ matrix = 0;
+ return 0;
+ }
+
+ // for the endcap, we turn off the boundary check, extending the EC infinitely to catch stuff heading for the transition region
+ boundaryCheck = false;
+ surface = disc;
+ p = m_extrapolator->extrapolate(perigee,
+ *surface,
+ Trk::alongMomentum,
+ boundaryCheck,
+ Trk::muon);
+ delete disc;
+ return p;
+}
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/ReVertex.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/ReVertex.cxx
new file mode 100644
index 00000000000..9ca25240412
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/ReVertex.cxx
@@ -0,0 +1,284 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+// ****************************************************************************
+// ----------------------------------------------------------------------------
+// ReVertex
+//
+// Konstantin Beloborodov <Konstantin.Beloborodov@cern.ch>
+//
+// ----------------------------------------------------------------------------
+// ****************************************************************************
+#include "DerivationFrameworkBPhys/ReVertex.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "JpsiUpsilonTools/PrimaryVertexRefitter.h"
+#include "JpsiUpsilonTools/JpsiUpsilonCommon.h"
+
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "BeamSpotConditionsData/BeamSpotData.h"
+#include "DerivationFrameworkBPhys/BPhysPVTools.h"
+#include "TrkVertexFitterInterfaces/IVertexFitter.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "InDetConversionFinderTools/VertexPointEstimator.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+
+using namespace DerivationFramework;
+
+ReVertex::ReVertex(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p), m_vertexEstimator("InDet::VertexPointEstimator"), m_iVertexFitter("Trk::TrkVKalVrtFitter"),
+ m_massConst(0.),
+ m_totalMassConst(0.),
+ m_v0Tools("Trk::V0Tools"),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter"),
+ m_doMassConst(false),
+ m_vertexFittingWithPV(false),
+ m_chi2cut(-1.0),
+ m_trkDeltaZ(-1.0),
+ m_useAdditionalTrack(false)
+{
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+ declareProperty("TrackIndices", m_TrackIndices);
+ declareProperty("TrkVertexFitterTool", m_iVertexFitter);
+ declareProperty("VertexPointEstimator",m_vertexEstimator);
+
+ declareProperty("OutputVtxContainerName", m_OutputContainerName);
+ declareProperty("InputVtxContainerName", m_inputContainerName);
+ declareProperty("TrackContainerName", m_trackContainer = "InDetTrackParticles");
+ declareProperty("UseVertexFittingWithPV", m_vertexFittingWithPV);
+
+ declareProperty("HypothesisNames",m_hypoNames);
+
+ declareProperty("V0Tools" , m_v0Tools);
+ declareProperty("PVRefitter" , m_pvRefitter);
+ declareProperty("PVContainerName" , m_pvContainerName = "PrimaryVertices");
+ declareProperty("RefPVContainerName" , m_refPVContainerName = "RefittedPrimaryVertices");
+
+ declareProperty("UseMassConstraint", m_doMassConst);
+ declareProperty("VertexMass", m_totalMassConst);
+ declareProperty("SubVertexMass", m_massConst);
+ declareProperty("MassInputParticles", m_trkMasses);
+ declareProperty("SubVertexTrackIndices", m_indices);
+
+ declareProperty("UseAdditionalTrack", m_useAdditionalTrack);
+
+ declareProperty("RefitPV" , m_refitPV = false);
+ //This parameter will allow us to optimize the number of PVs under consideration as the probability
+ //of a useful primary vertex drops significantly the higher you go
+ declareProperty("MaxPVrefit" , m_PV_max = 1000);
+ declareProperty("DoVertexType" , m_DoVertexType = 7);
+ // minimum number of tracks for PV to be considered for PV association
+ declareProperty("MinNTracksInPV" , m_PV_minNTracks = 0);
+ declareProperty("Do3d" , m_do3d = false);
+ declareProperty("AddPVData" , m_AddPVData = true);
+ declareProperty("StartingPoint0" , m_startingpoint0 = false);
+ declareProperty("BMassUpper",m_BMassUpper = std::numeric_limits<double>::max() );
+ declareProperty("BMassLower",m_BMassLower = std::numeric_limits<double>::min() );
+ declareProperty("Chi2Cut",m_chi2cut = std::numeric_limits<double>::max() );
+ declareProperty("TrkDeltaZ",m_trkDeltaZ);
+
+
+}
+
+StatusCode ReVertex::initialize() {
+ ATH_MSG_DEBUG("in initialize()");
+ if(m_TrackIndices.empty()) {
+ ATH_MSG_FATAL("No Indices provided");
+ return StatusCode::FAILURE;
+ }
+ m_VKVFitter = dynamic_cast<Trk::TrkVKalVrtFitter*>(&(*m_iVertexFitter));
+ if(m_VKVFitter==nullptr) return StatusCode::FAILURE;
+ ATH_CHECK(m_OutputContainerName.initialize());
+ ATH_CHECK(m_inputContainerName.initialize());
+ ATH_CHECK(m_trackContainer.initialize());
+ ATH_CHECK(m_pvContainerName.initialize());
+ ATH_CHECK(m_refPVContainerName.initialize());
+
+ return StatusCode::SUCCESS;
+}
+
+
+StatusCode ReVertex::addBranches() const {
+
+ SG::WriteHandle<xAOD::VertexContainer> vtxContainer(m_OutputContainerName);
+ ATH_CHECK(vtxContainer.record(std::make_unique<xAOD::VertexContainer>(), std::make_unique<xAOD::VertexAuxContainer>()));
+
+ const size_t Ntracks = m_TrackIndices.size();
+
+ SG::ReadHandle<xAOD::VertexContainer> InVtxContainer(m_inputContainerName);
+ SG::ReadHandle<xAOD::TrackParticleContainer> importedTrackCollection(m_trackContainer);
+ ATH_CHECK(InVtxContainer.isValid());
+ ATH_CHECK(importedTrackCollection.isValid());
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+ SG::ReadHandle<xAOD::VertexContainer> pvContainer(m_pvContainerName);
+ ATH_CHECK(pvContainer.isValid());
+
+ std::vector<const xAOD::TrackParticle*> fitpair(Ntracks + m_useAdditionalTrack);
+ for(const xAOD::Vertex* v : *InVtxContainer)
+ {
+
+ bool passed = false;
+ for(size_t i=0;i<m_hypoNames.size();i++) {
+ xAOD::BPhysHypoHelper onia(m_hypoNames.at(i), v);
+ passed |= onia.pass();
+ }
+ if (!passed && m_hypoNames.size()) continue;
+
+ for(size_t i =0; i<Ntracks; i++)
+ {
+ size_t trackN = m_TrackIndices[i];
+ if(trackN >= v->nTrackParticles())
+ {
+ ATH_MSG_FATAL("Indices exceeds limit in particle");
+ return StatusCode::FAILURE;
+ }
+ fitpair[i] = v->trackParticle(trackN);
+ }
+
+ if (m_useAdditionalTrack)
+ {
+ // Loop over ID tracks, call vertexing
+ for (auto trkItr=importedTrackCollection->cbegin(); trkItr!=importedTrackCollection->cend(); ++trkItr) {
+ const xAOD::TrackParticle* tp (*trkItr);
+ fitpair.back() = nullptr;
+ if (Analysis::JpsiUpsilonCommon::isContainedIn(tp,fitpair)) continue; // remove tracks which were used to build J/psi+2Tracks
+ fitpair.back() = tp;
+
+ // Daniel Scheirich: remove track too far from the Jpsi+2Tracks vertex (DeltaZ cut)
+ if(m_trkDeltaZ>0 &&
+ std::abs((tp)->z0() + (tp)->vz() - v->z()) > m_trkDeltaZ )
+ continue;
+
+ fitAndStore(vtxContainer.ptr(),v,InVtxContainer.cptr(),fitpair,importedTrackCollection.cptr(),pvContainer.cptr());
+ }
+ }
+ else
+ {
+ fitAndStore(vtxContainer.ptr(),v,InVtxContainer.cptr(),fitpair,importedTrackCollection.cptr(),pvContainer.cptr());
+ }
+ }
+
+ if(m_AddPVData){
+ // Give the helper class the ptr to v0tools and beamSpotsSvc to use
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVTools helper(&(*m_v0Tools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(m_PV_minNTracks);
+ helper.SetSave3d(m_do3d);
+
+ if(m_refitPV) {
+ //----------------------------------------------------
+ // Try to retrieve refitted primary vertices
+ //----------------------------------------------------
+ SG::WriteHandle<xAOD::VertexContainer> refPvContainer(m_refPVContainerName);
+ ATH_CHECK(refPvContainer.record(std::make_unique<xAOD::VertexContainer>(), std::make_unique<xAOD::VertexAuxContainer>()));
+
+ if(vtxContainer->size() >0){
+ ATH_CHECK(helper.FillCandwithRefittedVertices(vtxContainer.ptr(), pvContainer.cptr(), refPvContainer.ptr(), &(*m_pvRefitter) , m_PV_max, m_DoVertexType));
+ }
+ }else{
+ if(vtxContainer->size() >0) ATH_CHECK(helper.FillCandExistingVertices(vtxContainer.ptr(), pvContainer.cptr(), m_DoVertexType));
+ }
+ }
+
+ return StatusCode::SUCCESS;
+}
+
+void ReVertex::fitAndStore(xAOD::VertexContainer* vtxContainer,
+ const xAOD::Vertex* v,
+ const xAOD::VertexContainer *InVtxContainer,
+ const std::vector<const xAOD::TrackParticle*> &inputTracks,
+ const xAOD::TrackParticleContainer* importedTrackCollection,
+ const xAOD::VertexContainer* pvContainer) const
+{
+ std::unique_ptr<xAOD::Vertex> ptr(fit(inputTracks, nullptr));
+ if(!ptr)return;
+
+ double chi2DOF = ptr->chiSquared()/ptr->numberDoF();
+ ATH_MSG_DEBUG("Candidate chi2/DOF is " << chi2DOF);
+ bool chi2CutPassed = (m_chi2cut <= 0.0 || chi2DOF < m_chi2cut);
+ if(!chi2CutPassed) { ATH_MSG_DEBUG("Chi Cut failed!"); return; }
+ xAOD::BPhysHelper bHelper(ptr.get());//"get" does not "release" still automatically deleted
+ bHelper.setRefTrks();
+ if (m_trkMasses.size()==inputTracks.size()) {
+ TLorentzVector bMomentum = bHelper.totalP(m_trkMasses);
+ double bMass = bMomentum.M();
+ bool passesCuts = (m_BMassUpper > bMass && bMass > m_BMassLower);
+ if(!passesCuts)return;
+ }
+
+ DerivationFramework::BPhysPVTools::PrepareVertexLinks( ptr.get(), importedTrackCollection );
+ std::vector<const xAOD::Vertex*> thePreceding;
+ thePreceding.push_back(v);
+ if(m_vertexFittingWithPV){
+ const xAOD::Vertex* closestPV = Analysis::JpsiUpsilonCommon::ClosestPV(bHelper, pvContainer);
+ if (!closestPV) return;
+ std::unique_ptr<xAOD::Vertex> ptrPV(fit(inputTracks, closestPV));
+ if(!ptrPV) return;
+
+ double chi2DOFPV = ptrPV->chiSquared()/ptrPV->numberDoF();
+ ATH_MSG_DEBUG("CandidatePV chi2/DOF is " << chi2DOFPV);
+ bool chi2CutPassed = (m_chi2cut <= 0.0 || chi2DOFPV < m_chi2cut);
+ if(!chi2CutPassed) { ATH_MSG_DEBUG("Chi Cut failed!"); return; }
+ xAOD::BPhysHelper bHelperPV(ptrPV.get());//"get" does not "release" still automatically deleted
+ bHelperPV.setRefTrks();
+ if (m_trkMasses.size()==inputTracks.size()) {
+ TLorentzVector bMomentumPV = bHelperPV.totalP(m_trkMasses);
+ double bMass = bMomentumPV.M();
+ bool passesCuts = (m_BMassUpper > bMass && bMass > m_BMassLower);
+ if(!passesCuts)return;
+ }
+
+ bHelperPV.setPrecedingVertices(thePreceding, InVtxContainer);
+ vtxContainer->push_back(ptrPV.release());
+ return; //Don't store other vertex
+ }
+ bHelper.setPrecedingVertices(thePreceding, InVtxContainer);
+ vtxContainer->push_back(ptr.release());
+}
+
+ // *********************************************************************************
+
+ // ---------------------------------------------------------------------------------
+ // fit - does the fit
+ // ---------------------------------------------------------------------------------
+
+xAOD::Vertex* ReVertex::fit(const std::vector<const xAOD::TrackParticle*> &inputTracks,
+ const xAOD::Vertex* pv) const
+{
+ std::unique_ptr<Trk::IVKalState> state = m_VKVFitter->makeState();
+ if (m_doMassConst && (m_trkMasses.size()==inputTracks.size())) {
+ m_VKVFitter->setMassInputParticles(m_trkMasses, *state);
+ if (m_totalMassConst) m_VKVFitter->setMassForConstraint(m_totalMassConst, *state);
+ if (m_massConst) m_VKVFitter->setMassForConstraint(m_massConst, m_indices, *state);
+ }
+ if (pv) {
+ m_VKVFitter->setCnstType(8, *state);
+ m_VKVFitter->setVertexForConstraint(pv->position().x(),
+ pv->position().y(),
+ pv->position().z(), *state);
+ m_VKVFitter->setCovVrtForConstraint(pv->covariancePosition()(Trk::x,Trk::x),
+ pv->covariancePosition()(Trk::y,Trk::x),
+ pv->covariancePosition()(Trk::y,Trk::y),
+ pv->covariancePosition()(Trk::z,Trk::x),
+ pv->covariancePosition()(Trk::z,Trk::y),
+ pv->covariancePosition()(Trk::z,Trk::z), *state );
+ }
+
+ // Do the fit itself.......
+ // Starting point (use the J/psi position)
+ const Trk::Perigee& aPerigee1 = inputTracks[0]->perigeeParameters();
+ const Trk::Perigee& aPerigee2 = inputTracks[1]->perigeeParameters();
+ int sflag = 0;
+ int errorcode = 0;
+ Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&aPerigee1,&aPerigee2,sflag,errorcode);
+ if (errorcode != 0) {startingPoint(0) = 0.0; startingPoint(1) = 0.0; startingPoint(2) = 0.0;}
+ xAOD::Vertex* theResult = m_VKVFitter->fit(inputTracks, startingPoint, *state);
+
+ return theResult;
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_4mu.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_4mu.cxx
new file mode 100644
index 00000000000..4d4a7c80258
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_4mu.cxx
@@ -0,0 +1,269 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/////////////////////////////////////////////////////////////////
+// Reco_4mu.cxx
+///////////////////////////////////////////////////////////////////
+// Author: James Catmore <james.catmore@cern.ch>
+
+#include "DerivationFrameworkBPhys/Reco_4mu.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "DerivationFrameworkBPhys/BPhysPVTools.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+
+namespace DerivationFramework {
+
+ Reco_4mu::Reco_4mu(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_v0Tools("Trk::V0Tools"),
+ m_fourMuonTool("DerivationFramework::FourMuonTool"),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter")
+ {
+ declareInterface<DerivationFramework::ISkimmingTool>(this);
+
+ // Declare tools
+ declareProperty("V0Tools" , m_v0Tools);
+ declareProperty("FourMuonTool", m_fourMuonTool);
+ declareProperty("PVRefitter", m_pvRefitter);
+
+ // Declare user-defined properties
+ declareProperty("PairContainerName" , m_pairName = "Pairs");
+ declareProperty("QuadrupletContainerName", m_quadName = "Quadruplets");
+ declareProperty("PVContainerName" , m_pvContainerName = "PrimaryVertices");
+ declareProperty("RefPVContainerName" , m_refPVContainerName = "RefittedPrimaryVertices");
+ declareProperty("RefitPV" , m_refitPV = false);
+ declareProperty("MaxPVrefit" , m_PV_max = 1);
+ declareProperty("DoVertexType" , m_DoVertexType = 1);
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Reco_4mu::initialize()
+ {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // retrieve V0 tools
+ CHECK( m_v0Tools.retrieve() );
+
+ // get the JpsiFinder tool
+ CHECK( m_fourMuonTool.retrieve() );
+
+ // get the PrimaryVertexRefitter tool
+ CHECK( m_pvRefitter.retrieve() );
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Reco_4mu::finalize()
+ {
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ bool Reco_4mu::eventPassesFilter() const
+ {
+ // Output containers and its auxilliary store
+ xAOD::VertexContainer* pairContainer = NULL;
+ xAOD::VertexAuxContainer* pairAuxContainer = NULL;
+ xAOD::VertexContainer* quadContainer = NULL;
+ xAOD::VertexAuxContainer* quadAuxContainer = NULL;
+ bool acceptEvent(false);
+ //----------------------------------------------------
+ // call finder
+ //----------------------------------------------------
+ if( !m_fourMuonTool->performSearch(pairContainer, pairAuxContainer, quadContainer, quadAuxContainer, acceptEvent).isSuccess() ) {
+ ATH_MSG_FATAL("4mu tool (" << m_fourMuonTool << ") failed.");
+ return(false);
+ }
+
+ //----------------------------------------------------
+ // event selection
+ //----------------------------------------------------
+ /*if (quadContainer->size()==0) {
+ if (pairContainer!=NULL) delete pairContainer;
+ if (pairAuxContainer!=NULL) delete pairAuxContainer;
+ if (quadContainer!=NULL) delete quadContainer;
+ if (quadAuxContainer!=NULL) delete quadAuxContainer;
+ return(acceptEvent);
+ // acceptEvent based on muon selection only, not quads
+ }*/
+
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+ const xAOD::VertexContainer* pvContainer = NULL;
+ auto sc = evtStore()->retrieve(pvContainer, m_pvContainerName);
+ if(sc.isFailure()){
+ ATH_MSG_FATAL("Cannot find PV Container");
+ return false;
+ }
+ //----------------------------------------------------
+ // Refit primary vertices
+ //----------------------------------------------------
+ xAOD::VertexContainer* refPvContainer = NULL;
+ xAOD::VertexAuxContainer* refPvAuxContainer = NULL;
+
+ if(m_refitPV) {
+ refPvContainer = new xAOD::VertexContainer;
+ refPvAuxContainer = new xAOD::VertexAuxContainer;
+ refPvContainer->setStore(refPvAuxContainer);
+ }
+
+ BPhysPVTools helper(&(*m_v0Tools));//Give the helper class the ptr to v0tools to use
+
+ if(m_refitPV){
+ if(quadContainer->size() >0){
+ StatusCode SC = helper.FillCandwithRefittedVertices(quadContainer, pvContainer, refPvContainer, &(*m_pvRefitter) , m_PV_max, m_DoVertexType);
+ if(SC.isFailure()){
+ ATH_MSG_FATAL("refitting failed - check the vertices you passed");
+ return false;
+ }
+ }
+ if(pairContainer->size()>0) {
+ StatusCode SC = helper.FillCandwithRefittedVertices(pairContainer, pvContainer, refPvContainer, &(*m_pvRefitter) , m_PV_max, m_DoVertexType);
+ if(SC.isFailure()){
+ ATH_MSG_FATAL("refitting failed - check the vertices you passed");
+ return false;
+ }
+ }
+ }else{
+ if(quadContainer->size() >0){
+ auto sc = helper.FillCandExistingVertices(quadContainer, pvContainer, m_DoVertexType);
+ sc.ignore();
+ }
+ if(pairContainer->size() >0)
+ {
+ auto sc = helper.FillCandExistingVertices(pairContainer, pvContainer, m_DoVertexType);
+ sc.ignore();
+ }
+ }
+
+ //----------------------------------------------------
+ // Mass-hypothesis dependent quantities
+ //----------------------------------------------------
+
+ std::vector<double> muonPairMasses = std::vector<double>(2, 105.658);
+ std::vector<double> muonQuadMasses = std::vector<double>(4, 105.658);
+
+ bool doPt = (m_DoVertexType & 1) != 0;
+ bool doA0 = (m_DoVertexType & 2) != 0;
+ bool doZ0 = (m_DoVertexType & 4) != 0;
+ bool doZ0BA = (m_DoVertexType & 8) != 0;
+
+ // loop over pairs
+ xAOD::VertexContainer::iterator pairItr = pairContainer->begin();
+ ATH_MSG_DEBUG("Indices/masses of pairs follows....");
+ for(; pairItr!=pairContainer->end(); ++pairItr) {
+ // create BPhysHypoHelper
+ xAOD::BPhysHypoHelper pairHelper("PAIR", *pairItr);
+
+ //----------------------------------------------------
+ // decorate the vertex
+ //----------------------------------------------------
+ // a) invariant mass and error
+ if( !pairHelper.setMass(muonPairMasses) ) ATH_MSG_WARNING("Decoration pair.setMass failed");
+
+ double massErr = m_v0Tools->invariantMassError(pairHelper.vtx(), muonPairMasses);
+ if( !pairHelper.setMassErr(massErr) ) ATH_MSG_WARNING("Decoration pair.setMassErr failed");
+
+ // b) proper decay time and error:
+ // retrieve the refitted PV (or the original one, if the PV refitting was turned off)
+ if(doPt) ProcessVertex(pairHelper, xAOD::BPhysHelper::PV_MAX_SUM_PT2, muonPairMasses);
+ if(doA0) ProcessVertex(pairHelper, xAOD::BPhysHelper::PV_MIN_A0, muonPairMasses);
+ if(doZ0) ProcessVertex(pairHelper, xAOD::BPhysHelper::PV_MIN_Z0, muonPairMasses);
+ if(doZ0BA) ProcessVertex(pairHelper, xAOD::BPhysHelper::PV_MIN_Z0_BA, muonPairMasses);
+ ATH_MSG_DEBUG((*pairItr)->auxdata<std::string>("CombinationCode") << " : " << pairHelper.mass() << " +/- " << pairHelper.massErr());
+ }
+
+ // loop over quadruplets
+ xAOD::VertexContainer::iterator quadItr = quadContainer->begin();
+ ATH_MSG_DEBUG("Indices/masses of quadruplets follows....");
+ for(; quadItr!=quadContainer->end(); ++quadItr) {
+ // create BPhysHypoHelper
+ xAOD::BPhysHypoHelper quadHelper("QUAD", *quadItr);
+
+ //----------------------------------------------------
+ // decorate the vertex
+ //----------------------------------------------------
+ // a) invariant mass and error
+ if( !quadHelper.setMass(muonQuadMasses) ) ATH_MSG_WARNING("Decoration quad.setMass failed");
+
+ double massErr = m_v0Tools->invariantMassError(quadHelper.vtx(), muonQuadMasses);
+ if( !quadHelper.setMassErr(massErr) ) ATH_MSG_WARNING("Decoration quad.setMassErr failed");
+
+ // b) proper decay time and error:
+ // retrieve the refitted PV (or the original one, if the PV refitting was turned off)
+ if(doPt) ProcessVertex(quadHelper, xAOD::BPhysHelper::PV_MAX_SUM_PT2, muonQuadMasses);
+ if(doA0) ProcessVertex(quadHelper, xAOD::BPhysHelper::PV_MIN_A0, muonQuadMasses);
+ if(doZ0) ProcessVertex(quadHelper, xAOD::BPhysHelper::PV_MIN_Z0, muonQuadMasses);
+ if(doZ0BA) ProcessVertex(quadHelper, xAOD::BPhysHelper::PV_MIN_Z0_BA, muonQuadMasses);
+ ATH_MSG_DEBUG((*quadItr)->auxdata<std::string>("CombinationCode") << " : " << quadHelper.mass() << " +/- " << quadHelper.massErr());
+ }
+
+ //----------------------------------------------------
+ // save in the StoreGate
+ //----------------------------------------------------
+ // Pairs
+ if (!evtStore()->contains<xAOD::VertexContainer>(m_pairName))
+ evtStore()->record(pairContainer, m_pairName).ignore();
+ if (!evtStore()->contains<xAOD::VertexAuxContainer>(m_pairName+"Aux."))
+ evtStore()->record(pairAuxContainer, m_pairName+"Aux.").ignore();
+
+ // Quads
+ if (!evtStore()->contains<xAOD::VertexContainer>(m_quadName))
+ evtStore()->record(quadContainer, m_quadName).ignore();
+ if (!evtStore()->contains<xAOD::VertexAuxContainer>(m_quadName+"Aux."))
+ evtStore()->record(quadAuxContainer, m_quadName+"Aux.").ignore();
+
+ // Refitted PVs
+ if(m_refitPV) {
+ evtStore()->record(refPvContainer , m_refPVContainerName).ignore();
+ evtStore()->record(refPvAuxContainer, m_refPVContainerName+"Aux.").ignore();
+ }
+
+ return(acceptEvent);
+ }
+
+
+ void Reco_4mu::ProcessVertex(xAOD::BPhysHypoHelper &hypoHelper, xAOD::BPhysHelper::pv_type pv_t, std::vector<double> trackMasses) const{
+
+ const xAOD::Vertex* pv = hypoHelper.pv(pv_t);
+ if(pv) {
+ // decorate the vertex.
+
+ BPHYS_CHECK( hypoHelper.setTau( m_v0Tools->tau(hypoHelper.vtx(), pv, trackMasses),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ BPHYS_CHECK( hypoHelper.setTauErr( m_v0Tools->tauError(hypoHelper.vtx(), pv, trackMasses),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ //enum pv_type {PV_MAX_SUM_PT2, PV_MIN_A0, PV_MIN_Z0, PV_MIN_Z0BA};
+ }else{
+
+ const float errConst = -9999999;
+ BPHYS_CHECK( hypoHelper.setTau( errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ BPHYS_CHECK( hypoHelper.setTauErr( errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+ }
+
+ return;
+ }
+
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_V0Finder.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_V0Finder.cxx
new file mode 100644
index 00000000000..0b19d017b13
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_V0Finder.cxx
@@ -0,0 +1,307 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+/////////////////////////////////////////////////////////////////
+// Reco_V0Finder.cxx, (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Author: Adam Barton
+#include "DerivationFrameworkBPhys/Reco_V0Finder.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "GaudiKernel/IPartPropSvc.h"
+#include "EventKernel/PdtPdg.h"
+
+namespace DerivationFramework {
+
+ Reco_V0Finder::Reco_V0Finder(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_v0FinderTool("InDet::V0FinderTool"),
+ m_V0Tools("Trk::V0Tools"),
+ m_particleDataTable(nullptr),
+ m_masses(1),
+ m_masspi(139.57),
+ m_massp(938.272),
+ m_masse(0.510999),
+ m_massK0S(497.672),
+ m_massLambda(1115.68),
+ m_VxPrimaryCandidateName("PrimaryVertices"),
+ m_v0ContainerName("RecoV0Candidates"),
+ m_ksContainerName("RecoKshortCandidates"),
+ m_laContainerName("RecoLambdaCandidates"),
+ m_lbContainerName("RecoLambdabarCandidates")
+ {
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare user-defined properties
+ declareProperty("CheckVertexContainers", m_CollectionsToCheck);
+ declareProperty("V0FinderTool", m_v0FinderTool);
+ declareProperty("V0Tools", m_V0Tools);
+ declareProperty("masses", m_masses);
+ declareProperty("masspi", m_masspi);
+ declareProperty("massp", m_massp);
+ declareProperty("masse", m_masse);
+ declareProperty("massK0S", m_massK0S);
+ declareProperty("massLambda", m_massLambda);
+ declareProperty("VxPrimaryCandidateName", m_VxPrimaryCandidateName);
+ declareProperty("V0ContainerName", m_v0ContainerName);
+ declareProperty("KshortContainerName", m_ksContainerName);
+ declareProperty("LambdaContainerName", m_laContainerName);
+ declareProperty("LambdabarContainerName", m_lbContainerName);
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Reco_V0Finder::initialize()
+ {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // get the V0Finder tool
+ ATH_CHECK( m_v0FinderTool.retrieve());
+
+ // uploading the V0 tools
+ ATH_CHECK( m_V0Tools.retrieve());
+
+ // get the Particle Properties Service
+ IPartPropSvc* partPropSvc = nullptr;
+ StatusCode sc = service("PartPropSvc", partPropSvc, true);
+ if (sc.isFailure()) {
+ msg(MSG::ERROR) << "Could not initialize Particle Properties Service" << endmsg;
+ return StatusCode::FAILURE;
+ }
+ m_particleDataTable = partPropSvc->PDT();
+
+ const HepPDT::ParticleData* pd_pi = m_particleDataTable->particle(PDG::pi_plus);
+ const HepPDT::ParticleData* pd_p = m_particleDataTable->particle(PDG::p_plus);
+ const HepPDT::ParticleData* pd_e = m_particleDataTable->particle(PDG::e_minus);
+ const HepPDT::ParticleData* pd_K = m_particleDataTable->particle(PDG::K_S0);
+ const HepPDT::ParticleData* pd_L = m_particleDataTable->particle(PDG::Lambda0);
+ if (m_masses == 1) {
+ m_masspi = pd_pi->mass();
+ m_massp = pd_p->mass();
+ m_masse = pd_e->mass();
+ m_massK0S = pd_K->mass();
+ m_massLambda = pd_L->mass();
+ }
+
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Reco_V0Finder::finalize()
+ {
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Reco_V0Finder::addBranches() const
+ {
+ bool callV0Finder = false;
+ // Jpsi container and its auxilliary store
+ for(const auto &str : m_CollectionsToCheck){
+ const xAOD::VertexContainer* vertContainer = nullptr;
+ ATH_CHECK( evtStore()->retrieve(vertContainer, str) );
+ if(vertContainer->size() == 0) {
+ ATH_MSG_DEBUG("Container VertexContainer (" << str << ") is empty");
+ }else{
+ callV0Finder = true;
+ ATH_MSG_DEBUG("Container VertexContainer (" << str << ") has events N= " << vertContainer->size());
+ break;//No point checking other containers
+ }
+ }
+
+ // Call V0Finder
+
+
+// InDetV0 container and its auxilliary store
+ xAOD::VertexContainer* v0Container(nullptr);
+ xAOD::VertexAuxContainer* v0AuxContainer(nullptr);
+ xAOD::VertexContainer* ksContainer(nullptr);
+ xAOD::VertexAuxContainer* ksAuxContainer(nullptr);
+ xAOD::VertexContainer* laContainer(nullptr);
+ xAOD::VertexAuxContainer* laAuxContainer(nullptr);
+ xAOD::VertexContainer* lbContainer(nullptr);
+ xAOD::VertexAuxContainer* lbAuxContainer(nullptr);
+
+ if (callV0Finder) {
+
+ // Get primary vertex from StoreGate
+ const xAOD::Vertex * primaryVertex(0);
+ const xAOD::VertexContainer * importedVxContainer(0);
+ ATH_CHECK( evtStore()->retrieve(importedVxContainer, m_VxPrimaryCandidateName) );
+ ATH_MSG_DEBUG("Found " << m_VxPrimaryCandidateName << " in StoreGate!");
+ if (importedVxContainer->size()==0){
+ ATH_MSG_WARNING("You have no primary vertices: " << importedVxContainer->size());
+ } else {
+ primaryVertex = (*importedVxContainer)[0];
+ }
+
+ ATH_CHECK(m_v0FinderTool->performSearch(v0Container, v0AuxContainer, ksContainer, ksAuxContainer, laContainer, laAuxContainer, lbContainer, lbAuxContainer, primaryVertex, importedVxContainer));
+
+ ATH_MSG_DEBUG("Reco_V0Finder v0Container->size() " << v0Container->size());
+ ATH_MSG_DEBUG("Reco_V0Finder ksContainer->size() " << ksContainer->size());
+ ATH_MSG_DEBUG("Reco_V0Finder laContainer->size() " << laContainer->size());
+ ATH_MSG_DEBUG("Reco_V0Finder lbContainer->size() " << lbContainer->size());
+
+ SG::AuxElement::Decorator<float> mDecor_Ksmass("Kshort_mass");
+ SG::AuxElement::Decorator<float> mDecor_Ksmasse("Kshort_massError");
+ SG::AuxElement::Decorator<float> mDecor_Lamass("Lambda_mass");
+ SG::AuxElement::Decorator<float> mDecor_Lamasse("Lambda_massError");
+ SG::AuxElement::Decorator<float> mDecor_Lbmass("Lambdabar_mass");
+ SG::AuxElement::Decorator<float> mDecor_Lbmasse("Lambdabar_massError");
+ SG::AuxElement::Decorator<float> mDecor_mass("mass");
+ SG::AuxElement::Decorator<float> mDecor_massError("massError");
+ SG::AuxElement::Decorator<float> mDecor_pt("pT");
+ SG::AuxElement::Decorator<float> mDecor_ptError("pTError");
+ SG::AuxElement::Decorator<float> mDecor_rxy("Rxy");
+ SG::AuxElement::Decorator<float> mDecor_rxyError("RxyError");
+ SG::AuxElement::Decorator<float> mDecor_px("px");
+ SG::AuxElement::Decorator<float> mDecor_py("py");
+ SG::AuxElement::Decorator<float> mDecor_pz("pz");
+
+ xAOD::VertexContainer::const_iterator v0Itr = v0Container->begin();
+ for ( v0Itr=v0Container->begin(); v0Itr!=v0Container->end(); ++v0Itr )
+ {
+ const xAOD::Vertex * unconstrV0 = (*v0Itr);
+ double mass_ks = m_V0Tools->invariantMass(unconstrV0,m_masspi,m_masspi);
+ double mass_error_ks = m_V0Tools->invariantMassError(unconstrV0,m_masspi,m_masspi);
+ double mass_la = m_V0Tools->invariantMass(unconstrV0,m_massp,m_masspi);
+ double mass_error_la = m_V0Tools->invariantMassError(unconstrV0,m_massp,m_masspi);
+ double mass_lb = m_V0Tools->invariantMass(unconstrV0,m_masspi,m_massp);
+ double mass_error_lb = m_V0Tools->invariantMassError(unconstrV0,m_masspi,m_massp);
+ double pt = m_V0Tools->pT(unconstrV0);
+ double ptError = m_V0Tools->pTError(unconstrV0);
+ double rxy = m_V0Tools->rxy(unconstrV0);
+ double rxyError = m_V0Tools->rxyError(unconstrV0);
+ Amg::Vector3D momentum = m_V0Tools->V0Momentum(unconstrV0);
+ mDecor_Ksmass( *unconstrV0 ) = mass_ks;
+ mDecor_Ksmasse( *unconstrV0 ) = mass_error_ks;
+ mDecor_Lamass( *unconstrV0 ) = mass_la;
+ mDecor_Lamasse( *unconstrV0 ) = mass_error_la;
+ mDecor_Lbmass( *unconstrV0 ) = mass_lb;
+ mDecor_Lbmasse( *unconstrV0 ) = mass_error_lb;
+ mDecor_pt( *unconstrV0 ) = pt;
+ mDecor_ptError( *unconstrV0 ) = ptError;
+ mDecor_rxy( *unconstrV0 ) = rxy;
+ mDecor_rxyError( *unconstrV0 ) = rxyError;
+ mDecor_px( *unconstrV0 ) = momentum.x();
+ mDecor_py( *unconstrV0 ) = momentum.y();
+ mDecor_pz( *unconstrV0 ) = momentum.z();
+ ATH_MSG_DEBUG("Reco_V0Finder mass_ks " << mass_ks << " mass_la " << mass_la << " mass_lb " << mass_lb);
+ }
+ xAOD::VertexContainer::const_iterator ksItr = ksContainer->begin();
+ for ( ksItr=ksContainer->begin(); ksItr!=ksContainer->end(); ++ksItr )
+ {
+ const xAOD::Vertex * ksV0 = (*ksItr);
+ double mass_ks = m_V0Tools->invariantMass(ksV0,m_masspi,m_masspi);
+ double mass_error_ks = m_V0Tools->invariantMassError(ksV0,m_masspi,m_masspi);
+ double pt = m_V0Tools->pT(ksV0);
+ double ptError = m_V0Tools->pTError(ksV0);
+ double rxy = m_V0Tools->rxy(ksV0);
+ double rxyError = m_V0Tools->rxyError(ksV0);
+ Amg::Vector3D momentum = m_V0Tools->V0Momentum(ksV0);
+ mDecor_mass( *ksV0 ) = mass_ks;
+ mDecor_massError( *ksV0 ) = mass_error_ks;
+ mDecor_pt( *ksV0 ) = pt;
+ mDecor_ptError( *ksV0 ) = ptError;
+ mDecor_rxy( *ksV0 ) = rxy;
+ mDecor_rxyError( *ksV0 ) = rxyError;
+ mDecor_px( *ksV0 ) = momentum.x();
+ mDecor_py( *ksV0 ) = momentum.y();
+ mDecor_pz( *ksV0 ) = momentum.z();
+ ATH_MSG_DEBUG("Reco_V0Finder mass_ks " << mass_ks << " mass_error_ks " << mass_error_ks << " pt " << pt << " rxy " << rxy);
+ }
+ xAOD::VertexContainer::const_iterator laItr = laContainer->begin();
+ for ( laItr=laContainer->begin(); laItr!=laContainer->end(); ++laItr )
+ {
+ const xAOD::Vertex * laV0 = (*laItr);
+ double mass_la = m_V0Tools->invariantMass(laV0,m_massp,m_masspi);
+ double mass_error_la = m_V0Tools->invariantMassError(laV0,m_massp,m_masspi);
+ double pt = m_V0Tools->pT(laV0);
+ double ptError = m_V0Tools->pTError(laV0);
+ double rxy = m_V0Tools->rxy(laV0);
+ double rxyError = m_V0Tools->rxyError(laV0);
+ Amg::Vector3D momentum = m_V0Tools->V0Momentum(laV0);
+ mDecor_mass( *laV0 ) = mass_la;
+ mDecor_massError( *laV0 ) = mass_error_la;
+ mDecor_pt( *laV0 ) = pt;
+ mDecor_ptError( *laV0 ) = ptError;
+ mDecor_rxy( *laV0 ) = rxy;
+ mDecor_rxyError( *laV0 ) = rxyError;
+ mDecor_px( *laV0 ) = momentum.x();
+ mDecor_py( *laV0 ) = momentum.y();
+ mDecor_pz( *laV0 ) = momentum.z();
+ ATH_MSG_DEBUG("Reco_V0Finder mass_la " << mass_la << " mass_error_la " << mass_error_la << " pt " << pt << " rxy " << rxy);
+ }
+ xAOD::VertexContainer::const_iterator lbItr = lbContainer->begin();
+ for ( lbItr=lbContainer->begin(); lbItr!=lbContainer->end(); ++lbItr )
+ {
+ const xAOD::Vertex * lbV0 = (*lbItr);
+ double mass_lb = m_V0Tools->invariantMass(lbV0,m_masspi,m_massp);
+ double mass_error_lb = m_V0Tools->invariantMassError(lbV0,m_masspi,m_massp);
+ double pt = m_V0Tools->pT(lbV0);
+ double ptError = m_V0Tools->pTError(lbV0);
+ double rxy = m_V0Tools->rxy(lbV0);
+ double rxyError = m_V0Tools->rxyError(lbV0);
+ Amg::Vector3D momentum = m_V0Tools->V0Momentum(lbV0);
+ mDecor_mass( *lbV0 ) = mass_lb;
+ mDecor_massError( *lbV0 ) = mass_error_lb;
+ mDecor_pt( *lbV0 ) = pt;
+ mDecor_ptError( *lbV0 ) = ptError;
+ mDecor_rxy( *lbV0 ) = rxy;
+ mDecor_rxyError( *lbV0 ) = rxyError;
+ mDecor_px( *lbV0 ) = momentum.x();
+ mDecor_py( *lbV0 ) = momentum.y();
+ mDecor_pz( *lbV0 ) = momentum.z();
+ ATH_MSG_DEBUG("Reco_V0Finder mass_lb " << mass_lb << " mass_error_lb " << mass_error_lb << " pt " << pt << " rxy " << rxy);
+ }
+ }
+
+
+ if(!callV0Finder){ //Fill with empty containers
+ v0Container = new xAOD::VertexContainer;
+ v0AuxContainer = new xAOD::VertexAuxContainer;
+ v0Container->setStore(v0AuxContainer);
+ ksContainer = new xAOD::VertexContainer;
+ ksAuxContainer = new xAOD::VertexAuxContainer;
+ ksContainer->setStore(ksAuxContainer);
+ laContainer = new xAOD::VertexContainer;
+ laAuxContainer = new xAOD::VertexAuxContainer;
+ laContainer->setStore(laAuxContainer);
+ lbContainer = new xAOD::VertexContainer;
+ lbAuxContainer = new xAOD::VertexAuxContainer;
+ lbContainer->setStore(lbAuxContainer);
+ }
+
+ //---- Recording section: write the results to StoreGate ---//
+ CHECK(evtStore()->record(v0Container, m_v0ContainerName));
+
+ CHECK(evtStore()->record(v0AuxContainer, m_v0ContainerName+"Aux."));
+
+ CHECK(evtStore()->record(ksContainer, m_ksContainerName));
+
+ CHECK(evtStore()->record(ksAuxContainer, m_ksContainerName+"Aux."));
+
+ CHECK(evtStore()->record(laContainer, m_laContainerName));
+
+ CHECK(evtStore()->record(laAuxContainer, m_laContainerName+"Aux."));
+
+ CHECK(evtStore()->record(lbContainer, m_lbContainerName));
+
+ CHECK(evtStore()->record(lbAuxContainer, m_lbContainerName+"Aux."));
+
+ return StatusCode::SUCCESS;
+ }
+}
+
+
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_Vertex.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_Vertex.cxx
new file mode 100644
index 00000000000..9d2b236c841
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Reco_Vertex.cxx
@@ -0,0 +1,163 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+/////////////////////////////////////////////////////////////////
+// Reco_Vertex.cxx
+///////////////////////////////////////////////////////////////////
+// Author: Daniel Scheirich <daniel.scheirich@cern.ch>
+// Based on the Integrated Simulation Framework
+//
+// Basic Jpsi->mu mu derivation example
+
+#include "DerivationFrameworkBPhys/Reco_Vertex.h"
+#include "DerivationFrameworkBPhys/BPhysPVTools.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+
+namespace DerivationFramework {
+
+ Reco_Vertex::Reco_Vertex(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_v0Tools("Trk::V0Tools"),
+ m_SearchTool(),
+ m_pvRefitter("Analysis::PrimaryVertexRefitter")
+ {
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare tools
+ declareProperty("V0Tools" , m_v0Tools);
+ declareProperty("VertexSearchTool", m_SearchTool);
+ declareProperty("PVRefitter", m_pvRefitter);
+
+ // Declare user-defined properties
+ declareProperty("OutputVtxContainerName", m_outputVtxContainerName = "OniaCandidates");
+ declareProperty("PVContainerName" , m_pvContainerName = "PrimaryVertices");
+ declareProperty("RefPVContainerName" , m_refPVContainerName = "RefittedPrimaryVertices");
+ declareProperty("RefitPV" , m_refitPV = false);
+ declareProperty("MaxPVrefit" , m_PV_max = 1000);
+ declareProperty("DoVertexType" , m_DoVertexType = 7);
+ // minimum number of tracks for PV to be considered for PV association
+ declareProperty("MinNTracksInPV" , m_PV_minNTracks = 0);
+ declareProperty("Do3d" , m_do3d = false);
+ declareProperty("CheckCollections" , m_checkCollections = false);
+ declareProperty("CheckVertexContainers" , m_CollectionsToCheck);
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Reco_Vertex::initialize()
+ {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // retrieve V0 tools
+ CHECK( m_v0Tools.retrieve() );
+
+ // get the Search tool
+ CHECK( m_SearchTool.retrieve() );
+
+ // get the PrimaryVertexRefitter tool
+ CHECK( m_pvRefitter.retrieve() );
+
+ // Get the beam spot service
+ ATH_CHECK(m_beamSpotKey.initialize());
+
+
+ ATH_CHECK(m_outputVtxContainerName.initialize());
+ ATH_CHECK(m_pvContainerName.initialize());
+ ATH_CHECK(m_refPVContainerName.initialize());
+ if(m_checkCollections) ATH_CHECK(m_CollectionsToCheck.initialize());
+ return StatusCode::SUCCESS;
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Reco_Vertex::addBranches() const
+ {
+ bool callTool = true;
+ if(m_checkCollections) {
+ for(const auto &str : m_CollectionsToCheck){
+ SG::ReadHandle<xAOD::VertexContainer> handle(str);
+ ATH_CHECK(handle.isValid());
+ if(handle->size() == 0) {
+ callTool = false;
+ ATH_MSG_DEBUG("Container VertexContainer (" << str << ") is empty");
+ break;//No point checking other containers
+ }
+ }
+ }
+
+ // Vertex container and its auxilliary store
+ xAOD::VertexContainer* vtxContainer = nullptr;
+ xAOD::VertexAuxContainer* vtxAuxContainer = nullptr;
+
+ if(callTool) {
+ //----------------------------------------------------
+ // call Tool
+ //----------------------------------------------------
+ if( !m_SearchTool->performSearch(vtxContainer, vtxAuxContainer).isSuccess() ) {
+ ATH_MSG_FATAL("Tool (" << m_SearchTool << ") failed.");
+ return StatusCode::FAILURE;
+ }
+
+ //----------------------------------------------------
+ // retrieve primary vertices
+ //----------------------------------------------------
+ SG::ReadHandle<xAOD::VertexContainer> pvContainer(m_pvContainerName);
+
+ //----------------------------------------------------
+ // Try to retrieve refitted primary vertices
+ //----------------------------------------------------
+ xAOD::VertexContainer* refPvContainer = nullptr;
+ xAOD::VertexAuxContainer* refPvAuxContainer = nullptr;
+ if(m_refitPV) {
+ // refitted PV container does not exist. Create a new one.
+ refPvContainer = new xAOD::VertexContainer;
+ refPvAuxContainer = new xAOD::VertexAuxContainer;
+ refPvContainer->setStore(refPvAuxContainer);
+ }
+
+ // Give the helper class the ptr to v0tools and beamSpotsSvc to use
+ SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey };
+ if(not beamSpotHandle.isValid()) ATH_MSG_ERROR("Cannot Retrieve " << m_beamSpotKey.key() );
+ BPhysPVTools helper(&(*m_v0Tools), beamSpotHandle.cptr());
+ helper.SetMinNTracksInPV(m_PV_minNTracks);
+ helper.SetSave3d(m_do3d);
+
+ if(m_refitPV){
+ if(vtxContainer->size() >0){
+ StatusCode SC = helper.FillCandwithRefittedVertices(vtxContainer, pvContainer.cptr(), refPvContainer, &(*m_pvRefitter) , m_PV_max, m_DoVertexType);
+ if(SC.isFailure()){
+ ATH_MSG_FATAL("refitting failed - check the vertices you passed");
+ return SC;
+ }
+ }
+ }else{
+ if(vtxContainer->size() >0)CHECK(helper.FillCandExistingVertices(vtxContainer, pvContainer.cptr(), m_DoVertexType));
+ }
+
+ //----------------------------------------------------
+ // save in the StoreGate
+ //----------------------------------------------------
+ SG::WriteHandle<xAOD::VertexContainer> handle(m_outputVtxContainerName);
+ ATH_CHECK(handle.record(std::unique_ptr<xAOD::VertexContainer>(vtxContainer ), std::unique_ptr<xAOD::VertexAuxContainer>(vtxAuxContainer )));
+
+ if(m_refitPV) {
+ SG::WriteHandle<xAOD::VertexContainer> handle(m_refPVContainerName);
+ ATH_CHECK(handle.record(std::unique_ptr<xAOD::VertexContainer>(refPvContainer ), std::unique_ptr<xAOD::VertexAuxContainer>(refPvAuxContainer )));
+ }
+ }
+
+ if (!callTool) { //Fill with empty containers
+ SG::WriteHandle<xAOD::VertexContainer> handle(m_outputVtxContainerName);
+ ATH_CHECK(handle.record(std::unique_ptr<xAOD::VertexContainer>(new xAOD::VertexContainer ),
+ std::unique_ptr<xAOD::VertexAuxContainer>(new xAOD::VertexAuxContainer )));
+ }
+
+ return StatusCode::SUCCESS;
+ }
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Select_Bmumu.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Select_Bmumu.cxx
new file mode 100644
index 00000000000..d1027b9b2c3
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Select_Bmumu.cxx
@@ -0,0 +1,563 @@
+/*
+ Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
+*/
+
+//============================================================================
+// Select_Bmumu.cxx
+//============================================================================
+//
+// Author : Wolfgang Walkowiak <Wolfgang.Walkowiak@cern.ch.>
+// Changes:
+//
+// Based on Select_onia2mumu.h.
+// Original author: Daniel Scheirich <daniel.scheirich@cern.ch>
+//
+// Select B candidates for the B(s)mumu analysis including for
+// the reference channels used.
+//
+// For an example see BPHY8.py .
+//
+// Job options provided by this class:
+// - V0Tools -- ToolHandle for V0Tools (default: Trk::V0Tools)
+// - HypothesisName -- name given to the hypothesis (passed flag)
+// - InputVtxContainerName -- name of the input vertex container
+// - TrkMasses" -- list of masses to be assigned to the tracks
+// used for lifetime calculation
+// (Make sure to give them in correct order!)
+// - VtxMassHypo -- mass used in the calculation of lifetime
+// - MassMin -- minimum of mass range
+// - MassMax -- maximum of mass range
+// - Chi2Max -- maximum chi2 cut
+// - DoVertexType -- bits defining vertex association types
+// to be used
+// - Do3d -- add 3d proper time
+// - BlindMassMin -- minimum of blinded mass range
+// - BlindMassMax -- maximum blinded mass range
+// - DoBlinding -- switch to enable blinding (default: false)
+// - DoCutBlinded -- cut blinded vertices (default: false)
+// - BlindOnlyAllMuonsTight -- only blind candidates with all tight muons
+// - UseMuCalcMass -- use MUCALC mass in mass cuts (default: false)
+// - SubDecVtxContNames -- names of containers with sub-decay candidates
+// (in order of sub decays)
+// - SubDecVtxHypoCondNames -- names of hypothesis required to be passed
+// by sub-decay candidates
+// - SubDecVtxHypoFlagNames -- names of hypothesis passed flags set by
+// this algorithm on sub-decay candidates
+// (taken as
+// SupDecVtxHypoCondName+'_'+HypthesisName
+// if not explicitely given)
+//
+//============================================================================
+//
+#include "DerivationFrameworkBPhys/Select_Bmumu.h"
+
+#include <vector>
+#include <string>
+#include "TVector3.h"
+
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include "AthContainers/AuxElement.h"
+
+/*
+ * Some useful typedefs
+ */
+typedef ElementLink<xAOD::VertexContainer> VertexLink;
+typedef std::vector<VertexLink> VertexLinkVector;
+
+namespace DerivationFramework {
+
+ Select_Bmumu::Select_Bmumu(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ CfAthAlgTool(t,n,p),
+ m_v0Tools("Trk::V0Tools"),
+ m_muSelectionTool("CP::MuonSelectionTool/MuonSelectionTool") {
+
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare tools
+ declareProperty("V0Tools", m_v0Tools);
+ declareProperty("MuonSelectionTool", m_muSelectionTool);
+
+ // Declare user-defined properties
+
+ declareProperty("HypothesisName" , m_hypoName = "A");
+ declareProperty("InputVtxContainerName" , m_inputVtxContainerName = "JpsiCandidates");
+ declareProperty("TrkMasses" , m_trkMasses = std::vector<double>(2, 105.658) );
+ declareProperty("VtxMassHypo" , m_massHypo = 3096.916 );
+ declareProperty("MassMax" , m_massMax = 6000);
+ declareProperty("MassMin" , m_massMin = 2000);
+ declareProperty("Chi2Max" , m_chi2Max = 200);
+ declareProperty("DoVertexType" , m_DoVertexType = 7);
+ declareProperty("Do3d" , m_do3d = false);
+ declareProperty("BlindMassMin" , m_blindMassMin = 0.);
+ declareProperty("BlindMassMax" , m_blindMassMax = 0.);
+ declareProperty("DoBlinding" , m_doBlinding = false);
+ declareProperty("DoCutBlinded" , m_doCutBlinded = false);
+ declareProperty("BlindOnlyAllMuonsTight", m_blindOnlyAllMuonsTight = false);
+ declareProperty("UseMuCalcMass" , m_useMuCalcMass = false);
+ declareProperty("SubDecVtxContNames" , m_subDecVtxContNames = {});
+ declareProperty("SubDecVtxHypoCondNames", m_subDecVtxHypoCondNames = {});
+ declareProperty("SubDecVtxHypoFlagNames", m_subDecVtxHypoFlagNames = {});
+ }
+ //----------------------------------------------------------------------------
+ StatusCode Select_Bmumu::initialize() {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // retrieve V0 tools
+ CHECK( m_v0Tools.retrieve() );
+
+ // retrieve MuonSelectionTool
+ if ( m_blindOnlyAllMuonsTight ) {
+ CHECK( m_muSelectionTool.retrieve() );
+ }
+
+ // check length of sub-decay vertex container and required hypo name
+ // vectors
+ if ( m_subDecVtxContNames.size() != m_subDecVtxHypoCondNames.size() ) {
+ ATH_MSG_ERROR("initialize(): number of elements for options "
+ << "SubDecVtxContNames and SubDecVtxHypoCondNames does not "
+ << "match : " << m_subDecVtxContNames.size()
+ << " != " << m_subDecVtxHypoCondNames << " !!");
+ }
+ // check the length of condition and flag hypo name vectors and append
+ // to the later if necessary
+ if ( m_subDecVtxHypoCondNames.size() > m_subDecVtxHypoFlagNames.size() ) {
+ ATH_MSG_INFO("initialize(): SubDecVtxHypoFlagNames ("
+ << m_subDecVtxHypoFlagNames.size()
+ << ") < SubDecVtxHypoCondNames ("
+ << m_subDecVtxHypoCondNames.size()
+ << ") ... appending to the first.");
+ for ( unsigned int i = m_subDecVtxHypoFlagNames.size();
+ i < m_subDecVtxHypoCondNames.size(); ++i) {
+ std::string flagname = m_hypoName+"_"+m_subDecVtxHypoCondNames[i];
+ ATH_MSG_INFO("initialize(): SubDecVtxHypoFlagNames[" << i << "] = "
+ << flagname);
+ m_subDecVtxHypoFlagNames.push_back(flagname);
+ }
+ } else if ( m_subDecVtxHypoCondNames.size()
+ < m_subDecVtxHypoFlagNames.size() ) {
+ ATH_MSG_ERROR("initialize(): SubDecVtxHypoFlagNames ("
+ << m_subDecVtxHypoFlagNames.size()
+ << ") > SubDecVtxHypoCondNames ("
+ << m_subDecVtxHypoCondNames.size()
+ << ") ! Configuration error!");
+ }
+ return StatusCode::SUCCESS;
+ }
+ //----------------------------------------------------------------------------
+ StatusCode Select_Bmumu::finalize() {
+
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+ //---------------------------------------------------------------------------
+ void Select_Bmumu::ProcessVertex(xAOD::BPhysHypoHelper &bcand,
+ xAOD::BPhysHelper::pv_type pv_t) const {
+
+ constexpr float errConst = -9999999;
+ const xAOD::Vertex* pv = bcand.pv(pv_t);
+ if (pv) {
+ // decorate the vertex.
+ // Proper decay time assuming constant mass hypothesis m_massHypo
+ BPHYS_CHECK( bcand.setTau(m_v0Tools->tau(bcand.vtx(), pv, m_massHypo),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+ // Proper decay time assuming error constant mass hypothesis m_massHypo
+ BPHYS_CHECK( bcand.setTauErr( m_v0Tools->tauError(bcand.vtx(), pv,
+ m_massHypo),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+
+ BPHYS_CHECK( bcand.setTau(m_v0Tools->tau(bcand.vtx(),pv, m_trkMasses),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ BPHYS_CHECK( bcand.setTauErr(m_v0Tools->tauError(bcand.vtx(), pv,
+ m_trkMasses),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+ //enum pv_type {PV_MAX_SUM_PT2, PV_MIN_A0, PV_MIN_Z0, PV_MIN_Z0_BA};
+ } else {
+
+ BPHYS_CHECK( bcand.setTau(errConst, pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+ // Proper decay time assuming error constant mass hypothesis m_massHypo
+ BPHYS_CHECK( bcand.setTauErr( errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+
+ BPHYS_CHECK( bcand.setTau( errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ BPHYS_CHECK( bcand.setTauErr( errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+ }
+
+ if(m_do3d){
+
+ BPHYS_CHECK( bcand.setTau3d( pv ?
+ m_v0Tools->tau3D(bcand.vtx(), pv,
+ m_massHypo)
+ : errConst, pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+ // Proper decay time assuming error constant mass hypothesis m_massHypo
+ BPHYS_CHECK( bcand.setTau3dErr( pv ?
+ m_v0Tools->tau3DError(bcand.vtx(), pv,
+ m_massHypo)
+ : errConst, pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS)
+ );
+
+ BPHYS_CHECK( bcand.setTau3d( pv ?
+ m_v0Tools->tau3D(bcand.vtx(), pv,
+ m_trkMasses)
+ : errConst, pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ BPHYS_CHECK( bcand.setTau3dErr( pv ?
+ m_v0Tools->tau3DError(bcand.vtx(), pv,
+ m_trkMasses)
+ : errConst, pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS)
+ );
+ }
+
+ }
+ //---------------------------------------------------------------------------
+ StatusCode Select_Bmumu::addBranches() const {
+
+ // Jpsi container and its auxilliary store
+ xAOD::VertexContainer* bcandContainer = NULL;
+ xAOD::VertexAuxContainer* bcandAuxContainer = NULL;
+
+ // retrieve from the StoreGate
+ CHECK(evtStore()->retrieve(bcandContainer, m_inputVtxContainerName));
+ CHECK(evtStore()->retrieve(bcandAuxContainer,
+ m_inputVtxContainerName+"Aux."));
+
+ // for sub-decays
+ std::vector<xAOD::VertexContainer*> subCandConts;
+ std::vector<xAOD::VertexAuxContainer*> subCandAuxConts;
+
+ // retrieve from StoreGate
+ for (auto cname : m_subDecVtxContNames) {
+ xAOD::VertexContainer* subCandCont = NULL;
+ xAOD::VertexAuxContainer* subCandAuxCont = NULL;
+ CHECK(evtStore()->retrieve(subCandCont , cname));
+ CHECK(evtStore()->retrieve(subCandAuxCont, cname+"Aux."));
+ subCandConts.push_back(subCandCont);
+ subCandAuxConts.push_back(subCandAuxCont);
+ }
+
+ // preset pass flag to false for subdecays
+ for (unsigned int isub=0; isub < subCandConts.size(); ++isub) {
+ xAOD::VertexContainer* subCandCont = subCandConts[isub];
+ if ( subCandCont != NULL ) {
+ for (xAOD::VertexContainer::iterator it = subCandCont->begin();
+ it != subCandCont->end(); ++it) {
+ if ( *it != NULL ) {
+ // only set subdecay passed flag to false if not yet set at all
+ setPassIfNotAvailable(**it, m_subDecVtxHypoFlagNames[isub], false);
+ // set subdecay blinding flag to true if not yet set at all
+ // and blinding is requested
+ if ( m_doBlinding ) {
+ setPassIfNotAvailable(**it,
+ m_subDecVtxHypoFlagNames[isub]+"_blinded",
+ true);
+ }
+ } else {
+ ATH_MSG_WARNING("addBranches(): NULL pointer elements in "
+ "xAOD::VertexContainer !!");
+ }
+ } // for subCandCont
+ } // if subCandCont != NULL
+ } // for subCandConts
+
+ bool doPt = (m_DoVertexType & 1) != 0;
+ bool doA0 = (m_DoVertexType & 2) != 0;
+ bool doZ0 = (m_DoVertexType & 4) != 0;
+ bool doZ0BA = (m_DoVertexType & 8) != 0;
+
+ // loop over B candidates and perform selection and augmentation
+ // counters
+ int nPassMassCuts = 0;
+ int nPassChi2Cut = 0;
+ int nPassPrecVtxCut = 0;
+ int nInBlindedRegion = 0;
+ int nInBlindedRegionAllMuonsTight = 0;
+ xAOD::VertexContainer::iterator bcandItr = bcandContainer->begin();
+ for (; bcandItr!=bcandContainer->end(); ++bcandItr) {
+ // create BPhysHypoHelper
+ xAOD::BPhysHypoHelper bcand(m_hypoName, *bcandItr);
+
+ //----------------------------------------------------
+ // decorate the vertex - part 1
+ //----------------------------------------------------
+ // a) invariant mass and error
+ if ( !bcand.setMass(m_trkMasses) )
+ ATH_MSG_WARNING("Decoration bcand.setMass failed");
+
+ double massErr = m_v0Tools->invariantMassError(bcand.vtx(), m_trkMasses);
+ if ( !bcand.setMassErr(massErr) )
+ ATH_MSG_WARNING("Decoration bcand.setMassErr failed");
+
+ // b) proper decay time and error:
+ // retrieve the refitted PV (or the original one,
+ // if the PV refitting was turned off)
+ // -- deferred to after the selection --
+ /*
+ if (doPt) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
+ if (doA0) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_A0);
+ if (doZ0) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_Z0);
+ if (doZ0BA) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_Z0_BA);
+ */
+
+ //----------------------------------------------------
+ // perform the selection (i.e. flag the vertex)
+ //----------------------------------------------------
+ // flag the vertex indicating that it is selected by this selector
+ bcand.setPass(true);
+ if ( m_doBlinding ) {
+ setPass(*bcand.vtx(),
+ m_hypoName+"_blinded", false);
+ }
+
+ // now we check other cuts. if one of them didn't pass, set the flag to 0
+ // and continue to the next candidate:
+
+ // 1) invariant mass cuts
+ bool passedMuCalcMassCut(m_useMuCalcMass);
+ bool blindedMuCalcMass(true);
+ if ( m_useMuCalcMass ) {
+ std::string bname = m_hypoName+"_MUCALC_mass";
+ static SG::AuxElement::Accessor<float> mucalcAcc(bname);
+ if ( mucalcAcc.isAvailable(**bcandItr) ) {
+ passedMuCalcMassCut = massCuts(mucalcAcc(**bcandItr));
+ blindedMuCalcMass = massInBlindedRegion(mucalcAcc(**bcandItr));
+ } else {
+ passedMuCalcMassCut = false;
+ blindedMuCalcMass = false;
+ ATH_MSG_INFO("MUCALC mass not available: " << bname << " !");
+ }
+ }
+ bool passedMassCut = massCuts(bcand.mass());
+ bool blindedMass = massInBlindedRegion(bcand.mass());
+
+ // 1a) muon quality cuts
+ bool allMuonsTight =
+ !m_blindOnlyAllMuonsTight || checkAllMuonsTight(bcand.muons());
+
+ // 1b) mark candidates in blinded region
+ if ( blindedMass && blindedMuCalcMass ) {
+ if ( m_doBlinding ) {
+ nInBlindedRegion++;
+ if ( allMuonsTight ) {
+ nInBlindedRegionAllMuonsTight++;
+ setPass(*bcand.vtx(),
+ m_hypoName+"_blinded", true);
+ }
+ }
+ }
+
+ // 1c) cut on the mass range
+ if ( !(passedMassCut || passedMuCalcMassCut) ) {
+ bcand.setPass(false); // flag as failed
+ continue;
+ }
+ nPassMassCuts++;
+
+ // 2) chi2 cut
+ if ( bcand.vtx()->chiSquared() > m_chi2Max) {
+ bcand.setPass(false);; // flag as failed
+ continue;
+ }
+ nPassChi2Cut++;
+
+ // 3) preceeding vertices: within their mass ranges?
+ int npVtx = bcand.nPrecedingVertices();
+ if ( npVtx > (int)m_subDecVtxContNames.size() ) {
+ ATH_MSG_WARNING("addBranches(): npVtx > m_subDecVtxContNames.size() !"
+ " (" << npVtx << " > " << m_subDecVtxContNames.size()
+ << ")");
+ }
+ npVtx = std::min(npVtx, (int)m_subDecVtxContNames.size());
+ // check preceeding vertices
+ bool pVtxOk = true;
+ for (int ipv=0; ipv<npVtx; ++ipv) {
+ const xAOD::Vertex* pVtx = bcand.precedingVertex(ipv);
+ if ( !pass(*pVtx, m_subDecVtxHypoCondNames[ipv]) ) {
+ pVtxOk = false;
+ continue;
+ }
+ }
+ if ( !pVtxOk ) {
+ bcand.setPass(false);; // flag as failed
+ continue;
+ }
+ // mark preceeding vertices
+ for (int ipv=0; ipv<npVtx; ++ipv) {
+ setPass(*bcand.precedingVertex(ipv),
+ m_subDecVtxHypoFlagNames[ipv], true);
+ if ( m_doBlinding && !(blindedMass && blindedMuCalcMass
+ && allMuonsTight) ) {
+ setPass(*bcand.precedingVertex(ipv),
+ m_subDecVtxHypoFlagNames[ipv]+"_blinded", false);
+ }
+ }
+ nPassPrecVtxCut++;
+
+ //----------------------------------------------------
+ // decorate the vertex - part 2
+ //----------------------------------------------------
+ // b) proper decay time and error:
+ // retrieve the refitted PV (or the original one,
+ // if the PV refitting was turned off)
+ if (doPt) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
+ if (doA0) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_A0);
+ if (doZ0) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_Z0);
+ if (doZ0BA) ProcessVertex(bcand, xAOD::BPhysHelper::PV_MIN_Z0_BA);
+
+ } // end of loop over bcand candidates
+
+ // counters
+ // event level
+ addEvent("allEvents");
+ if ( bcandContainer->size() > 0 ) addEvent("eventsWithCands");
+ if ( nPassMassCuts > 0 ) addEvent("massCutEvents");
+ if ( nPassChi2Cut > 0 ) addEvent("chi2CutEvents");
+ if ( nPassPrecVtxCut > 0 ) addEvent("precVtxCutEvents");
+ if ( m_doBlinding && nInBlindedRegion > 0 ) addEvent("blindedRegionEvents");
+ // candidate level
+ addToCounter("allCandidates" , bcandContainer->size());
+ addToCounter("massCutCandidates" , nPassMassCuts);
+ addToCounter("chi2CutCandidates" , nPassChi2Cut);
+ addToCounter("precVtxCutCandidates", nPassPrecVtxCut);
+ if ( m_doBlinding ) {
+ addToCounter("blindedRegionCandidates", nInBlindedRegion);
+ if ( m_blindOnlyAllMuonsTight ) {
+ addToCounter("blindedRegionCandidatesWithAllMuonsTight",
+ nInBlindedRegionAllMuonsTight);
+ }
+ }
+
+ // all OK
+ return StatusCode::SUCCESS;
+ }
+ //---------------------------------------------------------------------------
+ // Check whether mass cuts (including a possibly blinding region cut)
+ // are passed.
+ //---------------------------------------------------------------------------
+ bool Select_Bmumu::massCuts(float mass) const {
+
+ return (mass > m_massMin && mass < m_massMax)
+ && !(m_doBlinding && m_doCutBlinded && massInBlindedRegion(mass) );
+ }
+ //---------------------------------------------------------------------------
+ // Check whether mass cuts (including a possibly blinding region cut)
+ // are passed.
+ //---------------------------------------------------------------------------
+ bool Select_Bmumu::massInBlindedRegion(float mass) const {
+ return ( mass > m_blindMassMin && mass < m_blindMassMax );
+ }
+ //--------------------------------------------------------------------------
+ // Check whether all muons are of quality tight.
+ //--------------------------------------------------------------------------
+ bool Select_Bmumu::checkAllMuonsTight(const std::vector<const xAOD::Muon*>&
+ muons, int maxMuonsToCheck) const {
+
+ bool allTight(true);
+ int ncheckMax = muons.size();
+ if ( maxMuonsToCheck > -1 ) {
+ ncheckMax = std::min((int)muons.size(), maxMuonsToCheck);
+ }
+ for (int imu=0; imu < ncheckMax; ++imu) {
+ xAOD::Muon::Quality muQuality =
+ m_muSelectionTool->getQuality(*muons[imu]);
+ if ( !(muQuality <= xAOD::Muon::Tight) ) {
+ allTight = false;
+ break;
+ }
+ }
+ return allTight;
+ }
+ //---------------------------------------------------------------------------
+ // Helper to check whether an element is marked as passing a specific
+ // hypothesis.
+ //---------------------------------------------------------------------------
+ bool Select_Bmumu::pass(const SG::AuxElement& em, std::string hypo) const {
+
+ SG::AuxElement::Accessor<Char_t> flagAcc("passed_"+hypo);
+ return flagAcc.isAvailable(em) && flagAcc(em) != 0;
+ }
+ //---------------------------------------------------------------------------
+ // Helper to set an element marked as passing a specific hypothesis.
+ //---------------------------------------------------------------------------
+ bool Select_Bmumu::setPass(const SG::AuxElement& em, std::string hypo,
+ bool passVal) const {
+
+ SG::AuxElement::Decorator<Char_t> flagDec("passed_"+hypo);
+ flagDec(em) = passVal;
+ return true;
+ }
+ //---------------------------------------------------------------------------
+ // Helper to set an element marked as passing a specific hypothesis
+ // if the element doesn't have the specific flag yet.
+ // Returns true if action had to be taken.
+ //---------------------------------------------------------------------------
+ bool Select_Bmumu::setPassIfNotAvailable(SG::AuxElement& em, std::string hypo,
+ bool passVal) const {
+
+ SG::AuxElement::Accessor<Char_t> flagAcc("passed_"+hypo);
+ bool exists = flagAcc.isAvailable(em);
+ if ( !exists ) {
+ setPass(em, hypo, passVal);
+ }
+ return !exists;
+ }
+ //---------------------------------------------------------------------------
+ // Fetch a vector of preceeding vertices for a specific vertex
+ //---------------------------------------------------------------------------
+ /*
+ std::vector<xAOD::Vertex*>
+ Select_Bmumu::getPrecedingVertices(const xAOD::Vertex* vtx) {
+
+ // new vector of vertices
+ std::vector<xAOD::Vertex*> vtxList;
+
+ // Create auxiliary branches accessors
+ static SG::AuxElement::Accessor<VertexLinkVector>
+ precedingVertexLinksAcc("PrecedingVertexLinks");
+
+ // check if branch exists
+ if( precedingVertexLinksAcc.isAvailable(*vtx) ) {
+
+ // retrieve the precedingVertex links...
+ const VertexLinkVector& precedingVertexLinks =
+ precedingVertexLinksAcc(*vtx);
+
+ // ... and check if they are all valid
+ for ( VertexLinkVector::const_iterator precedingVertexLinksItr =
+ precedingVertexLinks.begin();
+ precedingVertexLinksItr!=precedingVertexLinks.end();
+ ++precedingVertexLinksItr) {
+ // check if links are valid
+ if( (*precedingVertexLinksItr).isValid() ) {
+ // xAOD::Vertex* vtx2 = *precedingVertexLinkItr;
+ // vtxList.push_back(*(*precedingVertexLinksItr));
+ }
+ } // for
+ } // if available
+
+ return vtxList;
+ }
+ */
+ //---------------------------------------------------------------------------
+
+} // namespace DerivationFramework
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Select_onia2mumu.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Select_onia2mumu.cxx
new file mode 100644
index 00000000000..33913419bf7
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Select_onia2mumu.cxx
@@ -0,0 +1,197 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/////////////////////////////////////////////////////////////////
+// Select_onia2mumu.cxx
+///////////////////////////////////////////////////////////////////
+// Author: Daniel Scheirich <daniel.scheirich@cern.ch>
+// Based on the Integrated Simulation Framework
+//
+// Basic Jpsi->mu mu derivation example
+
+#include "DerivationFrameworkBPhys/Select_onia2mumu.h"
+
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+
+#include <vector>
+#include <string>
+
+namespace DerivationFramework {
+
+ Select_onia2mumu::Select_onia2mumu(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_v0Tools("Trk::V0Tools")
+ {
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare tools
+ declareProperty("V0Tools", m_v0Tools);
+
+ // Declare user-defined properties
+
+ declareProperty("HypothesisName" , m_hypoName = "A");
+ declareProperty("InputVtxContainerName", m_inputVtxContainerName = "JpsiCandidates");
+ declareProperty("TrkMasses" , m_trkMasses = std::vector<double>(2, 105.658) );
+ declareProperty("VtxMassHypo" , m_massHypo = 3096.916 );
+ declareProperty("MassMax" , m_massMax = 6000);
+ declareProperty("MassMin" , m_massMin = 2000);
+ declareProperty("Chi2Max" , m_chi2Max = 200);
+ declareProperty("DoVertexType" , m_DoVertexType = 7);
+ declareProperty("LxyMin" , m_lxyMin = std::numeric_limits<double>::lowest());
+ declareProperty("Do3d" , m_do3d = false);
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode Select_onia2mumu::initialize()
+ {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // retrieve V0 tools
+ CHECK( m_v0Tools.retrieve() );
+ ATH_CHECK(m_inputVtxContainerName.initialize());
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ void Select_onia2mumu::ProcessVertex(xAOD::BPhysHypoHelper &onia, xAOD::BPhysHelper::pv_type pv_t) const{
+ constexpr float errConst = -9999999;
+ const xAOD::Vertex* pv = onia.pv(pv_t);
+ if(pv) {
+ // decorate the vertex.
+ // Proper decay time assuming constant mass hypothesis m_massHypo
+ BPHYS_CHECK( onia.setTau( m_v0Tools->tau(onia.vtx(), pv, m_massHypo),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+ // Proper decay time assuming error constant mass hypothesis m_massHypo
+ BPHYS_CHECK( onia.setTauErr( m_v0Tools->tauError(onia.vtx(), pv, m_massHypo),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+
+ BPHYS_CHECK( onia.setTau( m_v0Tools->tau(onia.vtx(), pv, m_trkMasses),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ BPHYS_CHECK( onia.setTauErr( m_v0Tools->tauError(onia.vtx(), pv, m_trkMasses),
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ //enum pv_type {PV_MAX_SUM_PT2, PV_MIN_A0, PV_MIN_Z0, PV_MIN_Z0_BA};
+ }else{
+
+
+ BPHYS_CHECK( onia.setTau(errConst, pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+ // Proper decay time assuming error constant mass hypothesis m_massHypo
+ BPHYS_CHECK( onia.setTauErr( errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+
+ BPHYS_CHECK( onia.setTau( errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ BPHYS_CHECK( onia.setTauErr( errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+ }
+
+ if(m_do3d){
+ BPHYS_CHECK( onia.setTau3d( pv ? m_v0Tools->tau3D(onia.vtx(), pv, m_massHypo) : errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+ // Proper decay time assuming error constant mass hypothesis m_massHypo
+ BPHYS_CHECK( onia.setTau3dErr( pv ? m_v0Tools->tau3DError(onia.vtx(), pv, m_massHypo) : errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_CONST_MASS) );
+
+ BPHYS_CHECK( onia.setTau3d( pv ? m_v0Tools->tau3D(onia.vtx(), pv, m_trkMasses) : errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ BPHYS_CHECK( onia.setTau3dErr( pv ? m_v0Tools->tau3DError(onia.vtx(), pv, m_trkMasses) : errConst,
+ pv_t,
+ xAOD::BPhysHypoHelper::TAU_INV_MASS) );
+
+ }
+
+ }
+
+
+ StatusCode Select_onia2mumu::addBranches() const
+ {
+
+ SG::ReadHandle<xAOD::VertexContainer> oniaContainer(m_inputVtxContainerName);
+
+ bool doPt = (m_DoVertexType & 1) != 0;
+ bool doA0 = (m_DoVertexType & 2) != 0;
+ bool doZ0 = (m_DoVertexType & 4) != 0;
+ bool doZ0BA = (m_DoVertexType & 8) != 0;
+ // loop over onia candidates and perform selection and augmentation
+ xAOD::VertexContainer::const_iterator oniaItr = oniaContainer->begin();
+ for(; oniaItr!=oniaContainer->end(); ++oniaItr) {
+ // create BPhysHypoHelper
+ xAOD::BPhysHypoHelper onia(m_hypoName, *oniaItr);
+ if((*oniaItr)->nTrackParticles() != m_trkMasses.size())
+ ATH_MSG_WARNING("Vertex has " << (*oniaItr)->nTrackParticles() << " while provided masses " << m_trkMasses.size());
+ //----------------------------------------------------
+ // decorate the vertex
+ //----------------------------------------------------
+ // a) invariant mass and error
+ if( !onia.setMass(m_trkMasses) ) ATH_MSG_WARNING("Decoration onia.setMass failed");
+
+ double massErr = m_v0Tools->invariantMassError(onia.vtx(), m_trkMasses);
+ if( !onia.setMassErr(massErr) ) ATH_MSG_WARNING("Decoration onia.setMassErr failed");
+
+ // b) proper decay time and error:
+ // retrieve the refitted PV (or the original one, if the PV refitting was turned off)
+ if(doPt) ProcessVertex(onia, xAOD::BPhysHelper::PV_MAX_SUM_PT2);
+ if(doA0) ProcessVertex(onia, xAOD::BPhysHelper::PV_MIN_A0);
+ if(doZ0) ProcessVertex(onia, xAOD::BPhysHelper::PV_MIN_Z0);
+ if(doZ0BA) ProcessVertex(onia, xAOD::BPhysHelper::PV_MIN_Z0_BA);
+
+ //----------------------------------------------------
+ // perform the selection (i.e. flag the vertex)
+ //----------------------------------------------------
+ // flag the vertex indicating that it is selected by this selector
+ onia.setPass(true);
+
+ // now we check othe cuts. if one of them didn't pass, set the flag to 0
+ // and continue to the next candidate:
+
+ // 1) invariant mass cut
+ if( onia.mass() < m_massMin || onia.mass() > m_massMax) {
+ onia.setPass(false); // flag as failed
+ continue;
+ }
+
+ // 2) chi2 cut
+ if( onia.vtx()->chiSquared() > m_chi2Max) {
+ onia.setPass(false);; // flag as failed
+ continue;
+ }
+ // 3) lxy cut
+ if( onia.lxy(xAOD::BPhysHelper::PV_MAX_SUM_PT2) < m_lxyMin) {
+ onia.setPass(false);; // flag as failed
+ continue;
+ }
+
+ } // end of loop over onia candidates
+
+ // all OK
+ return StatusCode::SUCCESS;
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+
+}
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Thin_vtxDuplicates.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Thin_vtxDuplicates.cxx
new file mode 100644
index 00000000000..abb34bcd436
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Thin_vtxDuplicates.cxx
@@ -0,0 +1,176 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/////////////////////////////////////////////////////////////////
+// Thin_vtxDuplicates.cxx
+///////////////////////////////////////////////////////////////////
+// Matteo Bedognetti (matteo.bedognetti@cern.ch)
+//Based on Thin_vtxTrk.cxx, by
+
+
+
+#include "DerivationFrameworkBPhys/Thin_vtxDuplicates.h"
+#include "xAODTracking/TrackParticleContainer.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include <vector>
+#include <string>
+#include <algorithm> // for the sort function
+#include <iomanip>
+#include "StoreGate/ThinningHandle.h"
+// Constructor
+DerivationFramework::Thin_vtxDuplicates::Thin_vtxDuplicates(const std::string& t, const std::string& n, const IInterface* p ) :
+ AthAlgTool(t,n,p),
+ // m_acceptanceR(-1.),
+ m_noFlags(false),
+ m_nVtxTot(0),
+ m_nVtxPass(0)
+{
+ declareInterface<DerivationFramework::IThinningTool>(this);
+
+ declareProperty("VertexContainerName" , m_vertexContainerNames);
+ declareProperty("PassFlags" , m_passFlags);
+ //declareProperty("AcceptanceRadius" , m_acceptanceR);
+ declareProperty("ApplyAnd" , m_and = true); //This will be applied depending on the order in which the thinning tools are added to the kernel
+ declareProperty("IgnoreFlags" , m_noFlags);
+ //declareProperty("ApplyAndForTracks" , m_trackAnd = false);
+ //declareProperty("ThinTracks" , m_thinTracks = true);
+}
+
+// Destructor
+DerivationFramework::Thin_vtxDuplicates::~Thin_vtxDuplicates() = default;
+
+// Athena initialize and finalize
+StatusCode DerivationFramework::Thin_vtxDuplicates::initialize()
+{
+ // Decide which collections need to be checked for ID TrackParticles
+ ATH_MSG_VERBOSE("initialize() ...");
+ ATH_CHECK(m_vertexContainerNames.initialize(m_streamName));
+
+
+ if (m_passFlags.empty()) {
+ ATH_MSG_FATAL("No pass flags provided for thinning.");
+ return StatusCode::FAILURE;
+ } else {
+ for(auto itr = m_passFlags.cbegin(); itr!=m_passFlags.cend(); ++itr) {
+ ATH_MSG_INFO("Vertices must pass the \"" << itr->key() << "\" selection");
+ }
+ }
+
+ for(auto &key : m_passFlags){
+ key = m_vertexContainerNames.key() + '.' + key.key();
+ }
+ ATH_CHECK(m_passFlags.initialize());
+ return StatusCode::SUCCESS;
+}
+
+StatusCode DerivationFramework::Thin_vtxDuplicates::finalize()
+{
+ ATH_MSG_VERBOSE("finalize() ...");
+ ATH_MSG_INFO("Processed "<< m_nVtxTot <<" vertices, "<< m_nVtxPass<< " were retained ");
+
+ return StatusCode::SUCCESS;
+}
+
+// The thinning itself
+StatusCode DerivationFramework::Thin_vtxDuplicates::doThinning() const
+{
+ // retieve vertex
+ SG::ThinningHandle< xAOD::VertexContainer > vertexContainer(m_vertexContainerNames);
+ std::vector<bool> vtxMask(vertexContainer->size(), true); // default: keep all vertices
+ int vtxTot = 0;
+ int nVtxPass = 0;
+ // loop over vertices
+ int k = 0;
+ std::vector<SG::ReadDecorHandle<xAOD::VertexContainer, Char_t>> handles;
+ handles.reserve(m_passFlags.size());
+ for(const auto &key : m_passFlags){
+ handles.emplace_back(key);
+ if(!handles.back().isPresent()) return StatusCode::FAILURE;
+ }
+ for(auto vtxItr = vertexContainer->cbegin(); vtxItr!=vertexContainer->cend(); ++vtxItr, ++k) {
+ const xAOD::Vertex* vtx = *vtxItr;
+ // check if the vertex passed the required selections criteria (is run when the vertex is already excluded, because the counter needs the info)
+ bool passed = false;
+ if(m_noFlags){passed = true; vtxTot++; }
+ else{
+ for(auto &flagAcc : handles) {
+ if(flagAcc(*vtx) != 0) {
+ passed = true;
+ vtxTot++;//Have to count the ones which are accepted to start with
+ break;
+ }
+ } // end of loop over flags
+ }
+
+ // Skip if it has already been identified as duplicate
+ if(vtxMask[k] == false)continue; //After the flag-check to have the total-passed work correctly
+
+ if(!passed)vtxMask[k]= false;
+
+ if(passed) {
+ // vertex passed the selection
+ nVtxPass++;
+
+ // determine the sum of the tracks at vertex as centre for the cone
+ std::vector<const xAOD::TrackParticle*> presentVertex, compareVertex;
+
+ //Fill in the present vertex, for later comparison against other vertices
+ presentVertex.clear();
+ for(uint j=0; j<vtx->nTrackParticles(); ++j) {
+ presentVertex.push_back(vtx->trackParticle(j));
+ }
+ sort( presentVertex.begin(), presentVertex.end() ); //Sort the trackparticles BY POINTER ADDRESS
+
+ //Loop over the remaining vertices and remove them if needed
+ int loop_k = k+1;
+ for(auto vtxLoopItr = vtxItr+1; vtxLoopItr!=vertexContainer->cend(); vtxLoopItr++, loop_k++){
+
+ const xAOD::Vertex* loop_vtx = *vtxLoopItr;
+
+ //Vertices are distinct if have different size
+ if(vtx->nTrackParticles() != loop_vtx->nTrackParticles())continue;
+
+ //If the vertex is still active load and compare
+ if(vtxMask[loop_k]){
+
+ compareVertex.clear();
+ for(uint j=0; j<loop_vtx->nTrackParticles(); ++j) {
+ compareVertex.push_back(loop_vtx->trackParticle(j));
+ }
+
+ std::sort( compareVertex.begin(), compareVertex.end());
+
+ vtxMask[loop_k] = false;
+
+ ATH_MSG_DEBUG("Compared tracks: ");
+ ATH_MSG_DEBUG(std::setw(14)<<compareVertex[0]<<std::setw(14) << compareVertex[1]<<std::setw(14)<<compareVertex[2]);
+ ATH_MSG_DEBUG(std::setw(14)<<presentVertex[0]<<std::setw(14) << presentVertex[1]<<std::setw(14)<<presentVertex[2]);
+
+ for(uint j=0; j<loop_vtx->nTrackParticles(); ++j) {
+ if( compareVertex[j] != presentVertex[j] ){vtxMask[loop_k] = true; break;}
+ }
+ ATH_MSG_DEBUG("Verdict:"<<(vtxMask[loop_k]? "keep": "erase") );
+ }
+
+ } // Endo of extra loop over remaining vertices
+
+ } // if( passed )
+ } // end of loop over vertices
+
+ // Execute the thinning service based on the vtxMask.
+ if (m_and) {
+ vertexContainer.keep(vtxMask, SG::ThinningHandleBase::Op::And);
+ }
+ if (!m_and) {
+ vertexContainer.keep(vtxMask, SG::ThinningHandleBase::Op::Or);
+ }
+
+ m_nVtxTot.fetch_add( vtxTot, std::memory_order_relaxed);
+ m_nVtxPass.fetch_add( nVtxPass, std::memory_order_relaxed);
+
+
+
+ return StatusCode::SUCCESS;
+}
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Thin_vtxTrk.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Thin_vtxTrk.cxx
new file mode 100644
index 00000000000..14628f870cd
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/Thin_vtxTrk.cxx
@@ -0,0 +1,200 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/////////////////////////////////////////////////////////////////
+// Thin_vtxTrk.cxx
+///////////////////////////////////////////////////////////////////
+// Author: James Catmore (James.Catmore@cern.ch)
+// This is a trivial example of an implementation of a thinning tool
+// which removes all ID tracks which do not pass a user-defined cut
+
+#include "DerivationFrameworkBPhys/Thin_vtxTrk.h"
+
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include "StoreGate/ThinningHandle.h"
+#include <vector>
+#include <string>
+// Constructor
+DerivationFramework::Thin_vtxTrk::Thin_vtxTrk(const std::string& t, const std::string& n, const IInterface* p ) :
+ AthAlgTool(t,n,p),
+ m_ntot(0),
+ m_npass(0),
+ m_acceptanceR(-1.), // Do not add tracks within a cone from the vertex by default
+ m_nVtxTot(0),
+ m_nVtxPass(0),
+ m_noFlags(false)
+{
+ declareInterface<DerivationFramework::IThinningTool>(this);
+
+ declareProperty("TrackParticleContainerName", m_trackParticleContainerName = "InDetTrackParticles");
+ declareProperty("VertexContainerNames" , m_vertexContainerName);
+ declareProperty("PassFlags" , m_passFlags);
+ declareProperty("AcceptanceRadius" , m_acceptanceR);
+ declareProperty("IgnoreFlags" , m_noFlags);
+ declareProperty("ApplyAnd" , m_and = false);
+ declareProperty("ApplyAndForTracks" , m_trackAnd = false);
+ declareProperty("ThinTracks" , m_thinTracks = true);
+}
+
+// Destructor
+DerivationFramework::Thin_vtxTrk::~Thin_vtxTrk() = default;
+
+// Athena initialize and finalize
+StatusCode DerivationFramework::Thin_vtxTrk::initialize()
+{
+ // Decide which collections need to be checked for ID TrackParticles
+ ATH_MSG_VERBOSE("initialize() ...");
+ ATH_CHECK(m_trackParticleContainerName.initialize(m_streamName));
+
+
+ if( m_noFlags){
+ ATH_MSG_INFO("IgnoreFlags is set, all vertices in the container will be kept");
+ }
+
+ if( ! m_noFlags){
+ if (m_passFlags.empty()) {
+ ATH_MSG_FATAL("No pass flags provided for thinning.");
+ return StatusCode::FAILURE;
+ } else {
+ for(auto itr = m_passFlags.begin(); itr!=m_passFlags.end(); ++itr) {
+ ATH_MSG_INFO("Vertices must pass the \"" << *itr << "\" selection");
+ }
+ }
+ }
+
+ if (m_acceptanceR > 0.) {
+ ATH_MSG_INFO("Extra tracks must be within cone of "<<m_acceptanceR<<" from vertex candidate.");
+ }
+
+ for(auto &handle : m_vertexContainerName){
+ ATH_CHECK(handle.initialize(m_streamName));
+ }
+ for(const auto &tracknames : m_vertexContainerName){
+ for(const auto &str : m_passFlags){
+ m_passArray.emplace_back(tracknames.key() + '.' + str);
+ }
+ }
+ ATH_CHECK(m_passArray.initialize());
+ return StatusCode::SUCCESS;
+}
+
+StatusCode DerivationFramework::Thin_vtxTrk::finalize()
+{
+ ATH_MSG_VERBOSE("finalize() ...");
+ ATH_MSG_INFO("Processed "<< m_ntot <<" tracks, "<< m_npass<< " were retained ");
+ ATH_MSG_INFO("Processed "<< m_nVtxTot <<" vertices, "<< m_nVtxPass<< " were retained ");
+
+ return StatusCode::SUCCESS;
+}
+
+// The thinning itself
+StatusCode DerivationFramework::Thin_vtxTrk::doThinning() const
+{
+ // Retrieve main TrackParticle collection
+ SG::ThinningHandle<xAOD::TrackParticleContainer> importedTrackParticles(m_trackParticleContainerName);
+
+ // Check the event contains tracks
+ unsigned int nTracks = importedTrackParticles->size();
+ if (nTracks==0) return StatusCode::SUCCESS;
+
+ // Set up a trackMask with the same entries as the full TrackParticle collection
+ std::vector<bool> trackMask(nTracks,false); // default: don't keep any tracks
+ m_ntot += nTracks;
+ int nVtxTot =0;
+ int nVtxPass=0;
+
+ std::unordered_map<std::string, SG::ReadDecorHandle<xAOD::VertexContainer, Char_t>> handles;
+ handles.reserve(m_passArray.size());
+ for(const auto &key : m_passArray){
+ auto it = handles.emplace(key.key(), key);
+ if(!(*it.first).second.isPresent()) return StatusCode::FAILURE;
+ }
+
+ // retieve vertex
+ for(const auto& name : m_vertexContainerName){
+ SG::ThinningHandle<xAOD::VertexContainer> vertexContainer(name);
+ std::vector<bool> vtxMask(vertexContainer->size(), false); // default: don't keep any vertices
+
+ // loop over vertices
+ int k = 0;
+ for(auto vtxItr = vertexContainer->begin(); vtxItr!=vertexContainer->end(); ++vtxItr, ++k) {
+ const xAOD::Vertex* vtx = *vtxItr;
+ nVtxTot++;
+
+ // check if the vertex passed the required selections criteria
+ bool passed = false;
+ for(std::vector<std::string>::const_iterator flagItr = m_passFlags.begin(); flagItr!=m_passFlags.end(); ++flagItr) {
+ std::string lookupstr = name.key() + '.' + (*flagItr);
+ const auto& handle = handles.at(lookupstr);
+ if(handle(*vtx) != 0) {
+ passed = true;
+ break;
+ }
+ } // end of loop over flags
+
+ if(passed || m_noFlags) {
+ // vertex passed the selection
+ vtxMask[k] = true;
+ nVtxPass++;
+
+ // Add tracks according to DR selection
+ if(m_acceptanceR > 0.){
+
+ // determine the sum of the tracks at vertex as centre for the cone
+ TLorentzVector centreCandidate;
+ for(uint j=0; j<vtx->nTrackParticles(); ++j) {
+ centreCandidate += vtx->trackParticle(j)->p4();
+ }
+
+ for(uint i=0; i<nTracks; ++i) {
+ if(!trackMask[i]) { // do this only for tracks that haven't been selected, yet
+ const xAOD::TrackParticle* track = (*importedTrackParticles)[i];
+ if(centreCandidate.DeltaR(track->p4()) < m_acceptanceR) trackMask[i]= true;
+ }
+ }
+ }// end adding tracks according to DR selection
+
+ if(m_thinTracks) {
+ // loop over all tracks
+ for(uint i=0; i<nTracks; ++i) {
+ if(!trackMask[i]) { // do this only for tracks that haven't been selected, yet
+ const xAOD::TrackParticle* track = (*importedTrackParticles)[i];
+ // loop over tracks at vertex
+ for(uint j=0; j<vtx->nTrackParticles(); ++j) {
+ if(vtx->trackParticle(j) == track) {
+ trackMask[i] = true; // accept track
+ }
+ } // end of loop over tracks at vertex
+ }
+ } // end of loop over all tracks
+ }
+ }
+ } // end of loop over vertices
+
+ // Execute the thinning service based on the vtxMask.
+ if (m_and) {
+ vertexContainer.keep(vtxMask, SG::ThinningHandleBase::Op::And);
+ }
+ if (!m_and) {
+ vertexContainer.keep(vtxMask, SG::ThinningHandleBase::Op::Or);
+ }
+ }
+
+ // Count up the trackMask contents
+ m_npass += std::accumulate(trackMask.begin(), trackMask.end(), 0);
+ m_nVtxTot += nVtxTot;
+ m_nVtxPass+= nVtxPass;
+ if(m_thinTracks || m_acceptanceR > 0.) {
+ // Execute the thinning service based on the trackMask. Finish.
+ if (m_trackAnd) {
+ importedTrackParticles.keep(trackMask, SG::ThinningHandleBase::Op::And);
+ }
+ if (!m_trackAnd) {
+ importedTrackParticles.keep(trackMask, SG::ThinningHandleBase::Op::Or);
+ }
+ }
+
+ return StatusCode::SUCCESS;
+}
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/TriggerCountToMetadata.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/TriggerCountToMetadata.cxx
new file mode 100644
index 00000000000..58af23444ec
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/TriggerCountToMetadata.cxx
@@ -0,0 +1,62 @@
+/*
+Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+//============================================================================
+//
+// Author : Matteo Bedognetti <matteo.bedognetti@cern.ch.>
+// Changes:
+//
+// Store trigger counts for specific chains in the DAOD's MetaData.
+// This allows it to store information about triggers upon which events are NOT selected during the derivation
+//
+// Job options:
+// - TriggerList -- a vector containing all triggers to store as strings
+// - FolderName -- Is supposed to be the derivation name (some convention I guess)
+// - TrigDecisionTool -- if one wants to pass this a specific TrigDecisionTool
+//
+//============================================================================
+//
+
+#include "DerivationFrameworkBPhys/TriggerCountToMetadata.h"
+#include "AthenaPoolUtilities/CondAttrListCollection.h"
+
+#include <memory>
+
+namespace DerivationFramework {
+
+ //--------------------------------------------------------------------------
+ TriggerCountToMetadata::TriggerCountToMetadata(const std::string& t,
+ const std::string& n,
+ const IInterface* p)
+ : CfAthAlgTool(t,n,p), m_trigDecisionTool( "Trig::TrigDecisionTool/TrigDecisionTool" )
+ {
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ declareProperty("TrigDecisionTool", m_trigDecisionTool );
+ declareProperty("FolderName", m_folderName = "DerivationLevel");
+ declareProperty("TriggerList", m_triggerList);
+
+ }
+ //--------------------------------------------------------------------------
+ StatusCode TriggerCountToMetadata::initialize() {
+ ATH_CHECK(m_trigDecisionTool.retrieve());
+
+ return StatusCode::SUCCESS;
+ }
+
+ //--------------------------------------------------------------------------
+ StatusCode TriggerCountToMetadata::addBranches() const {
+
+ ATH_MSG_DEBUG("Inside TriggerCountToMetadata::addBranches()");
+
+ // W.w. method
+ addEvent("AllEvents");
+
+ for( unsigned int i=0; i<m_triggerList.size(); i++){
+ addEvent(m_triggerList[i] , m_trigDecisionTool->isPassed(m_triggerList[i]) );
+ }
+
+ return StatusCode::SUCCESS;
+ }
+
+} // End of namespace DerivationFramework
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexCaloIsolation.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexCaloIsolation.cxx
new file mode 100644
index 00000000000..c47d71389e3
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexCaloIsolation.cxx
@@ -0,0 +1,583 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+// VertexCaloIsolation.cxx by Matteo Bedognetti
+//
+// This code is based on CaloIsolationTool of IsolationTools package
+//
+// Etcone is determined as a topoCluster-isolation value minus Energy Density (ED) correction and minus the energy depositions of the muons
+// Muon's energy deposition is already stored in side the xAOD::Muon objects, but the muon-clusters are used to correct for the fact that they muons may have overlapping clusters
+// The muon-clusters are stored as well in connection with the muons themselves
+//
+// The idea of comparing topoClusters with muon-clusters to decide what part of the muon's deposition is of
+// importance had to be abandoned because topCluster cells are not present in xAOD
+//
+// It enforces the fact that for muons no core-surface is removed for the energy-density correction (thus the corrections are independent from each other)
+//
+// "isReliable" flag reports of each isolation value if all particles crossing the cone have been correctly corrected for.
+// In the case of 2mu+ 1 track it mirrors the fact that the track does not extrapolate into the cone (as tracks have no muon-cluster from which to determine the core-correction)
+//
+
+
+
+
+#include "DerivationFrameworkBPhys/VertexCaloIsolation.h"
+
+#include <vector>
+#include <string>
+#include "TVector3.h"
+
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+
+//#include "IsolationTool/CaloIsolationTool.h"
+//#include "IsolationTool/CaloIsolationTool.h"
+
+#include "RecoToolInterfaces/ICaloTopoClusterIsolationTool.h"
+
+//#include "IsolationTool/IsolationHelper.h"
+//#include "InDetTrackSelectionTool/InDetTrackSelectionTool.h"
+#include "CaloEvent/CaloCell.h" //Is used (though shown as auto)
+//#include "TrkParameters/TrackParameters.h"
+#include "CaloInterface/ICaloNoiseTool.h"
+#include "TrkCaloExtension/CaloExtension.h"
+//#include "CaloUtils/CaloClusterStoreHelper.h"
+//#include "CaloUtils/CaloCellList.h"
+//#include "CaloEvent/CaloCellContainer.h"
+#include "xAODTracking/TrackingPrimitives.h"
+#include "xAODPrimitives/IsolationHelpers.h"
+#include "TrackToCalo/CaloCellCollector.h"
+#include <set>
+
+//#include "Identifier/Identifier32.h"
+using namespace std;
+namespace DerivationFramework {
+
+ VertexCaloIsolation::VertexCaloIsolation(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_caloIsoTool("xAOD::CaloIsolationTool/CaloIsolationTool"),
+ m_trackContainerName("InDetTrackParticles"),
+ m_vertexContainerName("NONE"),
+ m_caloClusterContainerName("CaloCalTopoClusters"),
+ m_muonContainerName("Muons"),
+ m_caloExtTool("Trk::ParticleCaloExtensionTool/ParticleCaloExtensionTool"),
+ //m_caloNoiseTool(""),
+ m_cones(),
+ m_sigmaCaloNoiseCut(3.4),
+ m_vertexType(7)
+
+
+ // m_cellCollector("")
+
+
+// m_caloExtTool
+// m_caloNoiseTool, m_applyCaloNoiseCut, m_sigmaCaloNoiseCut
+// m_cellCollector
+
+ {
+ ATH_MSG_DEBUG("in constructor");
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare tools
+ declareProperty("CaloIsoTool" , m_caloIsoTool);
+ declareProperty("TrackContainer" , m_trackContainerName);
+ declareProperty("InputVertexContainer" , m_vertexContainerName);
+ declareProperty("CaloClusterContainer" , m_caloClusterContainerName);
+ declareProperty("ParticleCaloExtensionTool", m_caloExtTool);
+ declareProperty("MuonContainer", m_muonContainerName);
+ declareProperty("PassFlags" , m_passFlags);
+ declareProperty("IsolationTypes" , m_cones);
+ declareProperty("DoVertexTypes" , m_vertexType);
+
+
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode VertexCaloIsolation::initialize()
+ {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // retrieve CaloIsolationTool
+ CHECK( m_caloIsoTool.retrieve() );
+
+ // retrieve CaloIsolationTool
+ CHECK( m_caloExtTool.retrieve() );
+
+ //Check that flags were given to tag the correct vertices
+ if(m_passFlags.empty()){
+ ATH_MSG_WARNING("As no pass-flags are given, no vertices will be decorated");
+ }
+
+ // Control the IsolationType sequence
+ if(m_cones.empty()){
+ m_cones.push_back(xAOD::Iso::etcone40);
+ m_cones.push_back(xAOD::Iso::etcone30);
+ m_cones.push_back(xAOD::Iso::etcone20);
+ }
+
+ //if(m_applyCaloNoiseCut){
+ //ATH_MSG_ERROR("No handle to a caloNoiseTool is kept in this tool, ");
+ //return StatusCode::FAILURE;
+ //}
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode VertexCaloIsolation::finalize()
+ {
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode VertexCaloIsolation::addBranches() const {
+
+
+ // There is also the "MuonClusterCollection" which may already contain all the muon's clusters
+
+ const xAOD::TrackParticleContainer* idTrackParticleContainer = NULL;
+ const xAOD::VertexContainer* vertexContainer = NULL;
+
+ Rec::CaloCellCollector cellCollector; //To keep private dependence for this package it is used here
+
+
+ const xAOD::MuonContainer* muons = NULL;
+
+
+ //Load InDetTrackParticles
+ if(evtStore()->contains<xAOD::TrackParticleContainer>(m_trackContainerName)) {
+ CHECK( evtStore()->retrieve(idTrackParticleContainer, m_trackContainerName) );
+ }
+ else{ATH_MSG_ERROR("Failed loading IdTrackparticleContainer container");
+ return StatusCode::FAILURE;
+ }
+
+ // load vertices
+ if(evtStore()->contains<xAOD::VertexContainer>(m_vertexContainerName)) {
+ CHECK( evtStore()->retrieve(vertexContainer, m_vertexContainerName) );
+ }
+ else{ATH_MSG_ERROR("Failed loading vertex container");
+ return StatusCode::FAILURE;
+ }
+
+
+ const xAOD::CaloClusterContainer* caloClusterContainer = NULL;
+ // load CaloCalTopoClusters
+ if(evtStore()->contains<xAOD::CaloClusterContainer>(m_caloClusterContainerName)) {
+ CHECK( evtStore()->retrieve(caloClusterContainer, m_caloClusterContainerName) );
+ }
+ else{ATH_MSG_ERROR("Failed loading vertex container");
+ return StatusCode::FAILURE;
+ }
+
+
+ //Retrieve muon container
+ if(evtStore()->contains<xAOD::MuonContainer>(m_muonContainerName)) {
+ CHECK( evtStore()->retrieve(muons, m_muonContainerName) );
+ }
+ else{ATH_MSG_ERROR("Failed loading muon contianer");
+ return StatusCode::FAILURE;
+ }
+
+
+//-------------------------------------------------
+
+ std::vector<xAOD::Iso::IsolationType> cones; cones.resize(m_cones.size());
+
+// for(unsigned int cone : m_cones)
+// cones.push_back(xAOD::Iso::IsolationType(cone));
+
+ for (unsigned int i =0; i< m_cones.size(); i++)
+ cones[i] = xAOD::Iso::IsolationType(m_cones[i]);
+
+
+
+ //Loop over vertices
+ for(auto vertex : *vertexContainer){
+
+ bool passed = false;
+ for(std::vector<std::string>::const_iterator flagItr = m_passFlags.begin(); flagItr!=m_passFlags.end(); ++flagItr) {
+ SG::AuxElement::Accessor<Char_t> flagAcc(*flagItr);
+ if(flagAcc.isAvailable(*vertex) && flagAcc(*vertex) != 0) {
+ passed = true;
+ break;
+ }
+ } // end of loop over flags
+ if(passed){
+ ATH_MSG_DEBUG("Entered loop over vertices");
+ if(vertex->trackParticleLinks().size() != 3)ATH_MSG_WARNING("Vertex without 3 tracks, it has "<< vertex->trackParticleLinks().size() <<" instead");
+
+ TLorentzVector candidate;
+
+ std::set<const xAOD::TrackParticle*> exclusionset;
+
+ for(auto part : vertex->trackParticleLinks()){ //Loop over tracks linked to vertex
+ candidate += (*part)->p4();
+ exclusionset.insert( *part ); //If it crashes use the direct TP from the vertex
+ }
+
+ //List of corrections: only the pileup correction is applied within the tool
+ xAOD::CaloCorrection corrlist;
+ corrlist.calobitset.set(static_cast<unsigned int>(xAOD::Iso::pileupCorrection));
+
+
+
+ std::vector<const xAOD::Muon*> vtxMuons;
+ std::vector<TLorentzVector> extrVtxMuons ;
+ std::vector<const xAOD::CaloCluster*> vtxMuonCluster;
+
+ std::vector<const xAOD::TrackParticle*> usedVtxTracks;
+ //The information whether we are missing some core-corrections in the final isolation value
+ map<xAOD::Iso::IsolationType, bool> is_reliable;
+
+
+ TLorentzVector muonref; //Place holder for the extrapolated position
+ //Load the caloclusters of the various muons (which you need to load from here)
+ const xAOD::MuonContainer* muons = 0;
+ CHECK( evtStore()->retrieve( muons, "Muons" ) );
+ for ( auto muon : *muons ) {
+ //I ask for all information to be fine before filling in an entry (so all containers will have the same -matching- objects)
+ if(muon->inDetTrackParticleLink().isValid() && exclusionset.find(*muon->inDetTrackParticleLink() ) != exclusionset.end() ){
+ const xAOD::CaloCluster* clus = muon->cluster();
+ if(clus && extrapolateMuon(muonref, clus)){
+ // have a muon, an extrapolation and a cluster (hurray)
+ vtxMuonCluster.push_back(clus);
+ vtxMuons.push_back(muon);
+ usedVtxTracks.push_back( *muon->inDetTrackParticleLink() );
+ extrVtxMuons.push_back(muonref);
+ }else{
+ ATH_MSG_DEBUG("Cannot find clusters. Would need a consistent set of Trk::Tracks to run extrapolation.");
+
+ // //If working with the cluster failed, try extrapolating the track
+ // if(extrapolateTrack(muonref, *muon)){ //This does not use the muonic cluster, but uses both its tracks to determine a precise position
+ // vtxMuonCluster.push_back(clus); //Note clus can also be NULL (for if it's not in the cone there is no point to fret)
+ // vtxMuons.push_back(muon);
+ // usedVtxTracks.push_back( *muon->inDetTrackParticleLink() );
+ // extrVtxMuons.push_back(muonref);
+ //}
+ }
+ }
+ }
+
+
+ //What if there was a track and not a muon??
+ //Should be treated like the muon-without-cluster case
+
+ if(vtxMuonCluster.size() !=3){ //remember that some of the ctxMuonCluster elements may be NULL
+ ATH_MSG_DEBUG( "Attempt at extrapolating the IDtrack" );
+
+ //Attempt extrapolating the IDtrack for the missing cases
+ for(const xAOD::TrackParticle* missingTrk : exclusionset){
+ if(std::find(usedVtxTracks.begin(), usedVtxTracks.end(), missingTrk) == usedVtxTracks.end()){
+ if(extrapolateTrack(muonref, *missingTrk)){
+ vtxMuonCluster.push_back(NULL); //Null, for we didn't start from a muon
+ usedVtxTracks.push_back( missingTrk );
+ extrVtxMuons.push_back(muonref);
+ }
+ }
+ }
+
+ //If there are still missing ones values cannot be guaranteed to be reliable
+ if(vtxMuonCluster.size() !=3){
+ ATH_MSG_DEBUG( "For this vertex there were less than 3 muons found (or extrapolated)" );
+ for(xAOD::Iso::IsolationType isoCone : cones) is_reliable[isoCone] = false;
+ }
+ }
+ else{
+ for(xAOD::Iso::IsolationType isoCone : cones)
+ is_reliable[isoCone] = true;
+ }
+
+
+ // Adapt this loop!
+
+ for(unsigned int vertex_type = 0 ; vertex_type<= xAOD::BPhysHelper::PV_MIN_Z0 ; vertex_type++ ){
+
+ if((m_vertexType & (1 << vertex_type ) ) == 0)continue; //Stop if the type of vertex is not required
+
+ //This can be in an inside loop
+
+ xAOD::BPhysHelper::pv_type this_type = static_cast<xAOD::BPhysHelper::pv_type>( vertex_type );
+
+ xAOD::TrackParticle candidate_slyTrack;
+ makeSlyTrack(candidate_slyTrack, candidate, vertex, this_type);
+
+
+ xAOD::CaloIsolation result;
+
+ ATH_MSG_DEBUG("Check if the caloclus container has to be given or not... see line from 755 on of CaloIsolationTool");
+
+ bool successful = m_caloIsoTool->caloTopoClusterIsolation(result, candidate_slyTrack, cones, corrlist, caloClusterContainer);
+ if( !successful ) {
+ ATH_MSG_DEBUG("Calculation of caloTopoClusterIsolation failed");
+ return StatusCode::FAILURE;
+ }
+
+ // Make the extension to the calorimeter, as it is done inside the other tools...
+ TLorentzVector extr_candidate;
+ if( !extrapolateTrack(extr_candidate, candidate_slyTrack) ){
+ ATH_MSG_WARNING("Failure extrapolating the slyTrack "<<"pt="<<candidate_slyTrack.pt()<<" eta="<<candidate_slyTrack.eta()<<" phi="<<candidate_slyTrack.phi());
+ ATH_MSG_WARNING("Taking the original coordinates");
+ }
+
+
+ std::map<xAOD::Iso::IsolationType,float> coreCorrections;
+
+ //See if this is inside the cone, to determine the correct correction ^^
+ for(xAOD::Iso::IsolationType isoType : cones){
+
+ double conesize = xAOD::Iso::coneSize(isoType);
+ //check what is inside the cone
+ std::vector<xAOD::CaloCluster> clustersInCone;
+
+ for(unsigned int j=0; j < vtxMuonCluster.size(); j++){
+ auto mucluster = vtxMuonCluster[j];
+ // I should use the propagated values here, though the variation is very small, coming from the vertex position
+ float dr=extrVtxMuons[j].DeltaR(extr_candidate);
+
+
+
+ ATH_MSG_DEBUG("Cone size: "<<conesize<<" dr="<<dr);
+ ATH_MSG_DEBUG(extrVtxMuons[j].Eta() <<" - "<<extr_candidate.Eta()<<" and "<<extrVtxMuons[j].Phi() <<" - "<<extr_candidate.Phi());
+
+ if( dr < conesize ){ //This makes a copy, such that I can remove some cells if needed
+
+
+ //here do the check for the cluster, if it should go in, then prevent and set the bad for this cone
+ if(mucluster != NULL) clustersInCone.push_back( xAOD::CaloCluster(*mucluster) );
+ else is_reliable[isoType] = false;
+
+
+
+ }
+ }
+
+ // ATH_MSG_DEBUG("Muon clusters in cone "<<xAOD::Iso::toString(isoType)<<" "<< clustersInCone.size());
+ // if( msgLvl(MSG::DEBUG) ){
+ // for(auto muon : vtxMuons)
+ // if(muon->isAvailable<float>("ET_Core")) ATH_MSG_DEBUG("ET_core stored inside: "<< muon->auxdataConst<float>("ET_Core") );
+ // }
+ //remove eventually doubles in cells
+ if(clustersInCone.size() == 2){
+ for(auto cell : clustersInCone[0]){
+ clustersInCone[1].removeCell(cell);
+ }
+ }
+ if(clustersInCone.size() == 3){
+ for(auto cell : clustersInCone[0]){
+ clustersInCone[1].removeCell(cell);
+ clustersInCone[2].removeCell(cell);
+ }
+ for(auto cell : clustersInCone[1]){
+ clustersInCone[2].removeCell(cell);
+ }
+ }
+
+ //Calculate the core-correction
+ std::vector<float> etcore(4, 0.);
+ float coreCorr=0.;
+ for(auto cl : clustersInCone){
+ if(cl.size() != 0){ //Maybe two muons have a full cluster overlap??
+ ATH_MSG_DEBUG("Cells in this cluster: "<< cl.size());
+
+ cellCollector.collectEtCore( cl, etcore, nullptr, m_sigmaCaloNoiseCut ); //Note an empty handle to ICaloNoiseTool is passed
+ coreCorr += etcore[Rec::CaloCellCollector::ET_Core];
+ ATH_MSG_DEBUG("Their core-energy: "<< etcore[Rec::CaloCellCollector::ET_Core]);
+
+ }
+ }
+
+ //Store the core-correction
+ coreCorrections[isoType] = coreCorr;
+
+ }
+
+ //For a pion I have no such cone energy, do I? But then I should also see what the original vertex was
+ //If something is not a muon there is no way the calocluster was stored, I think
+ //Would need further study
+
+
+ //Collect all the required information
+ string ED("_EDcorr");
+ string core("_COREcorr");
+ string reliable("_isReliable");
+
+
+ string vtx_type[3] = {"SumPt", "A0", "Z0"};
+
+ string vtx = vtx_type[ vertex_type ];
+
+ ATH_MSG_DEBUG("Detailed: ");
+ for(unsigned int i=0; i< cones.size(); i++){
+ xAOD::Iso::IsolationType isoType = cones[i];
+ result.etcones[i] -= coreCorrections[isoType]; //Finish correcting the energy
+
+
+ // if(fabs(result.etcones[i]) < 0.1){
+ //
+ // ATH_MSG_INFO("Isolation: "<<xAOD::Iso::toString(isoType) ); // The name of the isolation
+ // ATH_MSG_ERROR(result.etcones[i]<<" + "<<(result.noncoreCorrections[xAOD::Iso::pileupCorrection])[i]<<" + "<<coreCorrections[isoType] );
+ // }
+
+ //Here do the decoration (store all, and as well if three muons are found)
+
+
+ string variableName = xAOD::Iso::toString(isoType) + vtx; //I corrected for the closest vertex in A0
+ SG::AuxElement::Decorator<float> isolation(variableName);
+ isolation(*vertex) = result.etcones[i];
+
+ isolation = SG::AuxElement::Decorator<float>(variableName + ED);
+ isolation(*vertex) = (result.noncoreCorrections[xAOD::Iso::pileupCorrection])[i];
+
+ isolation = SG::AuxElement::Decorator<float>(variableName + core);
+ isolation(*vertex) = coreCorrections[isoType];
+
+ //This variable contains the info whether 3 caloclusters have been found in the muons
+ //Future would be to see if their extrapolations are of interest anyhow (if not missing them is no issue)
+ //Fore some reason these seem to become chars (instead of bools) in the output
+ SG::AuxElement::Decorator<bool> reliability(variableName + reliable);
+ reliability(*vertex) = is_reliable[isoType];
+
+ }
+ } //Loop over primaryVertex choice
+
+ //Decorate the candidate with the new information
+
+
+// return StatusCode::SUCCESS;
+//
+// ///////////////////////////////////
+
+ }
+
+//END OF NEW PART
+ }//End of loop over vertices
+ return StatusCode::SUCCESS;
+ }
+
+ //Note that the full version had a different method for muons!!!! Maybe I should use that one instead!
+
+ //This is almost a perfect copy of CaloIsolationTool::GetExtrapEtaPhi, but only for the part relative to tracks
+ bool VertexCaloIsolation::extrapolateTrack(TLorentzVector& extr_tp, const xAOD::IParticle& tp) const{
+ extr_tp = tp.p4(); //Pre-set the output TLorentzVector to the input's 4-momentum
+ ATH_MSG_ERROR("VertexCaloIsolation::extrapolateTrack needs to be rewritten because of changes to the caloExtension");
+ throw std::runtime_error("VertexCaloIsolation::extrapolateTrack needs to be rewritten because of changes to the caloExtension");
+/*
+
+
+ const Trk::CaloExtension* caloExtension = 0;
+ if(!m_caloExtTool->caloExtension(tp,caloExtension)){
+ ATH_MSG_WARNING("Can not get caloExtension.");
+ return false;
+ }
+
+ const std::vector<const Trk::CurvilinearParameters*>& intersections = caloExtension->caloLayerIntersections();
+ if (intersections.size()>0) {
+ Amg::Vector3D avePoint(0,0,0);
+ for (unsigned int i = 0; i < intersections.size(); ++i){
+ const Amg::Vector3D& point = intersections[i]->position();
+ avePoint += point;
+ }
+ avePoint = (1./intersections.size())*avePoint;
+
+
+ extr_tp.SetPtEtaPhiE(1., avePoint.eta(), avePoint.phi(), 10.); //Using the three-vector constructor
+ //eta = avePoint.eta();
+ //phi = avePoint.phi();
+ ATH_MSG_DEBUG("Successfully extrapolated candidate eta/phi : "<<tp.eta()<<"/"<<tp.phi()<<" --> "<< extr_tp.Eta()<<"/"<<extr_tp.Phi());
+
+ }
+ else{ //This is very unlikely, it happens if a few cases in MC
+ ATH_MSG_WARNING("Candidate extrapolation failed. Keeping track's eta/phi values");
+ return false;
+
+ }
+
+ return true;
+*/
+
+ }
+
+ //Version for the muons
+ bool VertexCaloIsolation::extrapolateMuon(TLorentzVector& extr_tp, const xAOD::CaloCluster* cluster) const
+ {
+ //auto cluster = mu->cluster(); //done outside
+ if(cluster){
+ float etaT = 0, phiT = 0;
+ int nSample = 0;
+ for(unsigned int i=0; i<CaloSampling::Unknown; i++) // dangerous?
+ {
+ auto s = static_cast<CaloSampling::CaloSample>(i);
+ if(!cluster->hasSampling(s)) continue;
+ //ATH_MSG_DEBUG("Sampling: " << i << "eta-phi (" << cluster->etaSample(s) << ", " << cluster->phiSample(s) << ")");
+ etaT += cluster->etaSample(s);
+ phiT += cluster->phiSample(s);
+ nSample++;
+ }
+ if(nSample>0){
+
+ extr_tp.SetPtEtaPhiE(1., etaT/nSample, phiT/nSample, 10.); //Using the three-vector constructor
+ return true ;
+
+ }else{
+ ATH_MSG_WARNING("Muon calo cluster is empty????");
+ return false;
+ }
+ }else{
+ ATH_MSG_WARNING("Muon calo cluster not found. Calo extension can not be obtained!!!");
+ return false;
+ }
+ }
+
+ //Make a sly track to be fed to the CaloIsolationTool
+ xAOD::TrackParticle& VertexCaloIsolation::makeSlyTrack(xAOD::TrackParticle& candidate_slyTrack, const TLorentzVector& candidate, const xAOD::Vertex* vertex, xAOD::BPhysHelper::pv_type vertexType) const {
+
+ candidate_slyTrack.makePrivateStore();
+ candidate_slyTrack.setDefiningParameters(0, 0., candidate.Phi(), candidate.Theta(), 0. ); // avoided q/p = 1./candidate.P()
+
+ //I should set the correct d0 and z0, while setting momentum to enormous, to obtain a straight line
+ //I fear that q/p == 0 might cause some divide by 0, though.
+
+ //Somewhere this information will be checked, so I need to provide it
+ SG::AuxElement::Decorator<uint8_t> hypothesis("particleHypothesis");
+ hypothesis(candidate_slyTrack) = xAOD::undefined; //Value 99 as none of the common types (muon, pion, kaon, etc.)
+ SG::AuxElement::Decorator<std::vector<float> > covmat( "definingParametersCovMatrix" );
+ covmat(candidate_slyTrack) = std::vector<float>(25, 0.); // I am saying that there are no errors on my parameters
+ //The precision goes down a bit, but it's a matter of 10e-7 with our values of interest
+
+ xAOD::BPhysHelper vertex_h(vertex); //Use the BPhysHelper to access vertex quantities
+
+ SG::AuxElement::Decorator<float> vx( "vx" );
+ vx(candidate_slyTrack) = vertex_h.pv(vertexType)->x();
+
+ SG::AuxElement::Decorator<float> vy( "vy" );
+ vy(candidate_slyTrack) = vertex_h.pv(vertexType)->y();
+
+ SG::AuxElement::Decorator<float> vz( "vz" );
+ vz(candidate_slyTrack) = vertex_h.pv(vertexType)->z();
+ //The precision goes down a bit, but it's a matter of 10e-7 with our values of interest
+
+ return candidate_slyTrack;
+
+
+ }
+
+
+
+
+}//End of namespace DerivationFramework
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexPlus1TrackCascade.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexPlus1TrackCascade.cxx
new file mode 100644
index 00000000000..b3c4c221dd4
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexPlus1TrackCascade.cxx
@@ -0,0 +1,215 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include "DerivationFrameworkBPhys/VertexPlus1TrackCascade.h"
+
+#include "TrkVertexFitterInterfaces/IVertexFitter.h"
+#include "TrkVKalVrtFitter/TrkVKalVrtFitter.h"
+#include "TrkToolInterfaces/ITrackSelectorTool.h"
+
+namespace DerivationFramework {
+
+
+ typedef std::vector<const xAOD::TrackParticle*> TrackBag;
+
+ StatusCode VertexPlus1TrackCascade::initialize() {
+
+ // retrieving vertex Fitter
+ if ( m_iVertexFitter.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_iVertexFitter);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Retrieved tool " << m_iVertexFitter);
+ }
+
+ // Get the track selector tool from ToolSvc
+ if ( m_trkSelector.retrieve().isFailure() ) {
+ ATH_MSG_FATAL("Failed to retrieve tool " << m_trkSelector);
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Retrieved tool " << m_trkSelector);
+ }
+ if(!m_vertexContainerKey.key().empty()) ATH_CHECK(m_vertexContainerKey.initialize());
+ if(!m_TrackPContainerKey.key().empty()) ATH_CHECK(m_TrackPContainerKey.initialize());
+ if(!m_MuonsUsedInJpsiKey.key().empty()) ATH_CHECK(m_MuonsUsedInJpsiKey.initialize());
+
+ return StatusCode::SUCCESS;
+ }
+
+ StatusCode VertexPlus1TrackCascade::finalize() {
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ VertexPlus1TrackCascade::VertexPlus1TrackCascade(const std::string& t, const std::string& n, const IInterface* p) : AthAlgTool(t,n,p),
+ m_vertexContainerKey(""),
+ m_TrackPContainerKey(""),
+ m_MuonsUsedInJpsiKey(""),
+ m_Vtx1MassConstraint(0.),
+ m_Vtx2MassConstraint(0.0),
+ m_trkThresholdPt(0.0),
+ m_trkMaxEta(102.5),
+// m_BThresholdPt(0.0),
+// m_BMassUpper(0.0),
+// m_BMassLower(0.0),
+ m_roughMassLower(0.0),
+ m_roughMassUpper(0.0),
+ m_iVertexFitter("Trk::TrkVKalVrtFitter"),
+ m_trkSelector("InDet::TrackSelectorTool")
+ {
+ declareProperty("InitialVertices", m_vertexContainerKey);
+ declareProperty("TrackParticleCollection", m_TrackPContainerKey);
+ declareProperty("MuonCollection", m_MuonsUsedInJpsiKey);
+ declareProperty("MassHypthesis", m_massHypothesis);
+ declareProperty("MassContraintTracksVtx1", m_massConstraintTracksVtx1);
+ declareProperty("MassContraintTracksVtx2", m_massConstraintTracksVtx2);
+
+ declareProperty("Vtx1MassConstraint", m_Vtx1MassConstraint);
+ declareProperty("Vtx2MassConstraint", m_Vtx2MassConstraint);
+
+ declareProperty("trkThresholdPtCut", m_trkThresholdPt);
+ declareProperty("trkMassEtaCut", m_trkMaxEta);
+// declareProperty("BThresholdPtCut", m_BThresholdPt);
+// declareProperty("BMassUpperCut", m_BMassUpper);
+// declareProperty("BMassLowerCut", m_BMassLower);
+
+ declareProperty("RoughMassUpperCut", m_roughMassLower);
+ declareProperty("RoughMassLowerCut", m_roughMassUpper);
+
+ }
+
+ VertexPlus1TrackCascade::~VertexPlus1TrackCascade(){ }
+
+ double VertexPlus1TrackCascade::getInvariantMass(const TrackBag &Tracks, const std::vector<double> &massHypotheses){
+
+ TLorentzVector total;
+ total.SetVectM(Tracks[0]->p4().Vect(), massHypotheses[0]);
+ TLorentzVector temp;
+ for(size_t i=1; i < Tracks.size(); i++){
+ temp.SetVectM(Tracks[i]->p4().Vect(), massHypotheses[i]);
+ total += temp;
+ }
+ return total.M();
+ }
+
+ bool VertexPlus1TrackCascade::isContainedIn(const xAOD::TrackParticle* theTrack, const xAOD::MuonContainer* theColl) {
+ bool isContained(false);
+ for (auto muItr=theColl->cbegin(); muItr!=theColl->cend(); ++muItr) {
+ auto& link = ( *muItr )->inDetTrackParticleLink();
+ if ( link.isValid() && ( *link == theTrack ) ) {isContained=true; break;}
+ }
+ return isContained;
+ }
+
+ StatusCode VertexPlus1TrackCascade::performSearch(std::vector<Trk::VxCascadeInfo*> *cascadeinfoContainer) const
+ {
+ ATH_MSG_DEBUG( "VertexPlus1TrackCascade::performSearch" );
+ assert(cascadeinfoContainer!=nullptr);
+ SG::ReadHandle<xAOD::VertexContainer> vertexContainer(m_vertexContainerKey);
+ if(!vertexContainer.isValid()){
+ ATH_MSG_ERROR("No VertexContainer with key " << m_vertexContainerKey.key() << " found in StoreGate. BCandidates will be EMPTY!");
+ return StatusCode::FAILURE;
+ }
+
+ // Get tracks
+ SG::ReadHandle<xAOD::TrackParticleContainer> TrackPContainer(m_TrackPContainerKey);
+ if(!TrackPContainer.isValid()){
+ ATH_MSG_ERROR("No track particle collection with name " << m_TrackPContainerKey.key() << " found in StoreGate!");
+ return StatusCode::FAILURE;
+ }
+
+
+ // Get the muon collection used to build the J/psis
+ const xAOD::MuonContainer* importedMuonCollection = nullptr;
+ if (!m_MuonsUsedInJpsiKey.key().empty()) {
+ SG::ReadHandle<xAOD::MuonContainer> handle(m_MuonsUsedInJpsiKey);
+ if(handle.isValid()) importedMuonCollection = handle.cptr();
+ else {
+ ATH_MSG_FATAL("problem retrieving MuonContainer " << m_MuonsUsedInJpsiKey.key());
+ return StatusCode::FAILURE;
+ }
+ ATH_MSG_DEBUG("Muon container size "<< importedMuonCollection->size());
+ }
+
+ // Select the inner detector tracks
+ TrackBag theIDTracksAfterSelection;
+ for (auto tp : *TrackPContainer){
+ if ( tp->pt()<m_trkThresholdPt ) continue;
+ if ( fabs(tp->eta())>m_trkMaxEta ) continue;
+ if (importedMuonCollection!=NULL) {
+ if (isContainedIn(tp, importedMuonCollection)) continue;
+ }
+ if ( m_trkSelector->decision(*tp, NULL) ) theIDTracksAfterSelection.push_back(tp);
+ }
+
+ const std::vector<double> &fullMassHypoth = (m_massHypothesis);
+ const std::vector<double> initialVertexMassHypo(fullMassHypoth.begin(), fullMassHypoth.end()-1);
+
+ TrackBag originalVertexTracks(initialVertexMassHypo.size());
+ TrackBag secondVertexTracks(fullMassHypoth.size());
+
+ const std::vector< Trk::VertexID > emptyVtxList;
+ TrackBag ConstraintTracksVtx1(m_massConstraintTracksVtx1.size());
+ TrackBag ConstraintTracksVtx2(m_massConstraintTracksVtx2.size());
+
+ assert(fullMassHypoth.size() == secondVertexTracks.size());
+
+ for(auto vertex : *vertexContainer){ //Iterate over previous vertices
+
+ size_t OriginaltrackNum = vertex->nTrackParticles();
+ if(initialVertexMassHypo.size() != OriginaltrackNum){
+ ATH_MSG_FATAL("Mass hypothesis not correctly set");
+ return StatusCode::FAILURE;
+ }
+ for(size_t i = 0;i<OriginaltrackNum;i++)
+ originalVertexTracks[i] = secondVertexTracks[i] = (vertex->trackParticle(i));
+
+ for(auto newtrack : theIDTracksAfterSelection){
+ //Skip any track already used in vertex
+ if(std::find(originalVertexTracks.begin(), originalVertexTracks.end(), newtrack) != originalVertexTracks.end()) continue;
+
+ secondVertexTracks.back() = newtrack;
+
+ double roughmass = getInvariantMass(secondVertexTracks, fullMassHypoth);
+
+ if(m_roughMassUpper > 0.0 && (roughmass < m_roughMassLower || roughmass > m_roughMassUpper)) continue;
+
+ std::unique_ptr<Trk::IVKalState> state = m_iVertexFitter->makeState();
+ m_iVertexFitter->setRobustness( 0, *state );
+
+ auto vID1 = m_iVertexFitter->startVertex( originalVertexTracks, initialVertexMassHypo, *state );
+ auto vID2 = m_iVertexFitter->nextVertex( secondVertexTracks, fullMassHypoth, *state );
+
+ if(!m_massConstraintTracksVtx1.empty()){
+ for(size_t i =0; i<m_massConstraintTracksVtx1.size(); i++) ConstraintTracksVtx1[i] = originalVertexTracks.at(m_massConstraintTracksVtx1[i]);
+ if( !m_iVertexFitter->addMassConstraint( vID1, ConstraintTracksVtx1, emptyVtxList, *state, m_Vtx1MassConstraint ).isSuccess() ) {
+ ATH_MSG_WARNING( "cascade fit: addMassConstraint failed" );
+ }
+ }
+
+ if(!m_massConstraintTracksVtx2.empty()){
+ for(size_t i =0; i<m_massConstraintTracksVtx2.size(); i++) ConstraintTracksVtx2[i] = secondVertexTracks.at(m_massConstraintTracksVtx2[i]);
+ if( !m_iVertexFitter->addMassConstraint( vID2, ConstraintTracksVtx2, emptyVtxList,*state, m_Vtx2MassConstraint ).isSuccess() ) {
+ ATH_MSG_WARNING( "cascade fit: addMassConstraint failed" );
+ }
+ }
+
+ auto result = m_iVertexFitter->fitCascade(*state);
+ if(result ==nullptr ){ ATH_MSG_WARNING("Cascade Fit failed"); continue; }
+ assert(result->vertices().size()==2);
+ cascadeinfoContainer->push_back(result);
+
+ }
+
+ }
+ ATH_MSG_DEBUG("cascadeinfoContainer size " << cascadeinfoContainer->size());
+ return StatusCode::SUCCESS;
+ }
+
+
+}
+
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexTrackIsolation.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexTrackIsolation.cxx
new file mode 100644
index 00000000000..7ce8df7972f
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/VertexTrackIsolation.cxx
@@ -0,0 +1,274 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include "DerivationFrameworkBPhys/VertexTrackIsolation.h"
+
+#include <vector>
+#include <string>
+#include "TVector3.h"
+
+#include "xAODTracking/VertexContainer.h"
+#include "xAODTracking/VertexAuxContainer.h"
+#include "xAODBPhys/BPhysHelper.h"
+#include "xAODBPhys/BPhysHypoHelper.h"
+#include "TrkVertexAnalysisUtils/V0Tools.h"
+
+//#include "IsolationTool/CaloIsolationTool.h"
+//#include "IsolationTool/TrackIsolationTool.h"
+#include "RecoToolInterfaces/ITrackIsolationTool.h"
+#include "xAODPrimitives/IsolationHelpers.h" //For the definition of Iso::conesize
+
+//#include "IsolationTool/IsolationHelper.h"
+//#include "InDetTrackSelectionTool/InDetTrackSelectionTool.h"
+
+
+//#include "Identifier/Identifier32.h"
+using namespace std;
+namespace DerivationFramework {
+
+ VertexTrackIsolation::VertexTrackIsolation(const std::string& t,
+ const std::string& n,
+ const IInterface* p) :
+ AthAlgTool(t,n,p),
+ m_trackIsoTool("xAOD::TrackIsolationTool"),
+ m_trackContainerName("InDetTrackParticles"),
+ m_vertexContainerName("NONE"),
+ m_cones(),
+ m_vertexType(7),
+
+ m_doIsoPerTrk(false),
+ m_removeDuplicate(2)
+ {
+ ATH_MSG_DEBUG("in constructor");
+ declareInterface<DerivationFramework::IAugmentationTool>(this);
+
+ // Declare tools
+ declareProperty("TrackIsoTool" , m_trackIsoTool);
+
+ declareProperty("TrackContainer" , m_trackContainerName);
+ declareProperty("InputVertexContainer" , m_vertexContainerName);
+ declareProperty("PassFlags" , m_passFlags);
+ declareProperty("IsolationTypes" , m_cones);
+ declareProperty("DoVertexTypes" , m_vertexType);
+
+ declareProperty("DoIsoPerTrk" , m_doIsoPerTrk, "New property to deal with track isolation per track, the default option (m_doIsoPerTrk=false) preserves the old behavior");
+ declareProperty("RemoveDuplicate" , m_removeDuplicate, "Used with DoIsoPerTrk");
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode VertexTrackIsolation::initialize()
+ {
+
+ ATH_MSG_DEBUG("in initialize()");
+
+ // retrieve TrackIsolationTool
+ CHECK( m_trackIsoTool.retrieve() );
+
+ //Check that flags were given to tag the correct vertices
+ if(m_passFlags.empty()){
+ ATH_MSG_WARNING("As no pass-flags are given, no vertices will be decorated");
+ }
+
+ // Control the IsolationType sequence
+ if(m_cones.empty()){
+ ATH_MSG_INFO("Setting ptcones to default");
+
+ if(m_doIsoPerTrk) m_cones.push_back(xAOD::Iso::ptcone50);
+ m_cones.push_back(xAOD::Iso::ptcone40);
+ m_cones.push_back(xAOD::Iso::ptcone30);
+ m_cones.push_back(xAOD::Iso::ptcone20);
+
+ }
+
+ return StatusCode::SUCCESS;
+
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode VertexTrackIsolation::finalize()
+ {
+ // everything all right
+ return StatusCode::SUCCESS;
+ }
+
+ // check if the two vertices are composed of the same set of tracks
+ bool VertexTrackIsolation::isSame(const xAOD::Vertex* theVtx1, const xAOD::Vertex* theVtx2) const {
+ if(!theVtx1 || !theVtx2) return false;
+ if(theVtx1==theVtx2) return true;
+ if(theVtx1->nTrackParticles() != theVtx2->nTrackParticles()) return false;
+
+ if(m_removeDuplicate==2 && theVtx1->nTrackParticles()==4) { // a special case with sub-structure
+ bool firstTwoAreSame = std::set<const xAOD::TrackParticle*>( { theVtx1->trackParticle(0), theVtx1->trackParticle(1)} ) == std::set<const xAOD::TrackParticle*>( {theVtx2->trackParticle(0), theVtx2->trackParticle(1)} ); // the 1st pair of tracks
+ bool lastTwoAreSame = std::set<const xAOD::TrackParticle*>( { theVtx1->trackParticle(2), theVtx1->trackParticle(3)} ) == std::set<const xAOD::TrackParticle*>( {theVtx2->trackParticle(2), theVtx2->trackParticle(3)} ); // the 2nd pair of tracks
+ if(firstTwoAreSame && lastTwoAreSame) return true;
+ else return false;
+ }
+ else { // the general case
+ std::set<const xAOD::TrackParticle*> vtxset1;
+ std::set<const xAOD::TrackParticle*> vtxset2;
+ for(size_t i=0; i<theVtx1->nTrackParticles(); i++) vtxset1.insert(theVtx1->trackParticle(i));
+ for(size_t i=0; i<theVtx2->nTrackParticles(); i++) vtxset2.insert(theVtx2->trackParticle(i));
+ return vtxset1 == vtxset2;
+ }
+ }
+
+ bool VertexTrackIsolation::isContainedIn(const xAOD::Vertex* theVtx, const std::vector<const xAOD::Vertex*> &theColl) const {
+ for ( const auto vtxPtr : theColl ) {
+ if ( isSame(vtxPtr, theVtx) ) return true;
+ }
+ return false;
+ }
+
+ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+
+ StatusCode VertexTrackIsolation::addBranches() const {
+
+ const xAOD::TrackParticleContainer* idTrackParticleContainer = NULL;
+ const xAOD::VertexContainer* vertexContainer = NULL;
+
+ if(evtStore()->contains<xAOD::TrackParticleContainer>(m_trackContainerName)) {
+ CHECK( evtStore()->retrieve(idTrackParticleContainer, m_trackContainerName) );
+ }
+ else{ATH_MSG_ERROR("Failed loading IdTrackparticleContainer container");
+ return StatusCode::FAILURE;
+ }
+
+ // load vertices
+ if(evtStore()->contains<xAOD::VertexContainer>(m_vertexContainerName)) {
+ CHECK( evtStore()->retrieve(vertexContainer, m_vertexContainerName) );
+ }
+ else{ATH_MSG_ERROR("Failed loading vertex container");
+ return StatusCode::FAILURE;
+ }
+
+ std::vector<const xAOD::Vertex*> outVtxContainer;
+
+ //Convert m_cones (done per-event to avoid needing extra public dependency)
+
+ std::vector<xAOD::Iso::IsolationType> cones; cones.resize(m_cones.size());
+
+ for (unsigned int i =0; i< m_cones.size(); i++)
+ cones[i] = xAOD::Iso::IsolationType(m_cones[i]);
+ //for(unsigned int cone : m_cones)
+ // cones.push_back(xAOD::Iso::IsolationType(cone));
+
+ ATH_MSG_DEBUG("The provided IsolationTypes are re-ordered internally");
+ std::sort(cones.begin(),cones.end(),[](xAOD::Iso::IsolationType i, xAOD::Iso::IsolationType j) { return xAOD::Iso::coneSize(i) > xAOD::Iso::coneSize(j); } );
+
+ // loop over vertices
+ for(auto vertex : *vertexContainer){
+
+ bool passed = false;
+ for(std::vector<std::string>::const_iterator flagItr = m_passFlags.begin(); flagItr!=m_passFlags.end(); ++flagItr) {
+ SG::AuxElement::Accessor<Char_t> flagAcc(*flagItr);
+ if(flagAcc.isAvailable(*vertex) && flagAcc(*vertex) != 0) {
+ passed = true;
+ break;
+ }
+ } // end of loop over flags
+ if(passed){
+ if(!m_doIsoPerTrk) { // for legacy
+ if(vertex->trackParticleLinks().size() != 3)ATH_MSG_WARNING("Vertex without 3 tracks, it has "<< vertex->trackParticleLinks().size() <<" instead");
+ }
+ else {
+ if(m_removeDuplicate) {
+ if( isContainedIn(vertex, outVtxContainer) ) continue;
+ outVtxContainer.push_back(vertex);
+ }
+ }
+
+ TLorentzVector candidate;
+
+ std::set<const xAOD::TrackParticle*> exclusionset;
+
+ for(auto part : vertex->trackParticleLinks()){ //Loop over tracks linked to vertex
+ candidate += (*part)->p4();
+ exclusionset.insert( *part ); //If it crashes use the direct TP from the vertex
+ }
+ //No! the above candidate will fail acceptance of isolation() because it's neither a muon nor a TrackParticle
+
+ //Make a dummy TrackParticle, otherwise TrackIsolationTool cannot deal with it
+ xAOD::TrackParticle candidate_slyTrack;
+ candidate_slyTrack.makePrivateStore();
+ candidate_slyTrack.setDefiningParameters(0, 0., candidate.Phi(), candidate.Theta(), 0./*1./candidate.P()*/);
+ //The precision goes down a bit, but it's a matter of 10e-7 with our values of interest
+
+ //Make a correctionlist such that the given exclusionset will be removed from the used tracks
+ //There is no danger that the input particle will be excluded, as it is not part of inDetTrackContainer
+ xAOD::TrackCorrection corrlist;
+ corrlist.trackbitset.set(static_cast<unsigned int>(xAOD::Iso::coreTrackPtr));
+
+
+ string vtxType_name[3] = {"SumPt", "A0", "Z0"};
+
+ xAOD::BPhysHelper vertex_h(vertex); //Use the BPhysHelper to access vertex quantities
+
+
+ //Loop over refitted primary vertex choice
+ for(unsigned int vertex_type = 0 ; vertex_type<= xAOD::BPhysHelper::PV_MIN_Z0 ; vertex_type++ ){
+
+ if((m_vertexType & (1 << vertex_type ) ) == 0)continue; //Stop if the type of vertex is not required
+
+
+ //if(debug should go outside!!!)
+
+ ATH_MSG_DEBUG("List of cone types" );
+
+
+ for(unsigned int i =0; i < cones.size(); i++){
+
+ ATH_MSG_DEBUG("cone type = "<< xAOD::Iso::toString(xAOD::Iso::IsolationType(cones[i])) );
+ // ATH_MSG_DEBUG("isolation value "<< vtxType_name[vertex_type] << " = "<< result.ptcones[i] );
+ // ATH_MSG_DEBUG("isolation value "<<vtxType_name[vertex_type] <<" = "<< result.ptcones[i] );
+ }
+
+
+
+ const xAOD::Vertex* refVtx = vertex_h.pv( static_cast<xAOD::BPhysHelper::pv_type>(vertex_type) ); //Fix the cast
+
+ xAOD::TrackIsolation result;
+
+ if(!m_doIsoPerTrk) {
+ m_trackIsoTool->trackIsolation(result, candidate_slyTrack, cones, corrlist, refVtx, &exclusionset, idTrackParticleContainer);
+
+
+ //Decorate the vertex with all the isolation values
+ for(unsigned int i =0; i < cones.size(); i++){
+
+ string variableName;
+
+ variableName = xAOD::Iso::toString(xAOD::Iso::IsolationType(cones[i]));
+ variableName += vtxType_name[vertex_type];
+
+ SG::AuxElement::Decorator<float> isolation(variableName);
+ isolation(*vertex) = result.ptcones[i];
+
+ }
+ }
+ else {
+ for(size_t i=0; i<vertex->nTrackParticles(); i++) {
+ m_trackIsoTool->trackIsolation(result, *vertex->trackParticle(i), cones, corrlist, refVtx, &exclusionset, idTrackParticleContainer);
+
+ for(unsigned int j =0; j < cones.size(); j++) {
+ string variableName;
+ variableName = xAOD::Iso::toString(xAOD::Iso::IsolationType(cones[j]));
+ variableName += vtxType_name[vertex_type] + "_trk" + std::to_string(i+1);
+ SG::AuxElement::Decorator<float> isolation(variableName);
+ isolation(*vertex) = result.ptcones[j];
+ }
+ }
+ }
+ }
+
+ }// End of if passed
+ }// end of loop over vertices
+
+ return StatusCode::SUCCESS;
+ }
+
+}//End of namespace DerivationFramework
+
diff --git a/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/components/DerivationFrameworkBPhys_entries.cxx b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/components/DerivationFrameworkBPhys_entries.cxx
new file mode 100644
index 00000000000..9bd3917c40d
--- /dev/null
+++ b/PhysicsAnalysis/DerivationFramework/DerivationFrameworkBPhys/src/components/DerivationFrameworkBPhys_entries.cxx
@@ -0,0 +1,74 @@
+#include "DerivationFrameworkBPhys/Reco_Vertex.h"
+#include "DerivationFrameworkBPhys/Reco_4mu.h"
+#include "DerivationFrameworkBPhys/Select_onia2mumu.h"
+#include "DerivationFrameworkBPhys/Thin_vtxTrk.h"
+#include "DerivationFrameworkBPhys/Thin_vtxDuplicates.h"
+#include "DerivationFrameworkBPhys/AugOriginalCounts.h"
+#include "DerivationFrameworkBPhys/BPhysPVThinningTool.h"
+#include "DerivationFrameworkBPhys/VertexCaloIsolation.h"
+#include "DerivationFrameworkBPhys/VertexTrackIsolation.h"
+#include "DerivationFrameworkBPhys/BPhysMetadataBase.h"
+#include "DerivationFrameworkBPhys/Bmumu_metadata.h"
+//#include "DerivationFrameworkBPhys/CfAthAlgTool.h"
+#include "DerivationFrameworkBPhys/Bmumu_reco_mumu.h"
+#include "DerivationFrameworkBPhys/FourMuonTool.h"
+//#include "DerivationFrameworkBPhys/BPhysAddMuonBasedInvMass.h"
+//#include "DerivationFrameworkBPhys/BPhysVertexTrackBase.h"
+//#include "DerivationFrameworkBPhys/BVertexTrackIsoTool.h"
+//#include "DerivationFrameworkBPhys/BMuonTrackIsoTool.h"
+//#include "DerivationFrameworkBPhys/BVertexClosestTrackTool.h"
+#include "DerivationFrameworkBPhys/BTrackVertexMapLogger.h"
+//#include "DerivationFrameworkBPhys/Select_Bmumu.h"
+//#include "DerivationFrameworkBPhys/BPhysVarBlinder.h"
+//#include "DerivationFrameworkBPhys/BmumuThinningTool.h"
+#include "DerivationFrameworkBPhys/VertexPlus1TrackCascade.h"
+#include "DerivationFrameworkBPhys/TriggerCountToMetadata.h"
+#include "DerivationFrameworkBPhys/MuonExtrapolationTool.h"
+#include "DerivationFrameworkBPhys/CascadeTools.h"
+#include "DerivationFrameworkBPhys/Reco_V0Finder.h"
+#include "DerivationFrameworkBPhys/JpsiPlusV0Cascade.h"
+#include "DerivationFrameworkBPhys/JpsiPlusDsCascade.h"
+#include "DerivationFrameworkBPhys/JpsiPlusDpstCascade.h"
+#include "DerivationFrameworkBPhys/JpsiPlusDs1Cascade.h"
+#include "DerivationFrameworkBPhys/ReVertex.h"
+#include "DerivationFrameworkBPhys/BPhysConversionFinder.h"
+#include "DerivationFrameworkBPhys/Cascade3Plus1.h"
+
+using namespace DerivationFramework;
+
+DECLARE_COMPONENT( Reco_4mu )
+DECLARE_COMPONENT( Reco_Vertex )
+DECLARE_COMPONENT( Select_onia2mumu )
+DECLARE_COMPONENT( Thin_vtxTrk )
+DECLARE_COMPONENT( Thin_vtxDuplicates )
+DECLARE_COMPONENT( AugOriginalCounts )
+DECLARE_COMPONENT( BPhysPVThinningTool )
+DECLARE_COMPONENT( VertexCaloIsolation )
+DECLARE_COMPONENT( VertexTrackIsolation )
+DECLARE_COMPONENT( BPhysMetadataBase )
+DECLARE_COMPONENT( Bmumu_metadata )
+//DECLARE_COMPONENT( CfAthAlgTool )
+//DECLARE_COMPONENT( Bmumu_reco_mumu )
+DECLARE_COMPONENT( FourMuonTool )
+//DECLARE_COMPONENT( BPhysAddMuonBasedInvMass )
+//DECLARE_COMPONENT( BPhysVertexTrackBase )
+//DECLARE_COMPONENT( BVertexTrackIsoTool )
+//DECLARE_COMPONENT( BMuonTrackIsoTool )
+//DECLARE_COMPONENT( BVertexClosestTrackTool )
+DECLARE_COMPONENT( BTrackVertexMapLogger )
+//DECLARE_COMPONENT( Select_Bmumu )
+//DECLARE_COMPONENT( BPhysVarBlinder )
+//DECLARE_COMPONENT( BmumuThinningTool )
+DECLARE_COMPONENT( VertexPlus1TrackCascade )
+DECLARE_COMPONENT( TriggerCountToMetadata )
+DECLARE_COMPONENT( MuonExtrapolationTool )
+DECLARE_COMPONENT( CascadeTools )
+DECLARE_COMPONENT( Reco_V0Finder )
+DECLARE_COMPONENT( JpsiPlusV0Cascade )
+DECLARE_COMPONENT( JpsiPlusDsCascade )
+DECLARE_COMPONENT( JpsiPlusDpstCascade )
+DECLARE_COMPONENT( JpsiPlusDs1Cascade )
+DECLARE_COMPONENT( ReVertex )
+DECLARE_COMPONENT( BPhysConversionFinder )
+DECLARE_COMPONENT( Cascade3Plus1 )
+
--
GitLab