.gitmodules

 [submodule "faser-common"]
 	   path = faser-common
-	   url = https://gitlab.cern.ch/faser/faser-common.git
+	   url = ../../faser/faser-common.git

Tracking/Vertexing/SingleTrackExtrapolation/CMakeLists.txt

+atlas_subdir(Vertexing)
+
+atlas_add_component(SingleTrackExtrapolation
+                    src/*.cxx
+                    src/*.h
+                    src/components/*.cxx
+                    LINK_LIBRARIES AthenaBaseComps AthViews StoreGateLib GaudiKernel  
+                    xAODFaserWaveform 
+                    EventInfo GeneratorObjects TrackerSimData
+                    TrackerPrepRawData TrkTrack TrkRIO_OnTrack TrackerRIO_OnTrack
+                    FaserActsGeometryLib
+)
+
+atlas_install_python_modules( python/*.py )
\ No newline at end of file

Tracking/Vertexing/SingleTrackExtrapolation/python/SingleTrackExtrapolationConfig.py

+# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+
+#!/usr/bin/env python
+import sys
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
+from AthenaCommon.Configurable import Configurable
+from AthenaCommon.Constants import INFO
+from CalypsoConfiguration.AllConfigFlags import ConfigFlags
+from CalypsoConfiguration.MainServicesConfig import MainServicesCfg
+from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+from FaserSCT_GeoModel.FaserSCT_GeoModelConfig import FaserSCT_GeometryCfg
+from TrackerPrepRawDataFormation.TrackerPrepRawDataFormationConfig import FaserSCT_ClusterizationCfg
+
+def SingleTrackExtrapolationCfg(flags, **kwargs):
+
+    acc = FaserSCT_GeometryCfg(flags)
+    kwargs.setdefault("TrackCollection", "CKFTrackCollection")
+    SingleTrackExtrapolation = CompFactory.SingleTrackExtrapolation
+    acc.addEventAlgo(SingleTrackExtrapolation(**kwargs))
+
+    thistSvc = CompFactory.THistSvc()
+    thistSvc.Output = [f"HIST DATAFILE='SingleTrackTest.root' OPT='RECREATE'"]
+    acc.addService(thistSvc)
+
+    return acc
+
+if __name__ == "__main__":
+    from AthenaCommon.Logging import log
+    log.setLevel(INFO)
+
+    Configurable.configurableRun3Behavior = True
+
+   # Configure
+    ConfigFlags.Input.Files = [f'/afs/cern.ch/work/s/sshively/private/MDC/samples/FaserMC-MDC_FS_Aee_100MeV_1Em5-110001-00000-00009-s0003-RDO-r0007-xAOD.root']
+    ConfigFlags.GeoModel.FaserVersion = "FASERNU-03"
+    ConfigFlags.IOVDb.GlobalTag = "OFLCOND-FASER-02" 
+    ConfigFlags.IOVDb.DatabaseInstance = "OFLP200" #is this necessary?
+    ConfigFlags.GeoModel.Align.Dynamic = False
+    ConfigFlags.lock()
+
+    # Core components
+    acc = MainServicesCfg(ConfigFlags)
+    acc.merge(PoolReadCfg(ConfigFlags))
+
+    # Inner Detector
+    acc.merge(SingleTrackExtrapolationCfg(ConfigFlags))
+
+    # replicaSvc = acc.getService("DBReplicaSvc")
+    # replicaSvc.COOLSQLiteVetoPattern = ""
+    # replicaSvc.UseCOOLSQLite = True
+    # replicaSvc.UseCOOLFrontier = False
+    # replicaSvc.UseGeomSQLite = True
+
+    # Execute and finish
+    sys.exit(int(acc.run(maxEvents=20).isFailure()))

Tracking/Vertexing/SingleTrackExtrapolation/src/SingleTrackExtrapolation.cxx

+#include "SingleTrackExtrapolation.h"
+
+#include "Identifier/Identifier.h"
+#include "StoreGate/ReadHandle.h"
+#include "StoreGate/StoreGateSvc.h"
+
+#include "TrackerIdentifier/FaserSCT_ID.h"
+#include "TrackerPrepRawData/TrackerClusterCollection.h"
+#include "TrackerPrepRawData/FaserSCT_Cluster.h"
+#include "TrackerPrepRawData/FaserSCT_ClusterCollection.h"  
+
+#include "FaserActsGeometry/FaserActsExtrapolationTool.h"
+
+#include <TTree.h>
+#include <TBranch.h>
+
+
+SingleTrackExtrapolation::SingleTrackExtrapolation(const std::string &name, ISvcLocator* pSvcLocator): AthReentrantAlgorithm(name, pSvcLocator),  AthHistogramming(name), m_idHelper(nullptr), m_histSvc("THistSvc/THistSvc", name) {}
+
+
+
+StatusCode SingleTrackExtrapolation::initialize() {
+    ATH_CHECK( m_trackCollection.initialize() );
+    ATH_CHECK( m_mcEventKey.initialize() );
+    ATH_CHECK(m_extrapolationTool.retrieve());
+    //ATH_CHECK(detStore()->retrieve(m_idHelper, "FaserSCT_ID"));
+
+    m_tree = new TTree("trackCounts", "Track Counts");
+
+    m_tree->Branch("event_counts", &m_event_counts, "event_counts/I");
+    m_tree->Branch("track_counts", &m_track_counts, "track_counts/I");
+
+    m_tree->Branch("positiveMom",&m_positiveMom, "positiveMom/F");
+    m_tree->Branch("positiveDirX",&m_positiveDirX, "positiveDirX/F");
+    m_tree->Branch("positiveDirY",&m_positiveDirY, "positiveDirY/F");
+    m_tree->Branch("positiveDirZ",&m_positiveDirZ, "positiveDirZ/F");
+
+    m_tree->Branch("negativeMom",&m_negativeMom, "negativeMom/F");
+    m_tree->Branch("negativeDirX",&m_negativeDirX, "negativeDirX/F");
+    m_tree->Branch("negativeDirY",&m_negativeDirY, "negativeDirY/F");
+    m_tree->Branch("negativeDirZ",&m_negativeDirZ, "negativeDirZ/F");
+
+    m_tree->Branch("eta", &m_eta, "eta/F");
+    m_tree->Branch("theta", &m_theta, "theta/F");
+    m_tree->Branch("pt", &m_pt, "pt/F");
+
+    ATH_CHECK(histSvc()->regTree("/HIST/trackCounts", m_tree));
+
+
+    return StatusCode::SUCCESS;
+    }
+
+StatusCode SingleTrackExtrapolation::execute(const EventContext& ctx) const {
+    SG::ReadHandle<TrackCollection> trackCollection {m_trackCollection, ctx};
+    if (!trackCollection.isValid()){
+      ATH_MSG_ERROR("Could not read " << trackCollection.name());
+      return StatusCode::FAILURE;
+      }
+
+
+    int track_count=0;
+    m_event_counts=0;
+
+    SG::ReadHandle<TrackCollection> h_TrackCollection {m_trackCollection,ctx};
+    for (const Trk::Track* track : *h_TrackCollection)
+    {
+      if (track == nullptr) continue;
+      track_count+=1;
+      const Trk::TrackStateOnSurface* trackstate = (*track->trackStateOnSurfaces())[0];
+      const Trk::TrackParameters* param = trackstate->trackParameters();
+
+      
+      auto position = param->position();
+      auto momentum = param->momentum();
+
+      double charge = param->charge();
+
+      if (charge>0)
+      {
+        m_positiveMom= sqrt(pow(momentum[0],2)+pow(momentum[1],2)+pow(momentum[2],2)); //momentum.normalize();
+        m_positiveDirX=position[0];
+        m_positiveDirY=position[1];
+        m_positiveDirZ=position[2];
+      }
+      else if (charge<0)
+      {
+        m_negativeMom= sqrt(pow(momentum[0],2)+pow(momentum[1],2)+pow(momentum[2],2));//momentum.normalize();
+        m_negativeDirX=position[0];
+        m_negativeDirY=position[1];
+        m_negativeDirZ=position[2];
+      }
+      else 
+      {
+        m_positiveMom=0;
+        m_positiveDirX=0;
+        m_positiveDirY=0;
+        m_positiveDirZ=0;
+
+        m_negativeMom=0;
+        m_negativeDirX=0;
+        m_negativeDirY=0;
+        m_negativeDirZ=0;
+      }
+      }
+
+      m_track_counts=track_count;
+      m_event_counts=1;
+      m_tree->Fill();
+
+    SG::ReadHandle<McEventCollection> h_mcEvents(m_mcEventKey);
+    if (h_mcEvents->size() == 0) return StatusCode::FAILURE;
+    //what now?? isnt this already iterating over events? wtf
+/*
+1. go through list of tracks
+2. save tracks in tree. importantly should include: charge of ptle, ptle ID, x,y,z, extrapolation into magnet
+  - have to get extrapolation to work (work on including that in this module at least)
+3. compare tracks of an event.
+  - looking for +/- pairs
+  - compare locations in magnet; start from tracker, work backwards in increments (as dave said)
+  - momentum should also be symmetric (right?)
+  - while working back look for points where multiple tracks go into same xy coordinate and check for +/- and momentum 
+
+*/
+
+
+    
+
+    return StatusCode::SUCCESS;
+    }
+
+StatusCode SingleTrackExtrapolation::finalize() {return StatusCode::SUCCESS;}
\ No newline at end of file

Tracking/Vertexing/SingleTrackExtrapolation/src/SingleTrackExtrapolation.h

+#ifndef SINGLETRACKEXTRAPOLATION_H
+#define SINGLETRACKEXTRAPOLATION_H
+
+#include "AthenaBaseComps/AthReentrantAlgorithm.h"
+#include "AthenaBaseComps/AthHistogramming.h"
+#include "StoreGate/ReadHandleKey.h"
+
+#include "GeneratorObjects/McEventCollection.h"
+#include "TrackerSimData/TrackerSimDataCollection.h"
+#include "TrkTrack/TrackCollection.h"
+
+#include "TrackerPrepRawData/FaserSCT_ClusterContainer.h" 
+#include "TrackerIdentifier/FaserSCT_ID.h"
+
+#include "GaudiKernel/ServiceHandle.h"
+#include "GaudiKernel/ToolHandle.h"
+
+
+#include "TTree.h"
+#include "TFile.h"
+#include <TH1.h>
+#include <TProfile.h>
+
+#include "FaserActsGeometryInterfaces/IFaserActsExtrapolationTool.h"
+
+
+class FaserSCT_ID;
+
+class TTree;
+
+
+class SingleTrackExtrapolation : public AthReentrantAlgorithm, AthHistogramming
+ {
+    public:
+    /// Constructor with parameters:
+    SingleTrackExtrapolation(const std::string& name, ISvcLocator* pSvcLocator);
+
+    ///Retrieve the tools used and initialize variables
+    virtual StatusCode initialize() override;
+    ///Form clusters and record them in StoreGate (detector store)
+    virtual StatusCode execute(const EventContext& ctx) const override;
+    ///Clean up and release the collection containers
+    virtual StatusCode finalize() override;
+
+    const ServiceHandle<ITHistSvc>& histSvc() const;
+
+    private:
+        
+        const FaserSCT_ID* m_idHelper;
+        SG::ReadHandleKey<TrackCollection> m_trackCollection {this, "TrackCollection", "CKFTrackCollection", "Input track collection name" };
+        SG::ReadHandleKey<McEventCollection> m_mcEventKey { this, "McEventCollection", "TruthEvent" };
+
+        ToolHandle<IFaserActsExtrapolationTool> m_extrapolationTool { this, "ExtrapolationTool", "FaserActsExtrapolationTool" };  
+
+        mutable TTree* m_tree;
+        ServiceHandle<ITHistSvc> m_histSvc;
+
+        mutable int m_event_counts=0;
+        mutable int m_track_counts=0;
+
+        mutable float m_positiveMom;
+        mutable float m_positiveDirX;
+        mutable float m_positiveDirY;
+        mutable float m_positiveDirZ;
+
+        mutable float m_negativeMom;
+        mutable float m_negativeDirX;
+        mutable float m_negativeDirY;
+        mutable float m_negativeDirZ;
+
+
+        mutable double m_chi2;
+        mutable float m_eta;
+        mutable float m_theta;
+        mutable float m_phi;
+        mutable float m_pt;
+
+
+ };
+
+inline const ServiceHandle<ITHistSvc>& SingleTrackExtrapolation::histSvc() const {
+  return m_histSvc;
+}
+
+
+#endif // SINGLETRACKEXTRAPOLATION_H

Tracking/Vertexing/SingleTrackExtrapolation/src/components/SingleTrackExtrapolation_entries.cxx

+#include "../SingleTrackExtrapolation.h"
+
+DECLARE_COMPONENT( SingleTrackExtrapolation ) //change alg name if update file/class etc
\ No newline at end of file

faser-common @ 5124b0e7

-Subproject commit 69a90ec95da88a00097fb809bede6c2bae8c02d6
+Subproject commit 5124b0e78dbcc4a05c22f511700d5dbcdb4808df