TrkVxEdmCnv: Add ATLAS_THREAD_SAFETY

Tracking/TrkVertexFitter/TrkVxEdmCnv/TrkVxEdmCnv/ATLAS_CHECK_THREAD_SAFETY

+Tracking/TrkVertexFitter/TrkVxEdmCnv

Tracking/TrkVertexFitter/TrkVxEdmCnv/TrkVxEdmCnv/IVxCandidateXAODVertex.h

@@ -50,27 +50,30 @@ class IVxCandidateXAODVertex
   /*
    * Virtual destructor.
    */
-  virtual ~IVxCandidateXAODVertex(){};
+  virtual ~IVxCandidateXAODVertex()=default;
 
   /////////////////////////////////////////////////////////////////// 
   // Non-const methods: 
-  /////////////////////////////////////////////////////////////////// 
+  ///////////////////////////////////////////////////////////////////
   /**
-   * Convert xAOD::Vertex to a VxCandidate. 
+   * Convert xAOD::Vertex to a VxCandidate.
    * @param xAODVx input object
    * @param vxVertex return object, owned by the clients.
    */
-  virtual StatusCode createVxCandidate(const xAOD::Vertex &xAODVx, Trk::VxCandidate* &vxVertex) const = 0;
+  virtual StatusCode createVxCandidate(const xAOD::Vertex& xAODVx,
+                                       Trk::VxCandidate*& vxVertex) const = 0;
 
   /**
    * Convert a VxCandidate to a VxVertex. Return object is own by the clients.
-   * If a null pointer is given as output, then a new object is created with its own AuxStore.
-   * Otherwise pass a new xAOD::Vertex object already attached to an aux store (preferred).
+   * If a null pointer is given as output, then a new object is created with its
+   * own AuxStore. Otherwise pass a new xAOD::Vertex object already attached to
+   * an aux store (preferred).
    * @param vxVertex input object
    * @param xAODVx return object, owned by the clients
    */
-  virtual StatusCode createXAODVertex(const Trk::VxCandidate &vxVertex, xAOD::Vertex* &xAODVx) = 0;
-}; 
+  virtual StatusCode createXAODVertex(const Trk::VxCandidate& vxVertex,
+                                      xAOD::Vertex*& xAODVx) const = 0;
+};
 
 } //namespace Trk
 #endif //> !TRKVXEDMCVN_IVXCANDIDATEXAODVERTEX_H

Tracking/TrkVertexFitter/TrkVxEdmCnv/TrkVxEdmCnv/VxCandidateXAODVertex.h

@@ -11,6 +11,10 @@
 #ifndef VXEDMXAODCNV_VXCANDIDATEXAODVERTEX_H
 #define VXEDMXAODCNV_VXCANDIDATEXAODVERTEX_H
 
+
+#include "IVxCandidateXAODVertex.h"
+#include "TrkVertexFitterInterfaces/IVertexLinearizedTrackFactory.h"
+
 // STL includes
 #include <string>
 
@@ -19,12 +23,6 @@
 #include "GaudiKernel/ToolHandle.h"
 #include "GaudiKernel/ServiceHandle.h"
 
-#include "IVxCandidateXAODVertex.h"
-
-// Forward declaration
-namespace Trk{
-  class IVertexLinearizedTrackFactory;
-}
 
 namespace Trk {
 
@@ -46,30 +44,32 @@ class VxCandidateXAODVertex
 	     const std::string& name, 
 	     const IInterface* parent );
 
-  /// Destructor: 
-  virtual ~VxCandidateXAODVertex(); 
+  /// Destructor:
+  virtual ~VxCandidateXAODVertex() = default;
 
   // Athena algtool's Hooks
-  virtual StatusCode  initialize();
-  virtual StatusCode  finalize();
+  virtual StatusCode  initialize() override;
 
   /////////////////////////////////////////////////////////////////// 
   // Non-const methods: 
-  /////////////////////////////////////////////////////////////////// 
+  ///////////////////////////////////////////////////////////////////
   /**
    * Convert xAOD::Vertex to a VxCandidate. Return object is own by the clients.
    */
-  virtual StatusCode createVxCandidate(const xAOD::Vertex &xAODVx, Trk::VxCandidate* &vxVertex) const;
+  virtual StatusCode createVxCandidate(
+    const xAOD::Vertex& xAODVx,
+    Trk::VxCandidate*& vxVertex) const override;
 
   /**
    * Convert a VxCandidate to a VxVertex. Return object is own by the clients.
    */
-  virtual StatusCode createXAODVertex(const Trk::VxCandidate &vxVertex, xAOD::Vertex* &xAODVx);
+  virtual StatusCode createXAODVertex(const Trk::VxCandidate& vxVertex,
+                                      xAOD::Vertex*& xAODVx) const override;
 
-  /////////////////////////////////////////////////////////////////// 
-  // Private data: 
-  /////////////////////////////////////////////////////////////////// 
- private: 
+  ///////////////////////////////////////////////////////////////////
+  // Private data:
+  ///////////////////////////////////////////////////////////////////
+private: 
 
   /// Default constructor: 
   VxCandidateXAODVertex();

Tracking/TrkVertexFitter/TrkVxEdmCnv/src/VxCandidateXAODVertex.cxx

@@ -5,10 +5,10 @@
 
 
 ///////////////////////// -*- C++ -*- /////////////////////////////
-// VxCandidateXAODVertex.cxx 
+// VxCandidateXAODVertex.cxx
 // Implementation file for class VxCandidateXAODVertex
 // Author: S.Binet<binet@cern.ch>
-/////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////
 
 // VxEdmXAODCnv includes
 #include "TrkVxEdmCnv/VxCandidateXAODVertex.h"
@@ -28,34 +28,29 @@
 #include "TrkLinks/LinkToXAODTrackParticle.h"
 #include "TrkLinks/LinkToXAODNeutralParticle.h"
 
-#include "TrkVertexFitterInterfaces/IVertexLinearizedTrackFactory.h"
 
 
 namespace Trk{
-/////////////////////////////////////////////////////////////////// 
-// Public methods: 
-/////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////
+// Public methods:
+///////////////////////////////////////////////////////////////////
 
 // Constructors
 ////////////////
-VxCandidateXAODVertex::VxCandidateXAODVertex( const std::string& type, 
-		      const std::string& name, 
-		      const IInterface* parent ) : 
+VxCandidateXAODVertex::VxCandidateXAODVertex( const std::string& type,
+		      const std::string& name,
+		      const IInterface* parent ) :
   ::AthAlgTool  ( type, name, parent   ),
   m_LinearizedTrackFactory("Trk::InDetFullLinearizedTrackFactory", this)
 {
   declareInterface< IVxCandidateXAODVertex >(this);
   //
   // Property declaration
-  // 
+  //
   declareProperty("LinearizedTrackFactory",m_LinearizedTrackFactory);
 
 }
 
-// Destructor
-///////////////
-VxCandidateXAODVertex::~VxCandidateXAODVertex()
-{}
 
 // Athena algtool's Hooks
 ////////////////////////////
@@ -70,20 +65,15 @@ StatusCode VxCandidateXAODVertex::initialize()
   return StatusCode::SUCCESS;
 }
 
-StatusCode VxCandidateXAODVertex::finalize()
-{
-  ATH_MSG_VERBOSE ("Finalizing " << name() << "...");
-  return StatusCode::SUCCESS;
-}
 
-/////////////////////////////////////////////////////////////////// 
-// Public methods: 
-/////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////
+// Public methods:
+///////////////////////////////////////////////////////////////////
 
 
-/////////////////////////////////////////////////////////////////// 
-// Protected methods: 
-/////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////
+// Protected methods:
+///////////////////////////////////////////////////////////////////
 
   StatusCode VxCandidateXAODVertex::createVxCandidate(const xAOD::Vertex &xAODVx, Trk::VxCandidate* &vxVertex) const
   {
@@ -93,36 +83,36 @@ StatusCode VxCandidateXAODVertex::finalize()
     //create vxTrackAtVertex linearizing with respect to vertex
     std::vector <Trk::VxTrackAtVertex*> tavCollection;
     bool xaod_no_tracks = true;
-//check whether there are already VxTracksAtVertex here   
+//check whether there are already VxTracksAtVertex here
 #ifndef XAOD_STANDALONE
      if(xAODVx.vxTrackAtVertexAvailable())
      {
-//ok  there are some, let us convert them   
+//ok  there are some, let us convert them
 // remember that the VxCandidate takes over the ownership, so it needs a copy..
-     
+
       const std::vector< Trk::VxTrackAtVertex >& vtv = xAODVx.vxTrackAtVertex();
       unsigned int vtv_size = vtv.size();
       for(unsigned int i = 0;i<vtv_size;++i) tavCollection.push_back(vtv.at(i).clone());
       xaod_no_tracks = false;
      }//end of the VxTrackAtVertex conversion
 
-#endif   
-    
-    
+#endif
+
+
  //if they were not coming from xAOD, let us create them on the spot
     if(xaod_no_tracks)
     {
      // This is really ugly! This will make a copy of each ElementLink object
      // during the loop. But because Trk::LinkToXAODTrackParticle expects a
      // non-const reference (why???), we can't use "const auto&" as the type.
-     for (auto t : xAODVx.trackParticleLinks()) 
+     for (auto t : xAODVx.trackParticleLinks())
      {
        Trk::VxTrackAtVertex *tav = new VxTrackAtVertex();
-    
+
       //create ITrackLink to xAOD::TrackParticle
        Trk::LinkToXAODTrackParticle *elTrackParticle = new Trk::LinkToXAODTrackParticle( t );
        tav->setOrigTrack(elTrackParticle);
-	  
+
       //linearize with respect to given vertex (do we need/want it here?)
        Trk::LinearizedTrack* myLinearizedTrack=m_LinearizedTrackFactory->linearizedTrack(elTrackParticle->parameters(),xAODVx.position());
        tav->setLinTrack(myLinearizedTrack);
@@ -136,7 +126,7 @@ StatusCode VxCandidateXAODVertex::finalize()
       // - *m_fitQuality
 
       //push back into collection
-      tavCollection.push_back(tav);      
+      tavCollection.push_back(tav);
      }//end of loop over all tracks
      //Same for neutrals
      for (auto t : xAODVx.neutralParticleLinks())      {
@@ -148,7 +138,7 @@ StatusCode VxCandidateXAODVertex::finalize()
        Trk::LinearizedTrack* myLinearizedTrack=m_LinearizedTrackFactory->linearizedTrack(elNeutralParticle->neutralParameters(),xAODVx.position());
        tav->setLinTrack(myLinearizedTrack);
        //push back into collection
-       tavCollection.push_back(tav);      
+       tavCollection.push_back(tav);
      }//end of loop over all neutrals
     }//end of the xod check
 
@@ -156,18 +146,18 @@ StatusCode VxCandidateXAODVertex::finalize()
     vxVertex = new VxCandidate(recVtx, tavCollection);
     //TODO: only one enum should survive!
     vxVertex->setVertexType((Trk::VertexType)xAODVx.vertexType());
-    
+
     return StatusCode::SUCCESS;
   }
 
-  StatusCode VxCandidateXAODVertex::createXAODVertex(const Trk::VxCandidate &vxVertex, xAOD::Vertex* &xAODVx)
+  StatusCode VxCandidateXAODVertex::createXAODVertex(const Trk::VxCandidate &vxVertex, xAOD::Vertex* &xAODVx) const
   {
 
     ATH_MSG_DEBUG("Creating new xAOD vertex from VxCandidate ");
     ATH_MSG_VERBOSE(vxVertex);
     if (!xAODVx) {
       xAODVx = new xAOD::Vertex();
-      xAODVx->makePrivateStore(); 
+      xAODVx->makePrivateStore();
       ATH_MSG_VERBOSE("Internal Aux store implicitly associated to the new VxVertex object. Pass a valid xAODVx pointer for output for optimal performance.");
     }
 
@@ -179,20 +169,20 @@ StatusCode VxCandidateXAODVertex::finalize()
 
     //now set links to xAOD::TrackParticles
     unsigned int VTAVsize = vxVertex.vxTrackAtVertex()->size();
-    for (unsigned int i = 0 ; i < VTAVsize ; ++i) 
+    for (unsigned int i = 0 ; i < VTAVsize ; ++i)
     {
       Trk::VxTrackAtVertex* VTAV = vxVertex.vxTrackAtVertex()->at(i);
       if (not VTAV){ //added check on VTAV here, instead of inside the ifndef sroe 4 March 2015
         ATH_MSG_WARNING (" Trying to convert to xAOD::Vertex a Trk::VxCandidate. The VxTrackAtVertex is not found");
         continue;
       }
-#ifndef XAOD_STANDALONE      
-      xAODVx->vxTrackAtVertex().push_back(*VTAV); 
+#ifndef XAOD_STANDALONE
+      xAODVx->vxTrackAtVertex().push_back(*VTAV);
 #endif
-      
+
       Trk::ITrackLink*      trklink = VTAV->trackOrParticleLink();
       Trk::LinkToXAODTrackParticle* linkToXAODTP = dynamic_cast<Trk::LinkToXAODTrackParticle*>(trklink);
-      if (linkToXAODTP) 
+      if (linkToXAODTP)
       {
 				//Now set the newlink to the new xAOD vertex
 				xAODVx->addTrackAtVertex(*linkToXAODTP, VTAV->weight());
@@ -206,7 +196,7 @@ StatusCode VxCandidateXAODVertex::finalize()
       }
     }//end of loop
 
-    ATH_MSG_DEBUG("Successfully created new xAOD::Vertex  " << xAODVx);    
+    ATH_MSG_DEBUG("Successfully created new xAOD::Vertex  " << xAODVx);
     return StatusCode::SUCCESS;
   }