TP converter for space points

Tracker/TrackerEventCnv/TrackerEventAthenaPool/CMakeLists.txt

@@ -12,6 +12,7 @@ atlas_add_poolcnv_library( TrackerEventAthenaPoolPoolCnv
    FILES TrackerRawData/FaserSCT_RDO_Container.h
    TrackerPrepRawData/FaserSCT_ClusterContainer.h
    TrackerSimData/TrackerSimDataCollection.h
+   TrkSpacePoint/SpacePointContainer.h
 #   FaserSCT_ConditionsData/FaserSCT_FlaggedCondData.h
    LINK_LIBRARIES Identifier GeneratorObjectsTPCnv AthAllocators AthContainers
    AthenaBaseComps AthenaKernel SGTools StoreGateLib AthenaPoolCnvSvcLib
@@ -19,6 +20,8 @@ atlas_add_poolcnv_library( TrackerEventAthenaPoolPoolCnv
    TrackerReadoutGeometry TrackerEventTPCnv 
    TrackerRawData TrackerSimData
    TrackerPrepRawData TrkTrack 
+   TrkSpacePoint
+   TrackerSpacePoint
 #   FaserSCT_ConditionsData 
    )
 

Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/SpacePointContainerCnv.cxx

+/*
+  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;
+}

Tracker/TrackerEventCnv/TrackerEventAthenaPool/src/SpacePointContainerCnv.h

+/*
+ 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

Tracker/TrackerEventCnv/TrackerEventTPCnv/CMakeLists.txt

@@ -17,6 +17,8 @@ atlas_add_tpcnv_library( TrackerEventTPCnv
    TrackerPrepRawData 
    TrkEventTPCnv 
    TrkPrepRawData
+   TrkSpacePoint
+   TrackerSpacePoint
    PRIVATE_LINK_LIBRARIES AthenaBaseComps AthenaKernel
    EventPrimitives TrackerReadoutGeometry TrkSurfaces TrkEventPrimitives
    TrkMeasurementBase TrkRIO_OnTrack EventContainers )

Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointCnv_p0.h

+/*
+  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

Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointCollection_p0.h

+/*
+ 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

Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointContainerCnv_p0.h

+/*
+ 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

Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePointContainer_p0.h

+/*
+  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

Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/SpacePoint_p0.h

+/*
+ 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

Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/TrackerEventTPCnvDict.h

@@ -40,6 +40,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"
 
 namespace TrackerEventTPCnvDict {
  struct tmp
@@ -56,6 +59,8 @@ 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;
  };
 } //> namespace TrackerEventTPCnvDict
 

Tracker/TrackerEventCnv/TrackerEventTPCnv/TrackerEventTPCnv/selection.xml

@@ -73,3 +73,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" />
+
+</lcgdict>
\ No newline at end of file

Tracker/TrackerEventCnv/TrackerEventTPCnv/src/SpacePointCnv_p0.cxx

+/*
+ 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);
+}

Tracker/TrackerEventCnv/TrackerEventTPCnv/src/SpacePointContainerCnv_p0.cxx

+/*
+  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);
+    }
+  }
+}

Tracker/TrackerRecAlgs/TrackerSpacePointFormation/python/TrackerSpacePointFormationConfig.py

@@ -55,7 +55,8 @@ def StatisticsBasicCfg(flags, **kwargs):
 def TrackerSpacePointFinder_OutputCfg(flags):                                                                                                    
     """Return ComponentAccumulator with Output for SCT. Not standalone."""
     acc = ComponentAccumulator()
-    acc.merge(OutputStreamCfg(flags, "ESD"))
+    itemList = [ "SpacePointContainer#*"]
+    acc.merge(OutputStreamCfg(flags, "ESD", itemList))
     ostream = acc.getEventAlgo("OutputStreamESD")
     ostream.TakeItemsFromInput = True
     return acc