trackseed EDM class now ready

Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.cxx

@@ -65,7 +65,7 @@ namespace Tracker
   //-----------------------------------------------------------------------
   StatusCode TrackerSeedFinder::initialize() {
 
-    ATH_MSG_DEBUG( "AAAACCCC TrackerSeedFinder::initialize()" );
+    ATH_MSG_DEBUG( "TrackerSeedFinder::initialize()" );
 
     CHECK(m_thistSvc.retrieve());
     // Check that clusters, space points and ids have names
@@ -80,14 +80,19 @@ namespace Tracker
 
     // Initialize the key of input SiElementPropertiesTable and SiDetectorElementCollection for SCT
     ATH_CHECK(m_SCTDetEleCollKey.initialize());
-
-    if ( m_seed_spcontainerKey.key().empty()){
+    if (m_seed_spcontainerKey.key().empty()){
       ATH_MSG_FATAL( "No name set for output seeds space points");
       return StatusCode::FAILURE;
     }
 
     ATH_CHECK( m_seed_spcontainerKey.initialize() );
 
+    ATH_CHECK( m_trackerSeedContainerKey.initialize() );
+    if (m_trackerSeedContainerKey.key().empty()){
+      ATH_MSG_FATAL( "No name set for output track seeds");
+      return StatusCode::FAILURE;
+    }
+
     m_hist_n=new TH1D("sp_n","sp_n",20,0,20);
     m_hist_x=new TH1D("sp_x","sp_x",100,-200,200);
     m_hist_y=new TH1D("sp_y","sp_y",100,-200,200);
@@ -141,7 +146,6 @@ namespace Tracker
 
   StatusCode TrackerSeedFinder::execute (const EventContext& ctx) const {
     //StatusCode TrackerSeedFinder::execute (const EventContext& ctx) {
-
     ++m_numberOfEvents;
     
     // retrieve tracker spacepoint container
@@ -151,7 +155,7 @@ namespace Tracker
       return StatusCode::RECOVERABLE;
     }
 
-    ATH_MSG_DEBUG( "AACC Tracker spacepoint container found: " << sct_spcontainer->size() << " collections" );
+    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();
 
@@ -211,9 +215,9 @@ namespace Tracker
 
 	  pos.push_back((station-1)*3+plane);
 
-	  ATH_MSG_DEBUG( "AACC spacepoint n " << m_numberOfSP );
-	  ATH_MSG_DEBUG( "  station " << station << " plane " << plane << " pos " << pos.at(i-1) << " pos size " << pos.size());
-	  ATH_MSG_DEBUG( "  i " << i << "  x " << sp->globalPosition().x() << " y " << sp->globalPosition().y() << " z " << sp->globalPosition().z());
+	  ATH_MSG_VERBOSE( " spacepoint n " << m_numberOfSP );
+	  ATH_MSG_VERBOSE( "  station " << station << " plane " << plane << " pos " << pos.at(i-1) << " pos size " << pos.size());
+	  ATH_MSG_VERBOSE( "  i " << i << "  x " << sp->globalPosition().x() << " y " << sp->globalPosition().y() << " z " << sp->globalPosition().z());
 
 	  m_hist_r->Fill(sp->r());
 	  m_hist_eta->Fill(sp->eta());
@@ -295,6 +299,18 @@ namespace Tracker
       }
     }
 
+    // AC
+    //vector<const Trk::SpacePoint*> my_coll_0; 
+    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());
+
+    vector<const Trk::SpacePoint*> ciao;
+    //TrackerSeed* trackerSeed = new TrackerSeed(ciao);
+    Tracker::TrackerSeed* trackerSeed = new Tracker::TrackerSeed();
+    trackerSeed->add(ciao);
+    seedContainer->push_back(trackerSeed);
+
     return StatusCode::SUCCESS;
   }
 

Tracker/TrackerRecAlgs/TrackerSeedFinder/src/TrackerSeedFinder.h

@@ -19,6 +19,9 @@
 #include "TrkSpacePoint/SpacePoint.h"
 #include "TrkSpacePoint/SpacePointContainer.h"
 #include "TrackerSpacePoint/SpacePointForSeedCollection.h"
+
+#include "TrackerPrepRawData/TrackerSeedCollection.h"
+#include "TrackerPrepRawData/TrackerSeed.h"
 #include "TrkSpacePoint/SpacePointOverlapCollection.h"
 #include "TrackerSimEvent/FaserSiHitCollection.h"
 #include "TrackerRawData/FaserSCT_RDO_Container.h"
@@ -65,28 +68,28 @@ class TrackerSeedFinder:public AthReentrantAlgorithm {
 
   private:
 
-    TrackerSeedFinder() = delete;
-    TrackerSeedFinder(const TrackerSeedFinder&) =delete;
-    TrackerSeedFinder &operator=(const TrackerSeedFinder&) = delete;
-    SG::ReadHandleKey<SpacePointContainer>  m_Sct_spcontainerKey{this, "SpacePointsSCTName", "SCT spContainer"};
-
-    SG::WriteHandleKey<SpacePointForSeedCollection>  m_seed_spcontainerKey{this, "FaserSpacePointsSeedsName", "SpacePointForSeedCollection", "SpacePointForSeedCollection"};
-
-    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_numberOfSPCollection{0};
-    mutable std::atomic<int> m_numberOfEmptySPCollection{0};
-    mutable std::atomic<int> m_numberOfSP{0};
-
-    TH1* m_hist_n;
-    TH1* m_hist_x;
-    TH1* m_hist_y;
-    TH1* m_hist_z;
-    TH1* m_hist_r;
-    TH1* m_hist_phi;
+  TrackerSeedFinder() = delete;
+  TrackerSeedFinder(const TrackerSeedFinder&) =delete;
+  TrackerSeedFinder &operator=(const TrackerSeedFinder&) = delete;
+  SG::ReadHandleKey<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"};
+
+  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_numberOfSPCollection{0};
+  mutable std::atomic<int> m_numberOfEmptySPCollection{0};
+  mutable std::atomic<int> m_numberOfSP{0};
+  
+  TH1* m_hist_n;
+  TH1* m_hist_x;
+  TH1* m_hist_y;
+  TH1* m_hist_z;
+  TH1* m_hist_r;
+  TH1* m_hist_phi;
     TH1* m_hist_eta;
     TH1* m_hist_layer;
     TH1* m_hist_strip;

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

Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/TrackerSeed.h

 #ifndef TRACKERRAWDATA_TRACKERSEED_H
 #define TRACKERRAWDATA_TRACKERSEED_H
 
-// Space point Class
-#include "TrkSpacePoint/SpacePointCollection.h"
+#include "TrkSpacePoint/SpacePoint.h"
 
 #include <vector>
 
@@ -12,31 +11,34 @@ class MsgStream;
 
 namespace Tracker {
 
-class TrackerSeed {
+  class TrackerSeed {
 
- public:
-
-  TrackerSeed();
-  TrackerSeed(const TrackerSeed &);
-  TrackerSeed(TrackerSeed &&);
-  TrackerSeed &operator=(const TrackerSeed &);
-  TrackerSeed &operator=(TrackerSeed &&);
-  
-  TrackerSeed(vector<const Trk::SpacePoint*>);
-  TrackerSeed(vector<const Trk::SpacePoint*>&);
-
-  virtual MsgStream&    dump( MsgStream&    stream) const;
-  virtual std::ostream& dump( std::ostream& stream) const;
+  public:
     
- private:
-
-  vector<const Trk::SpacePoint*> m_seed;
-
-};
-
-
- MsgStream&    operator << (MsgStream& stream,    const TrackerSeed& prd);
- std::ostream& operator << (std::ostream& stream, const TrackerSeed& prd);
+    TrackerSeed();
+    TrackerSeed(const TrackerSeed &);
+    ~TrackerSeed();
+    
+    TrackerSeed(vector<const Trk::SpacePoint*> seed);
+    
+    void add(vector<const Trk::SpacePoint*> seed);
+    
+    int size() const;
+    
+    TrackerSeed &operator=(const TrackerSeed &);
 
+    virtual MsgStream& dump(MsgStream& stream) const;
+    virtual ostream&   dump(ostream&   stream) const;
+    
+  private:
+    
+    vector<const Trk::SpacePoint*> m_seed;
+    
+  };
+  
+  MsgStream& operator << (MsgStream& stream, const TrackerSeed& prd);
+  ostream&   operator << (ostream&   stream, const TrackerSeed& prd);
+  
 }
 #endif // TRACKERRAWDATA_TRACKERSEED_H
+  

Tracker/TrackerRecEvent/TrackerPrepRawData/TrackerPrepRawData/TrackerSeedCollection.h

 #ifndef TRACKERSEEDCOLLECTION_H
 #define TRACKERSEEDCOLLECTION_H
 
-// Base classes
 #include "AthenaKernel/CLASS_DEF.h"
 #include "AthContainers/DataVector.h"
 #include "GaudiKernel/DataObject.h"
-//class SpacePoint;
-#include "TrackerSpacePoint/SpacePointForSeed.h"
 #include "TrackerPrepRawData/TrackerSeed.h"
 
 namespace Tracker {
-typedef DataVector<TrackerSeed> TrackerSeedCollection;
+  typedef DataVector<TrackerSeed> TrackerSeedCollection;
 }
 
 CLASS_DEF(Tracker::TrackerSeedCollection, 1139531114, 1)

Tracker/TrackerRecEvent/TrackerPrepRawData/src/TrackerSeed.cxx

@@ -4,45 +4,41 @@ namespace Tracker {
 
   TrackerSeed::TrackerSeed() {}
 
-  TrackerSeed::TrackerSeed(vector<const Trk::SpacePoint*> seed) : m_seed(seed) {}
-  TrackerSeed::TrackerSeed(vector<const Trk::SpacePoint*>& seed) : m_seed(seed) {}
-
   TrackerSeed::TrackerSeed(const TrackerSeed& trackerSeed) : m_seed(trackerSeed.m_seed) {}
 
+  TrackerSeed::~TrackerSeed() {}
+
+  TrackerSeed::TrackerSeed(vector<const Trk::SpacePoint*> seed) { m_seed = seed; }
+  
+  void TrackerSeed::add(vector<const Trk::SpacePoint*> seed) { m_seed = seed; }
+  
+  int TrackerSeed::size() const { return m_seed.size(); }
+
   TrackerSeed& TrackerSeed::operator=(const TrackerSeed& trackSeed){
     if(&trackSeed != this) {
-      TrackerCluster::operator=(trackSeed);
+      TrackerSeed::operator=(trackSeed);
       m_seed = trackSeed.m_seed;
     }
     return *this;
   }
 
-  TrackerSeed& TrackerSeed::operator=(TrackerSeed& trackSeed){
-    if(&trackSeed != this) {
-      TrackerCluster::operator=(trackSeed);
-      m_seed = RIO.m_seed;
-    }
-    return *this;
+  MsgStream& TrackerSeed::dump(MsgStream& stream) const {
+    stream << "TrackerSeed object" << endl;
+    this->TrackerSeed::dump(stream);
+    return stream;
   }
 
-  MsgStream& operator << (MsgStream& stream, const TrackerSeed& trackSeed)
-  {
-    return trackSeed.dump(stream);
+  ostream& TrackerSeed::dump(ostream& stream) const {
+    stream << "TrackerSeed object" << endl;
+    this->TrackerSeed::dump(stream);
+    return stream;
   }
 
-  std::ostream& operator << (std::ostream& stream, const TrackerSeed& trackSeed) {
+  MsgStream& operator << (MsgStream& stream, const TrackerSeed& trackSeed) {
     return trackSeed.dump(stream);
   }
 
-  MsgStream& TrackerSeed::dump(MsgStream& stream) const {
-    stream << "TrackerSeed object" << endl;
-    this->TrackerCluster::dump(stream);
-    return stream;
-  }
-
-  std::ostream& TrackerSeed::dump( std::ostream& stream) const {
-    stream << "TrackerSeed object"<<std::endl;
-    this->TrackerCluster::dump(stream);
-    return stream;
+  ostream& operator << (ostream& stream, const TrackerSeed& trackSeed) {
+    return trackSeed.dump(stream);
   }
 }