Clean-up algorithm logic and handle "noDB" option better

InnerDetector/InDetConditions/BeamSpotConditions/src/BeamSpotCondAlg.cxx

@@ -2,6 +2,18 @@
 #include "BeamSpotCondAlg.h"
 #include "CoralBase/AttributeListException.h"
 
+const EventIDRange BeamSpotCondAlg::alwaysValid { EventIDBase { 1,
+                                                                EventIDBase::UNDEFEVT,
+                                                                EventIDBase::UNDEFNUM,
+                                                                EventIDBase::UNDEFNUM,
+                                                                0 },
+                                                  EventIDBase { EventIDBase::UNDEFNUM - 1,
+	                                                        EventIDBase::UNDEFEVT,
+	                                                        EventIDBase::UNDEFNUM,
+	                                                        EventIDBase::UNDEFNUM,
+	                                                        EventIDBase::UNDEFNUM - 1 }
+                                                };
+
 BeamSpotCondAlg::BeamSpotCondAlg( const std::string& name, ISvcLocator* pSvcLocator ) 
   : AthAlgorithm( name, pSvcLocator )
 { }
@@ -48,37 +60,38 @@ StatusCode BeamSpotCondAlg::execute()
     return StatusCode::SUCCESS;
   }
 
-  SG::ReadCondHandle<AthenaAttributeList> readHandle { m_readKey };
-  
-  const AthenaAttributeList* raw { *readHandle };
-  if ( raw == nullptr )
+  EventIDRange rangeW;
+  InDet::BeamSpotData* writeCdo = nullptr;
+
+  if ( !m_useDB )
   {
-    ATH_MSG_ERROR("Beam Spot data for key " << m_readKey.fullKey() << " not found");
-    return StatusCode::FAILURE;
+    rangeW = alwaysValid;
+    writeCdo = new InDet::BeamSpotData( m_status, m_posX, m_posY, m_posZ,
+				        m_sigmaX, m_sigmaY, m_sigmaZ,
+				        m_tiltX, m_tiltY, m_sigmaXY );
   }
-  
-  int   status  { m_status };
-  float posX    { m_posX };
-  float posY    { m_posY };
-  float posZ    { m_posZ };
-  float sigmaX  { m_sigmaX };
-  float sigmaY  { m_sigmaY };
-  float sigmaZ  { m_sigmaZ };
-  float tiltX   { m_tiltX };
-  float tiltY   { m_tiltY };
-  float sigmaXY { m_sigmaXY };
-
-  if (m_useDB)
+  else
   {
-    status = (*raw)["status"].data<int>();
-    posX = (*raw)["posX"].data<float>();
-    posY = (*raw)["posY"].data<float>();
-    posZ = (*raw)["posZ"].data<float>();
-    sigmaX = (*raw)["sigmaX"].data<float>();
-    sigmaY = (*raw)["sigmaY"].data<float>();
-    sigmaZ = (*raw)["sigmaZ"].data<float>();
-    tiltX = (*raw)["tiltX"].data<float>();
-    tiltY = (*raw)["tiltY"].data<float>();
+
+    SG::ReadCondHandle<AthenaAttributeList> readHandle { m_readKey };
+  
+    const AthenaAttributeList* raw { *readHandle };
+    if ( raw == nullptr )
+    {
+      ATH_MSG_ERROR("Beam Spot data for key " << m_readKey.fullKey() << " not found");
+      return StatusCode::FAILURE;
+    }
+  
+    int status { (*raw)["status"].data<int>() };
+    float posX { (*raw)["posX"].data<float>() };
+    float posY { (*raw)["posY"].data<float>() };
+    float posZ { (*raw)["posZ"].data<float>() };
+    float sigmaX { (*raw)["sigmaX"].data<float>() };
+    float sigmaY { (*raw)["sigmaY"].data<float>() };
+    float sigmaZ { (*raw)["sigmaZ"].data<float>() };
+    float tiltX  { (*raw)["tiltX"].data<float>() };
+    float tiltY  { (*raw)["tiltY"].data<float>() };
+    float sigmaXY { m_sigmaXY };
     try
     {
       sigmaXY = (*raw)["sigmaXY"].data<float>();
@@ -89,31 +102,30 @@ StatusCode BeamSpotCondAlg::execute()
     }
 
     ATH_MSG_INFO( "Read from condDB"
-	       << " status " << status
+               << " status " << status
 	       << " pos (" << posX << "," << posY << "," << posZ << ")"
 	       << " sigma (" << sigmaX << "," << sigmaY << "," << sigmaZ << ")"
 	       << " tilt (" << tiltX << "," << tiltY << ")"
 	       << " sigmaXY " << sigmaXY );
-  }
 
-  EventIDRange rangeW;
-  if ( !readHandle.range(rangeW) )
-  {
-    ATH_MSG_ERROR( "Failed to retrieve validity range for " << readHandle.key() );
-    return StatusCode::FAILURE;
+    if ( !readHandle.range(rangeW) )
+    {
+      ATH_MSG_ERROR( "Failed to retrieve validity range for " << readHandle.key() );
+      return StatusCode::FAILURE;
+    }
+
+    writeCdo = new InDet::BeamSpotData( status, posX, posY, posZ,
+				        sigmaX, sigmaY, sigmaZ,
+					tiltX, tiltY, sigmaXY );
   }
 
-  InDet::BeamSpotData* writeCdo = new InDet::BeamSpotData( status, posX, posY, posZ,
-							   sigmaX, sigmaY, sigmaZ,
-							   tiltX, tiltY, sigmaXY );
-  
   if ( writeHandle.record( rangeW, writeCdo ).isFailure() )
   {
     ATH_MSG_ERROR( "Could not record InDet::BeamSpotData " << writeHandle.key() <<
-		   " with EventRange " << rangeW << " into conditions store." );
+                   " with EventRange " << rangeW << " into conditions store." );
     return StatusCode::FAILURE;
   }
-
+  
   ATH_MSG_INFO( "Recorded new InDet::BeamSpotData to " << writeHandle.key() << " with range " << rangeW <<
 		" into conditions store." );
 

InnerDetector/InDetConditions/BeamSpotConditions/src/BeamSpotCondAlg.h

@@ -7,6 +7,8 @@
 #include "AthenaPoolUtilities/AthenaAttributeList.h"
 
 #include "GaudiKernel/ICondSvc.h"
+#include "GaudiKernel/EventIDRange.h" 
+#include <limits>
 
 #include "BeamSpotConditionsData/BeamSpotData.h"
 
@@ -21,6 +23,7 @@ class BeamSpotCondAlg : public AthAlgorithm
   virtual StatusCode  execute();        //per event
   virtual StatusCode  finalize();       //once, after all events processed
   
+  static const EventIDRange alwaysValid;
 
  private: 
 

InnerDetector/InDetConditions/BeamSpotConditionsData/BeamSpotConditionsData/BeamSpotData.h

@@ -6,6 +6,10 @@
 
 #include "GeoPrimitives/GeoPrimitives.h"
 
+#ifndef SIMULATIONBASE
+#include "VxVertex/RecVertex.h"
+#endif
+
 namespace InDet
 {
 
@@ -18,7 +22,20 @@ namespace InDet
 
     virtual ~BeamSpotData() { }
 
-    inline const Amg::Vector3D& beamPos() const { return m_beamPos; }
+    const Amg::Vector3D& beamPos() const;
+
+    float beamSigma(int i) const;
+
+    float beamSigmaXY() const;
+
+    float beamTilt(int i) const;
+
+    int beamStatus() const;
+
+#ifndef SIMULATIONBASE
+    const Trk::RecVertex& beamVtx() const;
+#endif
+    
 
   private:
 
@@ -33,10 +50,30 @@ namespace InDet
     float m_tiltY;
     float m_sigmaXY;
 
+    std::vector<float> m_errPar;
+
     Amg::Vector3D m_beamPos;
 
+#ifndef SIMULATIONBASE
+    Trk::RecVertex m_vertex;
+#endif
+
   };
 
+  inline const Amg::Vector3D& BeamSpotData::beamPos() const { return m_beamPos; }
+
+  inline float BeamSpotData::beamSigma(int i) const { return m_errPar[i]; }
+
+  inline float BeamSpotData::beamSigmaXY() const { return m_errPar[5]; }
+
+  inline float BeamSpotData::beamTilt(int i) const { return m_errPar[3+i]; }
+
+  inline int BeamSpotData::beamStatus() const { return m_status; }
+
+#ifndef SIMULATIONBASE
+  inline const Trk::RecVertex& BeamSpotData::beamVtx() const { return m_vertex; }
+#endif
+
 }
 
 CLASS_DEF(InDet::BeamSpotData,188569010,1)

InnerDetector/InDetConditions/BeamSpotConditionsData/CMakeLists.txt

@@ -5,16 +5,25 @@
 # package name
 atlas_subdir( BeamSpotConditionsData )
 
+# possible extra dependencies
+set ( extra_dep )
+set ( extra_lib )
+if ( NOT SIMULATIONBASE )
+   set ( extra_dep VxVertex )
+   set ( extra_lib VxVertex )
+endif()
+
 # dependencies
 atlas_depends_on_subdirs( PUBLIC
 			  Control/AthenaKernel
 			  AthenaPoolUtilities
 			  GeoPrimitives
+			  ${extra_dep}
 			)
 
 # components
 atlas_add_library( BeamSpotConditionsData
 		   src/*.cxx
 		   PUBLIC_HEADERS BeamSpotConditionsData
-		   LINK_LIBRARIES AthenaPoolUtilities GeoPrimitives 
+		   LINK_LIBRARIES AthenaPoolUtilities GeoPrimitives ${extra_lib}
 		 )

InnerDetector/InDetConditions/BeamSpotConditionsData/src/BeamSpotData.cxx

@@ -9,7 +9,24 @@ namespace InDet
     m_status { status }, m_posX { posX }, m_posY { posY }, m_posZ { posZ },
     m_sigmaX { sigmaX }, m_sigmaY { sigmaY }, m_sigmaZ { sigmaZ },
     m_tiltX { tiltX }, m_tiltY { tiltY }, m_sigmaXY { sigmaXY },
+    m_errPar { sigmaX, sigmaY, sigmaZ, tiltX, tiltY, sigmaXY },
     m_beamPos { posX, posY, posZ }
-  {  }
+  {  
+#ifndef SIMULATIONBASE
+    float sigmaX_tilt = tan(tiltX) * sigmaZ;
+    float sigmaY_tilt = tan(tiltY) * sigmaZ;
+    float sigmaX_all = sqrt(sigmaX*sigmaX + sigmaX_tilt*sigmaX_tilt);
+    float sigmaY_all = sqrt(sigmaY*sigmaY + sigmaY_tilt*sigmaY_tilt);
+    Amg::MatrixX beamErr(3, 3);
+    beamErr.setZero();
+    beamErr.fillSymmetric(0, 0, sigmaX_all*sigmaX_all);
+    beamErr.fillSymmetric(0, 1, sigmaXY);
+    beamErr.fillSymmetric(1, 1, sigmaY_all*sigmaY_all);
+    beamErr.fillSymmetric(0, 2, tan(tiltX)*sigmaZ*sigmaZ);
+    beamErr.fillSymmetric(1, 2, tan(tiltY)*sigmaZ*sigmaZ);
+    beamErr.fillSymmetric(2, 2, sigmaZ*sigmaZ);
+    m_vertex = Trk::RecVertex(m_beamPos, beamErr);
+#endif
+  }
 
 }