diff --git a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfigDb.py b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfigDb.py
index 585ac96728ffd7485b6663086a94c3b518a5455d..c344832b279a351c3619f635d70ee98139ae2b3e 100644
--- a/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfigDb.py
+++ b/Tracker/TrackerDetDescr/FaserSCT_GeoModel/python/FaserSCT_GeoModelConfigDb.py
@@ -1,6 +1,6 @@
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-from AthenaCommon.CfgGetter import addAlgorithm,addTool
+from AthenaCommon.CfgGetter import addTool
# add tools and algorithms to the ConfiguredFactory, see:
# https://twiki.cern.ch/twiki/bin/viewauth/AtlasComputing/ConfiguredFactory
addTool("FaserSCT_GeoModel.FaserSCT_GeoModelConfig.FasergetSCT_DetectorTool","FaserSCT_DetectorTool")
diff --git a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfig.py b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfig.py
index 3d9ec7a072ce801067ae843341e5ca9b8f84ce40..d875c327eb2673741a4d0580fe42d0458e285c62 100644
--- a/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfig.py
+++ b/Tracker/TrackerDigitization/FaserSCT_Digitization/python/FaserSCT_DigitizationConfig.py
@@ -49,7 +49,7 @@ def getFaserSCT_SurfaceChargesGenerator(name="FaserSCT_SurfaceChargesGenerator",
sct_SiPropertiesToolSetup.setSiliconTool(sct_SiliconConditionsToolSetup.getTool())
sct_SiPropertiesToolSetup.setup()
## Charge trapping tool - used by SCT_SurfaceChargesGenerator
- from AthenaCommon.AppMgr import ToolSvc
+# from AthenaCommon.AppMgr import ToolSvc
## SiLorentzAngleTool for SCT_SurfaceChargesGenerator
from SiLorentzAngleTool.SCTLorentzAngleToolSetup import SCTLorentzAngleToolSetup
sctLorentzAngleToolSetup = SCTLorentzAngleToolSetup()
@@ -185,9 +185,9 @@ def commonFaserSCT_DigitizationConfig(name,**kwargs):
# write out SCT1_RawData
#kwargs.setdefault("WriteSCT1_RawData", False)
- if digitizationFlags.doXingByXingPileUp():
- kwargs.setdefault("FirstXing", SCT_FirstXing())
- kwargs.setdefault("LastXing", SCT_LastXing() )
+# if digitizationFlags.doXingByXingPileUp():
+# kwargs.setdefault("FirstXing", SCT_FirstXing())
+# kwargs.setdefault("LastXing", SCT_LastXing() )
from AthenaCommon import CfgMgr
return CfgMgr.FaserSCT_DigitizationTool(name,**kwargs)
@@ -198,7 +198,7 @@ def commonFaserSCT_DigitizationConfig(name,**kwargs):
######################################################################################
def FaserSCT_DigitizationTool(name="FaserSCT_DigitizationTool", **kwargs):
- from Digitization.DigitizationFlags import digitizationFlags
+# from Digitization.DigitizationFlags import digitizationFlags
kwargs.setdefault("OutputObjectName", "SCT_RDOs")
kwargs.setdefault("OutputSDOName", "SCT_SDO_Map")
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt
index a6ff20cdab5cb61d20b97b17290b0224ee6192fc..87b41d357f9aeeae0a538a1601109cafa103a7fa 100644
--- a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt
@@ -16,18 +16,19 @@ atlas_add_library( TrackerEventAthenaPool
AthenaBaseComps AthenaKernel SGTools StoreGateLib AthenaPoolCnvSvcLib
AthenaPoolUtilities AtlasSealCLHEP GaudiKernel TrackerIdentifier
TrackerReadoutGeometry TrackerEventTPCnv TrackerRawData TrackerSimData
- TrackerPrepRawData TrkTrack )
+ TrackerPrepRawData TrackerSpacePoint TrkTrack )
atlas_add_poolcnv_library( TrackerEventAthenaPoolPoolCnv
FILES TrackerRawData/FaserSCT_RDO_Container.h
TrackerPrepRawData/FaserSCT_ClusterContainer.h
+ TrackerSpacePoint/FaserSCT_SpacePointContainer.h
src/TrackerTrack.h
TrackerSimData/TrackerSimDataCollection.h
LINK_LIBRARIES Identifier GeneratorObjectsTPCnv AthAllocators AthContainers
AthenaBaseComps AthenaKernel SGTools StoreGateLib AthenaPoolCnvSvcLib
AthenaPoolUtilities AtlasSealCLHEP GaudiKernel TrackerIdentifier
TrackerReadoutGeometry TrackerEventTPCnv TrackerRawData TrackerSimData
- TrackerPrepRawData TrkTrack TrackerEventAthenaPool )
+ TrackerPrepRawData TrackerSpacePoint TrkTrack TrackerEventAthenaPool )
atlas_add_dictionary( TrackerEventAthenaPoolCnvDict
TrackerEventAthenaPool/TrackerEventAthenaPoolCnvDict.h
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_SpacePointContainerCnv.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_SpacePointContainerCnv.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..5a63749a53243fc196ac93ccab92c040359e7d4b
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_SpacePointContainerCnv.cxx
@@ -0,0 +1,77 @@
+/*
+ Copyright (C) 2021 CERN for the benefit of the FASER collaboration
+ */
+
+#include "FaserSCT_SpacePointContainerCnv.h"
+
+/*
+StatusCode FaserSCT_SpacePointContainerCnv::initialize() {
+ ATH_MSG_INFO("FaserSCT_SpacePointContainerCnv::initialize()");
+
+ StatusCode sc = FaserSCT_SpacePointContainerCnvBase::initialize();
+ if (sc.isFailure()) {
+ ATH_MSG_FATAL("Cannot initialize cnv base !");
+ return StatusCode::FAILURE;
+ }
+
+ // get StoreGate service. This is needed only for clients
+ // that register collections directly to the SG instead of adding
+ // them to the container.
+ sc = service("StoreGateSvc", m_storeGate);
+ if (sc.isFailure()) {
+ ATH_MSG_FATAL("StoreGate service not found !");
+ return StatusCode::FAILURE;
+ }
+
+ // get DetectorStore service
+ StoreGateSvc* detStore(nullptr);
+ if (service("DetectorStore", detStore).isFailure()) {
+ ATH_MSG_FATAL("DetectorStore service not found !");
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Found DetectorStore.");
+ }
+
+ // Get the SCT helper from the detector store
+ const FaserSCT_ID* idhelper(nullptr);
+ if (detStore->retrieve(idhelper, "FaserSCT_ID").isFailure()) {
+ ATH_MSG_FATAL("Could not get FaserSCT_ID helper !");
+ return StatusCode::FAILURE;
+ } else {
+ ATH_MSG_DEBUG("Found the FaserSCT_ID helper.");
+ }
+ ATH_MSG_DEBUG("Converter initialized");
+
+ return StatusCode::SUCCESS;
+}
+*/
+
+FaserSCT_SpacePointContainer_PERS*
+FaserSCT_SpacePointContainerCnv::createPersistent (FaserSCT_SpacePointContainer* transObj) {
+ ATH_MSG_INFO("FaserSCT_SpacePointContainerCnv::createPersistent()");
+
+ FaserSCT_SpacePointContainerCnv_PERS converter;
+
+ FaserSCT_SpacePointContainer_PERS* persObj(nullptr);
+ persObj = converter.createPersistent(transObj, msg());
+ return persObj;
+}
+
+
+FaserSCT_SpacePointContainer*
+FaserSCT_SpacePointContainerCnv::createTransient() {
+ ATH_MSG_INFO("FaserSCT_SpacePointContainerCnv::createTransient()");
+
+ static const pool::Guid p0_guid("DB0397F9-A163-496F-BC17-C7E507A1FA50");
+ FaserSCT_SpacePointContainer* transObj(nullptr);
+
+ if (compareClassGuid(p0_guid)) {
+ std::unique_ptr<FaserSCT_SpacePointContainer_PERS> col_vect(poolReadObject<FaserSCT_SpacePointContainer_PERS>());
+ FaserSCT_SpacePointContainerCnv_PERS converter;
+ transObj = converter.createTransient( col_vect.get(), msg());
+ } else {
+ throw std::runtime_error("Unsupported persistent version of FaserSCT_SpacePointContainer");
+ }
+
+ return transObj;
+}
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_SpacePointContainerCnv.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_SpacePointContainerCnv.h
new file mode 100644
index 0000000000000000000000000000000000000000..0004da8e97d4c208533f063e53bcf79cb0178231
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/FaserSCT_SpacePointContainerCnv.h
@@ -0,0 +1,38 @@
+/*
+ Copyright 2021 CERN for the benefit of the FASER collaboration
+*/
+
+#ifndef FASERSCT_SPACEPOINTCONTAINERCNV_H
+#define FASERSCT_SPACEPOINTCONTAINERCNV_H
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolCustomCnv.h"
+
+#include "TrackerEventTPCnv/FaserSCT_SpacePointContainerCnv_p0.h"
+
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePointContainer_p0.h"
+#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "StoreGate/StoreGateSvc.h"
+#include "StoreGate/ReadCondHandle.h"
+
+
+typedef FaserSCT_SpacePointContainer_p0 FaserSCT_SpacePointContainer_PERS;
+typedef FaserSCT_SpacePointContainerCnv_p0 FaserSCT_SpacePointContainerCnv_PERS;
+
+typedef T_AthenaPoolCustomCnv<FaserSCT_SpacePointContainer, FaserSCT_SpacePointContainer_PERS> FaserSCT_SpacePointContainerCnvBase;
+
+class FaserSCT_SpacePointContainerCnv : public FaserSCT_SpacePointContainerCnvBase {
+ friend class CnvFactory<FaserSCT_SpacePointContainerCnv>;
+
+ public:
+ FaserSCT_SpacePointContainerCnv (ISvcLocator* svcloc) : FaserSCT_SpacePointContainerCnvBase(svcloc, "FaserSCT_SpacePointContainerCnv") {}
+
+ protected:
+ // Must initialize ID helpers
+// virtual StatusCode initialize();
+ virtual FaserSCT_SpacePointContainer_PERS* createPersistent (FaserSCT_SpacePointContainer* transObj);
+ virtual FaserSCT_SpacePointContainer* createTransient ();
+};
+
+#endif // SPACEPOINTCONTAINERCNV_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/SpacePointContainerCnv.cxx b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/SpacePointContainerCnv.cxx
deleted file mode 100644
index 4ea69f69454c3e5683f3202e17b844dde7fb4208..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/SpacePointContainerCnv.cxx
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- Copyright (C) 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#include "SpacePointContainerCnv.h"
-
-SpacePointContainer_PERS*
-SpacePointContainerCnv::createPersistent (SpacePointContainer* transObj) {
- ATH_MSG_INFO("SpacePointContainerCnv::createPersistent()");
-
- SpacePointContainerCnv_PERS converter;
-
- SpacePointContainer_PERS* persObj(nullptr);
- persObj = converter.createPersistent(transObj, msg());
- return persObj;
-}
-
-
-SpacePointContainer*
-SpacePointContainerCnv::createTransient() {
- ATH_MSG_INFO("SpacePointContainerCnv::createTransient()");
-
- static const pool::Guid p0_guid("DB0397F9-A163-496F-BC17-C7E507A1FA50");
- SpacePointContainer* transObj(nullptr);
-
- if (compareClassGuid(p0_guid)) {
- std::unique_ptr<SpacePointContainer_PERS> col_vect(poolReadObject<SpacePointContainer_PERS>());
- SpacePointContainerCnv_PERS converter;
- transObj = converter.createTransient( col_vect.get(), msg());
- } else {
- throw std::runtime_error("Unsupported persistent version of SpacePointContainer");
- }
-
- return transObj;
-}
diff --git a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/SpacePointContainerCnv.h b/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/SpacePointContainerCnv.h
deleted file mode 100644
index 9537ce3aad9f6327535b90dfef7bda79e9c313c3..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/SpacePointContainerCnv.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- Copyright 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#ifndef SPACEPOINTCONTAINERCNV_H
-#define SPACEPOINTCONTAINERCNV_H
-
-#include "AthenaPoolCnvSvc/T_AthenaPoolCustomCnv.h"
-
-#include "TrackerEventTPCnv/SpacePointContainerCnv_p0.h"
-
-#include "TrkSpacePoint/SpacePointContainer.h"
-#include "TrackerEventTPCnv/SpacePointContainer_p0.h"
-
-typedef SpacePointContainer_p0 SpacePointContainer_PERS;
-typedef SpacePointContainerCnv_p0 SpacePointContainerCnv_PERS;
-
-typedef T_AthenaPoolCustomCnv<SpacePointContainer, SpacePointContainer_PERS> SpacePointContainerCnvBase;
-
-class SpacePointContainerCnv : public SpacePointContainerCnvBase {
- friend class CnvFactory<SpacePointContainerCnv>;
-
- public:
- SpacePointContainerCnv (ISvcLocator* svcloc) : SpacePointContainerCnvBase(svcloc) {}
-
- protected:
- virtual SpacePointContainer_PERS* createPersistent (SpacePointContainer* transObj);
- virtual SpacePointContainer* createTransient ();
-};
-
-#endif // SPACEPOINTCONTAINERCNV_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/CMakeLists.txt b/Tracker/TrackerEventCnv/TrackerEventCnvTools/CMakeLists.txt
index 6053d2790392ae986af95db90127dedf1fc5c0b1..31dad792833d8b5aef2f1dc06a36cc676dbaa724 100644
--- a/Tracker/TrackerEventCnv/TrackerEventCnvTools/CMakeLists.txt
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/CMakeLists.txt
@@ -5,6 +5,6 @@ atlas_subdir( TrackerEventCnvTools )
# Component(s) in the package:
atlas_add_component( TrackerEventCnvTools
- src/*.cxx
+ src/*.cxx TrackerEventCnvTools/*h
src/components/*.cxx
- LINK_LIBRARIES AthenaBaseComps FaserDetDescr IdDictDetDescr Identifier TrackerIdentifier TrackerReadoutGeometry TrackerPrepRawData TrackerRIO_OnTrack StoreGateLib TrkPrepRawData TrkRIO_OnTrack TrkEventCnvToolsLib )
+ LINK_LIBRARIES AthenaBaseComps FaserDetDescr IdDictDetDescr Identifier TrackerIdentifier TrackerReadoutGeometry TrackerPrepRawData TrackerSpacePoint TrackerRIO_OnTrack StoreGateLib TrkPrepRawData TrkRIO_OnTrack TrkEventCnvToolsLib )
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/TrackerSpacePointCnvTool.h b/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/TrackerSpacePointCnvTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..115139c39fc4987243566831004795de5f8cd820
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/TrackerEventCnvTools/TrackerSpacePointCnvTool.h
@@ -0,0 +1,51 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ */
+
+#ifndef TRACKERSPACEPOINTCNVTOOL_H
+#define TRACKERSPACEPOINTCNVTOOL_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/ReadHandleKey.h"
+
+#include <utility>
+
+class Identifier;
+class IdentifierHash;
+
+
+namespace Tracker {
+ /**Helper tool uses to convert Tracker objects in generic tracking custom convertor TrkEventAthenaPool.
+
+ See "mainpage" for discussion of jobOpts.
+ */
+ class TrackerSpacePointCnvTool : public AthAlgTool
+ {
+ public:
+
+ TrackerSpacePointCnvTool(const std::string&,const std::string&,const IInterface*);
+
+ ~TrackerSpacePointCnvTool() = default;
+
+ virtual StatusCode initialize() override;
+
+
+ std::pair<const Tracker::FaserSCT_Cluster*, const Tracker::FaserSCT_Cluster*>
+ sctClusterLinks( const Identifier& id1, const IdentifierHash& idHash1, const Identifier& id2, const IdentifierHash& idHash2 ) const ;
+ void recreateSpacePoint( Tracker::FaserSCT_SpacePoint *sp, const Identifier& id1, const Identifier& id2, const IdentifierHash& idhash1, const IdentifierHash& idhash2 ) const ;
+
+
+ private:
+
+
+ SG::ReadHandleKey<Tracker::FaserSCT_ClusterContainer> m_sctClusContName{this, "SCT_ClusterContainer", "SCT_Clusters", "SCT Cluster container name"}; //!< location of container of sct clusters
+
+ };
+
+}
+#endif // MOORETOTRACKTOOL_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/TrackerSpacePointCnvTool.cxx b/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/TrackerSpacePointCnvTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..8649c37127b23639a993806971cf35e5124d2ea3
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/TrackerSpacePointCnvTool.cxx
@@ -0,0 +1,86 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+ */
+
+#include "TrackerEventCnvTools/TrackerSpacePointCnvTool.h"
+
+#include "Identifier/Identifier.h"
+#include "Identifier/IdentifierHash.h"
+
+#include "TrackerPrepRawData/FaserSCT_ClusterCollection.h"
+#include "TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h"
+
+#include <vector>
+#include <cassert>
+#include <iostream>
+
+Tracker::TrackerSpacePointCnvTool::TrackerSpacePointCnvTool(const std::string& t,
+ const std::string& n,
+ const IInterface* p )
+ :
+ AthAlgTool(t,n,p)
+{
+}
+
+StatusCode Tracker::TrackerSpacePointCnvTool::initialize() {
+
+ StatusCode sc = AthAlgTool::initialize();
+ if (sc.isFailure()) return sc;
+
+ ATH_CHECK( m_sctClusContName.initialize() );
+
+ return sc;
+
+}
+
+void Tracker::TrackerSpacePointCnvTool::recreateSpacePoint( Tracker::FaserSCT_SpacePoint *sp, const Identifier& id1, const Identifier& id2, const IdentifierHash& idhash1, const IdentifierHash& idhash2 ) const {
+ auto clusters= sctClusterLinks( id1,idhash1, id2,idhash2);
+ sp->setClusList(clusters);
+ return;
+}
+
+std::pair<const Tracker::FaserSCT_Cluster*, const Tracker::FaserSCT_Cluster*>
+Tracker::TrackerSpacePointCnvTool::sctClusterLinks( const Identifier& id1, const IdentifierHash & idHash1, const Identifier& id2, const IdentifierHash& idHash2 ) const {
+ const Tracker::FaserSCT_Cluster* clus1=nullptr;
+ const Tracker::FaserSCT_Cluster* clus2=nullptr;
+ // need to retrieve pointers to collections
+ // retrieve Pixel cluster container
+
+ // obviously this can be optimised! EJWM
+ SG::ReadHandle<Tracker::FaserSCT_ClusterContainer> h_sctClusCont(m_sctClusContName);
+ if (!h_sctClusCont.isValid()) {
+ ATH_MSG_ERROR("FaserSCT Cluster container not found at "<<m_sctClusContName);
+ return std::make_pair(clus1,clus2);
+ } else {
+ ATH_MSG_DEBUG("FaserSCT Cluster Container found" );
+ }
+ const Tracker::FaserSCT_ClusterCollection *ptr1 = h_sctClusCont->indexFindPtr(idHash1);
+ const Tracker::FaserSCT_ClusterCollection *ptr2 = h_sctClusCont->indexFindPtr(idHash2);
+ // if we find PRD, then recreate link
+ if (ptr1!=nullptr) {
+ //loop though collection to find matching PRD.
+ Tracker::FaserSCT_ClusterCollection::const_iterator collIt = ptr1->begin();
+ Tracker::FaserSCT_ClusterCollection::const_iterator collItEnd = ptr1->end();
+ // there MUST be a faster way to do this!!
+ for ( ; collIt!=collItEnd; collIt++) {
+ if ( (*collIt)->identify()==id1 )
+ clus1= &(**collIt);
+ }
+ }
+ // if we find PRD, then recreate link
+ if (ptr2!=nullptr) {
+ //loop though collection to find matching PRD.
+ Tracker::FaserSCT_ClusterCollection::const_iterator collIt = ptr2->begin();
+ Tracker::FaserSCT_ClusterCollection::const_iterator collItEnd = ptr2->end();
+ // there MUST be a faster way to do this!!
+ for ( ; collIt!=collItEnd; collIt++) {
+ if ( (*collIt)->identify()==id2 )
+ clus2= &(**collIt);
+ }
+ }
+ if(clus1==nullptr||clus2==nullptr)
+ ATH_MSG_DEBUG("No matching PRD found" );
+ return std::make_pair(clus1,clus2);
+}
+
+
diff --git a/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/components/TrackerEventCnvTool_entries.cxx b/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/components/TrackerEventCnvTool_entries.cxx
index 3d7144a021d532b496ba19bcba2422c01936ba11..73857c22607ce210ee2480e456e57e70a7796d5b 100644
--- a/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/components/TrackerEventCnvTool_entries.cxx
+++ b/Tracker/TrackerEventCnv/TrackerEventCnvTools/src/components/TrackerEventCnvTool_entries.cxx
@@ -1,6 +1,8 @@
#include "TrackerEventCnvTools/TrackerEventCnvTool.h"
+#include "TrackerEventCnvTools/TrackerSpacePointCnvTool.h"
using namespace Tracker;
DECLARE_COMPONENT( TrackerEventCnvTool )
+DECLARE_COMPONENT( TrackerSpacePointCnvTool)
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt b/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt
index 259453c94f261532d0e1054ace7259760fada14f..d097ad117081d6de28d584b3d8ea20fb9ba2cf40 100644
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt
@@ -21,7 +21,7 @@ atlas_add_tpcnv_library( TrackerEventTPCnv
TrkPrepRawData
TrkSpacePoint
TrackerSpacePoint
- PRIVATE_LINK_LIBRARIES AthenaBaseComps AthenaKernel
+ PRIVATE_LINK_LIBRARIES AthenaBaseComps AthenaKernel
EventPrimitives TrackerReadoutGeometry TrkSurfaces TrkEventPrimitives
TrkMeasurementBase TrkRIO_OnTrack EventContainers )
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointCnv_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointCnv_p0.h
new file mode 100644
index 0000000000000000000000000000000000000000..5b0b2afcb3ba4185dc003659c1d45e6d2d613eec
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointCnv_p0.h
@@ -0,0 +1,41 @@
+/*
+ Copyright (C) 2021 CERN for the benefit of the FASER collaboration
+*/
+
+#ifndef FASERSCT_SPACEPOINTCNV_P0_H
+#define FASERSCT_SPACEPOINTCNV_P0_H
+
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePoint_p0.h"
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
+#include "DataModelAthenaPool/ElementLinkCnv_p1.h"
+#include "AthLinks/ElementLink.h"
+//#include "TrackerEventCnvTools/TrackerSpacePointCnvTool.h"
+#include "TrackerPrepRawData/FaserSCT_Cluster.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+#include "StoreGate/ReadCondHandleKey.h"
+#include "StoreGate/ReadHandleKey.h"
+#include "StoreGate/StoreGateSvc.h"
+
+class FaserSCT_SpacePointCnv_p0 : public T_AthenaPoolTPCnvBase<Tracker::FaserSCT_SpacePoint, FaserSCT_SpacePoint_p0> {
+ public:
+ FaserSCT_SpacePointCnv_p0():m_sctClusContName{"SCT_ClusterContainer"} {};
+
+ virtual void persToTrans(const FaserSCT_SpacePoint_p0* persObj,
+ Tracker::FaserSCT_SpacePoint* transObj,
+ MsgStream& log);
+
+ virtual void transToPers(const Tracker::FaserSCT_SpacePoint* transObj,
+ FaserSCT_SpacePoint_p0* persObj,
+ MsgStream& log);
+ virtual StatusCode initialize( MsgStream& log );
+
+ ElementLinkCnv_p1<ElementLink<Tracker::FaserSCT_ClusterContainer>> m_elCnv;
+ private:
+ SG::ReadHandleKey<Tracker::FaserSCT_ClusterContainer> m_sctClusContName;
+// ToolHandle<Tracker::TrackerSpacePointCnvTool> m_cnvtool{this, "SpacePointCnvTool","SpacePointCnvTool"};
+
+};
+
+#endif // SPACEPOINTCNV_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointCollection_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointCollection_p0.h
new file mode 100644
index 0000000000000000000000000000000000000000..56f1b8574a1f08458ab37132687093b79b70ad5b
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointCollection_p0.h
@@ -0,0 +1,29 @@
+/*
+ Copyright 2021 CERN for the benefit of the FASER collaboration
+*/
+
+#ifndef FASERSCT_SPACEPOINTCOLLECTION_P0_H
+#define FASERSCT_SPACEPOINTCOLLECTION_P0_H
+
+#include <vector>
+
+class FaserSCT_SpacePointCollection_p0 {
+ public:
+ FaserSCT_SpacePointCollection_p0();
+ friend class FaserSCT_SpacePointClusterCnv_p0;
+
+ unsigned int m_idHash;
+ unsigned long long m_id;
+ unsigned int m_begin;
+ unsigned int m_end;
+ unsigned short m_size;
+};
+
+inline
+FaserSCT_SpacePointCollection_p0::FaserSCT_SpacePointCollection_p0() : m_idHash(0),
+m_id(0),
+m_begin(0),
+m_end(0),
+m_size(0){ }
+
+#endif // SPACEPOINTCOLLECTION_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointContainerCnv_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointContainerCnv_p0.h
new file mode 100644
index 0000000000000000000000000000000000000000..be233dc53618224c46ba209f29ac41fdd8119b93
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointContainerCnv_p0.h
@@ -0,0 +1,29 @@
+/*
+ Copyright 2021 CERN for the benefit of the FASER collaboration
+*/
+
+#ifndef FASERSCT_SPACEPOINTCONTAINERCNV_P0_H
+#define FASERSCT_SPACEPOINTCONTAINERCNV_P0_H
+
+#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
+
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePointContainer_p0.h"
+
+class FaserSCT_SpacePointContainerCnv_p0 : public T_AthenaPoolTPCnvBase<FaserSCT_SpacePointContainer, FaserSCT_SpacePointContainer_p0> {
+ public:
+ FaserSCT_SpacePointContainerCnv_p0() {};
+
+ virtual void persToTrans(const FaserSCT_SpacePointContainer_p0* persObj,
+ FaserSCT_SpacePointContainer* transObj,
+ MsgStream& log);
+
+ virtual void transToPers(const FaserSCT_SpacePointContainer* transObj,
+ FaserSCT_SpacePointContainer_p0* persObj,
+ MsgStream& log);
+
+ virtual FaserSCT_SpacePointContainer* createTransient(const FaserSCT_SpacePointContainer_p0* persObj, MsgStream& log);
+ private:
+};
+
+#endif // SPACEPOINTCONTAINERCNV_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointContainer_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointContainer_p0.h
new file mode 100644
index 0000000000000000000000000000000000000000..86bc426cd4c3fb74f6120f11b125eda88d8cdc34
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePointContainer_p0.h
@@ -0,0 +1,26 @@
+/*
+ Copyright (C) 2021 CERN for the benefit of the FASER collaboration
+*/
+
+#ifndef FASERSCT_SPACEPOINTCONTAINER_P0_H
+#define FASERSCT_SPACEPOINTCONTAINER_P0_H
+
+#include <vector>
+#include "TrackerEventTPCnv/FaserSCT_SpacePoint_p0.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePointCollection_p0.h"
+
+class FaserSCT_SpacePointContainer_p0 {
+ public:
+ FaserSCT_SpacePointContainer_p0();
+ friend class FaserSCT_SpacePointContainerCnv_p0;
+ private:
+ std::vector<FaserSCT_SpacePoint_p0> m_spacepoints;
+ std::vector<FaserSCT_SpacePointCollection_p0> m_spacepoint_collections;
+};
+
+inline FaserSCT_SpacePointContainer_p0::FaserSCT_SpacePointContainer_p0() {
+ m_spacepoints.clear();
+ m_spacepoint_collections.clear();
+}
+
+#endif // SPACEPOINTCONTAINER_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePoint_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePoint_p0.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e3a4e0c14dfc4757a424cb4a6b6976c11f40a2e
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/FaserSCT_SpacePoint_p0.h
@@ -0,0 +1,63 @@
+/*
+ Copyright 2021 CERN for the benefit of the FASER collaboration
+*/
+
+#ifndef FASERSCT_SPACEPOINT_P0_H
+#define FASERSCT_SPACEPOINT_P0_H
+#include "Identifier/IdentifierHash.h"
+#include "DataModelAthenaPool/ElementLink_p1.h"
+
+class FaserSCT_SpacePoint_p0 {
+ public:
+ FaserSCT_SpacePoint_p0();
+ friend class FaserSCT_SpacePointCnv_p0;
+
+ private:
+ unsigned int m_idHash0;
+ unsigned int m_idHash1;
+ unsigned long long m_id0;
+ unsigned long long m_id1;
+
+ float m_localpos_x;
+ float m_localpos_y;
+ float m_localcov00;
+ float m_localcov01;
+ float m_localcov11;
+
+ float m_pos_x;
+ float m_pos_y;
+ float m_pos_z;
+
+ float m_cov00;
+ float m_cov01;
+ float m_cov02;
+ float m_cov11;
+ float m_cov12;
+ float m_cov22;
+ ElementLinkInt_p1 m_link1;
+ ElementLinkInt_p1 m_link2;
+};
+
+inline
+FaserSCT_SpacePoint_p0::FaserSCT_SpacePoint_p0() :
+ m_idHash0(0),
+ m_idHash1(0),
+ m_id0(0),
+ m_id1(0),
+ m_localpos_x(0),
+ m_localpos_y(0),
+ m_localcov00(0),
+ m_localcov01(0),
+ m_localcov11(0),
+ m_pos_x(0),
+ m_pos_y(0),
+ m_pos_z(0),
+ m_cov00(0),
+ m_cov01(0),
+ m_cov02(0),
+ m_cov11(0),
+ m_cov12(0),
+ m_cov22(0)
+{}
+
+#endif // SPACEPOINT_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointCnv_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointCnv_p0.h
deleted file mode 100644
index 10c3090e3c98fa4a2cfb14afaa0a81b22cdb6900..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointCnv_p0.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- Copyright (C) 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#ifndef SPACEPOINTCNV_P0_H
-#define SPACEPOINTCNV_P0_H
-
-#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
-#include "TrackerEventTPCnv/SpacePoint_p0.h"
-
-#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
-
-class SpacePointCnv_p0 : public T_AthenaPoolTPCnvBase<Tracker::FaserSCT_SpacePoint, SpacePoint_p0> {
- public:
- SpacePointCnv_p0() {};
-
- virtual void persToTrans(const SpacePoint_p0* persObj,
- Tracker::FaserSCT_SpacePoint* transObj,
- MsgStream& log);
-
- virtual void transToPers(const Tracker::FaserSCT_SpacePoint* transObj,
- SpacePoint_p0* persObj,
- MsgStream& log);
-};
-
-#endif // SPACEPOINTCNV_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointCollection_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointCollection_p0.h
deleted file mode 100644
index 3d71dcf8f1f15bd0bb5628a743f3af614f354e7a..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointCollection_p0.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- Copyright 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#ifndef SPACEPOINTCOLLECTION_P0_H
-#define SPACEPOINTCOLLECTION_P0_H
-
-#include <vector>
-
-class SpacePointCollection_p0 {
- public:
- SpacePointCollection_p0();
- friend class SpacePointClusterCnv_p0;
-
- unsigned short m_idHash;
- unsigned short m_size;
-};
-
-inline
-SpacePointCollection_p0::SpacePointCollection_p0() : m_idHash(0) { }
-
-#endif // SPACEPOINTCOLLECTION_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointContainerCnv_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointContainerCnv_p0.h
deleted file mode 100644
index 2da19a3ce5880820fcf39fab7cac0a40ce3ffa4a..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointContainerCnv_p0.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- Copyright 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#ifndef SPACEPOINTCONTAINERCNV_P0_H
-#define SPACEPOINTCONTAINERCNV_P0_H
-
-#include "AthenaPoolCnvSvc/T_AthenaPoolTPConverter.h"
-
-#include "TrkSpacePoint/SpacePointContainer.h"
-#include "TrackerEventTPCnv/SpacePointContainer_p0.h"
-
-class SpacePointContainerCnv_p0 : public T_AthenaPoolTPCnvBase<SpacePointContainer, SpacePointContainer_p0> {
- public:
- SpacePointContainerCnv_p0() {};
-
- virtual void persToTrans(const SpacePointContainer_p0* persObj,
- SpacePointContainer* transObj,
- MsgStream& log);
-
- virtual void transToPers(const SpacePointContainer* transObj,
- SpacePointContainer_p0* persObj,
- MsgStream& log);
-};
-
-#endif // SPACEPOINTCONTAINERCNV_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointContainer_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointContainer_p0.h
deleted file mode 100644
index 0a9cdbe4d8da94c47e96797a486649073ff02ebf..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointContainer_p0.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- Copyright (C) 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#ifndef SPACEPOINTCONTAINER_P0_H
-#define SPACEPOINTCONTAINER_P0_H
-
-#include <vector>
-#include "TrackerEventTPCnv/SpacePoint_p0.h"
-#include "TrackerEventTPCnv/SpacePointCollection_p0.h"
-
-class SpacePointContainer_p0 {
- public:
- SpacePointContainer_p0();
- friend class SpacePointContainerCnv_p0;
- private:
- std::vector<SpacePoint_p0> m_spacepoints;
- std::vector<SpacePointCollection_p0> m_spacepoint_collections;
-};
-
-inline SpacePointContainer_p0::SpacePointContainer_p0() {
- m_spacepoints.clear();
- m_spacepoint_collections.clear();
-}
-
-#endif // SPACEPOINTCONTAINER_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePoint_p0.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePoint_p0.h
deleted file mode 100644
index 4a648fa58dd681f52f59f91ecac25635b16b7f30..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePoint_p0.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- Copyright 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#ifndef SPACEPOINT_P0_H
-#define SPACEPOINT_P0_H
-
-class SpacePoint_p0 {
- public:
- SpacePoint_p0();
- friend class SpacePointCnv_p0;
-
- private:
- unsigned int m_idHash0;
- unsigned int m_idHash1;
-
- float m_pos_x;
- float m_pos_y;
- float m_pos_z;
-
- float m_cov00;
- float m_cov01;
- float m_cov02;
- float m_cov11;
- float m_cov12;
- float m_cov22;
-};
-
-inline
-SpacePoint_p0::SpacePoint_p0() :
- m_idHash0(0),
- m_idHash1(0),
- m_pos_x(0),
- m_pos_y(0),
- m_pos_z(0),
- m_cov00(0),
- m_cov01(0),
- m_cov02(0),
- m_cov11(0),
- m_cov12(0),
- m_cov22(0)
-{}
-
-#endif // SPACEPOINT_P0_H
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h
index 1407bd063facddcf4166d72b55c2ce5389adb072..a025de2f061d627315f7ca781ab06e725dd1b174 100644
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h
@@ -42,9 +42,9 @@
// #include "InDetEventTPCnv/InDetLowBetaInfo/InDetLowBetaContainer_p1.h"
// #include "InDetEventTPCnv/InDetLowBetaInfo/InDetLowBetaCandidate_tlp1.h"
// #include "InDetEventTPCnv/InDetLowBetaInfo/InDetLowBetaContainer_tlp1.h"
-#include "TrackerEventTPCnv/SpacePoint_p0.h"
-#include "TrackerEventTPCnv/SpacePointCollection_p0.h"
-#include "TrackerEventTPCnv/SpacePointContainer_p0.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePoint_p0.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePointCollection_p0.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePointContainer_p0.h"
namespace TrackerEventTPCnvDict {
struct tmp
@@ -63,8 +63,9 @@ namespace TrackerEventTPCnvDict {
// std::vector< InDet::CompetingSCT_ClustersOnTrack_p1> m_v10;
// std::vector< InDet::CompetingTRT_DriftCirclesOnTrack_p1> m_v11;
// std::vector< InDetLowBetaCandidate_p1> m_v12;
- std::vector<SpacePoint_p0> m_v13;
- std::vector<SpacePointCollection_p0> m_v14;
+ std::vector<FaserSCT_SpacePoint_p0> m_v13;
+ std::vector<FaserSCT_SpacePointCollection_p0> m_v14;
+ std::vector<FaserSCT_SpacePointContainer_p0> m_v15;
};
} //> namespace TrackerEventTPCnvDict
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml
index efe77176618dbe588024e7bd8df2dcde8867e08d..3530369ae3c1eb2bc56a47d2809c48796e37eb23 100644
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml
@@ -75,11 +75,11 @@
<!-- <class name="std::pair<unsigned int,std::vector<unsigned int> >" /> -->
<class name="std::vector< std::pair<unsigned int, std::vector<unsigned int> > >" />
- <!-- SpacePoint -->
- <class name="SpacePoint_p0" />
- <class name="std::vector<SpacePoint_p0>" />
- <class name="SpacePointCollection_p0" />
- <class name="std::vector<SpacePointCollection_p0>" />
- <class name="SpacePointContainer_p0" id="DB0397F9-A163-496F-BC17-C7E507A1FA50" />
+ <!-- FaserSCT_SpacePoint -->
+ <class name="FaserSCT_SpacePoint_p0" />
+ <class name="std::vector<FaserSCT_SpacePoint_p0>" />
+ <class name="FaserSCT_SpacePointCollection_p0" />
+ <class name="std::vector<FaserSCT_SpacePointCollection_p0>" />
+ <class name="FaserSCT_SpacePointContainer_p0" id="DB0397F9-A163-496F-BC17-C7E507A1FA50" />
-</lcgdict>
\ No newline at end of file
+</lcgdict>
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/FaserSCT_SpacePointCnv_p0.cxx b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/FaserSCT_SpacePointCnv_p0.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..b6cbc9da2508bd734634af3702165b262885ceff
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/FaserSCT_SpacePointCnv_p0.cxx
@@ -0,0 +1,144 @@
+/*
+ Copyright (C) 2021 CERN for the benefit of the FASER collaboration
+ */
+
+#include "TrackerEventTPCnv/FaserSCT_SpacePointCnv_p0.h"
+// Athena
+#include "AthLinks/ElementLink.h"
+
+#include "Identifier/Identifier.h"
+#include "TrackerPrepRawData/FaserSCT_Cluster.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+
+StatusCode FaserSCT_SpacePointCnv_p0::initialize(MsgStream& log ) {
+
+// ISvcLocator* svcLocator = Gaudi::svcLocator();
+
+ // Get the messaging service, print where you are
+ log << MSG::INFO << "FaserSCT_SpacePointCnv::initialize()" << endmsg;
+ if(m_sctClusContName.initialize()!=StatusCode::SUCCESS)
+ log << MSG::WARNING<< "FaserSCT_SpacePointCnv failed to initialize the sct cluster container" << endmsg;
+
+ return StatusCode::SUCCESS;
+}
+
+void
+FaserSCT_SpacePointCnv_p0::persToTrans(const FaserSCT_SpacePoint_p0* persObj, Tracker::FaserSCT_SpacePoint* transObj, MsgStream& log) {
+
+ if(this->initialize(log)!=StatusCode::SUCCESS){
+ log << MSG::WARNING << "failed to initialize FaserSCT_SpacePointCnv_p0" << endmsg;
+ return;
+ }
+
+ ElementLink<Tracker::FaserSCT_ClusterContainer> link1;
+ ElementLink<Tracker::FaserSCT_ClusterContainer> link2;
+ m_elCnv.persToTrans(&persObj->m_link1,&link1,log);
+ m_elCnv.persToTrans(&persObj->m_link2,&link2,log);
+ Amg::Vector3D pos(persObj->m_pos_x,persObj->m_pos_y,persObj->m_pos_z);
+ Amg::Vector2D localpos(persObj->m_localpos_x,persObj->m_localpos_y);
+ Amg::MatrixX localcov(2,2);
+ localcov<<
+ persObj->m_localcov00, persObj->m_localcov01,
+ persObj->m_localcov01, persObj->m_localcov11;
+ Amg::MatrixX cov(3,3);
+ cov<<
+ persObj->m_cov00, persObj->m_cov01, persObj->m_cov02,
+ persObj->m_cov01, persObj->m_cov11, persObj->m_cov12,
+ persObj->m_cov02, persObj->m_cov12, persObj->m_cov22;
+ const Tracker::FaserSCT_Cluster* clus1=nullptr;
+ const Tracker::FaserSCT_Cluster* clus2=nullptr;
+
+ SG::ReadHandle<Tracker::FaserSCT_ClusterContainer> h_sctClusCont(m_sctClusContName);
+ if (!h_sctClusCont.isValid()) {
+ log<<MSG::ERROR<<"SCT Cluster container not found at "<<m_sctClusContName<<endmsg;
+ return ;
+ } else {
+ log<<MSG::DEBUG<<"SCT Cluster Container found" <<endmsg;
+ }
+ const Tracker::FaserSCT_ClusterCollection *ptr = h_sctClusCont->indexFindPtr(IdentifierHash(persObj->m_idHash0));
+ // if we find PRD, then recreate link
+ if (ptr!=nullptr) {
+ //loop though collection to find matching PRD.
+ Tracker::FaserSCT_ClusterCollection::const_iterator collIt= ptr->begin();
+ Tracker::FaserSCT_ClusterCollection::const_iterator collItEnd = ptr->end();
+ // there MUST be a faster way to do this!!
+ for ( ; collIt!=collItEnd; ++collIt) {
+ if ( (*collIt)->identify().get_compact()==persObj->m_id0 ) clus1= &(**collIt);
+ }
+ }
+
+ const Tracker::FaserSCT_ClusterCollection *ptr1 = h_sctClusCont->indexFindPtr(IdentifierHash(persObj->m_idHash1));
+ // if we find PRD, then recreate link
+ if (ptr1!=nullptr) {
+ //loop though collection to find matching PRD.
+ Tracker::FaserSCT_ClusterCollection::const_iterator collIt= ptr1->begin();
+ Tracker::FaserSCT_ClusterCollection::const_iterator collItEnd = ptr1->end();
+ // there MUST be a faster way to do this!!
+ for ( ; collIt!=collItEnd; ++collIt) {
+ if ( (*collIt)->identify().get_compact()==persObj->m_id1 ) clus2= &(**collIt);
+ }
+ }
+ /*
+ m_cnvtool->recreateSpacePoint(transObj,persObj->m_id0,persObj->m_idHash0,persObj->m_id1,persObj->m_idHash1);
+ */
+ // if(clus2==nullptr)std::cout<<"didnot found the second cluster"<<std::endl;
+ if(clus1==nullptr||clus2==nullptr){
+ log<<MSG::DEBUG<<"could not found the clusters"<<endmsg;
+ return;
+ }
+ // const TrackerDD::SiDetectorElement * de1 = elements->getDetectorElement( persObj->m_idHash0);
+ // const TrackerDD::SiDetectorElement * de2 = elements->getDetectorElement( persObj->m_idHash1);
+ // Tracker::FaserSCT_Cluster* clus1=const_cast<Tracker::FaserSCT_Cluster*>(link1.cachedElement());
+ // Tracker::FaserSCT_Cluster* clus2=const_cast<Tracker::FaserSCT_Cluster*>(link2.cachedElement());
+ // clus1->setDetectorElement(de1);
+ // clus2->setDetectorElement(de2);
+ // *transObj=Tracker::FaserSCT_SpacePoint(std::make_pair(persObj->m_idHash0,persObj->m_idHash1),&pos,&cov,&localpos,&localcov,link1,link2);
+ const std::pair<const Tracker::FaserSCT_Cluster*, const Tracker::FaserSCT_Cluster*> cluslist(clus1,clus2);
+ // transObj=new Tracker::FaserSCT_SpacePoint(std::make_pair(IdentifierHash(persObj->m_idHash0),IdentifierHash(persObj->m_idHash1)),&pos,&cluslist);
+ // //*transObj=Tracker::FaserSCT_SpacePoint(std::make_pair(IdentifierHash(persObj->m_idHash0),IdentifierHash(persObj->m_idHash1)),&pos,&cluslist);
+ // transObj->m_elelink1=link1;
+ // transObj->m_elelink1=link2;
+ transObj->setElemIdList(std::make_pair(IdentifierHash(persObj->m_idHash0),IdentifierHash(persObj->m_idHash1)));
+ transObj->setClusList(cluslist);
+ transObj->setGlobalParameters(pos);
+ transObj->setGlobalCovariance(cov);
+ transObj->setLocalCovariance(localcov);
+ transObj->setLocalParameters(localpos);
+
+}
+
+void
+FaserSCT_SpacePointCnv_p0::transToPers(const Tracker::FaserSCT_SpacePoint* transObj, FaserSCT_SpacePoint_p0* persObj, MsgStream& /*log*/) {
+
+ auto idHashs = transObj->elementIdList();
+ persObj->m_idHash0 = idHashs.first;
+ persObj->m_idHash1 = idHashs.second;
+
+ auto globalPosition = transObj->globalPosition();
+ persObj->m_pos_x = globalPosition.x();
+ persObj->m_pos_y = globalPosition.y();
+ persObj->m_pos_z = globalPosition.z();
+
+ auto cov = transObj->globCovariance();
+ persObj->m_cov00 = cov(0,0);
+ persObj->m_cov01 = cov(0,1);
+ persObj->m_cov02 = cov(0,2);
+ persObj->m_cov11 = cov(1,1);
+ persObj->m_cov12 = cov(1,2);
+ persObj->m_cov22 = cov(2,2);
+
+ persObj->m_id0= transObj->clusterList().first->identify().get_compact();
+ persObj->m_id1= transObj->clusterList().second->identify().get_compact();
+ auto localparam=transObj->localParameters();
+ persObj->m_localpos_x = localparam.x();
+ persObj->m_localpos_y = localparam.y();
+ auto localcov = transObj->localCovariance();
+ persObj->m_localcov00 = cov(0,0);
+ persObj->m_localcov01 = cov(0,1);
+ persObj->m_localcov11 = cov(1,2);
+
+ persObj->m_link1.m_contName = transObj->getElementLink1()->dataID();
+ persObj->m_link1.m_elementIndex = transObj->getElementLink1()->index();
+ persObj->m_link2.m_contName = transObj->getElementLink2()->dataID();
+ persObj->m_link2.m_elementIndex = transObj->getElementLink2()->index();
+}
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/FaserSCT_SpacePointContainerCnv_p0.cxx b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/FaserSCT_SpacePointContainerCnv_p0.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..80fc411dcd1469d3af8a1c7bc5c5f781ead630e3
--- /dev/null
+++ b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/FaserSCT_SpacePointContainerCnv_p0.cxx
@@ -0,0 +1,99 @@
+/*
+ Copyright (C) 2021 CERN for the benefit of the FASER collaboration
+ */
+
+#include "TrackerEventTPCnv/FaserSCT_SpacePointContainerCnv_p0.h"
+
+#include "TrackerEventTPCnv/FaserSCT_SpacePoint_p0.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePointCollection_p0.h"
+#include "TrackerEventTPCnv/FaserSCT_SpacePointCnv_p0.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "AthenaKernel/errorcheck.h"
+#include "GaudiKernel/StatusCode.h"
+
+void FaserSCT_SpacePointContainerCnv_p0::persToTrans(const FaserSCT_SpacePointContainer_p0* persObj, FaserSCT_SpacePointContainer* transObj, MsgStream& log) {
+
+ FaserSCT_SpacePointCollection* coll = 0;
+ FaserSCT_SpacePointCnv_p0 chanCnv;
+ unsigned int collBegin(0);
+
+ log<<MSG::VERBOSE<<" create Spacepoint container with "<<persObj->m_spacepoint_collections.size()<<" collections"<<endmsg;
+
+ for (unsigned int icoll = 0; icoll < persObj->m_spacepoint_collections.size(); ++icoll) {
+ const FaserSCT_SpacePointCollection_p0& pcoll = persObj->m_spacepoint_collections[icoll];
+ IdentifierHash collIDHash(IdentifierHash(pcoll.m_idHash));
+ coll = new FaserSCT_SpacePointCollection(collIDHash);
+ coll->setIdentifier(Identifier(pcoll.m_id));
+ log<<MSG::VERBOSE<<" create Spacepoint collection with identifier "<<pcoll.m_id<<" , and hash "<<pcoll.m_idHash<<" , and size ="<<pcoll.m_end - pcoll.m_begin<<endmsg;
+ unsigned int nchans = pcoll.m_end - pcoll.m_begin;
+ coll->resize(nchans);
+ for (unsigned int ichan = 0; ichan < nchans; ++ ichan) {
+ const FaserSCT_SpacePoint_p0* pchan=&(persObj->m_spacepoints[ichan+collBegin]);
+ Tracker::FaserSCT_SpacePoint* transSP=new Tracker::FaserSCT_SpacePoint();
+ chanCnv.persToTrans(pchan, transSP, log );
+ if(transSP==nullptr)
+ log << MSG::INFO<<"did not found space"<<endmsg;
+ (*coll)[ichan]=transSP;
+ }
+ collBegin +=nchans;
+ StatusCode sc = transObj->addCollection(coll, collIDHash);
+ if (sc.isFailure())
+ throw std::runtime_error("Failed to add collection to ID Container");
+
+ }
+
+}
+
+void FaserSCT_SpacePointContainerCnv_p0::transToPers(const FaserSCT_SpacePointContainer* transObj, FaserSCT_SpacePointContainer_p0* persObj, MsgStream& log) {
+ log << MSG::DEBUG<< "FaserSCT_SpacePointContainerCnv_p0::transToPers()" << endmsg;
+
+ FaserSCT_SpacePointCnv_p0 spCnv;
+ typedef FaserSCT_SpacePointContainer TRANS;
+
+ TRANS::const_iterator spColl;
+ TRANS::const_iterator spCollEnd = transObj->end();
+ unsigned int spCollId;
+ unsigned int spId = 0;
+ unsigned int nextSpId = 0;
+ //unsigned int lastIdHash = 0;
+
+ // resize data vectors
+ persObj->m_spacepoint_collections.resize(transObj->numberOfCollections());
+ int n_spacepoints = 0;
+ for (spColl = transObj->begin(); spColl != spCollEnd; spColl++) {
+ n_spacepoints += (*spColl)->size();
+ }
+ persObj->m_spacepoints.resize(n_spacepoints);
+
+ for (spColl = transObj->begin(), spCollId = 0; spColl != spCollEnd; ++spCollId, ++spColl) {
+ // create persitent representation of FaserSCT_SpacePointCollections
+ const FaserSCT_SpacePointCollection& collection = **spColl;
+ FaserSCT_SpacePointCollection_p0& pcollection = persObj->m_spacepoint_collections[spCollId];
+ pcollection.m_size = collection.size();
+ pcollection.m_idHash = (unsigned int)collection.identifyHash();
+ pcollection.m_id = collection.identify().get_compact();
+ log<<MSG::VERBOSE<<"Trans to Pers: create Spacepoint collection with identifier "<<collection.identify().get_compact()<<" , and hash "<<collection.identifyHash()<<" , and size ="<<collection.size()<<endmsg;
+ //lastIdHash = collection.identifyHash();
+
+ spId = nextSpId;
+ nextSpId += collection.size();
+
+ pcollection.m_begin=spId;
+ pcollection.m_end=nextSpId;
+
+ // create persitent representation of FaserSCT_SpacePoints
+ for (std::size_t i = 0; i < collection.size(); ++i) {
+ FaserSCT_SpacePoint_p0* persSP = &(persObj->m_spacepoints[i + spId]);
+ const Tracker::FaserSCT_SpacePoint* transSP = dynamic_cast<const Tracker::FaserSCT_SpacePoint*>(collection[i]);
+ spCnv.transToPers(transSP, persSP, log);
+ }
+ }
+}
+
+//================================================================
+FaserSCT_SpacePointContainer* FaserSCT_SpacePointContainerCnv_p0::createTransient(const FaserSCT_SpacePointContainer_p0* persObj, MsgStream& log) {
+ log << MSG::DEBUG << "FaserSCT_SpacePointContainerCnv_p3::createTransient called " << endmsg;
+ std::unique_ptr<FaserSCT_SpacePointContainer> trans(std::make_unique<FaserSCT_SpacePointContainer>(persObj->m_spacepoint_collections.size()));
+ persToTrans(persObj, trans.get(), log);
+ return(trans.release());
+}
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/SpacePointCnv_p0.cxx b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/SpacePointCnv_p0.cxx
deleted file mode 100644
index 63dba18507be95fe780a27de401cc6ac01a57027..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/SpacePointCnv_p0.cxx
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- Copyright (C) 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#include "TrackerEventTPCnv/SpacePointCnv_p0.h"
-
-void
-SpacePointCnv_p0::persToTrans(const SpacePoint_p0* persObj, Tracker::FaserSCT_SpacePoint* transObj, MsgStream& /*log*/) {
-
- // TODO
-
-}
-
-void
-SpacePointCnv_p0::transToPers(const Tracker::FaserSCT_SpacePoint* transObj, SpacePoint_p0* persObj, MsgStream& /*log*/) {
-
- auto idHashs = transObj->elementIdList();
- persObj->m_idHash0 = idHashs.first;
- persObj->m_idHash1 = idHashs.second;
-
- auto globalPosition = transObj->globalPosition();
- persObj->m_pos_x = globalPosition.x();
- persObj->m_pos_y = globalPosition.y();
- persObj->m_pos_z = globalPosition.z();
-
- auto cov = transObj->globCovariance();
- persObj->m_cov00 = cov(0,0);
- persObj->m_cov01 = cov(0,1);
- persObj->m_cov02 = cov(0,2);
- persObj->m_cov11 = cov(1,1);
- persObj->m_cov12 = cov(2,2);
- persObj->m_cov22 = cov(2,2);
-}
diff --git a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/SpacePointContainerCnv_p0.cxx b/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/SpacePointContainerCnv_p0.cxx
deleted file mode 100644
index 88c0f0b220c45bac9322484e027707ada331bc27..0000000000000000000000000000000000000000
--- a/Tracker/TrackerEventCnv/TrackerEventTPCnv/src/SpacePointContainerCnv_p0.cxx
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- Copyright (C) 2021 CERN for the benefit of the FASER collaboration
-*/
-
-#include "TrackerEventTPCnv/SpacePointContainerCnv_p0.h"
-
-#include "TrackerEventTPCnv/SpacePoint_p0.h"
-#include "TrackerEventTPCnv/SpacePointCollection_p0.h"
-#include "TrackerEventTPCnv/SpacePointCnv_p0.h"
-
-void SpacePointContainerCnv_p0::persToTrans(const SpacePointContainer_p0* /*persObj*/, SpacePointContainer* /*transObj*/, MsgStream& /*log*/) {
-
- // TODO
-
-}
-
-void SpacePointContainerCnv_p0::transToPers(const SpacePointContainer* transObj, SpacePointContainer_p0* persObj, MsgStream& log) {
- log << MSG::INFO << "SpacePointContainerCnv_p0::transToPers()" << endmsg;
-
- SpacePointCnv_p0 spCnv;
- typedef SpacePointContainer TRANS;
-
- TRANS::const_iterator spColl;
- TRANS::const_iterator spCollEnd = transObj->end();
- unsigned int spCollId;
- unsigned int spId = 0;
- unsigned int nextSpId = 0;
- unsigned int lastIdHash = 0;
-
- // resize data vectors
- persObj->m_spacepoint_collections.resize(transObj->numberOfCollections());
- int n_spacepoints = 0;
- for (spColl = transObj->begin(); spColl != spCollEnd; spColl++) {
- n_spacepoints += (*spColl)->size();
- }
- persObj->m_spacepoints.resize(n_spacepoints);
-
- for (spColl = transObj->begin(), spCollId = 0; spColl != spCollEnd; ++spCollId, ++spColl) {
- // create persitent representation of SpacePointCollections
- const SpacePointCollection& collection = **spColl;
- SpacePointCollection_p0& pcollection = persObj->m_spacepoint_collections[spCollId];
- pcollection.m_size = collection.size();
- pcollection.m_idHash = collection.identifyHash() - lastIdHash;
- lastIdHash = collection.identifyHash();
-
- spId = nextSpId;
- nextSpId += collection.size();
-
- // create persitent representation of SpacePoints
- for (std::size_t i = 0; i < collection.size(); ++i) {
- SpacePoint_p0* persSP = &(persObj->m_spacepoints[i + spId]);
- const Tracker::FaserSCT_SpacePoint* transSP = dynamic_cast<const Tracker::FaserSCT_SpacePoint*>(collection[i]);
- spCnv.transToPers(transSP, persSP, log);
- }
- }
-}
diff --git a/Tracker/TrackerRecAlgs/FaserSpacePoints/src/FaserSpacePoints.cxx b/Tracker/TrackerRecAlgs/FaserSpacePoints/src/FaserSpacePoints.cxx
index cda36287ee9cc3b682539c6b7e61e05f8a0b68e7..b9722a7c2f4318fd6d8e4cf2c76437ced6078d8e 100644
--- a/Tracker/TrackerRecAlgs/FaserSpacePoints/src/FaserSpacePoints.cxx
+++ b/Tracker/TrackerRecAlgs/FaserSpacePoints/src/FaserSpacePoints.cxx
@@ -1,7 +1,7 @@
#include "FaserSpacePoints.h"
#include "Identifier/Identifier.h"
-#include "TrkSpacePoint/SpacePoint.h"
-#include "TrackerPrepRawData/TrackerClusterCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterCollection.h"
namespace Tracker {
FaserSpacePoints::FaserSpacePoints(const std::string& name, ISvcLocator* pSvcLocator)
@@ -55,7 +55,7 @@ namespace Tracker {
ATH_MSG_DEBUG("run = " << m_run);
ATH_MSG_DEBUG("event = " << m_event);
- SG::ReadHandle<SpacePointContainer> sct_spcontainer( m_sct_spcontainer, ctx );
+ SG::ReadHandle<FaserSCT_SpacePointContainer> sct_spcontainer( m_sct_spcontainer, ctx );
if (!sct_spcontainer.isValid()){
ATH_MSG_FATAL("Could not find the data object " << sct_spcontainer.name());
return StatusCode::RECOVERABLE;
@@ -63,19 +63,19 @@ namespace Tracker {
m_nCollections = sct_spcontainer->size();
ATH_MSG_DEBUG("nCollections = " << m_nCollections);
- SpacePointContainer::const_iterator it = sct_spcontainer->begin();
- SpacePointContainer::const_iterator it_end = sct_spcontainer->end();
+ FaserSCT_SpacePointContainer::const_iterator it = sct_spcontainer->begin();
+ FaserSCT_SpacePointContainer::const_iterator it_end = sct_spcontainer->end();
for(; it != it_end; ++it) {
- const SpacePointCollection* col = *it;
+ const FaserSCT_SpacePointCollection* col = *it;
m_nSpacepoints = col->size();
ATH_MSG_DEBUG("nSpacepoints = " << m_nSpacepoints);
- SpacePointCollection::const_iterator it_sp = col->begin();
- SpacePointCollection::const_iterator it_sp_end = col->end();
+ FaserSCT_SpacePointCollection::const_iterator it_sp = col->begin();
+ FaserSCT_SpacePointCollection::const_iterator it_sp_end = col->end();
for (; it_sp != it_sp_end; ++it_sp) {
- const Trk::SpacePoint* sp = *it_sp;
- const Identifier id = sp->clusterList().first->identify();
+ const FaserSCT_SpacePoint* sp = *it_sp;
+ const auto id = sp->clusterList().first->identify();
int station = m_idHelper->station(id);
int plane = m_idHelper->layer(id);
m_layer = (station - 1) * 3 + plane;
@@ -101,4 +101,4 @@ namespace Tracker {
m_outputTree->Branch("y", &m_y);
m_outputTree->Branch("z", &m_z);
}
-}
\ No newline at end of file
+}
diff --git a/Tracker/TrackerRecAlgs/FaserSpacePoints/src/FaserSpacePoints.h b/Tracker/TrackerRecAlgs/FaserSpacePoints/src/FaserSpacePoints.h
index 0674992912ce4a16fff803b589ffce91f08e6b14..28807d73e7ac7939c5b830a758846028feedb815 100644
--- a/Tracker/TrackerRecAlgs/FaserSpacePoints/src/FaserSpacePoints.h
+++ b/Tracker/TrackerRecAlgs/FaserSpacePoints/src/FaserSpacePoints.h
@@ -3,7 +3,7 @@
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "TrackerIdentifier/FaserSCT_ID.h"
-#include "TrkSpacePoint/SpacePointContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
#include <string>
#include <atomic>
@@ -33,7 +33,7 @@ namespace Tracker {
mutable float m_z{0};
const FaserSCT_ID* m_idHelper{nullptr};
- SG::ReadHandleKey<SpacePointContainer> m_sct_spcontainer{this, "SpacePointsSCTName", "SCT spacepoint container"};
+ SG::ReadHandleKey<FaserSCT_SpacePointContainer> m_sct_spcontainer{this, "SpacePointsSCTName", "SCT spacepoint container"};
Gaudi::Property<std::string> m_filePath{this, "FilePath", "spacepoints.root", "Output root file for spacepoints"};
Gaudi::Property<std::string> m_treeName{this, "TreeName", "tree", ""};
@@ -43,4 +43,4 @@ namespace Tracker {
};
}
-#endif // FASERSPACEPOINTS_H
\ No newline at end of file
+#endif // FASERSPACEPOINTS_H
diff --git a/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/src/FaserSCT_Clusterization.cxx b/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/src/FaserSCT_Clusterization.cxx
index 04568b0e9f0c277ba54c7faf068d0c3107b58b5d..640ba15148970d76ad415f4a6f127f167afe9d62 100644
--- a/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/src/FaserSCT_Clusterization.cxx
+++ b/Tracker/TrackerRecAlgs/TrackerPrepRawDataFormation/src/FaserSCT_Clusterization.cxx
@@ -113,6 +113,8 @@ StatusCode FaserSCT_Clusterization::execute(const EventContext& ctx) const {
if (not dontDoClusterization) {
for (; rdoCollections != rdoCollectionsEnd; ++rdoCollections) {
++m_numberOfRDOCollection;
+// for (const FaserSCT_RDORawData* rdo: **rdoCollections) {
+// }
const TrackerRawDataCollection<FaserSCT_RDORawData>* rd{*rdoCollections};
ATH_MSG_DEBUG("RDO collection size=" << rd->size() << ", Hash=" << rd->identifyHash());
Tracker::FaserSCT_ClusterContainer::IDC_WriteHandle lock{clusterContainer->getWriteHandle(rdoCollections.hashId())};
@@ -184,4 +186,4 @@ StatusCode FaserSCT_Clusterization::finalize()
return StatusCode::SUCCESS;
}
-}
\ No newline at end of file
+}
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/CMakeLists.txt b/Tracker/TrackerRecAlgs/TrackerSPFit/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..665c1a291f1a87d541ce0166576618e836b9bb42
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/CMakeLists.txt
@@ -0,0 +1,18 @@
+################################################################################
+# Package: TrackerSPFit
+################################################################################
+
+# Declare the package name:
+atlas_subdir( TrackerSPFit)
+
+# External dependencies:
+find_package( Eigen )
+
+find_package( ROOT COMPONENTS Core Tree MathCore)
+
+atlas_add_component( TrackerSPFit
+ src/components/*.cxx src/*.cxx src/*.h
+ INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS}
+ LINK_LIBRARIES ${EIGEN_LIBRARIES} ${ROOT_LIBRARIES} AthenaBaseComps AthContainers GeoPrimitives Identifier GaudiKernel TrackerReadoutGeometry TrackerPrepRawData TrackerSpacePoint AthenaMonitoringKernelLib FaserDetDescr xAODEventInfo TrkEventPrimitives TrackerIdentifier FaserSiSpacePointToolLib TrkSpacePoint )
+
+atlas_install_python_modules( python/*.py )
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/ReadMe b/Tracker/TrackerRecAlgs/TrackerSPFit/ReadMe
new file mode 100644
index 0000000000000000000000000000000000000000..8a853447d3c1b57a281b357d79170cff82ca0d16
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/ReadMe
@@ -0,0 +1,6 @@
+TrackerSPFit:
+ Use the FaserSCT_SpacePoint to get the residuals for alignment
+
+For each station, select the spacepoint triplets first, then perform a 3D line fit and require the chi2 less than 10.
+Take the difference between the expected position and measured position as the residuals.
+In the tree names "spfit", the branch "sp_x_residual" and "sp_y_residual" are the residuals in x and y for each spacepoint, and "sp_station", "sp_layer" and "sp_module" are the stations (1-3), layer (0-2) and module (0-8) ID for.
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFit.py b/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFit.py
new file mode 100644
index 0000000000000000000000000000000000000000..8312136a38a664107de347e9808eafa156a16da4
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFit.py
@@ -0,0 +1,99 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+import sys
+from AthenaCommon.Logging import log, logging
+from AthenaCommon.Constants import DEBUG, VERBOSE, INFO
+from AthenaCommon.Configurable import Configurable
+from CalypsoConfiguration.AllConfigFlags import ConfigFlags
+from CalypsoConfiguration.MainServicesConfig import MainServicesCfg
+from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+# from AthenaPoolCnvSvc.PoolWriteConfig import PoolWriteCfg
+from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+# from Digitization.DigitizationParametersConfig import writeDigitizationMetadata
+from TrackerPrepRawDataFormation.TrackerPrepRawDataFormationConfig import FaserSCT_ClusterizationCfg
+from TrackerSpacePointFormation.TrackerSpacePointFormationConfig import TrackerSpacePointFinderCfg
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from FaserSCT_GeoModel.FaserSCT_GeoModelConfig import FaserSCT_GeometryCfg
+
+Tracker__TrackerSPFit, THistSvc=CompFactory.getComps("Tracker::TrackerSPFit", "THistSvc")
+
+
+def TrackerSPFitBasicCfg(flags, **kwargs):
+ """Return ComponentAccumulator for TrackerSPFit"""
+ acc = FaserSCT_GeometryCfg(flags)
+ kwargs.setdefault("SpacePointsSCTName", "SCT_SpacePointContainer")
+ kwargs.setdefault("SCT_ClustersName", "SCT_ClusterContainer")
+ kwargs.setdefault("MaxChi2", 20)
+ kwargs.setdefault("UseBiasedResidual", True)
+ kwargs.setdefault("SaveAllClusterInfo", True)
+ kwargs.setdefault("SaveAllSPInfo", True)
+ acc.addEventAlgo(Tracker__TrackerSPFit(**kwargs))
+ # attach ToolHandles
+ return acc
+
+def TrackerSPFit_OutputCfg(flags):
+ """Return ComponentAccumulator with Output for SCT. Not standalone."""
+ acc = ComponentAccumulator()
+ acc.merge(OutputStreamCfg(flags, "ESD"))
+ ostream = acc.getEventAlgo("OutputStreamESD")
+ ostream.TakeItemsFromInput = True
+ return acc
+
+def TrackerSPFitCfg(flags, **kwargs):
+ acc=TrackerSPFitBasicCfg(flags, **kwargs)
+ histSvc= THistSvc()
+ histSvc.Output += [ "TrackerSPFit DATAFILE='trackerspfit.root' OPT='RECREATE'" ]
+ acc.addService(histSvc)
+ acc.merge(TrackerSPFit_OutputCfg(flags))
+ return acc
+
+if __name__ == "__main__":
+ log.setLevel(DEBUG)
+ Configurable.configurableRun3Behavior = True
+
+ # Configure
+ ConfigFlags.Input.Files = ['my.RDO.pool.root']
+ ConfigFlags.Output.ESDFileName = "mySeeds.ESD.pool.root"
+ ConfigFlags.IOVDb.GlobalTag = "OFLCOND-FASER-01" # Always needed; must match FaserVersion
+ ConfigFlags.IOVDb.DatabaseInstance = "OFLP200" # Use MC conditions for now
+# ConfigFlags.Input.ProjectName = "data20" # Needed to bypass autoconfig
+ ConfigFlags.Input.isMC = True
+ # Needed to bypass autoconfig
+ ConfigFlags.GeoModel.FaserVersion = "FASER-01" # FASER cosmic ray geometry (station 2 only)
+ ConfigFlags.Common.isOnline = False
+ ConfigFlags.GeoModel.Align.Dynamic = False
+ ConfigFlags.Beam.NumberOfCollisions = 0.
+
+ ConfigFlags.lock()
+
+ # Core components
+ acc = MainServicesCfg(ConfigFlags)
+ acc.merge(PoolReadCfg(ConfigFlags))
+
+ #acc.merge(writeDigitizationMetadata(ConfigFlags))
+
+ # Inner Detector
+ acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags))
+ acc.merge(TrackerSpacePointFinderCfg(ConfigFlags))
+ acc.merge(TrackerSPFitCfg(ConfigFlags))
+
+ # Timing
+ #acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
+
+ # Dump config
+ logging.getLogger('forcomps').setLevel(VERBOSE)
+ acc.foreach_component("*").OutputLevel = VERBOSE
+ acc.foreach_component("*ClassID*").OutputLevel = INFO
+ # acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+ # acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+ acc.getService("StoreGateSvc").Dump = True
+ acc.getService("ConditionStore").Dump = True
+ acc.printConfig(withDetails=True)
+ ConfigFlags.dump()
+
+ # Execute and finish
+ sc = acc.run(maxEvents=-1)
+
+ # Success should be 0
+ sys.exit(not sc.isSuccess())
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFitConfig.py b/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFitConfig.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f273f51e642489b0cdd394b7d1bb053adc33951
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFitConfig.py
@@ -0,0 +1,28 @@
+"""Define methods to construct configured SCT Digitization tools and algorithms
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+#from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+Tracker__TrackerSPFit = CompFactory.getComps("Tracker::TrackerSPFit")
+
+#from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+from FaserSCT_GeoModel.FaserSCT_GeoModelConfig import FaserSCT_GeometryCfg
+
+def TrackerSPFitBasicCfg(flags, **kwargs):
+ """Return ComponentAccumulator for TrackerSpacePointMakerAlg"""
+# acc = ComponentAccumulator()
+ acc = FaserSCT_GeometryCfg(flags)
+ kwargs.setdefault("SpacePointsSCTName", "SCT_SpacePointContainer")
+ kwargs.setdefault("SCT_ClustersName", "SCT_ClusterContainer")
+ acc.addEventAlgo(Tracker__TrackerSPFit(**kwargs))
+ return acc
+
+
+def TrackerSPFitCfg(flags, **kwargs):
+ acc=TrackerSPFitBasicCfg(flags, **kwargs)
+ THistSvc=CompFactory.THistSvc
+ histSvc= THistSvc()
+ histSvc.Output += [ "TrackerSPFit DATAFILE='sp_fit.root' OPT='RECREATE'" ]
+ acc.addService(histSvc)
+ return acc
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFitTI12Data.py b/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFitTI12Data.py
new file mode 100644
index 0000000000000000000000000000000000000000..63286a5d697c96d4b45034ca989d28b02082241b
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/python/TrackerSPFitTI12Data.py
@@ -0,0 +1,105 @@
+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+import sys
+from AthenaCommon.Logging import log, logging
+from AthenaCommon.Constants import DEBUG, INFO
+from AthenaCommon.Configurable import Configurable
+from CalypsoConfiguration.AllConfigFlags import ConfigFlags
+from CalypsoConfiguration.MainServicesConfig import MainServicesCfg
+#from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+from AthenaPoolCnvSvc.PoolWriteConfig import PoolWriteCfg
+from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+from WaveRecAlgs.WaveRecAlgsConfig import WaveformReconstructionCfg
+from TrackerPrepRawDataFormation.TrackerPrepRawDataFormationConfig import FaserSCT_ClusterizationCfg
+from TrackerSpacePointFormation.TrackerSpacePointFormationConfig import TrackerSpacePointFinderCfg
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from FaserSCT_GeoModel.FaserSCT_GeoModelConfig import FaserSCT_GeometryCfg
+
+Tracker__TrackerSPFit, THistSvc=CompFactory.getComps("Tracker::TrackerSPFit", "THistSvc")
+
+
+def TrackerSPFitBasicCfg(flags, **kwargs):
+ """Return ComponentAccumulator for TrackerSPFit"""
+ acc = FaserSCT_GeometryCfg(flags)
+ kwargs.setdefault("SpacePointsSCTName", "SCT_SpacePointContainer")
+ kwargs.setdefault("SCT_ClustersName", "SCT_ClusterContainer")
+ kwargs.setdefault("MaxChi2", 100)
+ kwargs.setdefault("UseBiasedResidual", True)
+ acc.addEventAlgo(Tracker__TrackerSPFit(**kwargs))
+ # attach ToolHandles
+ return acc
+
+def TrackerSPFit_OutputCfg(flags):
+ """Return ComponentAccumulator with Output for SCT. Not standalone."""
+ acc = ComponentAccumulator()
+ acc.merge(OutputStreamCfg(flags, "ESD"))
+ ostream = acc.getEventAlgo("OutputStreamESD")
+ ostream.TakeItemsFromInput = True
+ return acc
+
+def TrackerSPFitCfg(flags, **kwargs):
+ acc=TrackerSPFitBasicCfg(flags, **kwargs)
+ histSvc= THistSvc()
+ histSvc.Output += [ "TrackerSPFit DATAFILE='trackerspfit.root' OPT='RECREATE'" ]
+ acc.addService(histSvc)
+ acc.merge(TrackerSPFit_OutputCfg(flags))
+ return acc
+
+if __name__ == "__main__":
+ log.setLevel(DEBUG)
+ Configurable.configurableRun3Behavior = True
+
+ # Configure
+ ConfigFlags.Input.Files = ['/eos/project-f/faser-commissioning/TI12Data/Run-004272/Faser-Physics-004272-00010.raw']
+ ConfigFlags.Output.ESDFileName = "mySeeds.ESD.pool.root"
+ ConfigFlags.IOVDb.GlobalTag = "OFLCOND-FASER-01" # Always needed; must match FaserVersion
+ ConfigFlags.IOVDb.DatabaseInstance = "OFLP200" # Use MC conditions for now
+ ConfigFlags.Input.ProjectName = "data21" # Needed to bypass autoconfig
+ ConfigFlags.Input.isMC = False
+ # Needed to bypass autoconfig
+ ConfigFlags.GeoModel.FaserVersion = "FASER-01" # FASER cosmic ray geometry (station 2 only)
+ ConfigFlags.Common.isOnline = False
+ ConfigFlags.GeoModel.Align.Dynamic = False
+ ConfigFlags.Beam.NumberOfCollisions = 0.
+
+ ConfigFlags.lock()
+
+ # Core components
+ acc = MainServicesCfg(ConfigFlags)
+ acc.merge(PoolWriteCfg(ConfigFlags))
+
+ from FaserByteStreamCnvSvc.FaserByteStreamCnvSvcConfig import FaserByteStreamCnvSvcCfg
+ acc.merge(FaserByteStreamCnvSvcCfg(ConfigFlags))
+ acc.merge(WaveformReconstructionCfg(ConfigFlags))
+ acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags, DataObjectName="SCT_EDGEMODE_RDOs"))
+# acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags))
+ acc.merge(TrackerSpacePointFinderCfg(ConfigFlags))
+ acc.merge(TrackerSPFitCfg(ConfigFlags))
+# from AthenaConfiguration.ComponentFactory import CompFactory
+# decoderTool = CompFactory.RawWaveformDecoderTool(name = "RawWaveformDecoderTool",
+## CaloChannels = [0, 1, 2,3, 4, 5],
+## PreshowerChannels = [6,7],
+## TriggerChannels = [8, 9],
+# VetoChannels=[])
+# acc.addPublicTool(decoderTool)
+
+ # Timing
+ #acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
+
+ # Dump config
+ logging.getLogger('forcomps').setLevel(INFO)
+ acc.foreach_component("*").OutputLevel = INFO
+ acc.foreach_component("*ClassID*").OutputLevel = INFO
+ # acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+ # acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+ acc.getService("StoreGateSvc").Dump = True
+ acc.getService("ConditionStore").Dump = True
+ acc.printConfig(withDetails=True)
+ ConfigFlags.dump()
+
+ # Execute and finish
+ sc = acc.run(maxEvents=-1)
+
+ # Success should be 0
+ sys.exit(not sc.isSuccess())
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/src/TrackerSPFit.cxx b/Tracker/TrackerRecAlgs/TrackerSPFit/src/TrackerSPFit.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..98b1c29f1f14f6f217b27d6223f7112e286e2111
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/src/TrackerSPFit.cxx
@@ -0,0 +1,757 @@
+/*
+ Copyright (C) 2002-2021 ChRN for the benefit of the ATLAS collaboration
+ */
+
+/***************************************************************************
+ -------------------
+ ***************************************************************************/
+
+//<<<<<< INCLUDES >>>>>>
+
+
+#include "TrackerSPFit.h"
+
+// For processing clusters
+#include "TrackerReadoutGeometry/SiLocalPosition.h"
+#include "TrackerReadoutGeometry/SiDetectorDesign.h"
+#include "TrackerReadoutGeometry/SiDetectorElement.h"
+
+// Space point Classes,
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+
+// general Atlas classes
+#include "FaserDetDescr/FaserDetectorID.h"
+#include "xAODEventInfo/EventInfo.h"
+#include "StoreGate/ReadCondHandle.h"
+
+#include "AthenaMonitoringKernel/Monitored.h"
+
+namespace Tracker
+{
+ //------------------------------------------------------------------------
+ TrackerSPFit::TrackerSPFit(const std::string& name,
+ ISvcLocator* pSvcLocator)
+ : AthReentrantAlgorithm(name, pSvcLocator)
+ , m_hist_x(0)
+ , m_hist_y(0)
+ , m_hist_z(0)
+ , m_hist_r(0)
+ , m_hist_eta(0)
+ , m_hist_phi(0)
+ , m_hist_station(0)
+ , m_hist_strip(0)
+ , m_hist_layer(0)
+ , m_hist_x_y_plane0(0)
+ , m_hist_x_y_plane1(0)
+ , m_hist_x_y_plane2(0)
+ , m_hist_x_y_plane3(0)
+ , m_hist_x_y_plane4(0)
+ , m_hist_x_y_plane5(0)
+ , m_hist_x_y_plane6(0)
+ , m_hist_x_y_plane7(0)
+ , m_hist_x_y_plane8(0)
+ , m_residual_y_plane0(0)
+ , m_residual_y_plane1(0)
+ , m_residual_y_plane2(0)
+ , m_residual_y_plane3(0)
+ , m_residual_y_plane4(0)
+ , m_residual_y_plane5(0)
+ , m_residual_y_plane6(0)
+ , m_residual_y_plane7(0)
+ , m_residual_y_plane8(0)
+ , m_residual_x_plane0(0)
+ , m_residual_x_plane1(0)
+ , m_residual_x_plane2(0)
+ , m_residual_x_plane3(0)
+ , m_residual_x_plane4(0)
+ , m_residual_x_plane5(0)
+ , m_residual_x_plane6(0)
+ , m_residual_x_plane7(0)
+ , m_residual_x_plane8(0)
+ , m_chi2(0)
+ , m_edm(0)
+ , m_ndf(0)
+ , m_thistSvc("THistSvc", name)
+ {
+ declareProperty("MaxChi2", m_maxchi2=20);
+ declareProperty("UseBiasedResidual", m_bias=true);
+ declareProperty("SaveAllClusterInfo", m_saveallcluster=true);
+ declareProperty("SaveAllSPInfo", m_saveallsp=true);
+ }
+
+ //-----------------------------------------------------------------------
+ StatusCode TrackerSPFit::initialize()
+ {
+ ATH_MSG_DEBUG( "TrackerSPFit::initialize()" );
+
+ CHECK(m_thistSvc.retrieve());
+ // Check that clusters, space points and ids have names
+ if(m_Sct_clcontainerKey.key().empty()){
+ ATH_MSG_FATAL( "SCTs selected and no name set for SCT clusters");
+ return StatusCode::FAILURE;
+ }
+ ATH_CHECK( m_Sct_clcontainerKey.initialize() );
+
+ if ( m_Sct_spcontainerKey.key().empty()){
+ ATH_MSG_FATAL( "SCTs selected and no name set for SCT clusters");
+ return StatusCode::FAILURE;
+ }
+ ATH_CHECK( m_Sct_spcontainerKey.initialize() );
+
+ m_tree= new TTree("spfit","tree");
+ TrackerSPFit::initializeTree();
+
+ // create containers (requires the Identifier Helpers)
+ ATH_CHECK(detStore()->retrieve(m_idHelper,"FaserSCT_ID"));
+
+ // Initialize the key of input SiElementPropertiesTable and SiDetectorElementCollection for SCT
+ ATH_CHECK(m_SCTDetEleCollKey.initialize());
+
+
+ m_hist_x=new TH1D("sp_x","sp_x",100,-200,200);
+ m_hist_y=new TH1D("sp_y","sp_y",100,-200,200);
+ m_hist_z=new TH1D("sp_z","sp_z",100,0,300);
+ m_hist_r=new TH1D("sp_r","sp_r",100,0,300);
+ m_hist_eta=new TH1D("sp_eta","sp_eta",100,0,5);
+ m_hist_phi=new TH1D("sp_phi","sp_phi",100,-3.2,3.2);
+ m_hist_strip=new TH1D("sp_strip","sp_strip",100,0,2000);
+ m_hist_layer=new TH1D("sp_layer","sp_layer",100,-10,10);
+ m_hist_station=new TH1D("sp_station","sp_station",100,-10,10);
+ m_hist_x_y_plane0=new TH2D("sp_x_y_plane0","sp_x_y_plane0",100,-200,200,100,-200,200);
+ m_hist_x_y_plane1=new TH2D("sp_x_y_plane1","sp_x_y_plane1",100,-200,200,100,-200,200);
+ m_hist_x_y_plane2=new TH2D("sp_x_y_plane2","sp_x_y_plane2",100,-200,200,100,-200,200);
+ m_hist_x_y_plane3=new TH2D("sp_x_y_plane3","sp_x_y_plane3",100,-200,200,100,-200,200);
+ m_hist_x_y_plane4=new TH2D("sp_x_y_plane4","sp_x_y_plane4",100,-200,200,100,-200,200);
+ m_hist_x_y_plane5=new TH2D("sp_x_y_plane5","sp_x_y_plane5",100,-200,200,100,-200,200);
+ m_hist_x_y_plane6=new TH2D("sp_x_y_plane6","sp_x_y_plane6",100,-200,200,100,-200,200);
+ m_hist_x_y_plane7=new TH2D("sp_x_y_plane7","sp_x_y_plane7",100,-200,200,100,-200,200);
+ m_hist_x_y_plane8=new TH2D("sp_x_y_plane8","sp_x_y_plane8",100,-200,200,100,-200,200);
+ m_residual_y_plane0=new TH1D("sp_residual_y_plane0","sp_residual_y_plane0",2000,-1,1);
+ m_residual_y_plane1=new TH1D("sp_residual_y_plane1","sp_residual_y_plane1",2000,-1,1);
+ m_residual_y_plane2=new TH1D("sp_residual_y_plane2","sp_residual_y_plane2",2000,-1,1);
+ m_residual_y_plane3=new TH1D("sp_residual_y_plane3","sp_residual_y_plane3",2000,-1,1);
+ m_residual_y_plane4=new TH1D("sp_residual_y_plane4","sp_residual_y_plane4",2000,-1,1);
+ m_residual_y_plane5=new TH1D("sp_residual_y_plane5","sp_residual_y_plane5",2000,-1,1);
+ m_residual_y_plane6=new TH1D("sp_residual_y_plane6","sp_residual_y_plane6",2000,-1,1);
+ m_residual_y_plane7=new TH1D("sp_residual_y_plane7","sp_residual_y_plane7",2000,-1,1);
+ m_residual_y_plane8=new TH1D("sp_residual_y_plane8","sp_residual_y_plane8",2000,-1,1);
+ m_residual_x_plane0=new TH1D("sp_residual_x_plane0","sp_residual_x_plane0",2000,-1,1);
+ m_residual_x_plane1=new TH1D("sp_residual_x_plane1","sp_residual_x_plane1",2000,-1,1);
+ m_residual_x_plane2=new TH1D("sp_residual_x_plane2","sp_residual_x_plane2",2000,-1,1);
+ m_residual_x_plane3=new TH1D("sp_residual_x_plane3","sp_residual_x_plane3",2000,-1,1);
+ m_residual_x_plane4=new TH1D("sp_residual_x_plane4","sp_residual_x_plane4",2000,-1,1);
+ m_residual_x_plane5=new TH1D("sp_residual_x_plane5","sp_residual_x_plane5",2000,-1,1);
+ m_residual_x_plane6=new TH1D("sp_residual_x_plane6","sp_residual_x_plane6",2000,-1,1);
+ m_residual_x_plane7=new TH1D("sp_residual_x_plane7","sp_residual_x_plane7",2000,-1,1);
+ m_residual_x_plane8=new TH1D("sp_residual_x_plane8","sp_residual_x_plane8",2000,-1,1);
+ m_chi2=new TH1D("chi2","chi2",100,0,100);
+ m_edm=new TH1D("edm","edm",100,0,0.01);
+ m_ndf=new TH1D("ndf","ndf",10,0,10);
+ CHECK(m_thistSvc->regTree("/TrackerSPFit/spfit",m_tree));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x",m_hist_x));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_y",m_hist_y));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_z",m_hist_z));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_r",m_hist_r));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_eta",m_hist_eta));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_phi",m_hist_phi));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_strip",m_hist_strip));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_layer",m_hist_layer));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_station",m_hist_station));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane0",m_hist_x_y_plane0));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane1",m_hist_x_y_plane1));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane2",m_hist_x_y_plane2));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane3",m_hist_x_y_plane3));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane4",m_hist_x_y_plane4));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane5",m_hist_x_y_plane5));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane6",m_hist_x_y_plane6));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane7",m_hist_x_y_plane7));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_x_y_plane8",m_hist_x_y_plane8));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane0",m_residual_y_plane0));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane1",m_residual_y_plane1));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane2",m_residual_y_plane2));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane3",m_residual_y_plane3));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane4",m_residual_y_plane4));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane5",m_residual_y_plane5));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane6",m_residual_y_plane6));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane7",m_residual_y_plane7));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_y_plane8",m_residual_y_plane8));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane0",m_residual_x_plane0));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane1",m_residual_x_plane1));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane2",m_residual_x_plane2));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane3",m_residual_x_plane3));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane4",m_residual_x_plane4));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane5",m_residual_x_plane5));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane6",m_residual_x_plane6));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane7",m_residual_x_plane7));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_residual_x_plane8",m_residual_x_plane8));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_chi2",m_chi2));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_edm",m_edm));
+ CHECK(m_thistSvc->regHist("/TrackerSPFit/sp/sp_ndf",m_ndf));
+ ATH_MSG_INFO( "TrackerSPFit::initialized" );
+ return StatusCode::SUCCESS;
+ }
+
+ //-------------------------------------------------------------------------
+ void TrackerSPFit::initializeTree(){
+ m_tree->Branch("evtId",&m_eventNumber);
+ m_tree->Branch("sp_track_x",&m_sp_track_x);
+ m_tree->Branch("sp_track_y",&m_sp_track_y);
+ m_tree->Branch("sp_track_z",&m_sp_track_z);
+ m_tree->Branch("sp_track_x_err",&m_sp_track_x_err);
+ m_tree->Branch("sp_track_y_err",&m_sp_track_y_err);
+ m_tree->Branch("sp_track_z_err",&m_sp_track_z_err);
+ m_tree->Branch("sp_track_x_predicted",&m_sp_track_x_predicted);
+ m_tree->Branch("sp_track_y_predicted",&m_sp_track_y_predicted);
+ m_tree->Branch("sp_track_z_predicted",&m_sp_track_z_predicted);
+ m_tree->Branch("sp_track_x_residual",&m_sp_track_x_residual);
+ m_tree->Branch("sp_track_y_residual",&m_sp_track_y_residual);
+ m_tree->Branch("sp_track_z_residual",&m_sp_track_z_residual);
+ m_tree->Branch("sp_track_station",&m_sp_track_station);
+ m_tree->Branch("sp_track_layer",&m_sp_track_layer);
+ m_tree->Branch("sp_track_module",&m_sp_track_module);
+ m_tree->Branch("trackId",&m_trackId);
+ m_tree->Branch("track_chi2",&m_track_chi2);
+ m_tree->Branch("track_edm",&m_track_edm);
+ m_tree->Branch("track_ndf",&m_track_ndf);
+ m_tree->Branch("track_p0",&m_track_p0);
+ m_tree->Branch("track_p1",&m_track_p1);
+ m_tree->Branch("track_p2",&m_track_p2);
+ m_tree->Branch("track_p3",&m_track_p3);
+ if(m_saveallcluster){
+ m_tree->Branch("cluster_all_local_x",&m_cluster_all_local_x);
+ m_tree->Branch("cluster_all_local_y",&m_cluster_all_local_y);
+ m_tree->Branch("cluster_global_x",&m_cluster_all_global_x);
+ m_tree->Branch("cluster_global_y",&m_cluster_all_global_y);
+ m_tree->Branch("cluster_global_z",&m_cluster_all_global_z);
+ m_tree->Branch("cluster_all_phiwidth",&m_cluster_all_phiwidth);
+ m_tree->Branch("cluster_all_size",&m_cluster_all_size);
+ m_tree->Branch("cluster_all_station",&m_cluster_all_station);
+ m_tree->Branch("cluster_all_layer",&m_cluster_all_layer);
+ m_tree->Branch("cluster_all_module",&m_cluster_all_module);
+ m_tree->Branch("cluster_all_side",&m_cluster_all_side);
+ m_tree->Branch("cluster_all_strip",&m_cluster_all_strip);
+ }
+ if(m_saveallsp){
+ m_tree->Branch("sp_all_x", &m_sp_all_x);
+ m_tree->Branch("sp_all_y", &m_sp_all_y);
+ m_tree->Branch("sp_all_z", &m_sp_all_z);
+ m_tree->Branch("sp_all_station", &m_sp_all_station);
+ m_tree->Branch("sp_all_layer", &m_sp_all_layer);
+ m_tree->Branch("sp_all_module", &m_sp_all_module);
+// if(m_saveallcluster){
+// m_tree->Branch("sp_all_clus1_index", &m_sp_all_clus1_index);
+// m_tree->Branch("sp_all_clus2_index", &m_sp_all_clus2_index);
+// }
+ }
+ }
+ //-------------------------------------------------------------------------
+ void TrackerSPFit::clearVariables() const {
+ if(m_saveallcluster){
+ m_cluster_all_local_x.clear();
+ m_cluster_all_local_y.clear();
+ m_cluster_all_global_x.clear();
+ m_cluster_all_global_y.clear();
+ m_cluster_all_global_z.clear();
+ m_cluster_all_phiwidth.clear();
+ m_cluster_all_size.clear();
+ m_cluster_all_station.clear();
+ m_cluster_all_layer.clear();
+ m_cluster_all_module.clear();
+ m_cluster_all_side.clear();
+ m_cluster_all_strip.clear();
+ }
+ if(m_saveallsp){
+ m_sp_all_x.clear();
+ m_sp_all_y.clear();
+ m_sp_all_z.clear();
+// if(m_saveallcluster){
+// m_sp_all_clus1_index.clear();
+// m_sp_all_clus2_index.clear();
+// }
+ m_sp_all_station.clear();
+ m_sp_all_layer.clear();
+ m_sp_all_module.clear();
+ }
+ m_sp_track_x.clear();
+ m_sp_track_y.clear();
+ m_sp_track_z.clear();
+ m_sp_track_x_err.clear();
+ m_sp_track_y_err.clear();
+ m_sp_track_z_err.clear();
+ m_sp_track_x_predicted.clear();
+ m_sp_track_y_predicted.clear();
+ m_sp_track_z_predicted.clear();
+ m_sp_track_x_residual.clear();
+ m_sp_track_y_residual.clear();
+ m_sp_track_z_residual.clear();
+ m_sp_track_station.clear();
+ m_sp_track_layer.clear();
+ m_sp_track_module.clear();
+ m_trackId.clear();
+ m_track_chi2.clear();
+ m_track_edm.clear();
+ m_track_ndf.clear();
+ m_track_p0.clear();
+ m_track_p1.clear();
+ m_track_p2.clear();
+ m_track_p3.clear();
+ }
+ //-------------------------------------------------------------------------
+
+ StatusCode TrackerSPFit::execute (const EventContext& ctx) const
+ {
+
+ ++m_numberOfEvents;
+ m_eventNumber=m_numberOfEvents;
+ clearVariables();
+ const TrackerDD::SiDetectorElementCollection* elements = nullptr;
+
+
+ SG::ReadCondHandle<TrackerDD::SiDetectorElementCollection> sctDetEle(m_SCTDetEleCollKey, ctx);
+ elements = sctDetEle.retrieve();
+ if (elements==nullptr) {
+ ATH_MSG_FATAL("Pointer of SiDetectorElementCollection (" << m_SCTDetEleCollKey.fullKey() << ") could not be retrieved");
+ return StatusCode::SUCCESS;
+ }
+
+ //read cluster
+ SG::ReadHandle<Tracker::FaserSCT_ClusterContainer> sct_clcontainer( m_Sct_clcontainerKey, ctx );
+ if ((!sct_clcontainer.isValid())&&m_saveallcluster){
+ msg(MSG:: FATAL) << "Could not find the data object "<< sct_clcontainer.name() << " !" << endmsg;
+ return StatusCode::RECOVERABLE;
+ }
+ // save all the cluster information
+ if(m_saveallcluster){
+ ATH_MSG_DEBUG( "SCT cluster container found: " << sct_clcontainer->size() << " collections" );
+ Tracker::FaserSCT_ClusterContainer::const_iterator clusit = sct_clcontainer->begin();
+ Tracker::FaserSCT_ClusterContainer::const_iterator clusend = sct_clcontainer->end();
+ for (; clusit != clusend; ++clusit){
+ ++m_numberOfClusterCol;
+ const Tracker::FaserSCT_ClusterCollection *colNext=&(**clusit);
+ FaserSCT_ClusterCollection::const_iterator clusters {colNext->begin()} ;
+ FaserSCT_ClusterCollection::const_iterator clustersEnd {colNext->end() };
+ for (; clusters != clustersEnd; ++clusters)
+ {
+ ++m_numberOfCluster;
+ const Tracker::FaserSCT_Cluster* clus=&(**clusters);
+ m_cluster_all_global_x.push_back(clus->globalPosition().x());
+ m_cluster_all_global_y.push_back(clus->globalPosition().y());
+ m_cluster_all_global_z.push_back(clus->globalPosition().z());
+ m_cluster_all_local_x.push_back(clus->localPosition().x());
+ m_cluster_all_local_y.push_back(clus->localPosition().y());
+ m_cluster_all_phiwidth.push_back(clus->width().phiR());
+ Identifier elementID = clus->identify();
+ m_cluster_all_station.push_back( m_idHelper->station(elementID));
+ m_cluster_all_layer.push_back( m_idHelper->layer(elementID));
+ int ietamodule = m_idHelper->eta_module(elementID);
+ int iphimodule = m_idHelper->phi_module(elementID);
+ if(ietamodule<0)iphimodule+=4;
+ m_cluster_all_module.push_back(iphimodule);
+ m_cluster_all_side.push_back(m_idHelper->side(elementID));
+ m_cluster_all_strip.push_back(m_idHelper->strip(elementID));
+ m_cluster_all_size.push_back(clus->rdoList().size());
+ }
+ }
+
+ }
+
+
+ // retrieve SCT spacepoint container
+ SG::ReadHandle<FaserSCT_SpacePointContainer> sct_spcontainer( m_Sct_spcontainerKey, ctx );
+ if (!sct_spcontainer.isValid()){
+ msg(MSG:: FATAL) << "Could not find the data object "<< sct_spcontainer.name() << " !" << endmsg;
+ return StatusCode::RECOVERABLE;
+ }
+
+ // save all the sp information
+ if(m_saveallsp){
+ ATH_MSG_DEBUG( "SCT spacepoint container found: " << sct_spcontainer->size() << " collections" );
+ FaserSCT_SpacePointContainer::const_iterator it = sct_spcontainer->begin();
+ FaserSCT_SpacePointContainer::const_iterator itend = sct_spcontainer->end();
+
+ for (; it != itend; ++it){
+ ++m_numberOfSPCol;
+ const FaserSCT_SpacePointCollection *colNext=&(**it);
+ FaserSCT_SpacePointCollection::const_iterator sp_begin= colNext->begin();
+ FaserSCT_SpacePointCollection::const_iterator sp_end= colNext->end();
+ Identifier elementID = colNext->identify();
+ for (; sp_begin != sp_end; ++sp_begin){
+ ++m_numberOfSP;
+ const Tracker::FaserSCT_SpacePoint* sp=&(**sp_begin);
+ m_sp_all_x.push_back(sp->globalPosition().x());
+ m_sp_all_y.push_back(sp->globalPosition().y());
+ m_sp_all_z.push_back(sp->globalPosition().z());
+ m_sp_all_station.push_back(m_idHelper->station(elementID));
+ m_sp_all_layer.push_back(m_idHelper->layer(elementID));
+ int ietamodule = m_idHelper->eta_module(elementID);
+ int iphimodule = m_idHelper->phi_module(elementID);
+ if(ietamodule<0)iphimodule+=4;
+ m_sp_all_module.push_back(iphimodule);
+ /* to be updated
+ if(m_saveallcluster){
+ const Tracker::FaserSCT_ClusterCollection *ptr1 = sct_clcontainer->indexFindPtr(sp->elemIDList().first());
+ const Tracker::FaserSCT_ClusterCollection *ptr2 = sct_clcontainer->indexFindPtr(sp->elemIDList().second());
+ m_sp_all_clus1_index.push_back(findClusterIndex(sp,ptr1));
+ m_sp_all_clus2_index.push_back(findClusterIndex(sp,ptr2));
+ }
+ */
+ }
+ }
+ }
+
+ // register the IdentifiableContainer into StoreGate
+
+ ATH_MSG_DEBUG( "SCT spacepoint container found: " << sct_spcontainer->size() << " collections" );
+ FaserSCT_SpacePointContainer::const_iterator it = sct_spcontainer->begin();
+ FaserSCT_SpacePointContainer::const_iterator itend = sct_spcontainer->end();
+
+ std::vector<SP_Seed> sp_sta0;
+ std::vector<SP_Seed> sp_sta1;
+ std::vector<SP_Seed> sp_sta2;
+ sp_sta0.clear();
+ sp_sta1.clear();
+ sp_sta2.clear();
+ for (; it != itend; ++it){
+ const FaserSCT_SpacePointCollection *colNext=&(**it);
+ // int nReceivedSPSCT = colNext->size();
+
+ // Create SpacePointCollection
+ // IdentifierHash idHash = colNext->identifyHash();
+ Identifier elementID = colNext->identify();
+
+ ATH_MSG_VERBOSE("reading SpacePoints collection "<<elementID.get_compact()<<" , and hash = "<<colNext->identifyHash() );
+ int istation = m_idHelper->station(elementID);
+ int ilayer = m_idHelper->layer(elementID);
+ int ietamodule = m_idHelper->eta_module(elementID);
+ int iphimodule = m_idHelper->phi_module(elementID);
+ int imodule=iphimodule;
+ if(ietamodule<0)imodule+=4;
+ m_hist_strip->Fill(m_idHelper->strip(elementID));
+ m_hist_station->Fill(istation);
+ m_hist_layer->Fill(ilayer);
+ size_t size = colNext->size();
+ if (size == 0){
+ ATH_MSG_DEBUG( "TrackerSPFit algorithm found no space points" );
+ } else {
+ //In a MT environment the cache maybe filled by another thread in which case this will delete the duplicate
+ FaserSCT_SpacePointCollection::const_iterator sp_begin= colNext->begin();
+ FaserSCT_SpacePointCollection::const_iterator sp_end= colNext->end();
+ for (; sp_begin != sp_end; ++sp_begin){
+ const FaserSCT_SpacePoint* sp=&(**sp_begin);
+ m_hist_r->Fill(sp->r());
+ m_hist_eta->Fill(sp->eta());
+ m_hist_phi->Fill(sp->phi());
+ Amg::Vector3D gloPos=sp->globalPosition();
+ m_hist_x->Fill(gloPos.x());
+ m_hist_y->Fill(gloPos.y());
+ m_hist_z->Fill(gloPos.z());
+ struct SP_Seed tmp{gloPos,sp->globCovariance(),ilayer,imodule};
+ ATH_MSG_DEBUG( "TrackerSPFit algorithm found no space points" );
+ if(istation==1)
+ sp_sta0.push_back(tmp);
+ else if(istation==2)
+ sp_sta1.push_back(tmp);
+ else
+ sp_sta2.push_back(tmp);
+
+ if ( ((istation-1)*3+ilayer) == 0 ) m_hist_x_y_plane0->Fill(gloPos.x(),gloPos.y());
+ if ( ((istation-1)*3+ilayer) == 1 ) m_hist_x_y_plane1->Fill(gloPos.x(),gloPos.y());
+ if ( ((istation-1)*3+ilayer) == 2 ) m_hist_x_y_plane2->Fill(gloPos.x(),gloPos.y());
+ if ( ((istation-1)*3+ilayer) == 3 ) m_hist_x_y_plane3->Fill(gloPos.x(),gloPos.y());
+ if ( ((istation-1)*3+ilayer) == 4 ) m_hist_x_y_plane4->Fill(gloPos.x(),gloPos.y());
+ if ( ((istation-1)*3+ilayer) == 5 ) m_hist_x_y_plane5->Fill(gloPos.x(),gloPos.y());
+ if ( ((istation-1)*3+ilayer) == 6 ) m_hist_x_y_plane6->Fill(gloPos.x(),gloPos.y());
+ if ( ((istation-1)*3+ilayer) == 7 ) m_hist_x_y_plane7->Fill(gloPos.x(),gloPos.y());
+ if ( ((istation-1)*3+ilayer) == 8 ) m_hist_x_y_plane8->Fill(gloPos.x(),gloPos.y());
+ }
+ ATH_MSG_VERBOSE( size << " SpacePoints successfully added to Container !" );
+ }
+ }
+ ATH_MSG_INFO( "TrackerSPFit number of spacepoints in each stations: "<<sp_sta0.size()<<" "<<sp_sta1.size()<<" "<<sp_sta2.size() );
+
+ bool ifTrack=false;
+ if(sp_sta0.size()>2&&sp_sta0.size()<100) {
+ auto tracks_sta0=makeTrackSeg(sp_sta0,m_maxchi2);
+ ATH_MSG_INFO( "TrackerSPFit found "<<tracks_sta0.size()<<" track segments in station 0 " );
+ if(tracks_sta0.size()>0){
+ ifTrack=true;
+ for(auto track:tracks_sta0){
+ auto pre=track.predicted;
+ auto pos=track.pos;
+ ++m_numberOfTrack;
+ m_trackId.push_back(int(m_numberOfTrack/3));
+ m_sp_track_x.push_back(pos.x());
+ m_sp_track_y.push_back(pos.y());
+ m_sp_track_z.push_back(pos.z());
+ m_sp_track_x_err.push_back(track.err.x());
+ m_sp_track_y_err.push_back(track.err.y());
+ m_sp_track_z_err.push_back(track.err.z());
+ m_sp_track_x_predicted.push_back(pre.x());
+ m_sp_track_y_predicted.push_back(pre.y());
+ m_sp_track_z_predicted.push_back(pre.z());
+ m_sp_track_x_residual.push_back(pre.x()-pos.x());
+ m_sp_track_y_residual.push_back(pre.y()-pos.y());
+ m_sp_track_z_residual.push_back(pre.z()-pos.z());
+ ATH_MSG_DEBUG(" fill the result "<<pre.x()<<" "<<pre.y()<<" "<<pre.z()<<" "<<pos.x()<<" "<<pos.y()<<" "<<pos.z());
+ m_sp_track_station.push_back(0);
+ m_sp_track_layer.push_back(track.layer);
+ m_sp_track_module.push_back(track.module);
+ if(m_bias){
+ m_track_chi2.push_back(track.chi2);
+ m_track_edm.push_back(track.edm);
+ m_track_ndf.push_back(track.ndf);
+ m_track_p0.push_back(track.p0);
+ m_track_p1.push_back(track.p1);
+ m_track_p2.push_back(track.p2);
+ m_track_p3.push_back(track.p3);
+ }
+ if(track.layer==0){ m_residual_x_plane0->Fill(pre.x()-pos.x());m_residual_y_plane0->Fill(pre.y()-pos.y());}
+ if(track.layer==1){ m_residual_x_plane1->Fill(pre.x()-pos.x());m_residual_y_plane1->Fill(pre.y()-pos.y());}
+ if(track.layer==2){ m_residual_x_plane2->Fill(pre.x()-pos.x());m_residual_y_plane2->Fill(pre.y()-pos.y());}
+ }
+ }
+ }
+ if(sp_sta1.size()>2&&sp_sta1.size()<100) {
+ auto tracks_sta1=makeTrackSeg(sp_sta1,m_maxchi2);
+ ATH_MSG_INFO( "TrackerSPFit found "<<tracks_sta1.size()<<" track segments in station 1 " );
+ if(tracks_sta1.size()>0){
+ ifTrack=true;
+ for(auto track:tracks_sta1){
+ auto pre=track.predicted;
+ auto pos=track.pos;
+ ++m_numberOfTrack;
+ m_trackId.push_back(int(m_numberOfTrack/3));
+ m_sp_track_x.push_back(pos.x());
+ m_sp_track_y.push_back(pos.y());
+ m_sp_track_z.push_back(pos.z());
+ m_sp_track_x_err.push_back(track.err.x());
+ m_sp_track_y_err.push_back(track.err.y());
+ m_sp_track_z_err.push_back(track.err.z());
+ m_sp_track_x_predicted.push_back(pre.x());
+ m_sp_track_y_predicted.push_back(pre.y());
+ m_sp_track_z_predicted.push_back(pre.z());
+ m_sp_track_x_residual.push_back(pre.x()-pos.x());
+ m_sp_track_y_residual.push_back(pre.y()-pos.y());
+ m_sp_track_z_residual.push_back(pre.z()-pos.z());
+ m_sp_track_station.push_back(1);
+ m_sp_track_layer.push_back(track.layer);
+ m_sp_track_module.push_back(track.module);
+ if(m_bias){
+ m_track_chi2.push_back(track.chi2);
+ m_track_edm.push_back(track.edm);
+ m_track_ndf.push_back(track.ndf);
+ m_track_p0.push_back(track.p0);
+ m_track_p1.push_back(track.p1);
+ m_track_p2.push_back(track.p2);
+ m_track_p3.push_back(track.p3);
+ }
+ if(track.layer==0){ m_residual_x_plane3->Fill(pre.x()-pos.x());m_residual_y_plane3->Fill(pre.y()-pos.y());}
+ if(track.layer==1){ m_residual_x_plane4->Fill(pre.x()-pos.x());m_residual_y_plane4->Fill(pre.y()-pos.y());}
+ if(track.layer==2){ m_residual_x_plane5->Fill(pre.x()-pos.x());m_residual_y_plane5->Fill(pre.y()-pos.y());}
+ }
+ }
+ }
+ if(sp_sta2.size()>2&&sp_sta2.size()<100) {
+ auto tracks_sta2=makeTrackSeg(sp_sta2,m_maxchi2);
+ ATH_MSG_INFO( "TrackerSPFit found "<<tracks_sta2.size()<<" track segments in station 2 " );
+ if(tracks_sta2.size()>0){
+ ifTrack=true;
+ for(auto track:tracks_sta2){
+ auto pre=track.predicted;
+ auto pos=track.pos;
+ ++m_numberOfTrack;
+ m_trackId.push_back(int(m_numberOfTrack/3));
+ m_sp_track_x.push_back(pos.x());
+ m_sp_track_y.push_back(pos.y());
+ m_sp_track_z.push_back(pos.z());
+ m_sp_track_x_err.push_back(track.err.x());
+ m_sp_track_y_err.push_back(track.err.y());
+ m_sp_track_z_err.push_back(track.err.z());
+ m_sp_track_x_predicted.push_back(pre.x());
+ m_sp_track_y_predicted.push_back(pre.y());
+ m_sp_track_z_predicted.push_back(pre.z());
+ m_sp_track_x_residual.push_back(pre.x()-pos.x());
+ m_sp_track_y_residual.push_back(pre.y()-pos.y());
+ m_sp_track_z_residual.push_back(pre.z()-pos.z());
+ m_sp_track_station.push_back(2);
+ m_sp_track_layer.push_back(track.layer);
+ m_sp_track_module.push_back(track.module);
+ if(m_bias){
+ m_track_chi2.push_back(track.chi2);
+ m_track_edm.push_back(track.edm);
+ m_track_ndf.push_back(track.ndf);
+ m_track_p0.push_back(track.p0);
+ m_track_p1.push_back(track.p1);
+ m_track_p2.push_back(track.p2);
+ m_track_p3.push_back(track.p3);
+ }
+ if(track.layer==0){ m_residual_x_plane6->Fill(pre.x()-pos.x());m_residual_y_plane6->Fill(pre.y()-pos.y());}
+ if(track.layer==1){ m_residual_x_plane7->Fill(pre.x()-pos.x());m_residual_y_plane7->Fill(pre.y()-pos.y());}
+ if(track.layer==2){ m_residual_x_plane8->Fill(pre.x()-pos.x());m_residual_y_plane8->Fill(pre.y()-pos.y());}
+ }
+ }
+ }
+
+ if(ifTrack)
+ m_tree->Fill();
+ else if(m_saveallcluster||m_saveallsp)
+ m_tree->Fill();
+ return StatusCode::SUCCESS;
+ }
+
+ //---------------------------------------------------------------------------
+ StatusCode TrackerSPFit::finalize()
+ {
+ ATH_MSG_INFO( "TrackerSPFit::finalize()" );
+ ATH_MSG_INFO( m_numberOfEvents << " events processed" );
+ ATH_MSG_INFO( m_numberOfClusterCol<< " sct Cluster collections processed" );
+ ATH_MSG_INFO( m_numberOfCluster<< " sct Cluster processed" );
+ ATH_MSG_INFO( m_numberOfSPCol<< " sct SP collections processed" );
+ ATH_MSG_INFO( m_numberOfSP<< " sct SP processed" );
+ return StatusCode::SUCCESS;
+ }
+
+ //--------------------------------------------------------------------------
+ std::vector<TrackerSPFit::SP_TSOS> TrackerSPFit::makeTrackSeg(std::vector<SP_Seed> sps, double maxchi2) const {
+ std::vector<SP_Seed> layer0;
+ std::vector<SP_Seed> layer1;
+ std::vector<SP_Seed> layer2;
+ layer0.clear();layer1.clear();layer2.clear();
+ std::vector<SP_TSOS> tracks;
+ tracks.clear();
+ for(unsigned int isp=0;isp<sps.size();isp++){
+ if(sps[isp].layer==0)layer0.push_back(sps[isp]);
+ if(sps[isp].layer==1)layer1.push_back(sps[isp]);
+ if(sps[isp].layer==2)layer2.push_back(sps[isp]);
+ }
+ if(layer0.size()>0&&layer1.size()>0&&layer2.size()>0){
+ for(unsigned int i0=0;i0<layer0.size();i0++){
+ for(unsigned int i1=0;i1<layer1.size();i1++){
+ for(unsigned int i2=0;i2<layer2.size();i2++){
+ if(m_bias){
+ //for biased residual
+ auto tmp=makeTrackSeg(layer0[i0],layer1[i1],layer2[i2],maxchi2);
+ tracks.insert(tracks.end(),tmp.begin(),tmp.end());
+ }
+ else{
+ //for un-biased residual
+ auto tmp=makeTrackSeg(layer0[i0],layer1[i1],layer2[i2]);
+ tracks.insert(tracks.end(),tmp.begin(),tmp.end());
+ }
+ }
+ }
+ }
+ }
+ return tracks;
+ }
+
+ std::vector<TrackerSPFit::SP_TSOS> TrackerSPFit::makeTrackSeg(SP_Seed sp0, SP_Seed sp1, SP_Seed sp2) const{
+ std::vector<SP_TSOS> spt;
+ spt.clear();
+ for(int isp=0;isp<3;isp++){
+ Amg::Vector3D error;
+
+ if(isp==0){
+ error=Amg::Vector3D(sqrt((sp0.cov)(0,0)),sqrt((sp0.cov)(1,1)),sqrt((sp0.cov)(2,2)));
+ //double resx= sp0.pos.x()-(sp1.pos.x()+sp2.pos.x())/2.;//from Jamie's code
+ double posx= (sp1.pos.x()-((sp1.pos.x()-sp2.pos.x())*(sp1.pos.z()-sp0.pos.z())/(sp1.pos.z()-sp2.pos.z())));
+ double posy= (sp1.pos.y()-((sp1.pos.y()-sp2.pos.y())*(sp1.pos.z()-sp0.pos.z())/(sp1.pos.z()-sp2.pos.z())));
+ Amg::Vector3D predictedpoint2(posx,posy,sp0.pos.z());
+
+ struct SP_TSOS tsos0{sp0.pos,predictedpoint2,error,sp0.layer,sp0.module};
+ spt.push_back(tsos0);
+ }
+ else if(isp==1){
+ error=Amg::Vector3D(sqrt((sp1.cov)(0,0)),sqrt((sp1.cov)(1,1)),sqrt((sp1.cov)(2,2)));
+ double posx= (sp2.pos.x()-((sp2.pos.x()-sp0.pos.x())*(sp2.pos.z()-sp1.pos.z())/(sp2.pos.z()-sp0.pos.z())));
+ double posy= (sp2.pos.y()-((sp2.pos.y()-sp0.pos.y())*(sp2.pos.z()-sp1.pos.z())/(sp2.pos.z()-sp0.pos.z())));
+ Amg::Vector3D predictedpoint2(posx,posy,sp1.pos.z());
+
+ struct SP_TSOS tsos0{sp1.pos,predictedpoint2,error,sp1.layer,sp1.module};
+ spt.push_back(tsos0);
+ }
+ else{
+ error=Amg::Vector3D(sqrt((sp2.cov)(0,0)),sqrt((sp2.cov)(1,1)),sqrt((sp2.cov)(2,2)));
+ double posx= (sp1.pos.x()-((sp1.pos.x()-sp0.pos.x())*(sp1.pos.z()-sp2.pos.z())/(sp1.pos.z()-sp0.pos.z())));
+ double posy= (sp1.pos.y()-((sp1.pos.y()-sp0.pos.y())*(sp1.pos.z()-sp2.pos.z())/(sp1.pos.z()-sp0.pos.z())));
+ Amg::Vector3D predictedpoint2(posx,posy,sp2.pos.z());
+
+ struct SP_TSOS tsos0{sp2.pos,predictedpoint2,error,sp2.layer,sp2.module};
+ spt.push_back(tsos0);
+ }
+
+ }
+ return spt;
+ }
+ std::vector<TrackerSPFit::SP_TSOS> TrackerSPFit::makeTrackSeg(SP_Seed sp0, SP_Seed sp1, SP_Seed sp2, double maxchi2) const{
+ std::vector<SP_TSOS> spt;
+ spt.clear();
+ TGraph2DErrors* gra= new TGraph2DErrors();
+ gra->SetPoint(0,sp0.pos.x(),sp0.pos.y(),sp0.pos.z());
+ gra->SetPoint(1,sp1.pos.x(),sp1.pos.y(),sp1.pos.z());
+ gra->SetPoint(2,sp2.pos.x(),sp2.pos.y(),sp2.pos.z());
+ gra->SetPointError(0,sqrt((sp0.cov)(0,0)),sqrt((sp0.cov)(1,1)),sqrt((sp0.cov)(2,2)));
+ gra->SetPointError(1,sqrt((sp1.cov)(0,0)),sqrt((sp1.cov)(1,1)),sqrt((sp1.cov)(2,2)));
+ gra->SetPointError(2,sqrt((sp2.cov)(0,0)),sqrt((sp2.cov)(1,1)),sqrt((sp2.cov)(2,2)));
+ ATH_MSG_DEBUG(" spacepoints in the station");
+ ATH_MSG_DEBUG("sp 0 "<<sp0.pos.x()<<" "<<sp0.pos.y()<<" "<<sp0.pos.z()<<" "<<sqrt((sp0.cov)(0,0))<<" "<<sqrt((sp0.cov)(1,1))<<" "<<sqrt((sp0.cov)(2.2)));
+ ATH_MSG_DEBUG("sp 1 "<<sp1.pos.x()<<" "<<sp1.pos.y()<<" "<<sp1.pos.z()<<" "<<sqrt((sp1.cov)(0,0))<<" "<<sqrt((sp1.cov)(1,1))<<" "<<sqrt((sp1.cov)(2.2)));
+ ATH_MSG_DEBUG("sp 2 "<<sp2.pos.x()<<" "<<sp2.pos.y()<<" "<<sp2.pos.z()<<" "<<sqrt((sp2.cov)(0,0))<<" "<<sqrt((sp2.cov)(1,1))<<" "<<sqrt((sp2.cov)(2.2)));
+ ROOT::Fit::Fitter fitter;
+ SumDistance2 sumdist(gra);
+ ROOT::Math::Functor fcn(sumdist,4);
+ double initParam[4]={1,1,1,1};
+ fitter.SetFCN(fcn,initParam);
+ // for (int i = 0; i < 4; ++i) fitter.Config().ParSettings(i).SetStepSize(0.01);
+ if(fitter.FitFCN()){
+ const ROOT::Fit::FitResult & result =fitter.Result();
+ double chi2=result.MinFcnValue();
+ double edm=result.Edm();
+ int ndf=result.Ndf();
+ ATH_MSG_DEBUG( "TrackerSPFit::makeTrackSeg(), track chi2 = "<<chi2<<" ; edm = "<<edm<<" ; ndf = "<<ndf );
+ m_chi2->Fill(chi2);
+ m_edm->Fill(edm);
+ m_ndf->Fill(ndf);
+
+ if(chi2<maxchi2){
+// result.Print(std::cout);
+ const double *fitParam=result.GetParams();
+ ATH_MSG_DEBUG(" fit status: ook "<<chi2<<" "<<edm<<" "<<ndf<<" "<<fitParam[0]<<" "<<fitParam[1]<<" "<<fitParam[2]<<" "<<fitParam[3]);
+ Amg::Vector3D err0(sqrt((sp0.cov)(0,0)),sqrt((sp0.cov)(1,1)),sqrt((sp0.cov)(2,2)));
+ Amg::Vector3D err1(sqrt((sp1.cov)(0,0)),sqrt((sp1.cov)(1,1)),sqrt((sp1.cov)(2,2)));
+ Amg::Vector3D err2(sqrt((sp2.cov)(0,0)),sqrt((sp2.cov)(1,1)),sqrt((sp2.cov)(2,2)));
+ struct SP_TSOS tsos0{sp0.pos,predicted(sp0.pos.z(),fitParam),err0,sp0.layer,sp0.module,chi2,edm,ndf,fitParam[0],fitParam[1],fitParam[2],fitParam[3]};
+ struct SP_TSOS tsos1{sp1.pos,predicted(sp1.pos.z(),fitParam),err1,sp1.layer,sp0.module,chi2,edm,ndf,fitParam[0],fitParam[1],fitParam[2],fitParam[3]};
+ struct SP_TSOS tsos2{sp2.pos,predicted(sp2.pos.z(),fitParam),err2,sp2.layer,sp0.module,chi2,edm,ndf,fitParam[0],fitParam[1],fitParam[2],fitParam[3]};
+ spt.push_back(tsos0);
+ spt.push_back(tsos1);
+ spt.push_back(tsos2);
+ }
+ }
+
+ return spt;
+ }
+
+ Amg::Vector3D TrackerSPFit::predicted(double z, const double *p) const {
+ return Amg::Vector3D(p[0]+p[1]*z,p[2]+p[3]*z,z);
+ }
+
+ /*
+ * need to be updated
+ int TrackerSPFit::findClusterIndex(const Tracker::FaserSCT_SpacePoint* sp, const Tracker::FaserSCT_ClusterCollection* ptr)const {
+ if (ptr!=nullptr) {
+ //loop though collection to find matching PRD.
+ Tracker::FaserSCT_ClusterCollection::const_iterator collIt = ptr->begin();
+ Tracker::FaserSCT_ClusterCollection::const_iterator collItEnd = ptr->end();
+ for ( ; collIt!=collItEnd; collIt++) {
+ if ( (*collIt)->identify()==id1 )
+ clus1= &(**collIt);
+ }
+ }
+
+ }
+ */
+
+}
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/src/TrackerSPFit.h b/Tracker/TrackerRecAlgs/TrackerSPFit/src/TrackerSPFit.h
new file mode 100755
index 0000000000000000000000000000000000000000..ae76af9941ae8b6b6480699108d0ebf48b1125b7
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/src/TrackerSPFit.h
@@ -0,0 +1,215 @@
+// -*- C++ -*-
+
+/*
+ Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+ */
+
+#ifndef TRACKERSPFIT_TRACKERSPACEPOINTMAKERALG_H
+#define TRACKERSPFIT_TRACKERSPACEPOINTMAKERALG_H
+
+#include "StoreGate/ReadCondHandleKey.h"
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "Identifier/Identifier.h"
+
+#include "TrackerPrepRawData/FaserSCT_ClusterCollection.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+#include "TrackerPrepRawData/TrackerClusterContainer.h"
+#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h"
+#include "TrkEventPrimitives/LocalParameters.h"
+
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/ITHistSvc.h"
+
+#include <string>
+#include <vector>
+#include "TH1.h"
+#include "TH2.h"
+#include "TTree.h"
+#include "TGraph2DErrors.h"
+#include "TMath.h"
+#include "Math/Functor.h"
+#include "Fit/Fitter.h"
+#include "Math/Vector3D.h"
+
+#include <string>
+
+class FaserSCT_ID;
+namespace Tracker
+{
+
+ class TrackerSPFit:public AthReentrantAlgorithm {
+
+ public:
+
+ /**
+ * @name AthReentrantAlgorithm methods
+ */
+ //@{
+ TrackerSPFit(const std::string& name,
+ ISvcLocator* pSvcLocator);
+
+ virtual ~TrackerSPFit() = default;
+
+ virtual StatusCode initialize() override;
+
+ virtual StatusCode execute (const EventContext& ctx) const override;
+
+ virtual StatusCode finalize() override;
+
+ struct SP_Seed{Amg::Vector3D pos; Amg::MatrixX cov; int layer; int module;};
+ struct SP_TSOS{Amg::Vector3D pos; Amg::Vector3D predicted; Amg::Vector3D err; int layer;int module; double chi2=-1.; double edm=-1.; int ndf=-1;double p0=0.;double p1=0.;double p2=0.;double p3=0;};
+ //struct SP_TSOS{Amg::Vector3D pos; Amg::Vector3D predicted; Amg::Vector3D err; int layer;int module; const double *p;};
+ std::vector<SP_TSOS> makeTrackSeg(std::vector<SP_Seed> sps, double maxchi2) const;
+ std::vector<SP_TSOS> makeTrackSeg(SP_Seed sp0, SP_Seed sp1, SP_Seed sp2, double maxchi2) const;
+ std::vector<SP_TSOS> makeTrackSeg(SP_Seed sp0, SP_Seed sp1, SP_Seed sp2) const;
+ Amg::Vector3D predicted(double z, const double *p) const;
+
+ // function Object to be minimized
+ struct SumDistance2 {
+ // the TGraph is a data member of the object
+ TGraph2DErrors *fGraph;
+ SumDistance2(TGraph2DErrors *g) : fGraph(g) {}
+ // calculate distance line-point
+ double distance2(double x,double y,double z, double xe, double ye, const double *p) {
+ double xpred=p[0]+p[1]*z;
+ double ypred=p[2]+p[3]*z;
+ double xchi2= (xpred-x)*(xpred-x)/xe/xe;
+ double ychi2= (ypred-y)*(ypred-y)/ye/ye;
+ double d2=xchi2+ychi2;
+ return d2;
+ }
+ // implementation of the function to be minimized
+ double operator() (const double *par) {
+ assert(fGraph != 0);
+ double * x = fGraph->GetX();
+ double * y = fGraph->GetY();
+ double * z = fGraph->GetZ();
+ double * xe = fGraph->GetEX();
+ double * ye = fGraph->GetEY();
+ int npoints = fGraph->GetN();
+ double sum = 0;
+ for (int i = 0; i < npoints; ++i) {
+ double d = distance2(x[i],y[i],z[i],xe[i],ye[i],par);
+ sum += d;
+ }
+ return sum;
+ }
+ };
+
+ private:
+ void initializeTree();
+ void clearVariables() const;
+ mutable TTree* m_tree;
+ TrackerSPFit() = delete;
+ TrackerSPFit(const TrackerSPFit&) =delete;
+ TrackerSPFit &operator=(const TrackerSPFit&) = delete;
+
+ SG::ReadHandleKey<FaserSCT_SpacePointContainer> m_Sct_spcontainerKey{this, "SpacePointsSCTName", "SCT_SpacePointContainer"};
+ SG::ReadHandleKey<Tracker::FaserSCT_ClusterContainer> m_Sct_clcontainerKey{this, "SCT_ClustersName", "SCT clContainer"};
+
+ SG::ReadCondHandleKey<TrackerDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
+
+ const FaserSCT_ID* m_idHelper{nullptr};
+ mutable std::atomic<int> m_numberOfEvents{0};
+ mutable std::atomic<int> m_numberOfSCT{0};
+ mutable std::atomic<int> m_numberOfTrack{0};
+ mutable std::atomic<int> m_numberOfSP{0};
+ mutable std::atomic<int> m_numberOfCluster{0};
+ mutable std::atomic<int> m_numberOfSPCol{0};
+ mutable std::atomic<int> m_numberOfClusterCol{0};
+ //@}
+ TH1* m_hist_x;
+ TH1* m_hist_y;
+ TH1* m_hist_z;
+ TH1* m_hist_r;
+ TH1* m_hist_eta;
+ TH1* m_hist_phi;
+ TH1* m_hist_station;
+ TH1* m_hist_strip;
+ TH1* m_hist_layer;
+ TH2* m_hist_x_y_plane0;
+ TH2* m_hist_x_y_plane1;
+ TH2* m_hist_x_y_plane2;
+ TH2* m_hist_x_y_plane3;
+ TH2* m_hist_x_y_plane4;
+ TH2* m_hist_x_y_plane5;
+ TH2* m_hist_x_y_plane6;
+ TH1* m_hist_x_y_plane7;
+ TH1* m_hist_x_y_plane8;
+ TH1* m_residual_y_plane0;
+ TH1* m_residual_y_plane1;
+ TH1* m_residual_y_plane2;
+ TH1* m_residual_y_plane3;
+ TH1* m_residual_y_plane4;
+ TH1* m_residual_y_plane5;
+ TH1* m_residual_y_plane6;
+ TH1* m_residual_y_plane7;
+ TH1* m_residual_y_plane8;
+ TH1* m_residual_x_plane0;
+ TH1* m_residual_x_plane1;
+ TH1* m_residual_x_plane2;
+ TH1* m_residual_x_plane3;
+ TH1* m_residual_x_plane4;
+ TH1* m_residual_x_plane5;
+ TH1* m_residual_x_plane6;
+ TH1* m_residual_x_plane7;
+ TH1* m_residual_x_plane8;
+ TH1* m_chi2;
+ TH1* m_edm;
+ TH1* m_ndf;
+ ServiceHandle<ITHistSvc> m_thistSvc;
+
+ mutable int m_eventNumber;
+ mutable std::vector<double> m_sp_track_x;
+ mutable std::vector<double> m_sp_track_y;
+ mutable std::vector<double> m_sp_track_z;
+ mutable std::vector<double> m_sp_track_x_err;
+ mutable std::vector<double> m_sp_track_y_err;
+ mutable std::vector<double> m_sp_track_z_err;
+ mutable std::vector<double> m_sp_track_x_predicted;
+ mutable std::vector<double> m_sp_track_y_predicted;
+ mutable std::vector<double> m_sp_track_z_predicted;
+ mutable std::vector<double> m_sp_track_x_residual;
+ mutable std::vector<double> m_sp_track_y_residual;
+ mutable std::vector<double> m_sp_track_z_residual;
+ mutable std::vector<int> m_sp_track_station;
+ mutable std::vector<int> m_sp_track_layer;
+ mutable std::vector<int> m_sp_track_module;
+ mutable std::vector<int> m_trackId;
+ mutable std::vector<double> m_track_chi2;
+ mutable std::vector<double> m_track_edm;
+ mutable std::vector<int> m_track_ndf;
+ mutable std::vector<double> m_track_p0;
+ mutable std::vector<double> m_track_p1;
+ mutable std::vector<double> m_track_p2;
+ mutable std::vector<double> m_track_p3;
+ double m_maxchi2;
+ bool m_bias;
+ bool m_saveallcluster;
+ mutable std::vector<double> m_cluster_all_global_x;
+ mutable std::vector<double> m_cluster_all_global_y;
+ mutable std::vector<double> m_cluster_all_global_z;
+ mutable std::vector<double> m_cluster_all_local_x;
+ mutable std::vector<double> m_cluster_all_local_y;
+ mutable std::vector<double> m_cluster_all_phiwidth;
+ mutable std::vector<int> m_cluster_all_size;
+ mutable std::vector<int> m_cluster_all_station;
+ mutable std::vector<int> m_cluster_all_layer;
+ mutable std::vector<int> m_cluster_all_module;
+ mutable std::vector<int> m_cluster_all_side;
+ mutable std::vector<int> m_cluster_all_strip;
+ bool m_saveallsp;
+ mutable std::vector<double> m_sp_all_x;
+ mutable std::vector<double> m_sp_all_y;
+ mutable std::vector<double> m_sp_all_z;
+ mutable std::vector<int> m_sp_all_station;
+ mutable std::vector<int> m_sp_all_layer;
+ mutable std::vector<int> m_sp_all_module;
+
+ };
+
+}
+#endif // TrackerSpacePointMakerAlg_TRACKERSPACEPOINTMAKERALG_H
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/src/components/TrackerSPFit_entries.cxx b/Tracker/TrackerRecAlgs/TrackerSPFit/src/components/TrackerSPFit_entries.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..dae3ad64eaa4a78be1459c5a8294d9db692e524d
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/src/components/TrackerSPFit_entries.cxx
@@ -0,0 +1,4 @@
+#include "../TrackerSPFit.h"
+
+DECLARE_COMPONENT( Tracker::TrackerSPFit )
+
diff --git a/Tracker/TrackerRecAlgs/TrackerSPFit/test/TrackerSPFitDbg.py b/Tracker/TrackerRecAlgs/TrackerSPFit/test/TrackerSPFitDbg.py
new file mode 100644
index 0000000000000000000000000000000000000000..6734b9ccadb9e9732f405eec826c00319bbf6a45
--- /dev/null
+++ b/Tracker/TrackerRecAlgs/TrackerSPFit/test/TrackerSPFitDbg.py
@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+"""Test various ComponentAccumulator Digitization configuration modules
+
+Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+"""
+import sys
+from AthenaCommon.Logging import log, logging
+from AthenaCommon.Constants import DEBUG, VERBOSE, INFO
+from AthenaCommon.Configurable import Configurable
+from CalypsoConfiguration.AllConfigFlags import ConfigFlags
+from AthenaConfiguration.TestDefaults import defaultTestFiles
+from CalypsoConfiguration.MainServicesConfig import MainServicesCfg
+from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+from AthenaPoolCnvSvc.PoolWriteConfig import PoolWriteCfg
+from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
+from TrackerSpacePointFormation.TrackerSpacePointFormationConfig import TrackerSpacePointFinderCfg
+from TrackerSPFit.TrackerSPFitConfig import TrackerSPFitCfg
+from TrackerPrepRawDataFormation.TrackerPrepRawDataFormationConfig import FaserSCT_ClusterizationCfg
+#from MCTruthSimAlgs.RecoTimingConfig import MergeRecoTimingObjCfg
+
+# Set up logging and new style config
+log.setLevel(DEBUG)
+Configurable.configurableRun3Behavior = True
+
+# Configure
+ConfigFlags.Input.Files = ['my.RDO.pool.root']
+ConfigFlags.Output.ESDFileName = "mySpacePoints.ESD.pool.root"
+ConfigFlags.IOVDb.GlobalTag = "OFLCOND-FASER-01" # Always needed; must match FaserVersion
+ConfigFlags.GeoModel.Align.Dynamic = False
+ConfigFlags.Beam.NumberOfCollisions = 0.
+
+ConfigFlags.lock()
+
+# Core components
+acc = MainServicesCfg(ConfigFlags)
+acc.merge(PoolReadCfg(ConfigFlags))
+acc.merge(PoolWriteCfg(ConfigFlags))
+
+#acc.merge(writeDigitizationMetadata(ConfigFlags))
+
+# Inner Detector
+acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags))
+acc.merge(TrackerSpacePointFinderCfg(ConfigFlags))
+acc.merge(TrackerSPFitCfg(ConfigFlags))
+
+# Timing
+#acc.merge(MergeRecoTimingObjCfg(ConfigFlags))
+
+# Dump config
+# logging.getLogger('forcomps').setLevel(VERBOSE)
+acc.foreach_component("*").OutputLevel = VERBOSE
+acc.foreach_component("*ClassID*").OutputLevel = INFO
+acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+# acc.getService("StoreGateSvc").Dump = True
+# acc.getService("ConditionStore").Dump = True
+# acc.printConfig(withDetails=True)
+# ConfigFlags.dump()
+
+# Execute and finish
+sc = acc.run(maxEvents=-1)
+
+# Success should be 0
+sys.exit(not sc.isSuccess())
diff --git a/Tracker/TrackerRecAlgs/TrackerSeedFinder/CMakeLists.txt b/Tracker/TrackerRecAlgs/TrackerSeedFinder/CMakeLists.txt
index b37eb389da8103ef92ad755e133465b92c3b9afa..f7c60bc83df79b7ee538b2cfe4f5e12842f50e68 100644
--- a/Tracker/TrackerRecAlgs/TrackerSeedFinder/CMakeLists.txt
+++ b/Tracker/TrackerRecAlgs/TrackerSeedFinder/CMakeLists.txt
@@ -10,13 +10,14 @@ find_package( Eigen )
# Component(s) in the package:
atlas_add_library( TrackerSeedFinderLib
- src/components/*.cxx src/*.cxx src/*.h
- NO_PUBLIC_HEADERS
+ src/components/*.cxx src/*.cxx TrackerSeedFinder/*.h
+ PUBLIC_HEADERS TrackerSeedFinder
INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS}
LINK_LIBRARIES ${EIGEN_LIBRARIES} AthenaBaseComps AthContainers GeoPrimitives Identifier GaudiKernel TrackerReadoutGeometry TrackerRawData TrackerSimData GeneratorObjects TrackerSimEvent TrackerSpacePoint VxVertex FaserDetDescr xAODEventInfo TrackerIdentifier TrackerPrepRawData AthenaMonitoringKernelLib)
atlas_add_component( TrackerSeedFinder
- src/components/*.cxx src/*.cxx src/*.h
+ src/components/*.cxx src/*.cxx TrackerSeedFinder/*.h
+ PUBLIC_HEADERS TrackerSeedFinder
INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS}
LINK_LIBRARIES ${EIGEN_LIBRARIES} AthenaBaseComps AthContainers GeoPrimitives Identifier GaudiKernel TrackerReadoutGeometry TrackerRawData TrackerSimData GeneratorObjects TrackerSimEvent TrackerSpacePoint VxVertex FaserDetDescr xAODEventInfo TrackerIdentifier TrackerPrepRawData AthenaMonitoringKernelLib)
diff --git a/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.h b/Tracker/TrackerRecAlgs/TrackerSeedFinder/TrackerSeedFinder/TrackerSeedFinder.h
similarity index 80%
rename from Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.h
rename to Tracker/TrackerRecAlgs/TrackerSeedFinder/TrackerSeedFinder/TrackerSeedFinder.h
index eabebe327c8d693b2f30e803ed778bd8b4916176..ab9d99ab5bf4868fda22b830d5d2076ae82bf576 100755
--- a/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.h
+++ b/Tracker/TrackerRecAlgs/TrackerSeedFinder/TrackerSeedFinder/TrackerSeedFinder.h
@@ -21,13 +21,13 @@
#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
#include "TrackerPrepRawData/TrackerClusterContainer.h"
#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
-#include "TrkSpacePoint/SpacePoint.h"
-#include "TrkSpacePoint/SpacePointContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h"
#include "TrackerSpacePoint/SpacePointForSeedCollection.h"
-#include "TrackerPrepRawData/TrackerSeedCollection.h"
-#include "TrackerPrepRawData/TrackerSeed.h"
-#include "TrkSpacePoint/SpacePointOverlapCollection.h"
+#include "TrackerSpacePoint/TrackerSeedCollection.h"
+#include "TrackerSpacePoint/TrackerSeed.h"
#include "TrackerSimEvent/FaserSiHitCollection.h"
#include "TrackerRawData/FaserSCT_RDO_Container.h"
#include "TrackerSimData/TrackerSimDataCollection.h"
@@ -67,29 +67,29 @@ namespace Tracker {
private:
struct seed {
- vector<const Trk::SpacePoint*> vsp;
+ vector<const FaserSCT_SpacePoint*> vsp;
double axz, bxz, ayz, byz;
double chi2_xz, chi2_yz;
string station;
int num;
- void add_sp(const Trk::SpacePoint* sp) {
+ void add_sp(const FaserSCT_SpacePoint* sp) {
vsp.push_back(sp);
}
- void add_vsp(vector<const Trk::SpacePoint*> v) {
- for (vector<const Trk::SpacePoint*>::iterator it = v.begin(); it != v.end(); ++it) {
+ void add_vsp(vector<const FaserSCT_SpacePoint*> v) {
+ for (vector<const FaserSCT_SpacePoint*>::iterator it = v.begin(); it != v.end(); ++it) {
vsp.push_back((*it));
}
}
};
- StatusCode make_triplets(vector< vector<const Trk::SpacePoint*> >&, vector<seed>&, string) const;
+ StatusCode make_triplets(vector< vector<const FaserSCT_SpacePoint*> >&, vector<seed>&, string) const;
TrackerSeedFinder() = delete;
TrackerSeedFinder(const TrackerSeedFinder&) =delete;
TrackerSeedFinder &operator=(const TrackerSeedFinder&) = delete;
- SG::ReadHandleKey<SpacePointContainer> m_Sct_spcontainerKey{this, "SpacePointsSCTName", "SCT spContainer"};
+ SG::ReadHandleKey<FaserSCT_SpacePointContainer> m_Sct_spcontainerKey{this, "SpacePointsSCTName", "SCT spContainer"};
SG::WriteHandleKey<SpacePointForSeedCollection> m_seed_spcontainerKey{this, "FaserSpacePointsSeedsName", "SpacePointForSeedCollection", "SpacePointForSeedCollection"};
SG::WriteHandleKey<Tracker::TrackerSeedCollection> m_trackerSeedContainerKey{this, "FaserTrackerSeedName", "FaserTrackerSeedCollection", "FaserTrackerSeedCollection"};
@@ -124,6 +124,9 @@ namespace Tracker {
TH1* m_hist_dx_intercept;
TH1* m_hist_dx_intercept_after;
TH1* m_hist_line;
+ TH1* m_hist_nseed;
+ TH1* m_hist_nsp1;
+ TH1* m_hist_nsp2;
ServiceHandle<ITHistSvc> m_thistSvc;
diff --git a/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.cxx b/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.cxx
index 53ffec6a238914461c8780138a4f36704c36f49c..96dbd3269a1a20e7ebdf884069ef08b9ab4693de 100755
--- a/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.cxx
+++ b/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.cxx
@@ -10,7 +10,7 @@
//<<<<<< INCLUDES >>>>>>
-#include "TrackerSeedFinder.h"
+#include "TrackerSeedFinder/TrackerSeedFinder.h"
// For processing clusters
#include "TrackerReadoutGeometry/SiLocalPosition.h"
@@ -18,7 +18,7 @@
#include "TrackerReadoutGeometry/SiDetectorElement.h"
// Space point Classes,
-#include "TrkSpacePoint/SpacePointCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointCollection.h"
#include "TrackerIdentifier/FaserSCT_ID.h"
// general Atlas classes
@@ -56,9 +56,12 @@ namespace Tracker
, m_hist_station(0)
, m_hist_x_z(0)
, m_hist_y_z(0)
- , m_hist_sp_plane (0)
- , m_hist_sp_layer (0)
- , m_hist_sp_station (0)
+ , m_hist_sp_plane(0)
+ , m_hist_sp_layer(0)
+ , m_hist_sp_station(0)
+ , m_hist_nseed(0)
+ , m_hist_nsp1(0)
+ , m_hist_nsp2(0)
, m_thistSvc("THistSvc", name)
{}
@@ -104,7 +107,10 @@ namespace Tracker
m_hist_layer=new TH1D("sp_layer","sp_layer",100,-10,10);
m_hist_station=new TH1D("sp_station","sp_station",100,-10,10);
m_hist_sp_station=new TH1D("sp_all_station","sp_station",100,-10,10);
- m_hist_sp_plane=new TH1D("sp_all_plane","sp_station",100,-10,10);
+ m_hist_nseed=new TH1D("sp_nseed","n track seeds",1000,0,1000);
+ m_hist_nsp1=new TH1D("sp_nsp1","n triplets in first station",100,0,100);
+ m_hist_nsp2=new TH1D("sp_nsp2","n triplets in second station",100,0,100);
+ m_hist_sp_plane=new TH1D("sp_all_plane","sp_station",10,0,10);
m_hist_sp_layer=new TH1D("sp_all_layer","sp_station",100,-10,10);
m_hist_x_z=new TH2D("sp_x_z","sp_x_z",100,-200,200,3500,0,3500);
m_hist_y_z=new TH2D("sp_y_z","sp_y_z",100,-200,200,3500,0,3500);
@@ -126,6 +132,9 @@ namespace Tracker
CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_layer",m_hist_layer));
CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_station",m_hist_station));
CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_all_station",m_hist_sp_station));
+ CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_nseed",m_hist_nseed));
+ CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_nsp1",m_hist_nsp1));
+ CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_nsp2",m_hist_nsp2));
CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_all_layer",m_hist_sp_layer));
CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_all_plane",m_hist_sp_plane));
CHECK(m_thistSvc->regHist("/TrackerSeedFinder/sp/sp_x_z",m_hist_x_z));
@@ -144,7 +153,7 @@ namespace Tracker
//-------------------------------------------------------------------------
- StatusCode TrackerSeedFinder::make_triplets(vector<vector<const Trk::SpacePoint*> >& vsp, vector<seed>& vt, string st) const {
+ StatusCode TrackerSeedFinder::make_triplets(vector<vector<const FaserSCT_SpacePoint*> >& vsp, vector<seed>& vt, string st) const {
int count=0;
double xs=0, ys=0, zs=0, z2s=0, xzs=0, yzs=0;
@@ -206,37 +215,42 @@ namespace Tracker
++m_numberOfEvents;
N_1_0=0, N_1_1=0, N_1_2=0, N_2_0=0, N_2_1=0, N_2_2=0, N_3_0=0, N_3_1=0, N_3_2=0;
+ int nseed=0,nsp1=0,nsp2=0;
// retrieve tracker spacepoint container
- SG::ReadHandle<SpacePointContainer> sct_spcontainer( m_Sct_spcontainerKey, ctx );
+ SG::ReadHandle<FaserSCT_SpacePointContainer> sct_spcontainer( m_Sct_spcontainerKey, ctx );
if (!sct_spcontainer.isValid()){
msg(MSG:: FATAL) << "Could not find the data object "<< sct_spcontainer.name() << " !" << endmsg;
return StatusCode::RECOVERABLE;
}
ATH_MSG_DEBUG( "Tracker spacepoint container found: " << sct_spcontainer->size() << " collections" );
- SpacePointContainer::const_iterator it = sct_spcontainer->begin();
- SpacePointContainer::const_iterator itend = sct_spcontainer->end();
+ FaserSCT_SpacePointContainer::const_iterator it = sct_spcontainer->begin();
+ FaserSCT_SpacePointContainer::const_iterator itend = sct_spcontainer->end();
+
+ SG::WriteHandle<TrackerSeedCollection> seedContainer(m_trackerSeedContainerKey, ctx);
+ ATH_CHECK(seedContainer.record( std::make_unique<TrackerSeedCollection>() ) );
+ ATH_MSG_DEBUG("Created track seed container " << m_trackerSeedContainerKey.key());
int i=0;
- vector<vector<const Trk::SpacePoint*> > vsp1(3);
- vector<vector<const Trk::SpacePoint*> > vsp2(3);
- vector<vector<const Trk::SpacePoint*> > vsp3(3);
+ vector<vector<const FaserSCT_SpacePoint*> > vsp1(3);
+ vector<vector<const FaserSCT_SpacePoint*> > vsp2(3);
+ vector<vector<const FaserSCT_SpacePoint*> > vsp3(3);
- vector<pair<int, const Trk::SpacePoint*>> msp;
+ vector<pair<int, const FaserSCT_SpacePoint*>> msp;
- vector<vector<pair<int, const Trk::SpacePoint*>>> mseeds;
+ vector<vector<pair<int, const FaserSCT_SpacePoint*>>> mseeds;
vector<int> pos;
ATH_MSG_DEBUG( "Start iteration of spacepoint collections" );
for (; it != itend; ++it){
++m_numberOfSPCollection;
- const SpacePointCollection *colNext=&(**it);
+ const FaserSCT_SpacePointCollection *colNext=&(**it);
int nReceivedSPSCT = colNext->size();
- // Create SpacePointCollection
+ // Create FaserSCT_SpacePointCollection
IdentifierHash idHash = colNext->identifyHash();
Identifier elementID = colNext->identify();
@@ -245,8 +259,8 @@ namespace Tracker
ATH_MSG_VERBOSE( "Algorithm found no space points" );
++m_numberOfEmptySPCollection;
} else {
- SpacePointCollection::const_iterator sp_begin= colNext->begin();
- SpacePointCollection::const_iterator sp_end= colNext->end();
+ FaserSCT_SpacePointCollection::const_iterator sp_begin= colNext->begin();
+ FaserSCT_SpacePointCollection::const_iterator sp_end= colNext->end();
ATH_MSG_DEBUG( "Iterate the spacepoint in collection " );
@@ -254,7 +268,7 @@ namespace Tracker
++i;
++m_numberOfSP;
- const Trk::SpacePoint* sp=&(**sp_begin);
+ const FaserSCT_SpacePoint* sp=&(**sp_begin);
const auto identifier = sp->clusterList().first->identify();
int station = m_idHelper->station(identifier);
@@ -270,6 +284,10 @@ namespace Tracker
vsp3.at(plane).push_back(sp);
}
+ m_hist_sp_plane->Fill((station-1)*3+plane);
+ m_hist_sp_station->Fill(station);
+ m_hist_sp_layer->Fill(plane);
+
if (station==1 && plane==0) {N_1_0++;} if (station==1 && plane==1) {N_1_1++;} if (station==1 && plane==2) {N_1_2++;}
if (station==2 && plane==0) {N_2_0++;} if (station==2 && plane==1) {N_2_1++;} if (station==2 && plane==2) {N_2_2++;}
if (station==3 && plane==0) {N_3_0++;} if (station==3 && plane==1) {N_3_1++;} if (station==3 && plane==2) {N_3_2++;}
@@ -299,6 +317,8 @@ namespace Tracker
ATH_MSG_VERBOSE( " 1st station " << N_1_0+N_1_1+N_1_2 << " (" << vsp1.at(0).size() << ";" << vsp1.at(1).size() << ";" << vsp1.at(2).size() << ")");
ATH_MSG_VERBOSE( " 2nd station " << N_2_0+N_2_1+N_2_2 << " (" << vsp2.at(0).size() << ";" << vsp2.at(1).size() << ";" << vsp2.at(2).size() << ")");
ATH_MSG_VERBOSE( " 3rd station " << N_3_0+N_3_1+N_3_2 << " (" << vsp3.at(0).size() << ";" << vsp3.at(1).size() << ";" << vsp3.at(2).size() << ")");
+ if((N_1_0+N_1_1+N_1_2)<3||(N_2_0+N_2_1+N_2_2)<3)
+ return StatusCode::SUCCESS;
vector<seed> vseed;
ATH_CHECK(make_triplets(vsp1, vseed, "1"));
@@ -306,6 +326,10 @@ namespace Tracker
vector<seed> vfseed;
for (vector<seed>::iterator it1 = vseed.begin(); it1 != vseed.end(); ++it1) {
+ if((*it1).station=="1")
+ nsp1++;
+ if((*it1).station=="2")
+ nsp2++;
for (vector<seed>::iterator it2 = vseed.begin(); it2 != vseed.end(); ++it2) {
if ((*it1).station == "1" && (*it2).station == "2") {
@@ -320,12 +344,7 @@ namespace Tracker
}
}
}
-
- SG::WriteHandle<TrackerSeedCollection> seedContainer(m_trackerSeedContainerKey, ctx);
- ATH_CHECK(seedContainer.record( std::make_unique<TrackerSeedCollection>() ) );
- ATH_MSG_INFO("Created track seed container " << m_trackerSeedContainerKey.key());
- int nseed=0;
for (vector<seed>::iterator it = vfseed.begin(); it != vfseed.end(); ++it) {
@@ -333,7 +352,7 @@ namespace Tracker
nseed++;
- vector<const Trk::SpacePoint*> mseed = (*it).vsp;
+ vector<const FaserSCT_SpacePoint*> mseed = (*it).vsp;
Tracker::TrackerSeed* trackerSeed = new Tracker::TrackerSeed();
trackerSeed->set_id(TrackerSeed::TRIPLET_SP_FIRSTSTATION);
@@ -342,7 +361,10 @@ namespace Tracker
seedContainer->push_back(trackerSeed);
}
- ATH_MSG_INFO("Saved " << nseed << " seeds in container");
+ m_hist_nsp1->Fill(nsp1);
+ m_hist_nsp2->Fill(nsp2);
+ m_hist_nseed->Fill(nseed);
+ ATH_MSG_DEBUG("Saved " << nseed << " seeds in container");
return StatusCode::SUCCESS;
}
diff --git a/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/components/TrackerSeedFinder_entries.cxx b/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/components/TrackerSeedFinder_entries.cxx
index 89e6db22cc8de4124d9ed41045ace3a79f430cb8..7423e761a0cbc679f7ef89c9fa6f9305559ca26a 100644
--- a/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/components/TrackerSeedFinder_entries.cxx
+++ b/Tracker/TrackerRecAlgs/TrackerSeedFinder/src/components/TrackerSeedFinder_entries.cxx
@@ -1,3 +1,3 @@
-#include "../TrackerSeedFinder.h"
+#include "TrackerSeedFinder/TrackerSeedFinder.h"
DECLARE_COMPONENT( Tracker::TrackerSeedFinder )
diff --git a/Tracker/TrackerRecAlgs/TrackerSeedFinder/test/TrackerSeedFinderDbg.py b/Tracker/TrackerRecAlgs/TrackerSeedFinder/test/TrackerSeedFinderDbg.py
index c6334704f6aef383a1057cd6266efa8398d16a04..d47891b213ebd487d3719c3c244e75064204fcbb 100644
--- a/Tracker/TrackerRecAlgs/TrackerSeedFinder/test/TrackerSeedFinderDbg.py
+++ b/Tracker/TrackerRecAlgs/TrackerSeedFinder/test/TrackerSeedFinderDbg.py
@@ -26,7 +26,8 @@ Configurable.configurableRun3Behavior = True
# Configure
ConfigFlags.Input.Files = ['my.RDO.pool.root']
ConfigFlags.Output.ESDFileName = "mySeeds.ESD.pool.root"
-ConfigFlags.IOVDb.GlobalTag = "OFLCOND-XXXX-XXX-XX"
+ConfigFlags.IOVDb.GlobalTag = "OFLCOND-FASER-01"
+# ConfigFlags.GeoModel.FaserVersion = "FASER-01"
ConfigFlags.GeoModel.Align.Dynamic = False
#ConfigFlags.Concurrency.NumThreads = 1
ConfigFlags.Beam.NumberOfCollisions = 0.
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py
index de8355dedc7b23a05ec50fe6757fcba0d00f759b..4bd7402d130957407bdf9d3ca3a660b18530060a 100644
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py
@@ -49,13 +49,14 @@ def StatisticsBasicCfg(flags, **kwargs):
acc = ComponentAccumulator()
acc.popToolsAndMerge(TrackerSpacePointMakerToolCfg(flags))
kwargs.setdefault("SpacePointsSCTName", "SCT_SpacePointContainer")
+ kwargs.setdefault("SCT_ClustersName", "SCT_ClusterContainer")
acc.addEventAlgo(Tracker__StatisticsAlg(**kwargs))
return acc
def TrackerSpacePointFinder_OutputCfg(flags):
"""Return ComponentAccumulator with Output for SCT. Not standalone."""
acc = ComponentAccumulator()
- itemList = [ "SpacePointContainer#*"]
+ itemList = [ "FaserSCT_SpacePointContainer#*"]
acc.merge(OutputStreamCfg(flags, "ESD", itemList))
ostream = acc.getEventAlgo("OutputStreamESD")
ostream.TakeItemsFromInput = True
@@ -66,7 +67,7 @@ def TrackerSpacePointFinderCfg(flags, **kwargs):
"""Return ComponentAccumulator for SCT SpacePoints and Output"""
acc=TrackerDDSiElementPropertiesTableCondAlgCfg(flags)
acc.merge(TrackerSpacePointFinderBasicCfg(flags, **kwargs))
- # acc.merge(TrackerSpacePointFinder_OutputCfg(flags))
+ acc.merge(TrackerSpacePointFinder_OutputCfg(flags))
return acc
def StatisticsCfg(flags, **kwargs):
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.cxx b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.cxx
index 5589297e584762c57a6450790c2a6d65a170a50e..68e9695ef1b05723ac2539b947ed9af644a621a0 100755
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.cxx
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.cxx
@@ -18,7 +18,7 @@
#include "TrackerReadoutGeometry/SiDetectorElement.h"
// Space point Classes,
-// #include "TrkSpacePoint/SpacePointContainer.h"
+ #include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
// #include "TrackerSpacePoint/TrackerSpacePointCLASS_DEF.h"
#include "TrackerIdentifier/FaserSCT_ID.h"
@@ -64,6 +64,11 @@ StatusCode StatisticsAlg::initialize()
ATH_MSG_DEBUG( "StatisticsAlg::initialize()" );
CHECK(m_thistSvc.retrieve());
+ if(m_Sct_clcontainerKey.key().empty()){
+ ATH_MSG_FATAL( "SCTs selected and no name set for SCT clusters");
+ return StatusCode::FAILURE;
+ }
+ ATH_CHECK( m_Sct_clcontainerKey.initialize() );
// Check that clusters, space points and ids have names
if ( m_Sct_spcontainerKey.key().empty()){
ATH_MSG_FATAL( "SCTs selected and no name set for SCT clusters");
@@ -137,9 +142,35 @@ StatusCode StatisticsAlg::execute (const EventContext& ctx) const
// register the IdentifiableContainer into StoreGate
+ //retrieve SCT cluster container
+ SG::ReadHandle<Tracker::FaserSCT_ClusterContainer> sct_clcontainer( m_Sct_clcontainerKey, ctx );
+ if (!sct_clcontainer.isValid()){
+ msg(MSG:: FATAL) << "Could not find the data object "<< sct_clcontainer.name() << " !" << endmsg;
+ return StatusCode::RECOVERABLE;
+ }
+ std::cout<<"read sct"<<std::endl;
+ Tracker::FaserSCT_ClusterContainer::const_iterator clusit = sct_clcontainer->begin();
+ Tracker::FaserSCT_ClusterContainer::const_iterator clusend = sct_clcontainer->end();
+
+ for (; clusit != clusend; ++clusit){
+ const Tracker::FaserSCT_ClusterCollection *colNext=&(**clusit);
+ Identifier elementID = colNext->identify();
+ std::cout<<"SCT hash "<<colNext->identify()<<" "<<colNext->identifyHash()<<" "<<colNext->size()<<std::endl;
+ FaserSCT_ClusterCollection::const_iterator clusters {colNext->begin()};
+ FaserSCT_ClusterCollection::const_iterator clustersEnd {colNext->end()};
+ for (; clusters != clustersEnd; ++clusters)
+ {
+
+ const TrackerDD::SiDetectorElement* elem = (*clusters)->detectorElement();
+ if (elem == nullptr)std::cout<<"not found detectorelement "<<std::endl;
+ else std::cout<<"element id "<<elem->identify();
+ }
+ }
+
+ std::cout<<"finish read sct"<<std::endl;
// retrieve SCT cluster container
- SG::ReadHandle<SpacePointContainer> sct_spcontainer( m_Sct_spcontainerKey, ctx );
+ SG::ReadHandle<FaserSCT_SpacePointContainer> sct_spcontainer( m_Sct_spcontainerKey, ctx );
if (!sct_spcontainer.isValid()){
msg(MSG:: FATAL) << "Could not find the data object "<< sct_spcontainer.name() << " !" << endmsg;
return StatusCode::RECOVERABLE;
@@ -147,11 +178,11 @@ StatusCode StatisticsAlg::execute (const EventContext& ctx) const
ATH_MSG_DEBUG( "SCT spacepoint container found: " << sct_spcontainer->size() << " collections" );
- SpacePointContainer::const_iterator it = sct_spcontainer->begin();
- SpacePointContainer::const_iterator itend = sct_spcontainer->end();
+ FaserSCT_SpacePointContainer::const_iterator it = sct_spcontainer->begin();
+ FaserSCT_SpacePointContainer::const_iterator itend = sct_spcontainer->end();
for (; it != itend; ++it){
- const SpacePointCollection *colNext=&(**it);
+ const FaserSCT_SpacePointCollection *colNext=&(**it);
// int nReceivedSPSCT = colNext->size();
// Create SpacePointCollection
@@ -167,15 +198,16 @@ StatusCode StatisticsAlg::execute (const EventContext& ctx) const
ATH_MSG_VERBOSE( "StatisticsAlg algorithm found no space points" );
} else {
//In a MT environment the cache maybe filled by another thread in which case this will delete the duplicate
- SpacePointCollection::const_iterator sp_begin= colNext->begin();
- SpacePointCollection::const_iterator sp_end= colNext->end();
+ FaserSCT_SpacePointCollection::const_iterator sp_begin= colNext->begin();
+ FaserSCT_SpacePointCollection::const_iterator sp_end= colNext->end();
for (; sp_begin != sp_end; ++sp_begin){
- const Trk::SpacePoint* sp=&(**sp_begin);
+ const FaserSCT_SpacePoint* sp=&(**sp_begin);
m_hist_r->Fill(sp->r());
m_hist_eta->Fill(sp->eta());
m_hist_phi->Fill(sp->phi());
Amg::Vector3D gloPos=sp->globalPosition();
m_hist_x->Fill(gloPos.x());
+ ATH_MSG_DEBUG( "SCT spacepoint positions in container : " << gloPos.x()<<" "<<gloPos.y()<<" "<<gloPos.z() );
m_hist_y->Fill(gloPos.y());
m_hist_z->Fill(gloPos.z());
if ( ((istation-1)*3+ilayer) == 0 ) m_hist_x_y_plane0->Fill(gloPos.x(),gloPos.y());
@@ -208,4 +240,4 @@ StatusCode StatisticsAlg::finalize()
//--------------------------------------------------------------------------
-}
\ No newline at end of file
+}
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.h b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.h
index 2683f2ec561400dae90233c055029f6aeccca4f1..26add4b59a62d9c5a6819ec695396b56bcbbf987 100755
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.h
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/StatisticsAlg.h
@@ -15,11 +15,9 @@
#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
#include "TrackerPrepRawData/TrackerClusterContainer.h"
#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
-// #include "TrackerSpacePointMakerAlg/SiElementPropertiesTable.h"
-// #include "TrackerSpacePointMakerTool/TrackerSpacePointMakerTool.h"
-#include "TrkSpacePoint/SpacePoint.h"
-#include "TrkSpacePoint/SpacePointContainer.h"
-#include "TrkSpacePoint/SpacePointOverlapCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ITHistSvc.h"
@@ -31,9 +29,6 @@
#include <string>
-// class TrackerSpacePointCollection;
-// class TrackerSpacePointOverlapCollection;
-// class TrackerSpacePointContainer;
class FaserSCT_ID;
namespace Tracker
{
@@ -64,8 +59,9 @@ namespace Tracker
StatisticsAlg &operator=(const StatisticsAlg&) = delete;
//@}
- SG::ReadHandleKey<SpacePointContainer> m_Sct_spcontainerKey{this, "SpacePointsSCTName", "SCT spContainer"};
+ SG::ReadHandleKey<FaserSCT_SpacePointContainer> m_Sct_spcontainerKey{this, "SpacePointsSCTName", "SCT spContainer"};
//@}
+ SG::ReadHandleKey<Tracker::FaserSCT_ClusterContainer> m_Sct_clcontainerKey{this, "SCT_ClustersName", "SCT clContainer"};
SG::ReadCondHandleKey<TrackerDD::SiDetectorElementCollection> m_SCTDetEleCollKey{this, "SCTDetEleCollKey", "SCT_DetectorElementCollection", "Key of SiDetectorElementCollection for SCT"};
//@}
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/TrackerSpacePointFinder.cxx b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/TrackerSpacePointFinder.cxx
index 62f63d8db08a27d9c04a347347954e07e4ee8968..4ccfe875bc7a7145520463997ee21fbe51e6749e 100755
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/TrackerSpacePointFinder.cxx
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/TrackerSpacePointFinder.cxx
@@ -18,7 +18,7 @@
#include "TrackerReadoutGeometry/SiDetectorElement.h"
// Space point Classes,
-#include "TrkSpacePoint/SpacePointCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointCollection.h"
// #include "TrkSpacePoint/SpacePointCLASS_DEF.h"
#include "TrackerIdentifier/FaserSCT_ID.h"
@@ -138,22 +138,22 @@ StatusCode TrackerSpacePointFinder::execute (const EventContext& ctx) const
// }
// register the IdentifiableContainer into StoreGate
- SG::WriteHandle<SpacePointContainer> spacePointContainer_SCT;
+ SG::WriteHandle<FaserSCT_SpacePointContainer> spacePointContainer_SCT;
if (m_selectSCTs){
- spacePointContainer_SCT = SG::WriteHandle<SpacePointContainer>( m_SpacePointContainer_SCTKey, ctx );
+ spacePointContainer_SCT = SG::WriteHandle<FaserSCT_SpacePointContainer>( m_SpacePointContainer_SCTKey, ctx );
if(m_SpacePointCache_SCTKey.key().empty()){
- ATH_CHECK( spacePointContainer_SCT.record( std::make_unique<SpacePointContainer>(m_idHelper->wafer_hash_max()) ) );
+ ATH_CHECK( spacePointContainer_SCT.record( std::make_unique<FaserSCT_SpacePointContainer>(m_idHelper->wafer_hash_max()) ) );
ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainer_SCTKey.key() << " N= " << m_idHelper->wafer_hash_max());
}else{
- SG::UpdateHandle<SpacePointCache> updateH( m_SpacePointCache_SCTKey, ctx );
+ SG::UpdateHandle<FaserSCT_SpacePointCache> updateH( m_SpacePointCache_SCTKey, ctx );
ATH_CHECK(updateH.isValid());
- ATH_CHECK( spacePointContainer_SCT.record( std::make_unique<SpacePointContainer>(updateH.ptr()) ) );
+ ATH_CHECK( spacePointContainer_SCT.record( std::make_unique<FaserSCT_SpacePointContainer>(updateH.ptr()) ) );
ATH_MSG_DEBUG("Created SpacePointContainer " << m_SpacePointContainer_SCTKey.key() << " from cache " << m_SpacePointCache_SCTKey.key());
}
}
- SG::WriteHandle<SpacePointOverlapCollection> spacepointoverlapCollection( m_spacepointoverlapCollectionKey, ctx );
- ATH_CHECK( spacepointoverlapCollection.record( std::make_unique<SpacePointOverlapCollection>() ) );
+ SG::WriteHandle<FaserSCT_SpacePointOverlapCollection> spacepointoverlapCollection( m_spacepointoverlapCollectionKey, ctx );
+ ATH_CHECK( spacepointoverlapCollection.record( std::make_unique<FaserSCT_SpacePointOverlapCollection>() ) );
ATH_MSG_DEBUG( "Container '" << spacepointoverlapCollection.name() << "' initialised" );
@@ -187,7 +187,7 @@ StatusCode TrackerSpacePointFinder::execute (const EventContext& ctx) const
// Create SpacePointCollection
IdentifierHash idHash = colNext->identifyHash();
- SpacePointContainer::IDC_WriteHandle lock = spacePointContainer_SCT->getWriteHandle(idHash);
+ FaserSCT_SpacePointContainer::IDC_WriteHandle lock = spacePointContainer_SCT->getWriteHandle(idHash);
if(lock.alreadyPresent()){
ATH_MSG_DEBUG("SCT Hash " << idHash << " is already in cache");
++sctCacheCount;
@@ -195,9 +195,10 @@ StatusCode TrackerSpacePointFinder::execute (const EventContext& ctx) const
}
Identifier elementID = colNext->identify();
- auto spacepointCollection = std::make_unique<SpacePointCollection>(idHash);
+ auto spacepointCollection = std::make_unique<FaserSCT_SpacePointCollection>(idHash);
spacepointCollection->setIdentifier(elementID);
+ ATH_MSG_DEBUG( "SCT cluster collection size "<<colNext->size() );
if ( colNext->size() != 0){
addSCT_SpacePoints(colNext, properties, elements,
spacepointCollection.get(), spacepointoverlapCollection.ptr(), r_cache);
@@ -270,10 +271,9 @@ void TrackerSpacePointFinder::
addSCT_SpacePoints(const Tracker::FaserSCT_ClusterCollection* next,
const TrackerDD::SiElementPropertiesTable* properties,
const TrackerDD::SiDetectorElementCollection* elements,
- SpacePointCollection* spacepointCollection, SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache &r_cache) const
+ FaserSCT_SpacePointCollection* spacepointCollection, FaserSCT_SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache &r_cache) const
{
- // Do nothing unless this is a side 1 detector (strips of const phi).
IdentifierHash thisHash(next->identifyHash());
// if it is not the stereo side
@@ -352,7 +352,7 @@ checkForSCT_Points(const Tracker::FaserSCT_ClusterCollection* clusters1,
const IdentifierHash id2,
const TrackerDD::SiDetectorElementCollection* elements,
double min, double max,
- SpacePointCollection* spacepointCollection, bool overlapColl, SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache &r_cache) const
+ FaserSCT_SpacePointCollection* spacepointCollection, bool overlapColl, FaserSCT_SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache &r_cache) const
{
@@ -376,7 +376,7 @@ checkForSCT_Points(const Tracker::FaserSCT_ClusterCollection* clusters1,
checkForSCT_Points(const Tracker::FaserSCT_ClusterCollection* clusters1,
const IdentifierHash id2,
const TrackerDD::SiDetectorElementCollection* elements,
- double min1, double max1, double min2, double max2, SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache &r_cache) const
+ double min1, double max1, double min2, double max2, FaserSCT_SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache &r_cache) const
{
// get the cluster collections for these two detectors. Clus1 must lie
@@ -388,4 +388,4 @@ checkForSCT_Points(const Tracker::FaserSCT_ClusterCollection* clusters1,
m_SiSpacePointMakerTool->fillSCT_SpacePointPhiOverlapCollection(clusters1, clusters2, min1, max1, min2, max2, m_allClusters, r_cache.vertex, elements, spacepointOverlapCollection);
}
-}
\ No newline at end of file
+}
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/TrackerSpacePointFinder.h b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/TrackerSpacePointFinder.h
index ae698bc3916d29c8c825732df5e4641cb628d4c0..c63cc6bb64e9f48300f7d6727e74a24fe8936198 100755
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/TrackerSpacePointFinder.h
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/src/TrackerSpacePointFinder.h
@@ -21,15 +21,12 @@
#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
#include "SiElementPropertiesTable.h"
#include "FaserSiSpacePointTool/TrackerSpacePointMakerTool.h"
-#include "TrkSpacePoint/SpacePoint.h"
-#include "TrkSpacePoint/SpacePointContainer.h"
-#include "TrkSpacePoint/SpacePointOverlapCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h"
#include <string>
-// class TrackerSpacePointCollection;
-// class TrackerSpacePointOverlapCollection;
-// class TrackerSpacePointContainer;
class FaserSCT_ID;
@@ -125,21 +122,21 @@ namespace Tracker
(const Tracker::FaserSCT_ClusterCollection* next,
const TrackerDD::SiElementPropertiesTable* properties,
const TrackerDD::SiDetectorElementCollection* elements,
- SpacePointCollection* spacepointCollection, SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache&) const;
+ FaserSCT_SpacePointCollection* spacepointCollection, FaserSCT_SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache&) const;
void checkForSCT_Points
(const Tracker::FaserSCT_ClusterCollection* clusters1,
const IdentifierHash id2,
const TrackerDD::SiDetectorElementCollection* elements,
double minDiff, double maxDiff,
- SpacePointCollection* spacepointCollection, bool overlapColl, SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache&) const;
+ FaserSCT_SpacePointCollection* spacepointCollection, bool overlapColl, FaserSCT_SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache&) const;
void checkForSCT_Points
(const Tracker::FaserSCT_ClusterCollection* clusters1,
const IdentifierHash id2,
const TrackerDD::SiDetectorElementCollection* elements,
double min1, double max1,
- double min2, double max2, SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache&) const;
+ double min2, double max2, FaserSCT_SpacePointOverlapCollection* spacepointOverlapCollection, SPFCache&) const;
//@}
// data members
@@ -167,15 +164,15 @@ namespace Tracker
* @name Output data using SG::WriteHandleKey
*/
//@{
- SG::WriteHandleKey<SpacePointContainer> m_SpacePointContainer_SCTKey{this, "SpacePointsSCTName", "SCT_SpacePoints", "SpacePoint SCT container"};
- SG::WriteHandleKey<SpacePointOverlapCollection> m_spacepointoverlapCollectionKey{this, "SpacePointsOverlapName", "OverlapSpacePoints", "Space Point Overlap collection"};
+ SG::WriteHandleKey<FaserSCT_SpacePointContainer> m_SpacePointContainer_SCTKey{this, "SpacePointsSCTName", "SCT_SpacePoints", "SpacePoint SCT container"};
+ SG::WriteHandleKey<FaserSCT_SpacePointOverlapCollection> m_spacepointoverlapCollectionKey{this, "SpacePointsOverlapName", "OverlapSpacePoints", "Space Point Overlap collection"};
//@}
/**
* @name Caches for HLT using SG::UpdateHandleKey
*/
//@{
- SG::UpdateHandleKey<SpacePointCache> m_SpacePointCache_SCTKey;
+ SG::UpdateHandleKey<FaserSCT_SpacePointCache> m_SpacePointCache_SCTKey;
//@}
/**
diff --git a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/StatisticsDbg.py b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/StatisticsDbg.py
index 55d4ee20812ac529068a8f233524a18a035ab3c8..5ad2fc49b5bbae6d3bf17bfd9b9e77708bc5e96c 100644
--- a/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/StatisticsDbg.py
+++ b/Tracker/TrackerRecAlgs/TrackerSpacePointFormation/test/StatisticsDbg.py
@@ -48,10 +48,10 @@ acc.merge(StatisticsCfg(ConfigFlags))
# Dump config
# logging.getLogger('forcomps').setLevel(VERBOSE)
-# acc.foreach_component("*").OutputLevel = VERBOSE
-# acc.foreach_component("*ClassID*").OutputLevel = INFO
-# acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
-# acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
+acc.foreach_component("*").OutputLevel = VERBOSE
+acc.foreach_component("*ClassID*").OutputLevel = INFO
+acc.getCondAlgo("FaserSCT_AlignCondAlg").OutputLevel = VERBOSE
+acc.getCondAlgo("FaserSCT_DetectorElementCondAlg").OutputLevel = VERBOSE
# acc.getService("StoreGateSvc").Dump = True
# acc.getService("ConditionStore").Dump = True
# acc.printConfig(withDetails=True)
diff --git a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.cxx b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.cxx
index 1094424fb0cbd11f0a9618aedbd2813bfca4ded8..d23327e1c5b6c8d59bcf7e41e7a9dbf58ca164bf 100755
--- a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.cxx
+++ b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.cxx
@@ -18,7 +18,7 @@
#include "TrackerReadoutGeometry/SiDetectorElement.h"
// Space point Classes,
-#include "TrkSpacePoint/SpacePointCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointCollection.h"
#include "TrackerIdentifier/FaserSCT_ID.h"
@@ -219,7 +219,7 @@ namespace Tracker
// retrieve SCT cluster container
- SG::ReadHandle<SpacePointContainer> sct_spcontainer( m_Sct_spcontainerKey, ctx );
+ SG::ReadHandle<FaserSCT_SpacePointContainer> sct_spcontainer( m_Sct_spcontainerKey, ctx );
if (!sct_spcontainer.isValid()){
msg(MSG:: FATAL) << "Could not find the data object "<< sct_spcontainer.name() << " !" << endmsg;
return StatusCode::RECOVERABLE;
@@ -234,14 +234,14 @@ namespace Tracker
//!!!!!!!!!!!!!!!!!!!!
ATH_MSG_DEBUG( "SCT spacepoint container found: " << sct_spcontainer->size() << " collections" );
- SpacePointContainer::const_iterator it = sct_spcontainer->begin();
- SpacePointContainer::const_iterator itend = sct_spcontainer->end();
+ FaserSCT_SpacePointContainer::const_iterator it = sct_spcontainer->begin();
+ FaserSCT_SpacePointContainer::const_iterator itend = sct_spcontainer->end();
int nTruthSP=0;
ATH_MSG_DEBUG( "Start iteration of spacepoint collections" );
for (; it != itend; ++it){
++m_numberOfSPCollection;
- const SpacePointCollection *colNext=&(**it);
+ const FaserSCT_SpacePointCollection *colNext=&(**it);
int nReceivedSPSCT = colNext->size();
// Create SpacePointCollection
@@ -254,13 +254,13 @@ namespace Tracker
ATH_MSG_VERBOSE( "Algorithm found no space points" );
++m_numberOfEmptySPCollection;
} else {
- SpacePointCollection::const_iterator sp_begin= colNext->begin();
- SpacePointCollection::const_iterator sp_end= colNext->end();
+ FaserSCT_SpacePointCollection::const_iterator sp_begin= colNext->begin();
+ FaserSCT_SpacePointCollection::const_iterator sp_end= colNext->end();
ATH_MSG_DEBUG( "Iterate the spacepoint in collection " );
for (; sp_begin != sp_end; ++sp_begin){
++m_numberOfSP;
- const Trk::SpacePoint* sp=&(**sp_begin);
+ const FaserSCT_SpacePoint* sp=&(**sp_begin);
bool match=false;
//get truth hit
const auto identifier = sp->clusterList().first->identify();
@@ -451,11 +451,11 @@ namespace Tracker
Acts::Vector3 pos2_1(0., 0., 0.);
Acts::Vector3 pos2_2(0., 0., 0.);
- SpacePointContainer::const_iterator it = sct_spcontainer->begin();
- SpacePointContainer::const_iterator itend = sct_spcontainer->end();
+ FaserSCT_SpacePointContainer::const_iterator it = sct_spcontainer->begin();
+ FaserSCT_SpacePointContainer::const_iterator itend = sct_spcontainer->end();
for (; it != itend; ++it){
- const SpacePointCollection *colNext=&(**it);
+ const FaserSCT_SpacePointCollection *colNext=&(**it);
// Create SpacePointCollection
IdentifierHash idHash = colNext->identifyHash();
@@ -467,10 +467,10 @@ namespace Tracker
ATH_MSG_VERBOSE( "StatisticsAlg algorithm found no space points" );
} else {
//In a MT environment the cache maybe filled by another thread in which case this will delete the duplicate
- SpacePointCollection::const_iterator sp_begin= colNext->begin();
- SpacePointCollection::const_iterator sp_end= colNext->end();
+ FaserSCT_SpacePointCollection::const_iterator sp_begin= colNext->begin();
+ FaserSCT_SpacePointCollection::const_iterator sp_end= colNext->end();
for (; sp_begin != sp_end; ++sp_begin){
- const Trk::SpacePoint* sp=&(**sp_begin);
+ const FaserSCT_SpacePoint* sp=&(**sp_begin);
Amg::Vector3D gloPos=sp->globalPosition();
if ( ((istation-1)*3+ilayer) == 0 ) pos1_0 = Acts::Vector3(gloPos.x(), gloPos.y(), gloPos.z());
if ( ((istation-1)*3+ilayer) == 1 ) pos1_1 = Acts::Vector3(gloPos.x(), gloPos.y(), gloPos.z());
diff --git a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.h b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.h
index bb09dfc937b252c2e4af9e4d8dd8e5e49e24358d..35a8c05f3dacb17018bbb40f5c97df11407b2590 100755
--- a/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.h
+++ b/Tracker/TrackerRecAlgs/TruthSeededTrackFinder/src/TruthSeededTrackFinder.h
@@ -16,10 +16,10 @@
#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
#include "TrackerPrepRawData/TrackerClusterContainer.h"
#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
-#include "TrkSpacePoint/SpacePoint.h"
-#include "TrkSpacePoint/SpacePointContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
#include "TrackerSpacePoint/SpacePointForSeedCollection.h"
-#include "TrkSpacePoint/SpacePointOverlapCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h"
#include "TrackerSimEvent/FaserSiHitCollection.h"
#include "TrackerRawData/FaserSCT_RDO_Container.h"
#include "TrackerSimData/TrackerSimDataCollection.h"
@@ -63,7 +63,7 @@ class TruthSeededTrackFinder:public AthReentrantAlgorithm {
TruthSeededTrackFinder() = delete;
TruthSeededTrackFinder(const TruthSeededTrackFinder&) =delete;
TruthSeededTrackFinder &operator=(const TruthSeededTrackFinder&) = delete;
- SG::ReadHandleKey<SpacePointContainer> m_Sct_spcontainerKey{this, "SpacePointsSCTName", "SCT spContainer"};
+ SG::ReadHandleKey<FaserSCT_SpacePointContainer> m_Sct_spcontainerKey{this, "SpacePointsSCTName", "SCT spContainer"};
SG::WriteHandleKey<SpacePointForSeedCollection> m_seed_spcontainerKey{this, "FaserSpacePointsSeedsName", "SpacePointForSeedCollection", "SpacePointForSeedCollection"};
diff --git a/Tracker/TrackerRecEvent/TrackerPrepRawData/CMakeLists.txt b/Tracker/TrackerRecEvent/TrackerPrepRawData/CMakeLists.txt
index d1630abf233ec25789022973377d7c17956c7dd0..fa3b4bb2fbd2b8c845cd9e4f0ab795b432cbbca2 100644
--- a/Tracker/TrackerRecEvent/TrackerPrepRawData/CMakeLists.txt
+++ b/Tracker/TrackerRecEvent/TrackerPrepRawData/CMakeLists.txt
@@ -15,7 +15,7 @@ atlas_add_library( TrackerPrepRawData
PUBLIC_HEADERS TrackerPrepRawData
INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS}
PRIVATE_INCLUDE_DIRS ${ROOT_INCLUDE_DIRS}
- LINK_LIBRARIES ${EIGEN_LIBRARIES} AthLinks CxxUtils AthenaKernel GeoPrimitives Identifier EventPrimitives GaudiKernel TrackerReadoutGeometry TrkSurfaces TrkEventPrimitives TrkPrepRawData TrackerRawData EventContainers TrkSpacePoint
+ LINK_LIBRARIES ${EIGEN_LIBRARIES} AthLinks CxxUtils AthenaKernel GeoPrimitives Identifier EventPrimitives GaudiKernel TrackerReadoutGeometry TrkSurfaces TrkEventPrimitives TrkPrepRawData TrackerRawData EventContainers TrkSpacePoint
PRIVATE_LINK_LIBRARIES ${ROOT_LIBRARIES} )
atlas_add_dictionary( TrackerPrepRawDataDict
diff --git a/Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/FaserSCT_ClusterContainer.h b/Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/FaserSCT_ClusterContainer.h
index 80768c29db91f4b66498dcac8826f0e9c046face..153646cdd2081be60bc57500deffb209f22c008c 100755
--- a/Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/FaserSCT_ClusterContainer.h
+++ b/Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/FaserSCT_ClusterContainer.h
@@ -13,8 +13,8 @@
// Version 1.0 25/09/2002 Veronique Boisvert
///////////////////////////////////////////////////////////////////
-#ifndef SCT_CLUSTERCONTAINER_H
-#define SCT_CLUSTERCONTAINER_H
+#ifndef FASERSCT_CLUSTERCONTAINER_H
+#define FASERSCT_CLUSTERCONTAINER_H
#include "AthenaKernel/CLASS_DEF.h"
#include "TrkPrepRawData/PrepRawDataContainer.h"
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/CMakeLists.txt b/Tracker/TrackerRecEvent/TrackerSpacePoint/CMakeLists.txt
index e00ba940671bf57fc6b94ca18a58c30d1ef243a6..bd83f9e974868a8e42bcf1f21562bd527df687c2 100644
--- a/Tracker/TrackerRecEvent/TrackerSpacePoint/CMakeLists.txt
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/CMakeLists.txt
@@ -10,9 +10,14 @@ find_package( Eigen )
# Component(s) in the package:
atlas_add_library( TrackerSpacePoint
- src/*.cxx src/*.h
+ src/*.cxx src/*.h
PUBLIC_HEADERS TrackerSpacePoint
PRIVATE_INCLUDE_DIRS ${EIGEN_INCLUDE_DIRS}
- LINK_LIBRARIES Identifier TrkDetElementBase TrkSpacePoint
- PRIVATE_LINK_LIBRARIES ${EIGEN_LIBRARIES} GeoPrimitives EventPrimitives TrkSurfaces TrkEventPrimitives TrkPrepRawData )
+ LINK_LIBRARIES Identifier TrkDetElementBase TrkSpacePoint AthLinks TrackerPrepRawData
+ PRIVATE_LINK_LIBRARIES ${EIGEN_LIBRARIES} GeoPrimitives EventPrimitives TrkSurfaces TrkEventPrimitives TrkPrepRawData )
+
+atlas_add_dictionary( TrackerSpacePointDict
+ TrackerSpacePoint/TrackerSpacePointDict.h
+ TrackerSpacePoint/selection.xml
+ LINK_LIBRARIES TrackerSpacePoint)
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePoint.h b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePoint.h
index 28c5cc2663b61019656504e176ff273779bb4820..f21facf6ae0533bcd14a0bd29ebbc92157328d39 100755
--- a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePoint.h
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePoint.h
@@ -1,6 +1,6 @@
/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
+ Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+ */
///////////////////////////////////////////////////////////////////
// SCT_SpacePoint.h
@@ -13,79 +13,244 @@
#ifndef TRACKERSPACEPOINT_SCTSPACEPOINT_H
#define TRACKERSPACEPOINT_SCTSPACEPOINT_H
-#include "TrkSpacePoint/SpacePoint.h"
+#include "AthLinks/ElementLink.h"
#include "Identifier/IdentifierHash.h"
+#include "TrkEventPrimitives/LocalParameters.h"
+#include "TrkSurfaces/Surface.h"
+#include "TrackerPrepRawData/FaserSCT_Cluster.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
+
+class FaserSCT_SpacePointContainerCnv;
+class FaserSCT_SpacePointContainerCnv_p0;
+class FaserSCT_SpacePointCnv_p0;
-namespace Trk
+namespace Tracker
{
class TrackerCluster;
}
+namespace Trk{
+ class LocalParameters;
+ class ErrorMatrix;
+ class Surface;
+}
+
namespace Tracker
{
/**
* @class SCT_SpacePoint
* An SCT_SpacePoint is created from two SCT_Cluster's from two different wafers.
*/
-
- class FaserSCT_SpacePoint : public Trk::SpacePoint
- {
-
- /////////////////////////////`//////////////////////////////////////
- // Public methods:
- ///////////////////////////////////////////////////////////////////
+
+ class FaserSCT_SpacePoint
+ {
+ friend class FaserSCT_SpacePointContainerCnv;
+ friend class FaserSCT_SpacePointContainerCnv_p0;
+ friend class FaserSCT_SpacePointCnv_p0;
+
+ /////////////////////////////`//////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
public:
-
- /** Default constructor */
- FaserSCT_SpacePoint() ;
-
- /**
- * @name Parametrised constructors
- * In order to ensure initialisation, the global Position has to be
- * on the surface associated to the FIRST member of the PRD-pair clusList.
- */
- //@{
- FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
- const Amg::Vector3D& position,
- const std::pair<const Trk::PrepRawData*, const Trk::PrepRawData*>& clusList) ;
- //@}
-
- /** Copy Constructor */
- FaserSCT_SpacePoint(const FaserSCT_SpacePoint &) ;
-
- /** Destructor */
- virtual ~FaserSCT_SpacePoint() = default;
-
- /** Overloading Assignment Operator */
- FaserSCT_SpacePoint &operator=(const FaserSCT_SpacePoint &);
-
- /** Clones */
- virtual Trk::SpacePoint* clone() const ;
-
- /**Interface method for output, to be overloaded by child classes* */
- virtual MsgStream& dump( MsgStream& out ) const ;
-
- /**Interface method for output, to be overloaded by child classes* */
- virtual std::ostream& dump( std::ostream& out ) const ;
-
- private:
- /** method to set up the local Covariance Matrix. */
- void setupLocalCovarianceSCT() ;
+ /** Default constructor */
+ FaserSCT_SpacePoint() ;
+
+ /**
+ * @name Parametrised constructors
+ * In order to ensure initialisation, the global Position has to be
+ * on the surface associated to the FIRST member of the PRD-pair clusList.
+ */
+ //@{
+ FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D* position,
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList) ;
+
+ FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D* position,
+ const Amg::MatrixX* loccov,//assumes ownership of loccov
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList) ;
+
+ FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D& position,
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList) ;
+ FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D* position,
+ Amg::MatrixX* globallcov,
+ const Amg::Vector2D* localpos,
+ Amg::MatrixX* localcov,
+ const ElementLink<Tracker::FaserSCT_ClusterContainer>& link1, const ElementLink<Tracker::FaserSCT_ClusterContainer>& link2) ;
+
+ FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D& position,
+ const Amg::MatrixX& loccov,//assumes ownership of loccov
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList) ;
+ FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D* position,
+ const ElementLink<Tracker::FaserSCT_ClusterContainer>& link1, const ElementLink<Tracker::FaserSCT_ClusterContainer>& link2) ;
+ //@}
+
+ /** Copy Constructor */
+ // FaserSCT_SpacePoint(const FaserSCT_SpacePoint &) ;
+
+ /** Destructor */
+ ~FaserSCT_SpacePoint() = default;
+
+ /** Overloading Assignment Operator */
+ // FaserSCT_SpacePoint &operator=(const FaserSCT_SpacePoint &);
+
+ /** Clones */
+ FaserSCT_SpacePoint* clone() const ;
+ /** return the pair of Ids of the element by reference*/
+ const std::pair<IdentifierHash, IdentifierHash>& elementIdList() const;
+
+ /** return the pair of cluster pointers by reference */
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>& clusterList() const;
+
+ /** return the error matrix by reference
+ The Matrix is calculated from the local Covariance Matrix when demanded and the cached */
+ const Amg::MatrixX& globCovariance() const;
+
+ /** calculate eta (not cached), needs z0 info */
+ double eta(double z0=0) const;
+
+ /**returns the r value of the SpacePoint's position (in cylindrical coordinates).
+ This is calculated once in the ctor and then cached*/
+ double r() const ;
+
+ /**returns the phi value of the SpacePoint's position (in cylindrical coordinates).
+ 0070 This is calculated once in the ctor and then cached*/
+ double phi() const ;
+
+
+ /**Interface method for output, to be overloaded by child classes* */
+ MsgStream& dump( MsgStream& out ) const ;
+
+ /**Interface method for output, to be overloaded by child classes* */
+ std::ostream& dump( std::ostream& out ) const ;
+
+ /**Interface method to get the LocalParameters*/
+ const Trk::LocalParameters& localParameters() const;
+
+ /**Interface method to get the localError*/
+ const Amg::MatrixX& localCovariance() const;
- /** common method used in constructors. */
- void setup(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
- const Amg::Vector3D& position,
- const std::pair<const Trk::PrepRawData*, const Trk::PrepRawData*>&clusList);
+ /**Interface method to get the associated Surface*/
+ const Trk::Surface& associatedSurface() const ;
+
+ /**Interface method to get the global Position*/
+ const Amg::Vector3D& globalPosition() const ;
+
+ // Here to help implement the relevant semantics for
+ // the derived classes
+ FaserSCT_SpacePoint(const FaserSCT_SpacePoint&) = default;
+ FaserSCT_SpacePoint(FaserSCT_SpacePoint&&) noexcept = default;
+ FaserSCT_SpacePoint& operator=(const FaserSCT_SpacePoint&);
+ FaserSCT_SpacePoint& operator=(FaserSCT_SpacePoint&&) noexcept = default;
+
+ //Element link to FaserSCT_Cluster
+ ElementLink<Tracker::FaserSCT_ClusterContainer>* getElementLink1(){return (&m_elelink1);}
+ ElementLink<Tracker::FaserSCT_ClusterContainer>* getElementLink2(){return (&m_elelink2);}
+ const ElementLink<Tracker::FaserSCT_ClusterContainer>* getElementLink1()const {return (&m_elelink1);}
+ const ElementLink<Tracker::FaserSCT_ClusterContainer>* getElementLink2()const {return (&m_elelink2);}
+ const Tracker::FaserSCT_Cluster* cluster1() const{if(m_elelink1.isValid())return m_elelink1.cachedElement();else return 0;}
+ const Tracker::FaserSCT_Cluster* cluster2() const{if(m_elelink2.isValid())return m_elelink2.cachedElement();else return 0;}
+
+ void setLocalParameters(Amg::Vector2D& loc){m_localParams = Trk::LocalParameters(loc);};
+ void setGlobalParameters(Amg::Vector3D& glo){m_position=glo;};
+ void setGlobalCovariance(Amg::MatrixX& glo){m_globalCovariance=glo;};
+ void setLocalCovariance(Amg::MatrixX& loc){m_localCovariance=loc;};
+ void setClusList(std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*> list){m_clusList=list; m_elelink1.setElement(list.first);
+ m_elelink2.setElement(list.second);
};
-
+ void setElemIdList(std::pair<IdentifierHash, IdentifierHash> list){m_elemIdList=list;};
+
+ protected:
+
+ Trk::LocalParameters m_localParams;
+ Amg::MatrixX m_localCovariance;
+ std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*> m_clusList;
+ std::pair<IdentifierHash, IdentifierHash> m_elemIdList;
+ Amg::Vector3D m_position;
+ Amg::MatrixX m_globalCovariance;
+
+ private:
+
+
+ ElementLink<Tracker::FaserSCT_ClusterContainer> m_elelink1, m_elelink2;
+ void setupGlobalFromLocalCovariance();
+ /** method to set up the local Covariance Matrix. */
+ void setupLocalCovarianceSCT() ;
+
+ /** common method used in constructors. */
+ void setup(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D& position,
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList);
+ };
+
///////////////////////////////////////////////////////////////////
// Inline methods:
///////////////////////////////////////////////////////////////////
- inline Trk::SpacePoint* FaserSCT_SpacePoint::clone() const
- { return new FaserSCT_SpacePoint(*this) ; }
-
+ inline FaserSCT_SpacePoint* FaserSCT_SpacePoint::clone() const
+ { return new FaserSCT_SpacePoint(*this) ; }
+
+ inline const Trk::LocalParameters&
+ FaserSCT_SpacePoint::localParameters() const
+ {
+ return m_localParams;
+ }
+
+ inline const Amg::MatrixX&
+ FaserSCT_SpacePoint::localCovariance() const
+ {
+ return m_localCovariance;
+ }
+
+ /**Overload of << operator for MsgStream for debug output*/
+ inline MsgStream&
+ operator<<(MsgStream& sl, const FaserSCT_SpacePoint& mbase)
+ {
+ return mbase.dump(sl);
+ }
+
+ /**Overload of << operator for std::ostream for debug output*/
+ inline std::ostream&
+ operator<<(std::ostream& sl, const FaserSCT_SpacePoint& mbase)
+ {
+ return mbase.dump(sl);
+ }
+ inline const std::pair<IdentifierHash, IdentifierHash>& FaserSCT_SpacePoint::elementIdList() const
+ { return m_elemIdList; }
+
+
+ inline const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>& FaserSCT_SpacePoint::clusterList() const
+ {
+ return m_clusList;
+ }
+
+ inline double FaserSCT_SpacePoint::eta(double z0) const
+ {
+ // double zr = (m_z-z0)/m_r;
+ double zr = (m_position.z() - z0)/m_position.perp();
+ return std::log(zr+std::sqrt(1.+zr*zr));
+ }
+
+ inline double FaserSCT_SpacePoint::r() const
+ { return m_position.perp(); }
+
+ inline double FaserSCT_SpacePoint::phi() const
+ { return m_position.phi(); }
+
+ // The methods required by MeasurementBase
+ inline const Amg::Vector3D& FaserSCT_SpacePoint::globalPosition() const
+ {
+ return m_position;
+ }
+ inline const Amg::MatrixX& FaserSCT_SpacePoint::globCovariance() const {
+ return m_globalCovariance;
+ }
+
}
#endif // TRACKERSPACEPOINT_SCTSPACEPOINT_H
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointCollection.h b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointCollection.h
new file mode 100755
index 0000000000000000000000000000000000000000..a68c658e1137e77ac95a5a0244659d92b3079e0c
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointCollection.h
@@ -0,0 +1,101 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// FaserSCT_SpacePointCollection.h
+// Header file for class FaserSCT_SpacePointCollection
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to contain all the SPs of a detector element:
+// module for Pixel or wafer for SCT or layer for TRT,
+// for Muons:
+// For SCT the DE is ambiguous, we are using the id of the R module (not the one with
+// the stereo angle )
+// The overlap space points are contained in the FaserSCT_SpacePointOverlapCollection
+///////////////////////////////////////////////////////////////////
+// Version 1.0 14/10/2003 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERSPACEPOINT_FASERSCT_SPACEPOINTCOLLECTION_H
+#define TRACKERSPACEPOINT_FASERSCT_SPACEPOINTCOLLECTION_H
+
+// Base classes
+#include "Identifier/Identifier.h"
+#include "Identifier/Identifiable.h"
+#include "Identifier/IdentifierHash.h"
+#include "AthContainers/DataVector.h"
+#include "GaudiKernel/DataObject.h"
+//class SpacePoint;
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+
+
+class FaserSCT_SpacePointCollectionCopyConstructorCalled{};
+
+
+class FaserSCT_SpacePointCollection
+ : public Identifiable,
+ public DataVector< Tracker::FaserSCT_SpacePoint >
+{
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+ public:
+
+ // Standard thinning code won't work on this type because
+ // we have no default constructor.
+ static bool constexpr supportsThinning = false;
+
+ // Constructor with parameters:
+ // Hashed offline identifier of the DE
+ FaserSCT_SpacePointCollection(const IdentifierHash idHash);
+
+ // Destructor:
+ virtual ~FaserSCT_SpacePointCollection();
+
+ /**added for 10.0.0 as a hack for HLT. DO NOT USE IT. It will throw an exception*/
+ FaserSCT_SpacePointCollection(const FaserSCT_SpacePointCollection& spc);
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Const methods:
+ ///////////////////////////////////////////////////////////////////
+
+ virtual Identifier identify() const override final;
+
+ virtual IdentifierHash identifyHash() const override final;
+
+ void setIdentifier(Identifier id);
+
+ virtual std::string type() const;
+
+ ///////////////////////////////////////////////////////////////////
+ // Private methods:
+ ///////////////////////////////////////////////////////////////////
+ private:
+
+ FaserSCT_SpacePointCollection() = delete;
+ FaserSCT_SpacePointCollection &operator=(const FaserSCT_SpacePointCollection&) = delete;
+
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+ private:
+ const IdentifierHash m_idHash;
+ Identifier m_id; // identifier of the DE
+};
+
+/**Overload of << operator for MsgStream for debug output*/
+MsgStream& operator << ( MsgStream& sl, const FaserSCT_SpacePointCollection& coll);
+
+/**Overload of << operator for std::ostream for debug output*/
+std::ostream& operator << ( std::ostream& sl, const FaserSCT_SpacePointCollection& coll);
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF(FaserSCT_SpacePointCollection,1129085627,1)
+
+#endif // TRKSPACEPOINT_SPACEPOINTCOLLECTION_H
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointContainer.h b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointContainer.h
new file mode 100755
index 0000000000000000000000000000000000000000..420d7579d53312267c1b1be5234db3c21bd4ad02
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointContainer.h
@@ -0,0 +1,95 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SpacePointContaine.h
+// Header file for class SpacePointContainer
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Container for SpacePoints collections for InnerDetector and Muons
+///////////////////////////////////////////////////////////////////
+// Version 1.0 14/10/2003 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERSPACEPOINT_FASERSCT_SPACEPOINTCONTAINER_H
+#define TRACKERSPACEPOINT_FASERSCT_SPACEPOINTCONTAINER_H
+
+// Base classes
+#include "EventContainers/IdentifiableContainer.h"
+//Needed Classes
+#include "TrackerSpacePoint/FaserSCT_SpacePointCollection.h"
+
+
+typedef EventContainers::IdentifiableCache< FaserSCT_SpacePointCollection > FaserSCT_SpacePointCache;
+
+class FaserSCT_SpacePointContainer
+: public IdentifiableContainer<FaserSCT_SpacePointCollection>{
+
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+
+ // Constructor with parameters:
+ FaserSCT_SpacePointContainer(unsigned int max);
+
+ FaserSCT_SpacePointContainer(FaserSCT_SpacePointCache*);
+
+ // Destructor:
+ virtual ~FaserSCT_SpacePointContainer();
+
+ /** return class ID */
+ static const CLID& classID()
+ {
+ static const CLID id = 1306592743;
+ return id;
+ // we do not know why using the traits does not work
+ //return ClassID_traits<SpacePointContainer>::ID();
+ }
+
+ /** return class ID */
+ virtual const CLID& clID() const
+ {
+ return classID();
+ }
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Const methods:
+ ///////////////////////////////////////////////////////////////////
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Non-const methods:
+ ///////////////////////////////////////////////////////////////////
+
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Private methods:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+ FaserSCT_SpacePointContainer() = delete;
+ FaserSCT_SpacePointContainer(const FaserSCT_SpacePointContainer&) = delete;
+ FaserSCT_SpacePointContainer &operator=(const FaserSCT_SpacePointContainer&) = delete;
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+};
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF(FaserSCT_SpacePointContainer,1306592743,1)
+
+
+CLASS_DEF( FaserSCT_SpacePointCache , 180888152, 1 )
+
+
+#endif // TRKSPACEPOINT_SPACEPOINTCONTAINER_H
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h
new file mode 100755
index 0000000000000000000000000000000000000000..75bf587a3831c2f51afbf9cdeda1ebbb7f8fb512
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h
@@ -0,0 +1,70 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SpacePointCollection.h
+// Header file for class SpacePointCollection
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class to contain all the overlap SPs, the other ones are in
+// the SpacePointCollection
+///////////////////////////////////////////////////////////////////
+// Version 1.0 14/10/2003 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#ifndef TRACKERSPACEPOINT_FASERSCTSPACEPOINTOVERLAPCOLLECTION_H
+#define TRACKERSPACEPOINT_FASERSCTSPACEPOINTOVERLAPCOLLECTION_H
+
+// Base classes
+#include "AthContainers/DataVector.h"
+#include "GaudiKernel/DataObject.h"
+//class SpacePoint;
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+
+class FaserSCT_SpacePointOverlapCollection : public DataVector< Tracker::FaserSCT_SpacePoint >{
+
+ ///////////////////////////////////////////////////////////////////
+ // Public methods:
+ ///////////////////////////////////////////////////////////////////
+public:
+
+ // Constructor
+ FaserSCT_SpacePointOverlapCollection();
+
+ // Destructor:
+ virtual ~FaserSCT_SpacePointOverlapCollection();
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Const methods:
+ ///////////////////////////////////////////////////////////////////
+
+
+
+ ///////////////////////////////////////////////////////////////////
+ // Private methods:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+ // FaserSCT_SpacePointOverlapCollection();
+ FaserSCT_SpacePointOverlapCollection(const FaserSCT_SpacePointOverlapCollection&) = delete;
+ FaserSCT_SpacePointOverlapCollection &operator=(const FaserSCT_SpacePointOverlapCollection&) = delete;
+
+ ///////////////////////////////////////////////////////////////////
+ // Private data:
+ ///////////////////////////////////////////////////////////////////
+private:
+
+
+};
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF(FaserSCT_SpacePointOverlapCollection,1114023127, 1)
+
+
+#endif // TRKSPACEPOINT_SPACEPOINTOVERLAPCOLLECTION_H
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/SpacePointForSeed.h b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/SpacePointForSeed.h
index 9b3f7fcf67b830190245546fe0923e19b08e4b61..41d19025428a8a7c1626ef5d3595938870288a48 100644
--- a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/SpacePointForSeed.h
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/SpacePointForSeed.h
@@ -1,23 +1,23 @@
#ifndef SpacePointForSeed_h
#define SpacePointForSeed_h
-#include "TrkSpacePoint/SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
-namespace Trk{
- class SpacePoint;
-}
+//namespace Trk{
+// class SpacePoint;
+//}
class SpacePointForSeed{
public:
SpacePointForSeed() = delete;
- SpacePointForSeed(const Trk::SpacePoint* sp) : m_spacepoint(sp) {};
+ SpacePointForSeed(const Tracker::FaserSCT_SpacePoint* sp) : m_spacepoint(sp) {};
~SpacePointForSeed() = default;
- const Trk::SpacePoint* SpacePoint() const {
+ const Tracker::FaserSCT_SpacePoint* SpacePoint() const {
return m_spacepoint;
}
private:
- const Trk::SpacePoint * m_spacepoint;
+ const Tracker::FaserSCT_SpacePoint * m_spacepoint;
};
#endif
diff --git a/Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/TrackerSeed.h b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSeed.h
similarity index 68%
rename from Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/TrackerSeed.h
rename to Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSeed.h
index 02d6a193aa081bbd2188288131a98a6bb2708096..80983149d647e9f5e41ec0c330a1e73ca78c8c43 100755
--- a/Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/TrackerSeed.h
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSeed.h
@@ -1,7 +1,7 @@
-#ifndef TRACKERRAWDATA_TRACKERSEED_H
-#define TRACKERRAWDATA_TRACKERSEED_H
+#ifndef TRACKERSPACEPOINT_TRACKERSEED_H
+#define TRACKERSPACEPOINT_TRACKERSEED_H
-#include "TrkSpacePoint/SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
#include <vector>
@@ -21,13 +21,14 @@ namespace Tracker {
TrackerSeed(const StrategyId, const TrackerSeed &);
virtual ~TrackerSeed();
- TrackerSeed(const StrategyId, vector<const Trk::SpacePoint*> seed);
+ TrackerSeed(const StrategyId, vector<const FaserSCT_SpacePoint*> seed);
void set_id(const StrategyId id) { m_strategyId = id; }
StrategyId id() const { return m_strategyId; }
- void add(vector<const Trk::SpacePoint*> seed);
+ void add(vector<const FaserSCT_SpacePoint*> seed);
+ vector<const FaserSCT_SpacePoint*> getSpacePoints() const {return m_seed;};
int size() const;
TrackerSeed &operator=(const TrackerSeed &);
@@ -38,7 +39,7 @@ namespace Tracker {
private:
StrategyId m_strategyId;
- vector<const Trk::SpacePoint*> m_seed;
+ vector<const FaserSCT_SpacePoint*> m_seed;
};
diff --git a/Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/TrackerSeedCollection.h b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSeedCollection.h
similarity index 88%
rename from Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/TrackerSeedCollection.h
rename to Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSeedCollection.h
index a90dedca94ed8580d9fe74dac784fc9c0ee70e69..2cfd8eda282b144c8d582af1526934947108808f 100755
--- a/Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/TrackerSeedCollection.h
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSeedCollection.h
@@ -4,7 +4,7 @@
#include "AthenaKernel/CLASS_DEF.h"
#include "AthContainers/DataVector.h"
#include "GaudiKernel/DataObject.h"
-#include "TrackerPrepRawData/TrackerSeed.h"
+#include "TrackerSpacePoint/TrackerSeed.h"
namespace Tracker {
typedef DataVector<TrackerSeed> TrackerSeedCollection;
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSpacePointDict.h b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSpacePointDict.h
new file mode 100644
index 0000000000000000000000000000000000000000..07b3407c20c2c2d33a8cf54fa37e147d3cfcc39e
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/TrackerSpacePointDict.h
@@ -0,0 +1,13 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS and FASER collaborations
+*/
+
+#ifndef TRACKERSPACEPOINTDICT_H
+#define TRACKERSPACEPOINTDICT_H
+
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+
+#endif
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/selection.xml b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/selection.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e94170445195d4267bcbd1ab99b657a1691f7b52
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/TrackerSpacePoint/selection.xml
@@ -0,0 +1,6 @@
+<lcgdict>
+ <class name="Tracker::FaserSCT_SpacePoint" >
+ </class>
+ <class name="FaserSCT_SpacePointCollection<Tracker::FaserSCT_SpacePoint>" id="B1069307-0EEF-48D8-B545-A47D2DFFD8FC" />
+ <class name="FaserSCT_SpacePointContainer" />
+ </lcgdict>
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePoint.cxx b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePoint.cxx
index 68554d010e724fbe59f5c07cbfbb2c02b64d97f9..4b7ec0ff4a74691bea1b079ea1cfa31bf5f0cf6e 100755
--- a/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePoint.cxx
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePoint.cxx
@@ -4,6 +4,8 @@
#include "TrkPrepRawData/PrepRawData.h"
#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerPrepRawData/FaserSCT_Cluster.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
#include "TrkEventPrimitives/LocalParameters.h"
#include "TrkSurfaces/Surface.h"
#include "EventPrimitives/EventPrimitivesToStringConverter.h"
@@ -14,53 +16,123 @@ namespace Tracker
//-------------------------------------------------------------
FaserSCT_SpacePoint::FaserSCT_SpacePoint()
- :
- Trk::SpacePoint()
{}
//-------------------------------------------------------------
+ FaserSCT_SpacePoint::FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D* position,
+ Amg::MatrixX* globalcov,
+ const Amg::Vector2D* localpos,
+ Amg::MatrixX* localcov,
+ const ElementLink<Tracker::FaserSCT_ClusterContainer>& link1, const ElementLink<Tracker::FaserSCT_ClusterContainer>& link2): m_elelink1(link1),m_elelink2(link2)
+ {
+ m_elemIdList.first = elementIdList.first ;
+ m_elemIdList.second = elementIdList.second ;
+ const FaserSCT_Cluster* clus1=link1.cachedElement();
+ const FaserSCT_Cluster* clus2=link2.cachedElement();
+ std::cout<<*clus1<<std::endl;;
+ std::cout<<clus1->identify()<<" "<<std::endl;
+ m_clusList.first = clus1;
+ m_clusList.second = clus2;
+ m_position = *position ;
+ m_globalCovariance = *globalcov;
+ m_localParams = Trk::LocalParameters(*localpos) ;
+ m_localCovariance = *localcov;
+ }
+ //-------------------------------------------------------------
+
+ FaserSCT_SpacePoint::FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D* position,
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList)
+ {
+ setup(elementIdList,*position,clusList);
+ setupLocalCovarianceSCT();
+ setupGlobalFromLocalCovariance();
+ m_elelink1.setElement(clusList->first);
+ m_elelink2.setElement(clusList->second);
+// delete position;
+ }
+
+ //-------------------------------------------------------------
+
+ FaserSCT_SpacePoint::FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D* position,
+ const ElementLink<Tracker::FaserSCT_ClusterContainer>& link1, const ElementLink<Tracker::FaserSCT_ClusterContainer>& link2): m_elelink1(link1),m_elelink2(link2)
+ {
+ const FaserSCT_Cluster* clus1=link1.cachedElement();
+ const FaserSCT_Cluster* clus2=link2.cachedElement();
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*> clusList(clus1,clus2);
+ setup(elementIdList,*position,&clusList);
+ setupLocalCovarianceSCT();
+ setupGlobalFromLocalCovariance();
+ delete position;
+ }
+
+ //-------------------------------------------------------------
+
+ FaserSCT_SpacePoint::FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D* position,
+ const Amg::MatrixX* loccov,
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList)
+ {
+ m_localCovariance = *loccov;
+ setup(elementIdList,*position,clusList);
+ setupGlobalFromLocalCovariance();
+ m_elelink1.setElement(clusList->first);
+ m_elelink2.setElement(clusList->second);
+ delete loccov;
+ delete position;
+ }
+
FaserSCT_SpacePoint::FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
const Amg::Vector3D& position,
- const std::pair<const Trk::PrepRawData*, const Trk::PrepRawData*>& clusList)
- :
- Trk::SpacePoint()
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList)
{
setup(elementIdList,position,clusList);
setupLocalCovarianceSCT();
setupGlobalFromLocalCovariance();
+ m_elelink1.setElement(clusList->first);
+ m_elelink2.setElement(clusList->second);
+ }
+
+ //-------------------------------------------------------------
+
+ FaserSCT_SpacePoint::FaserSCT_SpacePoint(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
+ const Amg::Vector3D& position,
+ const Amg::MatrixX& loccov,
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList)
+ {
+ m_localCovariance = loccov;
+ setup(elementIdList,position,clusList);
+ setupGlobalFromLocalCovariance();
+ m_elelink1.setElement(clusList->first);
+ m_elelink2.setElement(clusList->second);
}
+
//-------------------------------------------------------------
void FaserSCT_SpacePoint::setup(const std::pair<IdentifierHash, IdentifierHash>& elementIdList,
const Amg::Vector3D& position,
- const std::pair<const Trk::PrepRawData*, const Trk::PrepRawData*>& clusList)
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*>* clusList)
{
- m_clusList = clusList;
+ m_clusList.first = clusList->first;
+ m_clusList.second = clusList->second;
m_position = position ;
m_elemIdList.first = elementIdList.first ;
m_elemIdList.second = elementIdList.second ;
- assert( (clusList.first!=0) && (clusList.second!=0) );
+ assert( (clusList->first!=0) && (clusList->second!=0) );
assert(clusList->first->detectorElement()) ;
- std::optional<Amg::Vector2D> locpos{
- clusList.first->detectorElement()->surface().globalToLocal(position)
- };
+ std::optional<Amg::Vector2D> locpos{
+ clusList->first->detectorElement()->surface().globalToLocal(position)};
assert(locpos);
- Trk::MeasurementBase::m_localParams = Trk::LocalParameters(*locpos ) ;
+ m_localParams = Trk::LocalParameters(*locpos ) ;
}
//-------------------------------------------------------------
- FaserSCT_SpacePoint::FaserSCT_SpacePoint(const FaserSCT_SpacePoint &o)
- :
- Trk::SpacePoint(o)
- {
- }
-
- //-------------------------------------------------------------
-
//---------------------------------------------------------------
void FaserSCT_SpacePoint::setupLocalCovarianceSCT()
@@ -77,7 +149,7 @@ namespace Tracker
1.*deltaY, 25.*deltaY,
25.*deltaY, 1600.*deltaY;
- Trk::MeasurementBase::m_localCovariance = cov;
+ m_localCovariance = cov;
}
//-------------------------------------------------------------
@@ -115,16 +187,41 @@ std::ostream& FaserSCT_SpacePoint::dump( std::ostream& out ) const
return out;
}
- // ------------------------------------------------------------------
-
- //assignment operator
- FaserSCT_SpacePoint& FaserSCT_SpacePoint::operator=(const FaserSCT_SpacePoint& o)
+// ------------------------------------------------------------------
+
+//assignment operator
+FaserSCT_SpacePoint& FaserSCT_SpacePoint::operator=(const FaserSCT_SpacePoint& o)
+{
+ if (&o !=this)
{
- if (&o !=this)
- {
- Trk::SpacePoint::operator=(o);
- }
- return *this;
+ FaserSCT_SpacePoint::operator=(o);
}
+ return *this;
+}
+
+/** set up the global covariance matrix by rotating the local one */
+
+void FaserSCT_SpacePoint::setupGlobalFromLocalCovariance()
+{
+ const Amg::MatrixX& lc = this->localCovariance();
+
+ Amg::MatrixX cov(3,3);
-}
\ No newline at end of file
+ cov<<
+ lc(0,0),lc(0,1),0.,
+ lc(1,0),lc(1,1),0.,
+ // cppcheck-suppress constStatement
+ 0. ,0. ,0.;
+
+ const Amg::RotationMatrix3D& R = associatedSurface().transform().rotation();
+ m_globalCovariance = R*cov*R.transpose();
+
+}
+
+const Trk::Surface& FaserSCT_SpacePoint::associatedSurface() const
+{
+ assert(m_clusList.first->detectorElement());
+ return m_clusList.first->detectorElement()->surface();
+}
+
+}
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointCollection.cxx b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointCollection.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..63643d726fbbe3c1035bc6feb169404b0103fd74
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointCollection.cxx
@@ -0,0 +1,78 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SpacePointCollection.cxx
+// Implementation file for class SpacePointCollection
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 14/10/2003 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#include "TrackerSpacePoint/FaserSCT_SpacePointCollection.h"
+#include "GaudiKernel/MsgStream.h"
+// Constructor with parameters:
+FaserSCT_SpacePointCollection::FaserSCT_SpacePointCollection(const IdentifierHash idHash) :
+ m_idHash(idHash),
+ m_id()
+{}
+
+// Constructor with parameters:
+FaserSCT_SpacePointCollection::FaserSCT_SpacePointCollection(const FaserSCT_SpacePointCollection& spc) :
+ DataVector< Tracker::FaserSCT_SpacePoint >( spc ),
+ m_idHash(),
+ m_id()
+{
+ // added this ctor as a temporary hack for HLT
+ // it should never be called.
+ throw FaserSCT_SpacePointCollectionCopyConstructorCalled();
+}
+
+// Destructor:
+FaserSCT_SpacePointCollection::~FaserSCT_SpacePointCollection()
+{ }
+
+Identifier FaserSCT_SpacePointCollection::identify() const
+{
+ return m_id;
+}
+
+IdentifierHash FaserSCT_SpacePointCollection::identifyHash() const
+{
+ return m_idHash;
+}
+
+void FaserSCT_SpacePointCollection::setIdentifier(Identifier id)
+{
+ m_id = id;
+}
+
+std::string FaserSCT_SpacePointCollection::type() const
+{
+ return "FaserSCT_SpacePointCollection";
+}
+/**Overload of << operator for MsgStream for debug output*/
+MsgStream& operator << ( MsgStream& sl, const FaserSCT_SpacePointCollection& coll) {
+ sl << "FaserSCT_SpacePointCollection: "
+ << "identify()="<< coll.identify()
+ << ", SP=[";
+ FaserSCT_SpacePointCollection::const_iterator it = coll.begin();
+ FaserSCT_SpacePointCollection::const_iterator itEnd = coll.end();
+ for (;it!=itEnd;++it) { sl<< (**it)<<", ";}
+ sl <<" ]"<<std::endl;
+ return sl;
+}
+
+/**Overload of << operator for std::ostream for debug output*/
+std::ostream& operator << ( std::ostream& sl, const FaserSCT_SpacePointCollection& coll) {
+ sl << "FaserSCT_SpacePointCollection: "
+ << "identify()="<< coll.identify()
+ << ", SP=[";
+ FaserSCT_SpacePointCollection::const_iterator it = coll.begin();
+ FaserSCT_SpacePointCollection::const_iterator itEnd = coll.end();
+ for (;it!=itEnd;++it) { sl<< (**it)<<", ";}
+ sl <<" ]"<<std::endl;
+ return sl;
+}
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointContainer.cxx b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointContainer.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..a67f15d794562b4a2344e66100264777c02a245f
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointContainer.cxx
@@ -0,0 +1,34 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SpacePointContainer.cxx
+// Implementation file for class SpacePointContainer
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 14/10/2003 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+
+// Constructor with parameters:
+FaserSCT_SpacePointContainer::FaserSCT_SpacePointContainer(unsigned int max) :
+ IdentifiableContainer<FaserSCT_SpacePointCollection>(max)
+{
+}
+
+// Constructor with parameters:
+FaserSCT_SpacePointContainer::FaserSCT_SpacePointContainer(FaserSCT_SpacePointCache *cache) :
+ IdentifiableContainer<FaserSCT_SpacePointCollection>(cache)
+{
+}
+
+// Destructor:
+FaserSCT_SpacePointContainer::~FaserSCT_SpacePointContainer()
+{
+
+}
+
+
diff --git a/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointOverlapCollection.cxx b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointOverlapCollection.cxx
new file mode 100755
index 0000000000000000000000000000000000000000..aa875eb14851eb71a5cb0b2789c53678bfbc7359
--- /dev/null
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/FaserSCT_SpacePointOverlapCollection.cxx
@@ -0,0 +1,23 @@
+/*
+ Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SpacePointOverlapCollection.cxx
+// Implementation file for class SpacePointOverlapCollection
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Version 1.0 14/10/2003 Veronique Boisvert
+///////////////////////////////////////////////////////////////////
+
+#include "TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h"
+// Constructor with parameters:
+FaserSCT_SpacePointOverlapCollection::FaserSCT_SpacePointOverlapCollection()
+
+{}
+
+// Destructor:
+FaserSCT_SpacePointOverlapCollection::~FaserSCT_SpacePointOverlapCollection()
+{ }
+
diff --git a/Tracker/TrackerRecEvent/TrackerPrepRawData/src/TrackerSeed.cxx b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/TrackerSeed.cxx
similarity index 80%
rename from Tracker/TrackerRecEvent/TrackerPrepRawData/src/TrackerSeed.cxx
rename to Tracker/TrackerRecEvent/TrackerSpacePoint/src/TrackerSeed.cxx
index bd217ec892f499994db0f6eb5d557669357a6ef7..2e0f255193cc27af7b4f7b1ba76f36154f1d1faf 100755
--- a/Tracker/TrackerRecEvent/TrackerPrepRawData/src/TrackerSeed.cxx
+++ b/Tracker/TrackerRecEvent/TrackerSpacePoint/src/TrackerSeed.cxx
@@ -1,4 +1,4 @@
-#include "TrackerPrepRawData/TrackerSeed.h"
+#include "TrackerSpacePoint/TrackerSeed.h"
namespace Tracker {
@@ -8,9 +8,9 @@ namespace Tracker {
TrackerSeed::~TrackerSeed() {}
- TrackerSeed::TrackerSeed(const StrategyId id, vector<const Trk::SpacePoint*> seed) { m_strategyId = id; m_seed = seed; }
+ TrackerSeed::TrackerSeed(const StrategyId id, vector<const FaserSCT_SpacePoint*> seed) { m_strategyId = id; m_seed = seed; }
- void TrackerSeed::add(vector<const Trk::SpacePoint*> seed) { m_seed = seed; }
+ void TrackerSeed::add(vector<const FaserSCT_SpacePoint*> seed) { m_seed = seed; }
int TrackerSeed::size() const { return m_seed.size(); }
diff --git a/Tracker/TrackerRecTools/FaserSiSpacePointTool/FaserSiSpacePointTool/FaserSCTinformation.h b/Tracker/TrackerRecTools/FaserSiSpacePointTool/FaserSiSpacePointTool/FaserSCTinformation.h
index dccb140241e894b4cf21788acd05b98f040462cf..dc825852fcb0304839c2a3df703b54fce587d765 100644
--- a/Tracker/TrackerRecTools/FaserSiSpacePointTool/FaserSiSpacePointTool/FaserSCTinformation.h
+++ b/Tracker/TrackerRecTools/FaserSiSpacePointTool/FaserSiSpacePointTool/FaserSCTinformation.h
@@ -19,7 +19,7 @@
#define FaserSCTinformation_h
-class TrackerCluster;
+class FaserSCT_Cluster;
namespace Tracker
{
@@ -31,13 +31,13 @@ namespace Tracker
public:
- FaserSCTinformation(const Tracker::TrackerCluster* CL, const Amg::Vector3D& a, const Amg::Vector3D& b, const Amg::Vector3D& vec);
+ FaserSCTinformation(const Tracker::FaserSCT_Cluster* CL, const Amg::Vector3D& a, const Amg::Vector3D& b, const Amg::Vector3D& vec);
FaserSCTinformation(const FaserSCTinformation&) = default;
virtual ~FaserSCTinformation() = default;
FaserSCTinformation& operator = (const FaserSCTinformation&) = default;
- const Tracker::TrackerCluster* cluster() const;
+ const Tracker::FaserSCT_Cluster* cluster() const;
const Amg::Vector3D& a() const;
const Amg::Vector3D& q() const;
const Amg::Vector3D& s() const;
@@ -49,7 +49,7 @@ namespace Tracker
private:
- const Tracker::TrackerCluster* m_CL;
+ const Tracker::FaserSCT_Cluster* m_CL;
Amg::Vector3D m_A;
Amg::Vector3D m_Q;
Amg::Vector3D m_S;
@@ -67,7 +67,7 @@ namespace Tracker
/////////////////////////////////////////////////////////////////////////////////
inline FaserSCTinformation::FaserSCTinformation
- (const Tracker::TrackerCluster* CL, const Amg::Vector3D& a, const Amg::Vector3D& b, const Amg::Vector3D& vec)
+ (const Tracker::FaserSCT_Cluster* CL, const Amg::Vector3D& a, const Amg::Vector3D& b, const Amg::Vector3D& vec)
{
m_CL = CL ;
m_A = 0.5*(a+b) ; // Center of strip
@@ -80,7 +80,7 @@ namespace Tracker
/////////////////////////////////////////////////////////////////////////////////
// Getter methods
/////////////////////////////////////////////////////////////////////////////////
- inline const Tracker::TrackerCluster* FaserSCTinformation::cluster() const
+ inline const Tracker::FaserSCT_Cluster* FaserSCTinformation::cluster() const
{
return m_CL;
}
diff --git a/Tracker/TrackerRecTools/FaserSiSpacePointTool/FaserSiSpacePointTool/TrackerSpacePointMakerTool.h b/Tracker/TrackerRecTools/FaserSiSpacePointTool/FaserSiSpacePointTool/TrackerSpacePointMakerTool.h
index d6245810e9e61a9614a5044855b6c425b5c5b05a..aac1d65775356b508461468ab380593c47beb53f 100644
--- a/Tracker/TrackerRecTools/FaserSiSpacePointTool/FaserSiSpacePointTool/TrackerSpacePointMakerTool.h
+++ b/Tracker/TrackerRecTools/FaserSiSpacePointTool/FaserSiSpacePointTool/TrackerSpacePointMakerTool.h
@@ -11,21 +11,21 @@
#include "GeoPrimitives/GeoPrimitives.h"
#include "TrackerPrepRawData/FaserSCT_ClusterCollection.h"
#include "FaserSiSpacePointTool/FaserSCTinformation.h"
-#include "TrkSpacePoint/SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
#include <mutex>
#include <string>
class FaserSCT_ID;
-class SpacePointCollection;
-class SpacePointOverlapCollection;
+class FaserSCT_SpacePointCollection;
+class FaserSCT_SpacePointOverlapCollection;
namespace TrackerDD {
class SiDetectorElementCollection;
class SiDetectorElement;
}
namespace Tracker {
- class TrackerCluster;
+ class FaserSCT_Cluster;
}
@@ -60,7 +60,7 @@ namespace Tracker
void newEvent() const;
/// Convert clusters to space points: SCT_Clusters -> SCT_SpacePoints
- Trk::SpacePoint* makeSCT_SpacePoint(const TrackerCluster& cluster1, const TrackerCluster& cluster2,
+ FaserSCT_SpacePoint* makeSCT_SpacePoint(const FaserSCT_Cluster& cluster1, const FaserSCT_Cluster& cluster2,
const Amg::Vector3D& vertexVec,
const TrackerDD::SiDetectorElement* element1, const TrackerDD::SiDetectorElement* element2, double stripLengthGapTolerance) const;
@@ -68,21 +68,21 @@ namespace Tracker
void fillSCT_SpacePointCollection(const FaserSCT_ClusterCollection* clusters1,
const FaserSCT_ClusterCollection* clusters2, double min, double max, bool allClusters,
const Amg::Vector3D& vertexVec, const TrackerDD::SiDetectorElementCollection* elements,
- SpacePointCollection* spacepointCollection) const;
+ FaserSCT_SpacePointCollection* spacepointCollection) const;
/// Convert clusters to space points using eta direction overlaps: SCT_Clusters -> OverlapSpacePoints
void fillSCT_SpacePointEtaOverlapCollection(const FaserSCT_ClusterCollection* clusters1,
const FaserSCT_ClusterCollection* clusters2, double min, double max, bool allClusters,
const Amg::Vector3D& vertexVec, const TrackerDD::SiDetectorElementCollection* elements,
- SpacePointOverlapCollection* spacepointOverlapCollection) const;
+ FaserSCT_SpacePointOverlapCollection* spacepointOverlapCollection) const;
/// Convert clusters to space points using phi direction overlaps: SCT_Clusters -> OverlapSpacePoints
void fillSCT_SpacePointPhiOverlapCollection(const FaserSCT_ClusterCollection* clusters1,
const FaserSCT_ClusterCollection* clusters2, double min1, double max1, double min2,
double max2, bool allClusters, const Amg::Vector3D& vertexVec ,
const TrackerDD::SiDetectorElementCollection* elements,
- SpacePointOverlapCollection* spacepointOverlapCollection) const;
+ FaserSCT_SpacePointOverlapCollection* spacepointOverlapCollection) const;
private:
/// @name Cut parameters
@@ -110,7 +110,7 @@ namespace Tracker
/// To hold event dependent data
struct CacheEntry {
EventContext::ContextEvt_t m_evt{EventContext::INVALID_CONTEXT_EVT}; //!< Event number, slot number, used to check if already processed event or not.
- std::vector<Trk::SpacePoint*> m_tmpSpacePoints{}; //!< SpacePoint cache
+ std::vector<FaserSCT_SpacePoint*> m_tmpSpacePoints{}; //!< SpacePoint cache
std::vector<FaserSCTinformation> m_SCT0{}; //!< SCTinformation vector for 0-th element (side 0)
std::vector<FaserSCTinformation> m_SCT1{}; //!< SCTinformation vector for 1-st element (side 1)
const TrackerDD::SiDetectorElement* m_element0{nullptr}; //!< SiDetectorElement for 0-th element (side 0)
@@ -119,7 +119,7 @@ namespace Tracker
/// Clear all members of event dependent data
void clear() {
if (m_tmpSpacePoints.size()) {
- for (Trk::SpacePoint* sp : m_tmpSpacePoints) {
+ for (FaserSCT_SpacePoint* sp : m_tmpSpacePoints) {
delete sp;
}
}
diff --git a/Tracker/TrackerRecTools/FaserSiSpacePointTool/src/TrackerSpacePointMakerTool.cxx b/Tracker/TrackerRecTools/FaserSiSpacePointTool/src/TrackerSpacePointMakerTool.cxx
index d04d721c7a748433d02087fc9ac981e46eeb205d..814fc31a5b82c9705472a283ba8abfd074ed067b 100644
--- a/Tracker/TrackerRecTools/FaserSiSpacePointTool/src/TrackerSpacePointMakerTool.cxx
+++ b/Tracker/TrackerRecTools/FaserSiSpacePointTool/src/TrackerSpacePointMakerTool.cxx
@@ -5,8 +5,8 @@
#include "FaserSiSpacePointTool/TrackerSpacePointMakerTool.h"
// Cluster and space point collections
-#include "TrkSpacePoint/SpacePointCollection.h"
-#include "TrkSpacePoint/SpacePointOverlapCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointOverlapCollection.h"
// For processing clusters
#include "TrackerIdentifier/FaserSCT_ID.h"
@@ -59,8 +59,8 @@ void TrackerSpacePointMakerTool::newEvent() const {
}
}
//--------------------------------------------------------------------------
-Trk::SpacePoint* TrackerSpacePointMakerTool::makeSCT_SpacePoint(const Tracker::TrackerCluster& cluster1,
- const Tracker::TrackerCluster& cluster2,
+FaserSCT_SpacePoint* TrackerSpacePointMakerTool::makeSCT_SpacePoint(const Tracker::FaserSCT_Cluster& cluster1,
+ const Tracker::FaserSCT_Cluster& cluster2,
const Amg::Vector3D& vertexVec,
const TrackerDD::SiDetectorElement* element1,
const TrackerDD::SiDetectorElement* element2,
@@ -184,8 +184,8 @@ Trk::SpacePoint* TrackerSpacePointMakerTool::makeSCT_SpacePoint(const Tracker::T
if (ok) {
ATH_MSG_VERBOSE( "SpacePoint generated at: ( " << point.x() << " , " << point.y() << " , " << point.z() << " ) " );
std::pair<IdentifierHash,IdentifierHash> elementIdList( element1->identifyHash() , element2->identifyHash() );
- std::pair<const Trk::PrepRawData*, const Trk::PrepRawData*> clusList {&cluster1, &cluster2 };
- return new FaserSCT_SpacePoint(elementIdList, point, clusList);
+ std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*> clusList {&cluster1, &cluster2 };
+ return new FaserSCT_SpacePoint(elementIdList, point, &clusList);
}
return nullptr;
@@ -197,7 +197,7 @@ void TrackerSpacePointMakerTool::fillSCT_SpacePointCollection(const Tracker::Fas
double min, double max, bool allClusters,
const Amg::Vector3D& vertexVec,
const TrackerDD::SiDetectorElementCollection* elements,
- SpacePointCollection* spacepointCollection) const {
+ FaserSCT_SpacePointCollection* spacepointCollection) const {
double stripLengthGapTolerance = 0.;
// Try all combinations of clusters for space points
@@ -217,7 +217,7 @@ void TrackerSpacePointMakerTool::fillSCT_SpacePointCollection(const Tracker::Fas
}
//tmpSpacePoints changed to local variable to enable rentrancy
- std::vector<Trk::SpacePoint*> tmpSpacePoints;
+ std::vector<FaserSCT_SpacePoint*> tmpSpacePoints;
for (; clusters1Next!=clusters1Finish; ++clusters1Next){
Amg::Vector2D locpos = (*clusters1Next)->localPosition();
@@ -248,7 +248,7 @@ void TrackerSpacePointMakerTool::fillSCT_SpacePointCollection(const Tracker::Fas
Amg::Vector2D localPos = Amg::Vector2D(locpos[0], locpos[1]);
double diff = TrackerDD::SiLocalPosition(localPos.y(), localPos.x(), 0.).xPhi() - xPhi1;
if (((min <= diff) and (diff <= max)) or allClusters) {
- Trk::SpacePoint* sp =
+ FaserSCT_SpacePoint* sp =
makeSCT_SpacePoint(**clusters1Next, **clusters2Next, vertexVec, element1, element2, stripLengthGapTolerance);
if (sp) {
tmpSpacePoints.push_back(sp);
@@ -258,7 +258,7 @@ void TrackerSpacePointMakerTool::fillSCT_SpacePointCollection(const Tracker::Fas
}
spacepointCollection->reserve(spacepointCollection->size() + tmpSpacePoints.size());
- for (Trk::SpacePoint* sp: tmpSpacePoints) {
+ for (FaserSCT_SpacePoint* sp: tmpSpacePoints) {
spacepointCollection->push_back(sp);
}
}
@@ -271,7 +271,7 @@ void TrackerSpacePointMakerTool::fillSCT_SpacePointEtaOverlapCollection(const Tr
double min, double max, bool allClusters,
const Amg::Vector3D& vertexVec,
const TrackerDD::SiDetectorElementCollection* elements,
- SpacePointOverlapCollection* spacepointoverlapCollection) const {
+ FaserSCT_SpacePointOverlapCollection* spacepointoverlapCollection) const {
double stripLengthGapTolerance = 0.;
@@ -318,7 +318,7 @@ void TrackerSpacePointMakerTool::fillSCT_SpacePointEtaOverlapCollection(const Tr
Amg::Vector2D localPos = Amg::Vector2D(locpos[0], locpos[1]);
double diff = TrackerDD::SiLocalPosition(localPos.y(), localPos.x(), 0.).xPhi() - xPhi1;
if (((min <= diff) and (diff <= max)) or allClusters){
- Trk::SpacePoint* sp =
+ FaserSCT_SpacePoint* sp =
makeSCT_SpacePoint(**clusters1Next, **clusters2Next, vertexVec, element1, element2, stripLengthGapTolerance);
if (sp) {
spacepointoverlapCollection->push_back(sp);
@@ -337,7 +337,7 @@ void TrackerSpacePointMakerTool::fillSCT_SpacePointPhiOverlapCollection(const Tr
bool allClusters,
const Amg::Vector3D& vertexVec,
const TrackerDD::SiDetectorElementCollection* elements,
- SpacePointOverlapCollection* spacepointoverlapCollection) const {
+ FaserSCT_SpacePointOverlapCollection* spacepointoverlapCollection) const {
double stripLengthGapTolerance = 0.;
if (m_SCTgapParameter != 0.) {
@@ -390,7 +390,7 @@ void TrackerSpacePointMakerTool::fillSCT_SpacePointPhiOverlapCollection(const Tr
Amg::Vector2D localPos = Amg::Vector2D(locpos[0], locpos[1]);
double xPhi2 = TrackerDD::SiLocalPosition(localPos.y(), localPos.x(), 0.).xPhi();
if (((min2<= xPhi2) and (xPhi2 <= max2)) or allClusters) {
- Trk::SpacePoint* sp =
+ FaserSCT_SpacePoint* sp =
makeSCT_SpacePoint(**clusters1Next, **clusters2Next, vertexVec, element1, element2, stripLengthGapTolerance);
if (sp) {
spacepointoverlapCollection->push_back(sp);
@@ -475,7 +475,7 @@ void TrackerSpacePointMakerTool::makeSCT_SpacePoints(const double stripLengthGap
ent->m_evt = ctx.evt();
} else {
if (ent->m_tmpSpacePoints.size()) {
- for (Trk::SpacePoint* sp : ent->m_tmpSpacePoints) {
+ for (FaserSCT_SpacePoint* sp : ent->m_tmpSpacePoints) {
delete sp;
}
}
@@ -530,10 +530,10 @@ void TrackerSpacePointMakerTool::makeSCT_SpacePoints(const double stripLengthGap
ATH_MSG_VERBOSE("SpacePoint generated at: ( " << point.x() << " , " << point.y() << " , " << point.z() << " ) ");
const std::pair<IdentifierHash, IdentifierHash> elementIdList(ent->m_element0->identifyHash(), ent->m_element1->identifyHash());
- const std::pair<const Trk::PrepRawData*, const Trk::PrepRawData*> clusList {(*I).cluster(), (*J).cluster()};
- ent->m_tmpSpacePoints.push_back(new FaserSCT_SpacePoint(elementIdList, point, clusList));
+ const std::pair<const FaserSCT_Cluster*, const FaserSCT_Cluster*> clusList {(*I).cluster(), (*J).cluster()};
+ ent->m_tmpSpacePoints.push_back(new FaserSCT_SpacePoint(elementIdList, point, &clusList));
}
}
}
-}
\ No newline at end of file
+}
diff --git a/Tracking/Acts/FaserActsGeometry/python/FaserActsMaterialMapping_jobOptions.py b/Tracking/Acts/FaserActsGeometry/python/FaserActsMaterialMapping_jobOptions.py
index feb3b04d2f978297bfcbea4229d0ff35862d5aee..6466848fb515373c2b33bd8c0978d4f162e053bb 100644
--- a/Tracking/Acts/FaserActsGeometry/python/FaserActsMaterialMapping_jobOptions.py
+++ b/Tracking/Acts/FaserActsGeometry/python/FaserActsMaterialMapping_jobOptions.py
@@ -18,7 +18,7 @@ from FaserActsGeometry.ActsGeometryConfig import ActsMaterialStepConverterToolCf
from FaserActsGeometry.ActsGeometryConfig import ActsSurfaceMappingToolCfg, ActsVolumeMappingToolCfg
from FaserActsGeometry.ActsGeometryConfig import ActsMaterialJsonWriterToolCfg
-from FaserActsGeometry.ActsGeometryConfig import ActsAlignmentCondAlgCfg
+#from FaserActsGeometry.ActsGeometryConfig import ActsAlignmentCondAlgCfg
from FaserGeoModel.FaserGeoModelConfig import FaserGeometryCfg
def ActsMaterialMappingCfg(configFlags, name = "FaserActsMaterialMapping", **kwargs):
@@ -52,7 +52,7 @@ def ActsMaterialMappingCfg(configFlags, name = "FaserActsMaterialMapping", **kwa
if "__main__" == __name__:
from AthenaCommon.Configurable import Configurable
from AthenaCommon.Logging import log
- from AthenaCommon.Constants import VERBOSE, INFO
+ from AthenaCommon.Constants import INFO
from CalypsoConfiguration.AllConfigFlags import ConfigFlags
from CalypsoConfiguration.MainServicesConfig import MainServicesCfg
from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
diff --git a/Tracking/Acts/FaserActsKalmanFilter/CMakeLists.txt b/Tracking/Acts/FaserActsKalmanFilter/CMakeLists.txt
index 2feb67193700e480376545dd8d14d05d22c71b83..a59281e363f8fd5dde3136a6b753d0eed8c0d0d6 100755
--- a/Tracking/Acts/FaserActsKalmanFilter/CMakeLists.txt
+++ b/Tracking/Acts/FaserActsKalmanFilter/CMakeLists.txt
@@ -39,7 +39,10 @@ atlas_add_component(FaserActsKalmanFilter
MagFieldElements
MagFieldConditions
TrkPrepRawData
+ TrkTrack
TrackerPrepRawData
+ TrackerRIO_OnTrack
+ TrkRIO_OnTrack
TrackerSpacePoint
GeoModelFaserUtilities
GeneratorObjects
@@ -47,6 +50,7 @@ atlas_add_component(FaserActsKalmanFilter
TrackerReadoutGeometry
Identifier
TrackerSimData
+ TrackerSeedFinderLib
)
# Install files from the package:
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/.__afsCDFD b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/.__afsCDFD
new file mode 100644
index 0000000000000000000000000000000000000000..c066165b27f5fabec539af3ca012c6ab0585c276
--- /dev/null
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/.__afsCDFD
@@ -0,0 +1,71 @@
+#ifndef COMBINATORIALKALMANFILTERALG_H
+#define COMBINATORIALKALMANFILTERALG_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "FaserActsGeometryInterfaces/IFaserActsTrackingGeometryTool.h"
+#include "FaserActsKalmanFilter/TruthBasedInitialParameterTool.h"
+#include "FaserActsKalmanFilter/SPSimpleInitialParameterTool.h"
+#include "FaserActsKalmanFilter/SPSeedBasedInitialParameterTool.h"
+#include "Acts/TrackFinding/CombinatorialKalmanFilter.hpp"
+#include "Acts/TrackFinding/MeasurementSelector.hpp"
+#include "FaserActsKalmanFilter/Measurement.h"
+#include "MagFieldConditions/FaserFieldCacheCondObj.h"
+#include "FaserActsKalmanFilter/TrajectoryWriterTool.h"
+#include "TrkTrack/TrackCollection.h"
+
+class FaserSCT_ID;
+
+namespace Trk
+{
+class TrackStateOnSurface;
+}
+
+namespace TrackerDD {
+ class SCT_DetectorManager;
+}
+
+class CombinatorialKalmanFilterAlg : public AthReentrantAlgorithm {
+ public:
+ CombinatorialKalmanFilterAlg(const std::string& name, ISvcLocator* pSvcLocator);
+ virtual ~CombinatorialKalmanFilterAlg() = default;
+
+ StatusCode initialize() override;
+ StatusCode execute(const EventContext& ctx) const override;
+ StatusCode finalize() override;
+
+ using TrackFinderOptions =
+ Acts::CombinatorialKalmanFilterOptions<IndexSourceLinkAccessor, MeasurementCalibrator, Acts::MeasurementSelector>;
+ using FitterResult = Acts::Result<Acts::CombinatorialKalmanFilterResult<IndexSourceLink>>;
+ using TrackFinderResult = std::vector<FitterResult>;
+// using TrackFinderResult = std::vector<
+// Acts::Result<Acts::CombinatorialKalmanFilterResult<IndexSourceLink>>>;
+ using TrackFinderFunction = std::function<TrackFinderResult(
+ const IndexSourceLinkContainer&, const std::vector<Acts::CurvilinearTrackParameters>&,
+ const TrackFinderOptions&)>;
+
+ static TrackFinderFunction makeTrackFinderFunction(
+ std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry);
+
+ Acts::MagneticFieldContext getMagneticFieldContext(const EventContext& ctx) const;
+
+
+ private:
+ const FaserSCT_ID* m_idHelper{nullptr};
+ const TrackerDD::SCT_DetectorManager* m_detManager{nullptr};
+
+ std::unique_ptr<Trk::Track> makeTrack(Acts::GeometryContext& tgContext, FitterResult& fitResult, std::vector<Tracker::FaserSCT_SpacePoint> seed_spcollection) const;
+ const Trk::TrackParameters* ConvertActsTrackParameterToATLAS(const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext& gctx) const;
+
+ SG::WriteHandleKey<TrackCollection> m_trackCollection { this, "FaserActsCKFTrackCollection", "FaserActsCKFTrackCollection", "Output trackcollectionname" };
+
+ ToolHandle<IFaserActsTrackingGeometryTool> m_trackingGeometryTool{this, "TrackingGeometryTool", "FaserActsTrackingGeometryTool"};
+ ToolHandle<SPSeedBaseInitialParameterTool> m_initialParameterTool{this, "InitialParameterTool", "SPSeedBaseInitialParameterTool"};
+ //ToolHandle<SPSimpleInitialParameterTool> m_initialParameterTool{this, "InitialParameterTool", "SPSimpleInitialParameterTool"};
+ //ToolHandle<TruthBasedInitialParameterTool> m_initialParameterTool{this, "InitialParameterTool", "TruthBasedInitialParameterTool"};
+ ToolHandle<TrajectoryWriterTool> m_trajectoryWriterTool{this, "OutputTool", "TrajectoryWriterTool"};
+ SG::ReadCondHandleKey<FaserFieldCacheCondObj> m_fieldCondObjInputKey {this, "FaserFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"};
+ SG::ReadHandleKey<FaserSCT_SpacePointContainer> m_SpacePointContainerKey{this, "SpacePointsSCTName", "SCT_SpacePointContainer", "SCT space point container"};
+};
+
+#endif // COMBINATORIALKALMANFILTERALG_H
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h
index 3d147019b115c7d7f6818bb06c7aef1c65c6bfec..db3f086debf367530d61ba47c58bb6602a84ff3e 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h
@@ -2,15 +2,29 @@
#define COMBINATORIALKALMANFILTERALG_H
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
-#include "TrkSpacePoint/SpacePointContainer.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointContainer.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h"
#include "FaserActsGeometryInterfaces/IFaserActsTrackingGeometryTool.h"
#include "FaserActsKalmanFilter/TruthBasedInitialParameterTool.h"
+#include "FaserActsKalmanFilter/SPSimpleInitialParameterTool.h"
+#include "FaserActsKalmanFilter/SPSeedBasedInitialParameterTool.h"
#include "Acts/TrackFinding/CombinatorialKalmanFilter.hpp"
#include "Acts/TrackFinding/MeasurementSelector.hpp"
#include "FaserActsKalmanFilter/Measurement.h"
#include "MagFieldConditions/FaserFieldCacheCondObj.h"
#include "FaserActsKalmanFilter/TrajectoryWriterTool.h"
+#include "TrkTrack/TrackCollection.h"
+class FaserSCT_ID;
+
+namespace Trk
+{
+class TrackStateOnSurface;
+}
+
+namespace TrackerDD {
+ class SCT_DetectorManager;
+}
class CombinatorialKalmanFilterAlg : public AthReentrantAlgorithm {
public:
@@ -23,8 +37,10 @@ class CombinatorialKalmanFilterAlg : public AthReentrantAlgorithm {
using TrackFinderOptions =
Acts::CombinatorialKalmanFilterOptions<IndexSourceLinkAccessor, MeasurementCalibrator, Acts::MeasurementSelector>;
- using TrackFinderResult = std::vector<
- Acts::Result<Acts::CombinatorialKalmanFilterResult<IndexSourceLink>>>;
+ using FitterResult = Acts::Result<Acts::CombinatorialKalmanFilterResult<IndexSourceLink>>;
+ using TrackFinderResult = std::vector<FitterResult>;
+// using TrackFinderResult = std::vector<
+// Acts::Result<Acts::CombinatorialKalmanFilterResult<IndexSourceLink>>>;
using TrackFinderFunction = std::function<TrackFinderResult(
const IndexSourceLinkContainer&, const std::vector<Acts::CurvilinearTrackParameters>&,
const TrackFinderOptions&)>;
@@ -36,11 +52,32 @@ class CombinatorialKalmanFilterAlg : public AthReentrantAlgorithm {
private:
+ const FaserSCT_ID* m_idHelper{nullptr};
+ const TrackerDD::SCT_DetectorManager* m_detManager{nullptr};
+
+// std::unique_ptr<Trk::Track> makeTrack(Acts::GeometryContext& tgContext, FitterResult& fitResult, std::vector<Tracker::FaserSCT_Cluster> seed_spcollection) const;
+ std::unique_ptr<Trk::Track> makeTrack(Acts::GeometryContext& tgContext, FitterResult& fitResult, std::vector<Tracker::FaserSCT_SpacePoint> seed_spcollection) const;
+ const Trk::TrackParameters* ConvertActsTrackParameterToATLAS(const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext& gctx) const;
+
+ SG::WriteHandleKey<TrackCollection> m_trackCollection { this, "FaserActsCKFTrackCollection", "FaserActsCKFTrackCollection", "Output trackcollectionname" };
+
ToolHandle<IFaserActsTrackingGeometryTool> m_trackingGeometryTool{this, "TrackingGeometryTool", "FaserActsTrackingGeometryTool"};
- ToolHandle<TruthBasedInitialParameterTool> m_initialParameterTool{this, "InitialParameterTool", "TruthBasedInitialParameterTool"};
+// ToolHandle<SPSeedBasedInitialParameterTool> m_initialParameterTool{this, "InitialParameterTool", "SPSeedBasedInitialParameterTool"};
+ ToolHandle<SPSimpleInitialParameterTool> m_initialParameterTool{this, "InitialParameterTool", "SPSimpleInitialParameterTool"};
+ //ToolHandle<TruthBasedInitialParameterTool> m_initialParameterTool{this, "InitialParameterTool", "TruthBasedInitialParameterTool"};
ToolHandle<TrajectoryWriterTool> m_trajectoryWriterTool{this, "OutputTool", "TrajectoryWriterTool"};
SG::ReadCondHandleKey<FaserFieldCacheCondObj> m_fieldCondObjInputKey {this, "FaserFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"};
- SG::ReadHandleKey<SpacePointContainer> m_SpacePointContainerKey{this, "SpacePointsSCTName", "SCT_SpacePointContainer", "SCT space point container"};
+ SG::ReadHandleKey<FaserSCT_SpacePointContainer> m_SpacePointContainerKey{this, "SpacePointsSCTName", "SCT_SpacePointContainer", "SCT space point container"};
+ SG::ReadHandleKey<Tracker::FaserSCT_ClusterContainer> m_Sct_clcontainerKey{this, "SCT_ClusterContainer", "SCT_ClusterContainer"};
+ mutable int m_nevents;
+ mutable int m_ntracks;
+ mutable int m_nseeds;
+ mutable int m_nsp1;
+ mutable int m_nsp2;
+ mutable int m_nsp3;
+ mutable int m_nsp10;
+ mutable int m_nsp11;
+ mutable int m_ncom;
};
#endif // COMBINATORIALKALMANFILTERALG_H
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h
index fd7801c9eef4aa76b4f71215996983cc1a9efd5e..8e90ed858c09efc3d46985a7edb354ea2de6c280 100755
--- a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h
@@ -15,14 +15,15 @@
#include "StoreGate/StoreGateSvc.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "TrackerPrepRawData/FaserSCT_ClusterCollection.h"
-#include "TrkSpacePoint/SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerSpacePoint/SpacePointForSeedCollection.h"
#include "MagFieldConditions/FaserFieldCacheCondObj.h"
#include "MagFieldElements/FaserFieldCache.h"
#include "TrackerReadoutGeometry/SiDetectorElementCollection.h"
-#include "TrackerSpacePoint/SpacePointForSeedCollection.h"
#include "Identifier/Identifier.h"
#include "GeneratorObjects/McEventCollection.h"
#include "TrackerSimData/TrackerSimDataCollection.h"
+#include "TrkTrack/TrackCollection.h"
// ACTS
#include "Acts/MagneticField/ConstantBField.hpp"
@@ -103,6 +104,10 @@ public:
void fillFitResult(const Acts::GeometryContext& geoctx, const TrajectoryContainer& trajectories, const Acts::BoundTrackParameters& truthParam);
+ // Create a track from the fitter result
+ std::unique_ptr<Trk::Track> makeTrack(Acts::GeometryContext& tgContext, FitterResult& fitResult,const SpacePointForSeedCollection* seed_spcollection ) const;
+ const Trk::TrackParameters* ConvertActsTrackParameterToATLAS(const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext& gctx) const;
+
void clearTrackVariables();
private:
@@ -122,6 +127,8 @@ private:
SG::ReadHandleKey<TrackerSimDataCollection> m_sctMap {this, "TrackerSimDataCollection", "SCT_SDO_Map"};
const TrackerDD::SCT_DetectorManager* m_detManager{nullptr};
+ SG::WriteHandleKey<TrackCollection> m_trackCollection { this, "FaserActsCKFTrackCollection", "FaserActsCKFTrackCollection", "Output trackcollection name" };
+
ServiceHandle<ITHistSvc> m_thistSvc;
TTree *m_trackTree{nullptr};
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/SPSeedBasedInitialParameterTool.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/SPSeedBasedInitialParameterTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..678fef289c9f5b01a1e4a566a24ebee0353ba386
--- /dev/null
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/SPSeedBasedInitialParameterTool.h
@@ -0,0 +1,36 @@
+#ifndef SPSEEDBASEDINITIALPARAMETERTOOL_H
+#define SPSEEDBASEDINITIALPARAMETERTOOL_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "TrackerSeedFinder/TrackerSeedFinder.h"
+#include "TrackerSpacePoint/TrackerSeedCollection.h"
+#include "TrackerSpacePoint/TrackerSeed.h"
+
+class FaserSCT_ID;
+
+namespace Acts {
+ struct SinglyCharged;
+ template <typename charge_t> class SingleCurvilinearTrackParameters;
+ using CurvilinearTrackParameters =
+ SingleCurvilinearTrackParameters<SinglyCharged>;
+}
+
+
+class SPSeedBasedInitialParameterTool : public AthAlgTool {
+ public:
+ SPSeedBasedInitialParameterTool (const std::string& type,
+ const std::string& name, const IInterface* parent);
+ ~SPSeedBasedInitialParameterTool() = default;
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode finalize() override;
+
+ std::vector<Acts::CurvilinearTrackParameters> getInitialParameters() const;
+ //Acts::CurvilinearTrackParameters getInitialParameters(std::vector<Identifier> ids) const;
+
+ private:
+ const FaserSCT_ID* m_idHelper{nullptr};
+ SG::ReadHandleKey<Tracker::TrackerSeedCollection> m_trackerSeedContainerKey{this, "FaserTrackerSeedName", "FaserTrackerSeedCollection", "FaserTrackerSeedCollection"};
+};
+
+#endif // TRUTHBASEDINITIALPARAMETERTOOL_H
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/SPSimpleInitialParameterTool.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/SPSimpleInitialParameterTool.h
new file mode 100644
index 0000000000000000000000000000000000000000..9db75f35f692669dfd3739872697d9309a967228
--- /dev/null
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/SPSimpleInitialParameterTool.h
@@ -0,0 +1,37 @@
+#ifndef SPSIMPLEBASEDINITIALPARAMETERTOOL_H
+#define SPSIMPLEBASEDINITIALPARAMETERTOOL_H
+
+#include "AthenaBaseComps/AthAlgTool.h"
+#include "Acts/EventData/TrackParameters.hpp"
+#include "Acts/Definitions/Units.hpp"
+#include "Acts/Geometry/GeometryIdentifier.hpp"
+#include "Acts/Definitions/Algebra.hpp"
+
+class FaserSCT_ID;
+
+namespace Acts {
+ struct SinglyCharged;
+ template <typename charge_t> class SingleCurvilinearTrackParameters;
+ using CurvilinearTrackParameters =
+ SingleCurvilinearTrackParameters<SinglyCharged>;
+}
+
+
+class SPSimpleInitialParameterTool : public AthAlgTool {
+ public:
+ SPSimpleInitialParameterTool (const std::string& type,
+ const std::string& name, const IInterface* parent);
+ ~SPSimpleInitialParameterTool() = default;
+
+ virtual StatusCode initialize() override;
+ virtual StatusCode finalize() override;
+
+ Acts::CurvilinearTrackParameters getInitialParameters(Acts::Vector3 pos1, Acts::Vector3 pos2, Acts::Vector3 pos3) const;
+ Acts::CurvilinearTrackParameters getInitialParameters_2stations(Acts::Vector3 pos1, Acts::Vector3 pos2, Acts::Vector3 pos3) const;
+ std::vector<Acts::CurvilinearTrackParameters> getInitialParameters_1station(std::vector<Acts::Vector3> pos1, std::vector<Acts::Vector3> pos2, std::vector<Acts::Vector3> pos3) const;
+ //Acts::CurvilinearTrackParameters getInitialParameters(std::vector<Identifier> ids) const;
+
+ private:
+};
+
+#endif // TRUTHBASEDINITIALPARAMETERTOOL_H
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/TrajectoryWriterTool.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/TrajectoryWriterTool.h
index 2a3f348b0b467348eb9924c3e93b1c6482922bad..659cea7fa08321bb43a38fcc598a7054b119262c 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/TrajectoryWriterTool.h
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/TrajectoryWriterTool.h
@@ -3,6 +3,7 @@
#include "AthenaBaseComps/AthAlgTool.h"
#include "Acts/Geometry/GeometryContext.hpp"
+#include "Acts/TrackFinding/MeasurementSelector.hpp"
class TFile;
class TTree;
@@ -20,7 +21,7 @@ class TrajectoryWriterTool : public AthAlgTool {
virtual StatusCode finalize() override;
void writeout(TrajectoriesContainer trajectories,
- Acts::GeometryContext geoContext) const;
+ Acts::GeometryContext geoContext,std::vector<Acts::CurvilinearTrackParameters> traj ) const;
void clearVariables() const;
@@ -162,6 +163,27 @@ class TrajectoryWriterTool : public AthAlgTool {
mutable std::vector<float> m_pz_smt;
mutable std::vector<float> m_eta_smt;
mutable std::vector<float> m_pT_smt;
+
+ mutable std::vector<float> m_eLOC0_ini;
+ mutable std::vector<float> m_eLOC1_ini;
+ mutable std::vector<float> m_ePHI_ini;
+ mutable std::vector<float> m_eTHETA_ini;
+ mutable std::vector<float> m_eQOP_ini;
+ mutable std::vector<float> m_eT_ini;
+ mutable std::vector<float> m_err_eLOC0_ini;
+ mutable std::vector<float> m_err_eLOC1_ini;
+ mutable std::vector<float> m_err_ePHI_ini;
+ mutable std::vector<float> m_err_eTHETA_ini;
+ mutable std::vector<float> m_err_eQOP_ini;
+ mutable std::vector<float> m_err_eT_ini;
+ mutable std::vector<float> m_x_ini;
+ mutable std::vector<float> m_y_ini;
+ mutable std::vector<float> m_z_ini;
+ mutable std::vector<float> m_px_ini;
+ mutable std::vector<float> m_py_ini;
+ mutable std::vector<float> m_pz_ini;
+ mutable std::vector<float> m_eta_ini;
+ mutable std::vector<float> m_pT_ini;
};
#endif // TRAJECTORYWRITERTOOL_H
diff --git a/Tracking/Acts/FaserActsKalmanFilter/python/CombinatorialKalmanFilterConfig.py b/Tracking/Acts/FaserActsKalmanFilter/python/CombinatorialKalmanFilterConfig.py
index b4bef9af0883abd8219a5d908e3c39603674da55..46c01fd06268dddf34867f76d358e4ab10f961e3 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/python/CombinatorialKalmanFilterConfig.py
+++ b/Tracking/Acts/FaserActsKalmanFilter/python/CombinatorialKalmanFilterConfig.py
@@ -12,6 +12,26 @@ def CombinatorialKalmanFilter_OutputCfg(flags):
ostream.TakeItemsFromInput = True
return acc
+def CombinatorialKalmanFilter_OutputAODCfg(flags):
+ acc = ComponentAccumulator()
+ itemList = ["xAOD::EventInfo#*",
+ "xAOD::EventAuxInfo#*",
+ "FaserSCT_RDO_Container#*",
+ "xAOD::FaserTriggerData#*",
+ "xAOD::FaserTriggerDataAux#*",
+ "ScintWaveformContainer#*",
+ "TrackCollection#*",
+ "xAOD::WaveformHitContainer#*",
+ "xAOD::WaveformHitAuxContainer#*",
+ "xAOD::WaveformClock#*",
+ "xAOD::WaveformClockAuxInfo#*"
+ ]
+ acc.merge(OutputStreamCfg(flags, "AOD",itemList))
+ ostream = acc.getEventAlgo("OutputStreamAOD")
+ ostream.TakeItemsFromInput = True
+ return acc
+
+
def CombinatorialKalmanFilterCfg(flags, **kwargs):
acc = ComponentAccumulator()
@@ -19,4 +39,5 @@ def CombinatorialKalmanFilterCfg(flags, **kwargs):
combinatorialKalmanFilterAlg = CompFactory.CombinatorialKalmanFilterAlg(**kwargs)
acc.addEventAlgo(combinatorialKalmanFilterAlg)
acc.merge(CombinatorialKalmanFilter_OutputCfg(flags))
+ acc.merge(CombinatorialKalmanFilter_OutputAODCfg(flags))
return acc
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/CombinatorialKalmbanFilterAlg.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/CombinatorialKalmbanFilterAlg.cxx
index 564760f72f7e5a502d4e21f9474a1f00c9e52221..08e9f2b2283089fbcda678d65234c3cce03c3c7e 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/src/CombinatorialKalmbanFilterAlg.cxx
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/CombinatorialKalmbanFilterAlg.cxx
@@ -2,9 +2,13 @@
#include "StoreGate/ReadHandle.h"
#include "StoreGate/ReadCondHandleKey.h"
-#include "TrkSpacePoint/SpacePointCollection.h"
-#include "TrkSpacePoint/SpacePoint.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePointCollection.h"
+#include "TrackerSpacePoint/FaserSCT_SpacePoint.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
#include "TrkPrepRawData/PrepRawData.h"
+#include "TrackerPrepRawData/FaserSCT_Cluster.h"
+#include "TrackerRIO_OnTrack/FaserSCT_ClusterOnTrack.h"
+#include "TrkRIO_OnTrack/RIO_OnTrack.h"
#include "TrkSurfaces/Surface.h"
#include "Identifier/Identifier.h"
#include "Acts/Geometry/GeometryIdentifier.hpp"
@@ -28,48 +32,115 @@ CombinatorialKalmanFilterAlg::CombinatorialKalmanFilterAlg(
StatusCode CombinatorialKalmanFilterAlg::initialize() {
ATH_MSG_INFO("CombinatorialKalmanFilterAlg::initialize");
+ m_nevents=0;
+ m_ntracks=0;
+ m_nseeds=0;
+ m_nsp10=0;
+ m_nsp11=0;
+ m_ncom=0;
+ m_nsp1=0;
+ m_nsp2=0;
+ m_nsp3=0;
ATH_CHECK(m_trackingGeometryTool.retrieve());
ATH_CHECK(m_initialParameterTool.retrieve());
ATH_CHECK(m_trajectoryWriterTool.retrieve());
+ ATH_CHECK(detStore()->retrieve(m_idHelper,"FaserSCT_ID"));
ATH_CHECK( m_fieldCondObjInputKey.initialize() );
+ ATH_CHECK(m_trackCollection.initialize());
+
if (m_SpacePointContainerKey.key().empty()) {
ATH_MSG_FATAL("empty space point container key");
return StatusCode::FAILURE;
}
ATH_CHECK(m_SpacePointContainerKey.initialize());
+ ATH_CHECK(m_Sct_clcontainerKey.initialize() );
return StatusCode::SUCCESS;
}
StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const {
- ATH_MSG_INFO("CombinatorialKalmanFilterAlg::execute");
+ ATH_MSG_DEBUG("CombinatorialKalmanFilterAlg::execute");
+ m_nevents++;
- SG::ReadHandle<SpacePointContainer> spcontainer(m_SpacePointContainerKey, ctx);
+ SG::ReadHandle<FaserSCT_SpacePointContainer> spcontainer(m_SpacePointContainerKey, ctx);
if (!spcontainer.isValid()) {
ATH_MSG_FATAL( "Could not find the data object "<< spcontainer.name());
return StatusCode::FAILURE;
}
+ SG::ReadHandle<Tracker::FaserSCT_ClusterContainer> sct_clcontainer( m_Sct_clcontainerKey, ctx );
+if (!sct_clcontainer.isValid()){
+msg(MSG:: FATAL) << "Could not find the data object "<< sct_clcontainer.name() << " !" << endmsg;
+return StatusCode::RECOVERABLE;
+}
+
+
+ //make TrackCollection
+ SG::WriteHandle<TrackCollection> trackContainer{m_trackCollection,ctx};
+ std::unique_ptr<TrackCollection> outputTracks = std::make_unique<TrackCollection>();
const std::shared_ptr<IdentifierMap> identifierMap
= m_trackingGeometryTool->getIdentifierMap();
+ /*
// Create measurement and source link containers
IndexSourceLinkContainer sourceLinks;
MeasurementContainer measurements;
std::vector<Identifier> sp_ids;
+ std::vector<Tracker::FaserSCT_Cluster> sps;
+
+ std::vector<Acts::Vector3> pos1;
+ std::vector<Acts::Vector3> pos2;
+ std::vector<Acts::Vector3> pos3;
+ pos1.clear();pos2.clear();pos3.clear();
+ Tracker::FaserSCT_ClusterContainer::const_iterator coll_it = sct_clcontainer->begin();
+ Tracker::FaserSCT_ClusterContainer::const_iterator coll_itend = sct_clcontainer->end();
+ for (; coll_it != coll_itend; ++coll_it) {
+ const Tracker::FaserSCT_ClusterCollection* spcollection = *coll_it;
+ Tracker::FaserSCT_ClusterCollection::const_iterator sp_it = spcollection->begin();
+ Tracker::FaserSCT_ClusterCollection::const_iterator sp_end = spcollection->end();
+ for (; sp_it != sp_end; ++sp_it) {
+ const Tracker::FaserSCT_Cluster* sp = *sp_it;
+ Identifier id = sp->detectorElement()->identify();
+ //Identifier id = sp->associatedSurface().associatedDetectorElementIdentifier();
+ Acts::GeometryIdentifier geoId = identifierMap->at(id);
+ IndexSourceLink sourceLink(geoId, measurements.size());
+ sourceLinks.emplace_hint(sourceLinks.end(), std::move(sourceLink));
+ ThisMeasurement meas(sourceLink, indices, sp->localPosition(), sp->localCovariance());
+ //ThisMeasurement meas(sourceLink, indices, sp->localParameters(), sp->localCovariance());
+ measurements.emplace_back(std::move(meas));
- SpacePointContainer::const_iterator coll_it = spcontainer->begin();
- SpacePointContainer::const_iterator coll_itend = spcontainer->end();
+ if(m_idHelper->station(sp->identify())==1)pos1.push_back(Acts::Vector3(sp->globalPosition().x(),sp->globalPosition().y(),sp->globalPosition().z()));
+ if(m_idHelper->station(sp->identify())==2)pos2.push_back(Acts::Vector3(sp->globalPosition().x(),sp->globalPosition().y(),sp->globalPosition().z()));
+ if(m_idHelper->station(sp->identify())==3)pos3.push_back(Acts::Vector3(sp->globalPosition().x(),sp->globalPosition().y(),sp->globalPosition().z()));
+ sp_ids.push_back(sp->identify());
+ sps.push_back(*sp);
+ }
+ }
+*/
+ // Create measurement and source link containers
+ IndexSourceLinkContainer sourceLinks;
+ MeasurementContainer measurements;
+ std::vector<Identifier> sp_ids;
+ std::vector<Tracker::FaserSCT_SpacePoint> sps;
+
+ std::vector<Acts::Vector3> pos1;
+ std::vector<Acts::Vector3> pos2;
+ std::vector<Acts::Vector3> pos3;
+ pos1.clear();pos2.clear();pos3.clear();
+ std::vector<int> layer1;
+ layer1.clear();
+ FaserSCT_SpacePointContainer::const_iterator coll_it = spcontainer->begin();
+ FaserSCT_SpacePointContainer::const_iterator coll_itend = spcontainer->end();
for (; coll_it != coll_itend; ++coll_it) {
- const SpacePointCollection* spcollection = *coll_it;
- SpacePointCollection::const_iterator sp_it = spcollection->begin();
- SpacePointCollection::const_iterator sp_end = spcollection->end();
+ const FaserSCT_SpacePointCollection* spcollection = *coll_it;
+ FaserSCT_SpacePointCollection::const_iterator sp_it = spcollection->begin();
+ FaserSCT_SpacePointCollection::const_iterator sp_end = spcollection->end();
for (; sp_it != sp_end; ++sp_it) {
- const Trk::SpacePoint* sp = *sp_it;
+ const Tracker::FaserSCT_SpacePoint* sp = *sp_it;
Identifier id = sp->associatedSurface().associatedDetectorElementIdentifier();
Acts::GeometryIdentifier geoId = identifierMap->at(id);
IndexSourceLink sourceLink(geoId, measurements.size());
@@ -77,15 +148,90 @@ StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const
ThisMeasurement meas(sourceLink, indices, sp->localParameters(), sp->localCovariance());
measurements.emplace_back(std::move(meas));
+ if(m_idHelper->station(sp->clusterList().first->identify())==1){
+ pos1.push_back(Acts::Vector3(sp->globalPosition().x(),sp->globalPosition().y(),sp->globalPosition().z()));
+ layer1.push_back(m_idHelper->layer(sp->clusterList().first->identify()));
+ }
+ if(m_idHelper->station(sp->clusterList().first->identify())==2)pos2.push_back(Acts::Vector3(sp->globalPosition().x(),sp->globalPosition().y(),sp->globalPosition().z()));
+ if(m_idHelper->station(sp->clusterList().first->identify())==3)pos3.push_back(Acts::Vector3(sp->globalPosition().x(),sp->globalPosition().y(),sp->globalPosition().z()));
sp_ids.push_back(sp->clusterList().first->identify());
- }
- }
-
- // Get initial parameters
- // FIXME: Get initial parameters from clusterFitter or SeedFinder not MC!
- std::vector<Acts::CurvilinearTrackParameters> initialParameters;
- auto initialParameter = m_initialParameterTool->getInitialParameters(sp_ids);
- initialParameters.push_back(initialParameter);
+ sps.push_back(*sp);
+ }
+ }
+
+ // Get initial parameters
+ // FIXME: Get initial parameters from clusterFitter or SeedFinder not MC!
+ // std::vector<Acts::CurvilinearTrackParameters> initialParameters;
+ // auto initialParameter = m_initialParameterTool->getInitialParameters(sp_ids);
+ // initialParameters.push_back(initialParameter);
+ //std::cout<<"n spacepoints in stations : "<<pos1.size()<<" "<<pos2.size()<<" "<<pos3.size()<<std::endl;
+// if(pos1.size()<1||pos2.size()<1||pos3.size()<1) return StatusCode::SUCCESS;
+ std::vector<Acts::CurvilinearTrackParameters> initialParameters;
+ initialParameters.clear();
+ Acts::Vector3 pos1a(0,0,0);
+ Acts::Vector3 pos2a(0,0,0);
+ Acts::Vector3 pos3a(0,0,0);
+ for(long unsigned int i1=0;i1<pos1.size();i1++)pos1a+=pos1[i1];
+ for(long unsigned int i1=0;i1<pos2.size();i1++)pos2a+=pos2[i1];
+ for(long unsigned int i1=0;i1<pos3.size();i1++)pos3a+=pos3[i1];
+ pos1a/=pos1.size();
+ pos2a/=pos2.size();
+ pos3a/=pos3.size();
+ m_nsp1+=pos1.size();
+ m_nsp2+=pos2.size();
+ m_nsp3+=pos3.size();
+// for(int i1=0;i1<pos1.size();i1++){
+// for(int i2=0;i2<pos2.size();i2++){
+// for(int i3=0;i3<pos3.size();i3++){
+// auto initialParameter=m_initialParameterTool->getInitialParameters(pos1[i1],pos2[i2],pos3[i3]);
+// initialParameters.push_back(initialParameter);
+// }
+// }
+// }
+ /*
+ if(pos1.size()>0&&pos2.size()>0&&pos3.size()>0) {
+ auto initialParameter=m_initialParameterTool->getInitialParameters(pos1a,pos2a,pos3a);
+ if(initialParameter.momentum().z()>0){
+ m_nseeds++;
+ initialParameters.push_back(initialParameter);
+ */
+ // for one stations
+ if(pos1.size()>2) {
+ std::vector<Acts::Vector3> pos10;
+ std::vector<Acts::Vector3> pos11;
+ std::vector<Acts::Vector3> pos12;
+ pos10.clear();pos11.clear();pos12.clear();
+ for(std::size_t ipos=0;ipos<pos1.size();ipos++){
+ if(layer1[ipos]==0)pos10.push_back(pos1[ipos]);
+ if(layer1[ipos]==1)pos11.push_back(pos1[ipos]);
+ if(layer1[ipos]==2)pos12.push_back(pos1[ipos]);
+ }
+ if(pos10.size()>0&&pos11.size()>0&&pos12.size()>0){
+ auto initialParameter=m_initialParameterTool->getInitialParameters_1station(pos10,pos11,pos12);
+ initialParameters.insert(initialParameters.end(),initialParameter.begin(),initialParameter.end());
+ /*
+ //for two stations
+ if(pos1.size()>1&&pos2.size()>0) {
+ Acts::Vector3 pos10a(0,0,0);
+ Acts::Vector3 pos11a(0,0,0);
+ int n10a=0,n11a=0;
+ for(int ipos=0;ipos<pos1.size();ipos++){
+ if(layer1[ipos]==0){pos10a+=pos1[ipos];n10a++;}
+ if(layer1[ipos]>0){pos11a+=pos1[ipos];n11a++;}
+ }
+ m_nsp10+=n10a;
+ m_nsp11+=n11a;
+ if(n10a>0&&n11a>0){
+ m_ncom++;
+ pos10a/=n10a;
+ pos11a/=n11a;
+ Acts::Vector3 dir1=(pos11a-pos10a).normalized();
+ auto initialParameter=m_initialParameterTool->getInitialParameters_2stations(pos1a,pos2a,dir1);
+ if(initialParameter.momentum().z()>0){
+ m_nseeds++;
+ initialParameters.push_back(initialParameter);
+ }
+ */
// Prepare the output data with MultiTrajectory
TrajectoriesContainer trajectories;
@@ -97,6 +243,16 @@ StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const
Acts::PropagatorPlainOptions pOptions;
pOptions.maxSteps = 10000;
+ /*
+ Acts::DirectNavigator navigator;
+ std::unique_ptr<ActsExtrapolationDetail::VariantPropagator> varProp;
+ Acts::Vector3 constantFieldVector = Acts::Vector3(0,0,0.55);
+ auto bField = std::make_shared<Acts::ConstantBField>(constantFieldVector);
+ auto stepper = Acts::EigenStepper<>(std::move(bField));
+ auto propagator = Acts::Propagator<decltype(stepper), Acts::DirectNavigator>(std::move(stepper),
+ std::move(navigator));
+ varProp = std::make_unique<VariantPropagator>(propagator);
+ */
Acts::GeometryContext geoContext = m_trackingGeometryTool->getNominalGeometryContext().context();
Acts::MagneticFieldContext magFieldContext = getMagneticFieldContext(ctx);
@@ -114,6 +270,7 @@ StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const
geoContext, magFieldContext, calibContext,
IndexSourceLinkAccessor(), MeasurementCalibrator(measurements),
Acts::MeasurementSelector(measurementSelectorCfg),
+ //Acts::LoggerWrapper{*logger}, varProp, &(*pSurface));
Acts::LoggerWrapper{*logger}, pOptions, &(*pSurface));
std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry
@@ -133,6 +290,12 @@ StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const
if (result.ok()) {
// Get the track finding output object
const auto& trackFindingOutput = result.value();
+ std::unique_ptr<Trk::Track> track = makeTrack(geoContext, result,sps);
+ m_ntracks++;
+ if(track!=nullptr)
+ outputTracks->push_back(std::move(track));
+ else
+ ATH_MSG_DEBUG("No Trk::Track is created" );
// Create a Trajectories result struct
trajectories.emplace_back(std::move(trackFindingOutput.fittedStates),
std::move(trackFindingOutput.lastMeasurementIndices),
@@ -146,7 +309,16 @@ StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const
}
}
- m_trajectoryWriterTool->writeout(trajectories, geoContext);
+ m_trajectoryWriterTool->writeout(trajectories, geoContext,initialParameters);
+ }
+ }
+
+ if(outputTracks->size()>0)
+ ATH_MSG_DEBUG("Found "<<outputTracks->size()<<" tracks");
+ else
+ ATH_MSG_WARNING("No track is found");
+
+ ATH_CHECK(trackContainer.record(std::move(outputTracks)));
return StatusCode::SUCCESS;
}
@@ -154,6 +326,10 @@ StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const
StatusCode CombinatorialKalmanFilterAlg::finalize() {
ATH_MSG_INFO("CombinatorialKalmanFilterAlg::finalize");
+ ATH_MSG_INFO("Summary info");
+ ATH_MSG_INFO("In taotal, "<<m_nevents<<" events, and "<<m_nseeds<<" seeds, and "<<m_ntracks<<" tracks");
+ ATH_MSG_INFO("In taotal, "<<m_nsp1<<" , "<<m_nsp2<<" , "<<m_nsp3<<" ,"<<m_nsp10<<" , "<<m_nsp11<<" , "<<m_ncom);
+
return StatusCode::SUCCESS;
}
@@ -169,3 +345,177 @@ Acts::MagneticFieldContext CombinatorialKalmanFilterAlg::getMagneticFieldContext
return Acts::MagneticFieldContext(fieldCondObj);
}
+
+/*
+void CombinatorialKalmanFilterAlg::makeTrack(Acts::GeometryContext& tgContext, TrajectoryiesContainer trajectories,
+ const FaserSCT_SpacePointContainer* seed_spcollection, TrackCollection* outputTracks
+ ) const {
+ // Loop over the trajectories
+ int iTraj = 0;
+ for (const auto& traj : trajectories) {
+
+ // The trajectory entry indices and the multiTrajectory
+ const auto& [trackTips, mj] = traj.trajectory();
+ if (trackTips.empty()) {
+ ATH_MSG_WARNING("Empty multiTrajectory.");
+ continue;
+ }
+ // Get the entry index for the single trajectory
+ auto& trackTip = trackTips.front();
+ std::cout<<"trackTip = "<<trackTip<<std::endl;
+
+ // Collect the trajectory summary info
+ auto trajState =
+ Acts::MultiTrajectoryHelpers::trajectoryState(mj, trackTip);
+ if (traj.hasTrackParameters(trackTip))
+ {
+ 242 mj.visitBackwards(trackTip, [&](const auto &state) {
+ 243 /// Only fill the track states with non-outlier measurement
+ 244 auto typeFlags = state.typeFlags();
+ 245 if (not typeFlags.test(Acts::TrackStateFlag::MeasurementFlag))
+ 246 {
+ 247 return true;
+ 248 }
+ 252 /// Get the geometry ID
+ 253 auto geoID = state.referenceSurface().geometryId();
+ 254 m_volumeID.push_back(geoID.volume());
+ 255 m_layerID.push_back(geoID.layer());
+ 256 m_moduleID.push_back(geoID.sensitive());
+ 257
+ 258 // expand the local measurements into the full bound space
+ 259 Acts::BoundVector meas =
+ 260 state.projector().transpose() * state.calibrated();
+ 261
+ 262 // extract local and global position
+ 263 Acts::Vector2 local(meas[Acts::eBoundLoc0], meas[Acts::eBoundLoc1]);
+ 264 Acts::Vector3 mom(1, 1, 1);
+ Acts::Vector3 global =
+ 266 surface.localToGlobal(geoContext, local, mom);
+ jjjjj
+ }
+}
+
+*/
+std::unique_ptr<Trk::Track>
+//CombinatorialKalmanFilterAlg::makeTrack(Acts::GeometryContext& tgContext, FitterResult& fitResult, std::vector<Tracker::FaserSCT_Cluster> sps
+CombinatorialKalmanFilterAlg::makeTrack(Acts::GeometryContext& tgContext, FitterResult& fitResult, std::vector<Tracker::FaserSCT_SpacePoint> sps
+ ) const {
+ std::unique_ptr<Trk::Track> newtrack = nullptr;
+ //Get the fit output object
+ const auto& fitOutput = fitResult.value();
+// if (fitOutput.result)
+ if (fitOutput.fittedParameters.size()>0) {
+ DataVector<const Trk::TrackStateOnSurface>* finalTrajectory=new DataVector<const Trk::TrackStateOnSurface>{};
+ std::vector<std::unique_ptr<const Acts::BoundTrackParameters>> actsSmoothedParam;
+ ATH_MSG_DEBUG("makeTrack : trackTip "<<fitOutput.lastMeasurementIndices.size());
+ // Loop over all the output state to create track state
+ fitOutput.fittedStates.visitBackwards(fitOutput.lastMeasurementIndices.front(), [&](const auto &state) {
+ auto flag = state.typeFlags();
+ if (state.referenceSurface().associatedDetectorElement() != nullptr) {
+// const auto* actsElement = dynamic_cast<const FaserActsDetectorElement*>(state.referenceSurface().associatedDetectorElement());
+// if (actsElement != nullptr ){
+ // We need to determine the type of state
+ std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
+ const Trk::TrackParameters *parm;
+
+ // State is a hole (no associated measurement), use predicted para meters
+ if (flag[Acts::TrackStateFlag::HoleFlag] == true){
+ const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
+ state.predicted(),
+ state.predictedCovariance());
+ parm = ConvertActsTrackParameterToATLAS(actsParam, tgContext);
+ // auto boundaryCheck = m_boundaryCheckTool->boundaryCheck(*p arm);
+ typePattern.set(Trk::TrackStateOnSurface::Hole);
+ }
+ // The state was tagged as an outlier, use filtered parameters
+ else if (flag[Acts::TrackStateFlag::OutlierFlag] == true){
+ const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
+ state.filtered(),
+ state.filteredCovariance());
+ parm = ConvertActsTrackParameterToATLAS(actsParam, tgContext);
+ typePattern.set(Trk::TrackStateOnSurface::Outlier);
+ }
+ // The state is a measurement state, use smoothed parameters
+ else{
+ const Acts::BoundTrackParameters actsParam(state.referenceSurface().getSharedPtr(),
+ state.smoothed(),
+ state.smoothedCovariance());
+
+ actsSmoothedParam.push_back(std::make_unique<const Acts::BoundTrackParameters>(Acts::BoundTrackParameters(actsParam)));
+ // const auto& psurface=actsParam.referenceSurface();
+ // std::cout<<"position "<<psurface.center(tgContext)<<std::endl;
+ // std::cout<<"position "<<psurface.associatedDetectorElement()->thickness()<<std::endl;
+ // std::cout<<"geometry "<<psurface.geometryId().volume()<<" "<<psurface.geometryId().layer()<<" "<<psurface.geometryId().sensitive()<<std::endl;
+ Acts::Vector2 local(actsParam.parameters()[Acts::eBoundLoc0], actsParam.parameters()[Acts::eBoundLoc1]);
+// const Acts::Vector3 dir = Acts::makeDirectionUnitFromPhiTheta(actsParam.parameters()[Acts::eBoundPhi], actsParam.parameters()[Acts::eBoundTheta]);
+// auto pos=actsParam.position(tgContext);
+
+ parm = ConvertActsTrackParameterToATLAS(actsParam, tgContext);
+ typePattern.set(Trk::TrackStateOnSurface::Measurement);
+ }
+
+ Tracker::FaserSCT_ClusterOnTrack* measState = nullptr;
+ if (state.hasUncalibrated()){
+ auto sp= sps.at(state.uncalibrated().index());
+ //const Tracker::FaserSCT_Cluster* fitCluster=&sp;
+ const Tracker::FaserSCT_Cluster* fitCluster=sp.clusterList().first;
+ if(fitCluster !=nullptr){
+ measState = new Tracker::FaserSCT_ClusterOnTrack{ fitCluster, Trk::LocalParameters { Trk::DefinedParameter { fitCluster->localPosition()[0], Trk::loc1 }, Trk::DefinedParameter { fitCluster->localPosition()[1], Trk::loc2 } }, fitCluster->localCovariance(), m_idHelper->wafer_hash(fitCluster->detectorElement()->identify())};
+ }
+ }
+ double nDoF = state.calibratedSize();
+ const Trk::FitQualityOnSurface *quality = new Trk::FitQualityOnSurface(state.chi2(), nDoF);
+ const Trk::TrackStateOnSurface *perState = new Trk::TrackStateOnSurface(measState, parm, quality, nullptr, typePattern);
+ // If a state was succesfully created add it to the trajectory
+ if (perState) {
+ finalTrajectory->insert(finalTrajectory->begin(), perState);
+
+ }
+ // }
+ }
+ return;
+ });
+/*
+ // Convert the perigee state and add it to the trajectory
+ const Acts::BoundTrackParameters actsPer = fitOutput.fittedParameters.value();
+ const Trk::TrackParameters *per = ConvertActsTrackParameterToATLAS(actsPer, tgContext);
+ std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
+ typePattern.set(Trk::TrackStateOnSurface::Perigee);
+ const Trk::TrackStateOnSurface *perState = new Trk::TrackStateOnSurface(nullptr, per, nullptr, nullptr, typePattern);
+ if (perState) finalTrajectory->insert(finalTrajectory->begin(), perState);
+ */
+
+ // Create the track using the states
+ const Trk::TrackInfo newInfo(Trk::TrackInfo::TrackFitter::KalmanFitter, Trk::ParticleHypothesis::muon);
+// Trk::FitQuality* q = nullptr;
+ // newInfo.setTrackFitter(Trk::TrackInfo::TrackFitter::KalmanFitter ); //Mark the fitter as KalmanFitter
+ newtrack = std::make_unique<Trk::Track>(newInfo, std::move(*finalTrajectory), nullptr);
+ }
+ return newtrack;
+}
+
+const Trk::TrackParameters*
+CombinatorialKalmanFilterAlg ::ConvertActsTrackParameterToATLAS(const Acts::BoundTrackParameters &actsParameter, const Acts::GeometryContext& gctx) const {
+ using namespace Acts::UnitLiterals;
+ std::optional<AmgSymMatrix(5)> cov = std::nullopt;
+ if (actsParameter.covariance()){
+ AmgSymMatrix(5) newcov(actsParameter.covariance()->topLeftCorner<5, 5> (0, 0));
+ // Convert the covariance matrix to GeV
+ for(int i=0; i < newcov.rows(); i++){
+ newcov(i, 4) = newcov(i, 4)*1_MeV;
+ }
+ for(int i=0; i < newcov.cols(); i++){
+ newcov(4, i) = newcov(4, i)*1_MeV;
+ }
+ cov = std::optional<AmgSymMatrix(5)>(newcov);
+ }
+ const Amg::Vector3D& pos=actsParameter.position(gctx);
+ double tphi=actsParameter.get<Acts::eBoundPhi>();
+ double ttheta=actsParameter.get<Acts::eBoundTheta>();
+ double tqOverP=actsParameter.get<Acts::eBoundQOverP>()*1_MeV;
+ double p = std::abs(1. / tqOverP);
+ Amg::Vector3D tmom(p * std::cos(tphi) * std::sin(ttheta), p * std::sin(tphi) * std::sin(ttheta), p * std::cos(ttheta));
+ const Trk::CurvilinearParameters * curv = new Trk::CurvilinearParameters(pos,tmom,tqOverP>0, cov);
+ return curv;
+}
+
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/FaserActsKalmanFilterAlg.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/FaserActsKalmanFilterAlg.cxx
index 9d11c2f800b559ebb694765e7286cea85d62ee8d..c9427a0f8f9940f6d181e4f4775bcb9a8e2ae527 100755
--- a/Tracking/Acts/FaserActsKalmanFilter/src/FaserActsKalmanFilterAlg.cxx
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/FaserActsKalmanFilterAlg.cxx
@@ -265,7 +265,7 @@ StatusCode FaserActsKalmanFilterAlg::execute()
SpacePointForSeedCollection::const_iterator it = seed_spcollection->begin();
SpacePointForSeedCollection::const_iterator itend = seed_spcollection->end();
for (; it != itend; ++it){
- const Trk::SpacePoint *sp = (&(**it))->SpacePoint();
+ const Tracker::FaserSCT_SpacePoint *sp = (&(**it))->SpacePoint();
const Identifier id = sp->clusterList().first->identify();
const TrackerDD::SiDetectorElement* siSpElement = m_detManager->getDetectorElement(id);
@@ -453,8 +453,8 @@ StatusCode FaserActsKalmanFilterAlg::execute()
std::shared_ptr<const Acts::Surface> initSurface = Acts::Surface::makeShared<Acts::PlaneSurface>(center, normal);
// extrapolate the particle from production point to the first layer
const Acts::Vector4 truthPosTime (pPos.x(), pPos.y(), pPos.z(), time);
- const Acts::Vector3 truthMomentum_dir = pMom.normalized();
- double truthMomentum_abs = pMom.norm();
+// const Acts::Vector3 truthMomentum_dir = pMom.normalized();
+// double truthMomentum_abs = pMom.norm();
BoundVector params = BoundVector::Zero();
params[Acts::eBoundLoc0] = pPos.x();
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/SPSeedBasedInitialParameterTool.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/SPSeedBasedInitialParameterTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f29ce6e80e65a9ca759f931174318fd1c1a68b68
--- /dev/null
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/SPSeedBasedInitialParameterTool.cxx
@@ -0,0 +1,123 @@
+#include "FaserActsKalmanFilter/SPSeedBasedInitialParameterTool.h"
+
+#include "StoreGate/ReadHandle.h"
+#include "HepMC/GenVertex.h"
+#include "Acts/EventData/TrackParameters.hpp"
+#include "Acts/Definitions/Units.hpp"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include <random>
+#include <cmath>
+
+
+using namespace Acts::UnitLiterals;
+
+SPSeedBasedInitialParameterTool::SPSeedBasedInitialParameterTool(
+ const std::string& type, const std::string& name, const IInterface* parent) :
+ AthAlgTool(type, name, parent) {}
+
+
+ StatusCode SPSeedBasedInitialParameterTool::initialize() {
+ ATH_MSG_INFO("SPSeedBasedInitialParameterTool::initialize");
+ ATH_CHECK(m_trackerSeedContainerKey.initialize());
+ ATH_CHECK(detStore()->retrieve(m_idHelper,"FaserSCT_ID"));
+ return StatusCode::SUCCESS;
+ }
+
+
+StatusCode SPSeedBasedInitialParameterTool::finalize() {
+ ATH_MSG_INFO("SPSeedBasedInitialParameterTool::finalize");
+ return StatusCode::SUCCESS;
+}
+
+
+std::vector<Acts::CurvilinearTrackParameters> SPSeedBasedInitialParameterTool::getInitialParameters() const {
+ std::vector<Acts::CurvilinearTrackParameters> initialParameters;
+ initialParameters.clear();
+ SG::ReadHandle<Tracker::TrackerSeedCollection> trackerSeedCollection(m_trackerSeedContainerKey);
+ if (!trackerSeedCollection.isValid()){
+ msg(MSG::FATAL) << "Could not find the data object "<< trackerSeedCollection.name() << " !" << endmsg;
+ return initialParameters;
+ }
+ // msg(MSG::INFO) << "found "<< trackerSeedCollection.size()<< " seeds" << endmsg;
+
+ double charge = 1;
+ double B = 0.55;
+
+ Tracker::TrackerSeedCollection::const_iterator it = trackerSeedCollection->begin();
+ Tracker::TrackerSeedCollection::const_iterator itend = trackerSeedCollection->end();
+ for (; it != itend; ++it){
+ const Tracker::TrackerSeed *colNext=&(**it);
+ auto sps=colNext->getSpacePoints();
+ msg(MSG::DEBUG) << "found "<< sps.size()<< "spacepoints in the seed" << endmsg;
+
+ Acts::Vector3 pos1_0(0., 0., 0.);
+ Acts::Vector3 pos1_1(0., 0., 0.);
+ Acts::Vector3 pos1_2(0., 0., 0.);
+ Acts::Vector3 pos2_0(0., 0., 0.);
+ Acts::Vector3 pos2_1(0., 0., 0.);
+ Acts::Vector3 pos2_2(0., 0., 0.);
+ for(auto isp : sps){
+ //get the cluster ID
+ const Identifier id = isp->clusterList().first->identify();
+ Amg::Vector3D gloPos=isp->globalPosition();
+ int station = m_idHelper->station(id);
+ int plane = m_idHelper->layer(id);
+ if (station==1 && plane==0) pos1_0 = Acts::Vector3(gloPos.x(), gloPos.y(), gloPos.z());
+ if (station==1 && plane==1) pos1_1 = Acts::Vector3(gloPos.x(), gloPos.y(), gloPos.z());
+ if (station==1 && plane==2) pos1_2 = Acts::Vector3(gloPos.x(), gloPos.y(), gloPos.z());
+ if (station==2 && plane==0) pos2_0 = Acts::Vector3(gloPos.x(), gloPos.y(), gloPos.z());
+ if (station==2 && plane==1) pos2_1 = Acts::Vector3(gloPos.x(), gloPos.y(), gloPos.z());
+ if (station==2 && plane==2) pos2_2 = Acts::Vector3(gloPos.x(), gloPos.y(), gloPos.z());
+ }
+ if((pos1_0.z()==0)||(pos1_1.z()==0)||(pos1_2.z()==0)||(pos2_0.z()==0)||(pos2_1.z()==0)||(pos2_2.z()==0)){
+ msg(MSG::WARNING) << "failed to find 2 triplets "<< endmsg;
+ continue;
+ }
+
+ //const Acts::Vector3 pos = pos1_0;
+ const Acts::Vector3 pos(pos1_0.x(), pos1_0.y(), pos1_0.z());
+ Acts::Vector3 d1 = pos1_2 - pos1_0;
+ Acts::Vector3 d2 = pos2_2 - pos2_0;
+ // the direction of momentum in the first station
+ Acts::Vector3 direct1 = d1.normalized();
+ // the direction of momentum in the second station
+ Acts::Vector3 direct2 = d2.normalized();
+ // the vector pointing from the center of circle to the particle at la yer 2 in Y-Z plane
+ double R1_z = charge * direct1.y() / std::sqrt(direct1.y()*direct1.y() + direct1.z()*direct1.z());
+ // double R1_y = -charge * direct1.z() / std::sqrt(direct1.y()*direct1 .y() + direct1.z()*direct1.z());
+ double R2_z = charge * direct2.y() / std::sqrt(direct2.y()*direct2.y() + direct2.z()*direct2.z());
+ double R = (pos2_0.z() - pos1_2.z()) / (R2_z - R1_z);
+ // the norm of momentum in Y-Z plane
+ double p_yz = 0.3*B*R / 1000.0; // R(mm), p(GeV), B(T)
+ double p_z = p_yz * direct1.z() / std::sqrt(direct1.y()*direct1.y() + direct1.z()*direct1.z());
+ double p_y = p_yz * direct1.y() / std::sqrt(direct1.y()*direct1.y() + direct1.z()*direct1.z());
+ double p_x = direct1.x() * p_z / direct1.z();
+ // total momentum at the layer 0
+ const Acts::Vector3 mom(p_x, p_y, p_z);
+ double p = mom.norm();
+ msg(MSG::DEBUG)<<"!!!!!!!!!!! InitTrack momentum on layer 0: ( "<<mom.x()*1000<<", "<<mom.y()*1000<<", "<<mom.z()*1000<<", "<<p*1000<<") "<<endmsg;
+ // build the track covariance matrix using the smearing sigmas
+ double sigmaU = 200_um;
+ double sigmaV = 200_um;
+ double sigmaPhi = 1_degree;
+ double sigmaTheta = 1_degree;
+ double sigmaQOverP = 0.01*p / (p*p);
+ double sigmaT0 = 1_ns;
+ Acts::BoundSymMatrix cov = Acts::BoundSymMatrix::Zero();
+ cov(Acts::eBoundLoc0, Acts::eBoundLoc0) = sigmaU * sigmaU;
+ cov(Acts::eBoundLoc1, Acts::eBoundLoc1) = sigmaV * sigmaV;
+ cov(Acts::eBoundPhi, Acts::eBoundPhi) = sigmaPhi * sigmaPhi;
+ cov(Acts::eBoundTheta, Acts::eBoundTheta) = sigmaTheta * sigmaTheta;
+ cov(Acts::eBoundQOverP, Acts::eBoundQOverP) = sigmaQOverP * sigmaQOverP;
+ cov(Acts::eBoundTime, Acts::eBoundTime) = sigmaT0 * sigmaT0;
+ double time =0;
+ const Acts::Vector4 postime(pos.x(), pos.y(), pos.z(),time);
+ Acts::CurvilinearTrackParameters InitTrackParam(postime, mom.normalized(), mom.norm(), charge, std::make_optional(std::move(cov)));
+
+ // Acts::CurvilinearTrackParameters InitTrackParam(std::make_optional(std::move(cov)), pos, mom, charge, time); // calculated initial parameters
+ initialParameters.push_back(InitTrackParam);
+ }
+
+
+ return initialParameters;
+}
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/SPSimpleInitialParameterTool.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/SPSimpleInitialParameterTool.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..f3d227dcb6e81085b28a12d6e68a5161d171dba3
--- /dev/null
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/SPSimpleInitialParameterTool.cxx
@@ -0,0 +1,169 @@
+#include "FaserActsKalmanFilter/SPSimpleInitialParameterTool.h"
+
+#include "StoreGate/ReadHandle.h"
+#include "HepMC/GenVertex.h"
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include <random>
+#include <cmath>
+
+
+using namespace Acts::UnitLiterals;
+
+SPSimpleInitialParameterTool::SPSimpleInitialParameterTool(
+ const std::string& type, const std::string& name, const IInterface* parent) :
+ AthAlgTool(type, name, parent) {}
+
+
+ StatusCode SPSimpleInitialParameterTool::initialize() {
+ ATH_MSG_INFO("SPSimpleInitialParameterTool::initialize");
+ return StatusCode::SUCCESS;
+ }
+
+
+StatusCode SPSimpleInitialParameterTool::finalize() {
+ ATH_MSG_INFO("SPSimpleInitialParameterTool::finalize");
+ return StatusCode::SUCCESS;
+}
+
+
+Acts::CurvilinearTrackParameters SPSimpleInitialParameterTool::getInitialParameters(Acts::Vector3 pos1, Acts::Vector3 pos2, Acts::Vector3 pos3) const {
+
+ double charge = pos1.y()+pos3.y()>2.*pos2.y()?1:-1;
+ double B = 0.55;
+
+ Acts::Vector3 amc=pos3-pos1;
+ Acts::Vector3 amb=pos2-pos1;
+ Acts::Vector3 bmc=pos3-pos2;
+ Acts::Vector3 apc=(pos3+pos1)/2.;
+ double tmpa=sqrt(amc.y()*amc.y()+amc.z()*amc.z())/2.;
+ double tmpb=sqrt((pos2.y()-apc.y())*(pos2.y()-apc.y())+(pos2.z()-apc.z())*(pos2.z()-apc.z()));
+ double R=(tmpa*tmpa+tmpb*tmpb)/2./tmpb;
+ double p_yz = 0.3*B*R / 1000.0; // R(mm), p(GeV), B(T)
+
+ Acts::Vector3 d1=amc.normalized()+amb.normalized()-bmc.normalized();
+ Acts::Vector3 d2=(pos3+pos2)/2.-pos1;
+ double p_z=p_yz*d1.z()/sqrt(d1.z()*d1.z()+d1.y()*d1.y());
+ double p_y=p_z*d1.y()/d1.z();
+ double p_x=p_z*d2.x()/d2.z();
+
+ const Acts::Vector3 mom(p_x, p_y, p_z);
+ double p = mom.norm();
+ msg(MSG::DEBUG)<<"!!!!!!!!!!! InitTrack momentum on layer 0: ( "<<mom.x()*1000<<", "<<mom.y()*1000<<", "<<mom.z()*1000<<", "<<p*1000<<") "<<endmsg;
+ // build the track covariance matrix using the smearing sigmas
+ double sigmaU = 10000_um;
+ double sigmaV = 10000_um;
+ double sigmaPhi = 20_degree;
+ double sigmaTheta = 10_degree;
+ double sigmaQOverP = 10.00*p / (p*p);
+ //double sigmaQOverP = 0.02*p / (p*p);
+ double sigmaT0 = 1_ns;
+ Acts::BoundSymMatrix cov = Acts::BoundSymMatrix::Zero();
+ cov(Acts::eBoundLoc0, Acts::eBoundLoc0) = sigmaU * sigmaU;
+ cov(Acts::eBoundLoc1, Acts::eBoundLoc1) = sigmaV * sigmaV;
+ cov(Acts::eBoundPhi, Acts::eBoundPhi) = sigmaPhi * sigmaPhi;
+ cov(Acts::eBoundTheta, Acts::eBoundTheta) = sigmaTheta * sigmaTheta;
+ cov(Acts::eBoundQOverP, Acts::eBoundQOverP) = sigmaQOverP * sigmaQOverP;
+ cov(Acts::eBoundTime, Acts::eBoundTime) = sigmaT0 * sigmaT0;
+ double time =0;
+ const Acts::Vector4 postime(pos1.x(), pos1.y(), pos1.z(),time);
+ Acts::CurvilinearTrackParameters InitTrackParam(postime, mom.normalized(), mom.norm(), charge, std::make_optional(std::move(cov)));
+
+ return InitTrackParam;
+}
+
+Acts::CurvilinearTrackParameters SPSimpleInitialParameterTool::getInitialParameters_2stations(Acts::Vector3 pos1, Acts::Vector3 pos2, Acts::Vector3 dir1) const {
+
+ Acts::Vector3 dir2=(pos2-pos1).normalized();
+ dir1*=1./sqrt(dir1.y()*dir1.y()+dir1.z()*dir1.z());
+ dir2*=1./sqrt(dir2.y()*dir2.y()+dir2.z()*dir2.z());
+ Acts::Vector3 dir1p2=(dir1+dir2)/2.;
+ Acts::Vector3 dir1m2=(dir1-dir2)/2.;
+ double charge = dir2.y()>dir1.y()?1:-1;
+ double B = 0.55;
+ double st=2.*sqrt(dir1p2.y()*dir1p2.y()+dir1p2.z()*dir1p2.z())*sqrt(dir1m2.y()*dir1m2.y()+dir1m2.z()*dir1m2.z());
+ dir2=(pos2-pos1)/2.;
+ double R=sqrt(dir2.y()*dir2.y()+dir2.z()*dir2.z())/st;
+
+ double p_yz = 0.3*B*R / 1000.0; // R(mm), p(GeV), B(T)
+ double p_z=p_yz*dir1.z()/sqrt(dir1.y()*dir1.y()+dir1.z()*dir1.z());
+ double p_y=p_z*dir1.y()/dir1.z();
+ double p_x=p_z*dir1.x()/dir1.z();
+
+
+ const Acts::Vector3 mom(p_x, p_y, p_z);
+ double p = mom.norm();
+ msg(MSG::DEBUG)<<"!!!!!!!!!!! InitTrack momentum on layer 0: ( "<<mom.x()*1000<<", "<<mom.y()*1000<<", "<<mom.z()*1000<<", "<<p*1000<<") "<<st<<" "<<charge<<endmsg;
+ // build the track covariance matrix using the smearing sigmas
+ double sigmaU = 1000_um;
+ double sigmaV = 1000_um;
+ double sigmaPhi = 10_degree;
+ double sigmaTheta = 2_degree;
+ double sigmaQOverP = 0.20*p / (p*p);
+ //double sigmaQOverP = 0.02*p / (p*p);
+ double sigmaT0 = 1_ns;
+ Acts::BoundSymMatrix cov = Acts::BoundSymMatrix::Zero();
+ cov(Acts::eBoundLoc0, Acts::eBoundLoc0) = sigmaU * sigmaU;
+ cov(Acts::eBoundLoc1, Acts::eBoundLoc1) = sigmaV * sigmaV;
+ cov(Acts::eBoundPhi, Acts::eBoundPhi) = sigmaPhi * sigmaPhi;
+ cov(Acts::eBoundTheta, Acts::eBoundTheta) = sigmaTheta * sigmaTheta;
+ cov(Acts::eBoundQOverP, Acts::eBoundQOverP) = sigmaQOverP * sigmaQOverP;
+ cov(Acts::eBoundTime, Acts::eBoundTime) = sigmaT0 * sigmaT0;
+ double time =0;
+ const Acts::Vector4 postime(pos1.x(), pos1.y(), pos1.z(),time);
+ Acts::CurvilinearTrackParameters InitTrackParam(postime, mom.normalized(), mom.norm(), charge, std::make_optional(std::move(cov)));
+
+ return InitTrackParam;
+}
+
+std::vector<Acts::CurvilinearTrackParameters> SPSimpleInitialParameterTool::getInitialParameters_1station(std::vector<Acts::Vector3> pos1, std::vector<Acts::Vector3> pos2, std::vector<Acts::Vector3> pos3) const {
+ std::vector<Acts::CurvilinearTrackParameters> InitTrackParams;
+ InitTrackParams.clear();
+
+ for(std::size_t i1=0;i1<pos1.size();i1++){
+ for(std::size_t i2=0;i2<pos2.size();i2++){
+ for(std::size_t i3=0;i3<pos3.size();i3++){
+ if(fabs(pos3[i3].y()-pos2[i2].y())>1.5*fabs(pos2[i2].y()-pos1[i1].y()))continue;
+ if(fabs(pos3[i3].x()-pos2[i2].x())>1.5*fabs(pos2[i2].x()-pos1[i1].x()))continue;
+ Acts::Vector3 pstart=pos1[i1];
+ Acts::Vector3 pend=(pos2[i2]+pos3[i3])/2.;
+ Acts::Vector3 dir=pend-pstart;
+
+ double charge = 1;
+ // double B = 0.55;
+
+ double p_yz = 100.;
+ //double p_yz = 0.3*B*R / 1000.0; // R(mm), p(GeV), B(T)
+ double p_z=p_yz*dir.y()/sqrt(dir.y()*dir.y()+dir.z()*dir.z());
+ if(p_z<0)continue;
+ double p_y=p_z*dir.y()/dir.z();
+ double p_x=p_z*dir.x()/dir.z();
+
+
+ const Acts::Vector3 mom(p_x, p_y, p_z);
+ double p = mom.norm();
+ msg(MSG::DEBUG)<<"!!!!!!!!!!! InitTrack momentum on layer 0: ( "<<mom.x()*1000<<", "<<mom.y()*1000<<", "<<mom.z()*1000<<", "<<p*1000<<") "<<endmsg;
+ // build the track covariance matrix using the smearing sigmas
+ double sigmaU = 2000_um;
+ double sigmaV = 2000_um;
+ double sigmaPhi = 30_degree;
+ double sigmaTheta = 10_degree;
+ double sigmaQOverP = 1.20*p / (p*p);
+ //double sigmaQOverP = 0.02*p / (p*p);
+ double sigmaT0 = 1_ns;
+ Acts::BoundSymMatrix cov = Acts::BoundSymMatrix::Zero();
+ cov(Acts::eBoundLoc0, Acts::eBoundLoc0) = sigmaU * sigmaU;
+ cov(Acts::eBoundLoc1, Acts::eBoundLoc1) = sigmaV * sigmaV;
+ cov(Acts::eBoundPhi, Acts::eBoundPhi) = sigmaPhi * sigmaPhi;
+ cov(Acts::eBoundTheta, Acts::eBoundTheta) = sigmaTheta * sigmaTheta;
+ cov(Acts::eBoundQOverP, Acts::eBoundQOverP) = sigmaQOverP * sigmaQOverP;
+ cov(Acts::eBoundTime, Acts::eBoundTime) = sigmaT0 * sigmaT0;
+ double time =0;
+ const Acts::Vector4 postime(pstart.x(), pstart.y(), pstart.z(),time);
+ Acts::CurvilinearTrackParameters InitTrackParam(postime, mom.normalized(), mom.norm(), charge, std::make_optional(std::move(cov)));
+ InitTrackParams.push_back(InitTrackParam);
+ }
+ }
+ }
+
+ return InitTrackParams;
+}
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/TrajectoryWriterTool.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/TrajectoryWriterTool.cxx
index 5eaf25b910681d92dd53a31975c6f451037f13cc..f742348b0197db4f89a164acee6067aecf9dfe07 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/src/TrajectoryWriterTool.cxx
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/TrajectoryWriterTool.cxx
@@ -162,11 +162,31 @@ void TrajectoryWriterTool::initializeTree() {
m_tree->Branch("pz_smt", &m_pz_smt);
m_tree->Branch("eta_smt", &m_eta_smt);
m_tree->Branch("pT_smt", &m_pT_smt);
+ m_tree->Branch("eLOC0_ini", &m_eLOC0_ini);
+ m_tree->Branch("eLOC1_ini", &m_eLOC1_ini);
+ m_tree->Branch("ePHI_ini", &m_ePHI_ini);
+ m_tree->Branch("eTHETA_ini", &m_eTHETA_ini);
+ m_tree->Branch("eQOP_ini", &m_eQOP_ini);
+ m_tree->Branch("eT_ini", &m_eT_ini);
+ m_tree->Branch("err_eLOC0_ini", &m_err_eLOC0_ini);
+ m_tree->Branch("err_eLOC1_ini", &m_err_eLOC1_ini);
+ m_tree->Branch("err_ePHI_ini", &m_err_ePHI_ini);
+ m_tree->Branch("err_eTHETA_ini", &m_err_eTHETA_ini);
+ m_tree->Branch("err_eQOP_ini", &m_err_eQOP_ini);
+ m_tree->Branch("err_eT_ini", &m_err_eT_ini);
+ m_tree->Branch("g_x_ini", &m_x_ini);
+ m_tree->Branch("g_y_ini", &m_y_ini);
+ m_tree->Branch("g_z_ini", &m_z_ini);
+ m_tree->Branch("px_ini", &m_px_ini);
+ m_tree->Branch("py_ini", &m_py_ini);
+ m_tree->Branch("pz_ini", &m_pz_ini);
+ m_tree->Branch("eta_ini", &m_eta_ini);
+ m_tree->Branch("pT_ini", &m_pT_ini);
}
void TrajectoryWriterTool::writeout(TrajectoriesContainer trajectories,
- Acts::GeometryContext geoContext) const {
+ Acts::GeometryContext geoContext,std::vector<Acts::CurvilinearTrackParameters> initialparameters) const {
m_eventNumber = Gaudi::Hive::currentContext().eventID().event_number();
@@ -176,10 +196,42 @@ void TrajectoryWriterTool::writeout(TrajectoriesContainer trajectories,
for (const auto& traj : trajectories) {
m_trajNumber = iTraj;
+ //initial paramter
+ m_eLOC0_ini.push_back(initialparameters[iTraj].parameters()[Acts::eBoundLoc0]);
+ m_eLOC1_ini.push_back(initialparameters[iTraj].parameters()[Acts::eBoundLoc1]);
+ m_ePHI_ini.push_back(initialparameters[iTraj].parameters()[Acts::eBoundPhi]);
+ m_eTHETA_ini.push_back(initialparameters[iTraj].parameters()[Acts::eBoundTheta]);
+ m_eQOP_ini.push_back(initialparameters[iTraj].parameters()[Acts::eBoundQOverP]);
+ m_eT_ini.push_back(initialparameters[iTraj].parameters()[Acts::eBoundTime]);
+
+ /// Smoothed parameter uncertainties
+ const auto &covariance_ini = *(initialparameters[iTraj]).covariance();
+ m_err_eLOC0_ini.push_back(
+ sqrt(covariance_ini(Acts::eBoundLoc0, Acts::eBoundLoc0)));
+ m_err_eLOC1_ini.push_back(
+ sqrt(covariance_ini(Acts::eBoundLoc1, Acts::eBoundLoc1)));
+ m_err_ePHI_ini.push_back(
+ sqrt(covariance_ini(Acts::eBoundPhi, Acts::eBoundPhi)));
+ m_err_eTHETA_ini.push_back(
+ sqrt(covariance_ini(Acts::eBoundTheta, Acts::eBoundTheta)));
+ m_err_eQOP_ini.push_back(
+ sqrt(covariance_ini(Acts::eBoundQOverP, Acts::eBoundQOverP)));
+ m_err_eT_ini.push_back(
+ sqrt(covariance_ini(Acts::eBoundTime, Acts::eBoundTime)));
+ m_x_ini.push_back(initialparameters[iTraj].position(geoContext).x());
+ m_y_ini.push_back(initialparameters[iTraj].position(geoContext).y());
+ m_z_ini.push_back(initialparameters[iTraj].position(geoContext).z());
+ m_px_ini.push_back(initialparameters[iTraj].momentum().x());
+ m_py_ini.push_back(initialparameters[iTraj].momentum().y());
+ m_pz_ini.push_back(initialparameters[iTraj].momentum().z());
+ m_pT_ini.push_back(initialparameters[iTraj].transverseMomentum());
+ m_eta_ini.push_back(eta(initialparameters[iTraj].position(geoContext)));
+
// The trajectory entry indices and the multiTrajectory
const auto& [trackTips, mj] = traj.trajectory();
if (trackTips.empty()) {
ATH_MSG_WARNING("Empty multiTrajectory.");
+ m_nMeasurements = -1;
continue;
}
@@ -192,6 +244,7 @@ void TrajectoryWriterTool::writeout(TrajectoriesContainer trajectories,
Acts::MultiTrajectoryHelpers::trajectoryState(mj, trackTip);
m_nMeasurements = trajState.nMeasurements;
+// if(m_nMeasurements<2)continue;
m_nStates = trajState.nStates;
m_nOutliers = trajState.nOutliers;
m_nHoles = trajState.nHoles;
@@ -258,12 +311,17 @@ void TrajectoryWriterTool::writeout(TrajectoriesContainer trajectories,
// expand the local measurements into the full bound space
Acts::BoundVector meas =
state.projector().transpose() * state.calibrated();
+ std::cout<<state.projector()<<std::endl;
+ std::cout<<state.projector().transpose()<<std::endl;
+ std::cout<<state.calibrated()<<std::endl;
+ std::cout<<meas<<std::endl;
// extract local and global position
Acts::Vector2 local(meas[Acts::eBoundLoc0], meas[Acts::eBoundLoc1]);
+const Acts::Vector3 dir = Acts::makeDirectionUnitFromPhiTheta(meas[Acts::eBoundPhi], meas[Acts::eBoundTheta]);
Acts::Vector3 mom(1, 1, 1);
Acts::Vector3 global =
- surface.localToGlobal(geoContext, local, mom);
+ surface.localToGlobal(geoContext, local, dir);
// fill the measurement info
m_lx_hit.push_back(local[Acts::ePos0]);
@@ -676,5 +734,25 @@ void TrajectoryWriterTool::clearVariables() const {
m_pz_smt.clear();
m_eta_smt.clear();
m_pT_smt.clear();
+ m_eLOC0_ini.clear();
+ m_eLOC1_ini.clear();
+ m_ePHI_ini.clear();
+ m_eTHETA_ini.clear();
+ m_eQOP_ini.clear();
+ m_eT_ini.clear();
+ m_err_eLOC0_ini.clear();
+ m_err_eLOC1_ini.clear();
+ m_err_ePHI_ini.clear();
+ m_err_eTHETA_ini.clear();
+ m_err_eQOP_ini.clear();
+ m_err_eT_ini.clear();
+ m_x_ini.clear();
+ m_y_ini.clear();
+ m_z_ini.clear();
+ m_px_ini.clear();
+ m_py_ini.clear();
+ m_pz_ini.clear();
+ m_eta_ini.clear();
+ m_pT_ini.clear();
}
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/components/FaserActsKalmanFilter_entries.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/components/FaserActsKalmanFilter_entries.cxx
index d933e0f480d2c488361f93f2dee2c9087c2e5c79..bb963dd1927d09d03fa2661efb5913f1c33e4dd4 100755
--- a/Tracking/Acts/FaserActsKalmanFilter/src/components/FaserActsKalmanFilter_entries.cxx
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/components/FaserActsKalmanFilter_entries.cxx
@@ -5,6 +5,8 @@
#include "FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h"
#include "FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h"
#include "FaserActsKalmanFilter/TruthBasedInitialParameterTool.h"
+#include "FaserActsKalmanFilter/SPSeedBasedInitialParameterTool.h"
+#include "FaserActsKalmanFilter/SPSimpleInitialParameterTool.h"
#include "FaserActsKalmanFilter/TrajectoryWriterTool.h"
#include "FaserActsKalmanFilter/SimWriterTool.h"
@@ -12,5 +14,7 @@
DECLARE_COMPONENT(FaserActsKalmanFilterAlg)
DECLARE_COMPONENT(CombinatorialKalmanFilterAlg)
DECLARE_COMPONENT(TruthBasedInitialParameterTool)
+DECLARE_COMPONENT(SPSeedBasedInitialParameterTool)
+DECLARE_COMPONENT(SPSimpleInitialParameterTool)
DECLARE_COMPONENT(TrajectoryWriterTool)
DECLARE_COMPONENT(SimWriterTool)
diff --git a/Tracking/Acts/FaserActsKalmanFilter/test/CombinatorialKalmanFilterAlg.py b/Tracking/Acts/FaserActsKalmanFilter/test/CombinatorialKalmanFilterAlg.py
index 3a18e531c7a862da30939e0fc03bbbd9dee99fa4..ab47c4719fcb7ed6b420ddcd691965a82570b600 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/test/CombinatorialKalmanFilterAlg.py
+++ b/Tracking/Acts/FaserActsKalmanFilter/test/CombinatorialKalmanFilterAlg.py
@@ -10,6 +10,7 @@ from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
# from AthenaPoolCnvSvc.PoolWriteConfig import PoolWriteCfg
from TrackerPrepRawDataFormation.TrackerPrepRawDataFormationConfig import FaserSCT_ClusterizationCfg
from TrackerSpacePointFormation.TrackerSpacePointFormationConfig import TrackerSpacePointFinderCfg
+from TrackerSeedFinder.TrackerSeedFinderConfig import TrackerSeedFinderCfg
from FaserActsKalmanFilter.CombinatorialKalmanFilterConfig import CombinatorialKalmanFilterCfg
log.setLevel(DEBUG)
@@ -17,6 +18,7 @@ Configurable.configurableRun3Behavior = True
ConfigFlags.Input.Files = ['my.RDO.pool.root']
ConfigFlags.Output.ESDFileName = "myCKF.ESD.pool.root"
+ConfigFlags.Output.AODFileName = "myCKF.AOD.pool.root"
ConfigFlags.IOVDb.GlobalTag = "OFLCOND-FASER-01"
# ConfigFlags.GeoModel.FaserVersion = "FASER-01"
ConfigFlags.GeoModel.Align.Dynamic = False
@@ -29,10 +31,11 @@ acc.merge(PoolReadCfg(ConfigFlags))
acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags))
acc.merge(TrackerSpacePointFinderCfg(ConfigFlags))
+acc.merge(TrackerSeedFinderCfg(ConfigFlags))
acc.merge(CombinatorialKalmanFilterCfg(ConfigFlags))
-logging.getLogger('forcomps').setLevel(VERBOSE)
-acc.foreach_component("*").OutputLevel = VERBOSE
+logging.getLogger('forcomps').setLevel(INFO)
+acc.foreach_component("*").OutputLevel = INFO
acc.foreach_component("*ClassID*").OutputLevel = INFO
acc.getService("StoreGateSvc").Dump = True
acc.getService("ConditionStore").Dump = True
diff --git a/Tracking/Acts/FaserActsKalmanFilter/test/CombinatorialKalmanFilterAlg_Data.py b/Tracking/Acts/FaserActsKalmanFilter/test/CombinatorialKalmanFilterAlg_Data.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cf53fa5fb7cb4262c4c276374d54a8ea51402ef
--- /dev/null
+++ b/Tracking/Acts/FaserActsKalmanFilter/test/CombinatorialKalmanFilterAlg_Data.py
@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+
+import sys
+from AthenaCommon.Logging import log, logging
+from AthenaCommon.Constants import DEBUG, VERBOSE, INFO
+from AthenaCommon.Configurable import Configurable
+from CalypsoConfiguration.AllConfigFlags import ConfigFlags
+from CalypsoConfiguration.MainServicesConfig import MainServicesCfg
+from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+from AthenaPoolCnvSvc.PoolWriteConfig import PoolWriteCfg
+from WaveRecAlgs.WaveRecAlgsConfig import WaveformReconstructionCfg
+from TrackerPrepRawDataFormation.TrackerPrepRawDataFormationConfig import FaserSCT_ClusterizationCfg
+from TrackerSpacePointFormation.TrackerSpacePointFormationConfig import TrackerSpacePointFinderCfg
+from TrackerSeedFinder.TrackerSeedFinderConfig import TrackerSeedFinderCfg
+from FaserActsKalmanFilter.CombinatorialKalmanFilterConfig import CombinatorialKalmanFilterCfg
+
+log.setLevel(DEBUG)
+Configurable.configurableRun3Behavior = True
+
+ConfigFlags.Input.Files = ['/eos/project-f/faser-commissioning/TI12Data/Run-004411/Faser-Physics-004411-00000.raw']
+ConfigFlags.Output.ESDFileName = "myCKF.ESD.pool.root"
+ConfigFlags.Output.AODFileName = "myCKF.AOD.pool.root"
+ConfigFlags.IOVDb.GlobalTag = "OFLCOND-FASER-01"
+ConfigFlags.IOVDb.DatabaseInstance = "OFLP200" # Use MC conditions for now
+ConfigFlags.Input.ProjectName = "data21" # Needed to bypass autoconfig
+ConfigFlags.Input.isMC = False # Needed to bypass autoconfig
+ConfigFlags.GeoModel.FaserVersion = "FASER-01" # FASER geometry
+ConfigFlags.Common.isOnline = False
+ConfigFlags.GeoModel.Align.Dynamic = False
+ConfigFlags.Beam.NumberOfCollisions = 0.
+ConfigFlags.Detector.GeometryFaserSCT = True
+ConfigFlags.lock()
+
+acc = MainServicesCfg(ConfigFlags)
+#acc.merge(PoolReadCfg(ConfigFlags))
+acc.merge(PoolWriteCfg(ConfigFlags))
+from FaserByteStreamCnvSvc.FaserByteStreamCnvSvcConfig import FaserByteStreamCnvSvcCfg
+acc.merge(FaserByteStreamCnvSvcCfg(ConfigFlags))
+acc.merge(WaveformReconstructionCfg(ConfigFlags))
+acc.merge(FaserSCT_ClusterizationCfg(ConfigFlags, DataObjectName="SCT_EDGEMODE_RDOs"))
+acc.merge(TrackerSpacePointFinderCfg(ConfigFlags))
+acc.merge(TrackerSeedFinderCfg(ConfigFlags))
+acc.merge(CombinatorialKalmanFilterCfg(ConfigFlags))
+
+logging.getLogger('forcomps').setLevel(VERBOSE)
+acc.foreach_component("*").OutputLevel = VERBOSE
+acc.foreach_component("*ClassID*").OutputLevel = INFO
+acc.getService("StoreGateSvc").Dump = True
+acc.getService("ConditionStore").Dump = True
+acc.printConfig(withDetails=True)
+ConfigFlags.dump()
+
+sc = acc.run(maxEvents=-1)
+
+sys.exit(not sc.isSuccess())