Database/AthenaPOOL/AthenaPoolUtilities/cmake/AthenaPoolUtilitiesTestConfig.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 
 #
-# $Id: AthenaPoolUtilitiesTestConfig.cmake 780067 2016-10-24 14:39:09Z krasznaa $
 # @file AthenaPoolUtilities/share/AthenaPoolUtilitiesTestConfig.make
 # @author sss
 # @date May, 2016
@@ -20,19 +19,20 @@ function( run_tpcnv_legacy_test testName refName )
    atlas_get_package_name( pkgName )
 
    # Find the test runner script:
-   find_file( _testSkel run_tpcnv_legacy_test.sh.in
-      PATH_SUFFIXES share scripts
-      PATHS ${AthenaPoolUtilitiesTest_DIR}/..
-      ${CMAKE_BINARY_DIR}/${ATLAS_PLATFORM}/cmake/modules
+   find_file( ATLAS_TPCNV_LEGACY_TEST_RUNNER "run_tpcnv_legacy_test.sh.in"
+      PATH_SUFFIXES "share" "scripts"
+      PATHS "${AthenaPoolUtilitiesTest_DIR}/.."
+      "${CMAKE_BINARY_DIR}/${ATLAS_PLATFORM}/cmake/modules"
       ${CMAKE_MODULE_PATH} )
-   if( NOT _testSkel )
+   if( NOT ATLAS_TPCNV_LEGACY_TEST_RUNNER )
       message( WARNING "Couldn't find run_tpcnv_legacy_test.sh.in" )
       return()
    endif()
+   mark_as_advanced( ATLAS_TPCNV_LEGACY_TEST_RUNNER )
 
    # Create the script that will be run:
-   configure_file( ${_testSkel}
-      ${CMAKE_CURRENT_BINARY_DIR}/tpcnv_legacy_${testName}.sh
+   configure_file( "${ATLAS_TPCNV_LEGACY_TEST_RUNNER}"
+      "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/tpcnv_legacy_${testName}.sh"
       @ONLY )
 
     set( _env )
@@ -42,7 +42,8 @@ function( run_tpcnv_legacy_test testName refName )
 
    # Create a test with it:
    atlas_add_test( ${testName}
-      SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/tpcnv_legacy_${testName}.sh
+      SCRIPT
+      "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/tpcnv_legacy_${testName}.sh"
       PROPERTIES TIMEOUT 600
       POST_EXEC_SCRIPT "post_tpcnvtest.sh ${testName}" ${_env} )
 
@@ -56,19 +57,20 @@ function( run_tpcnv_test testName refName )
    atlas_get_package_name( pkgName )
 
    # Find the test runner script:
-   find_file( _testSkel run_tpcnv_test.sh.in
-      PATH_SUFFIXES share scripts
-      PATHS ${AthenaPoolUtilitiesTest_DIR}/..
-      ${CMAKE_BINARY_DIR}/${ATLAS_PLATFORM}/cmake/modules
+   find_file( ATLAS_TPCNV_TEST_RUNNER "run_tpcnv_test.sh.in"
+      PATH_SUFFIXES "share" "scripts"
+      PATHS "${AthenaPoolUtilitiesTest_DIR}/.."
+      "${CMAKE_BINARY_DIR}/${ATLAS_PLATFORM}/cmake/modules"
       ${CMAKE_MODULE_PATH} )
-   if( NOT _testSkel )
+   if( NOT ATLAS_TPCNV_TEST_RUNNER )
       message( WARNING "Couldn't find run_tpcnv_test.sh.in" )
       return()
    endif()
+   mark_as_advanced( ATLAS_TPCNV_TEST_RUNNER )
 
    # Create the script that will be run:
-   configure_file( ${_testSkel}
-      ${CMAKE_CURRENT_BINARY_DIR}/tpcnv_${testName}.sh
+   configure_file( "${ATLAS_TPCNV_TEST_RUNNER}"
+      "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/tpcnv_${testName}.sh"
       @ONLY )
 
     set( _env )
@@ -78,7 +80,8 @@ function( run_tpcnv_test testName refName )
 
    # Create a test with it:
    atlas_add_test( ${testName}
-      SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/tpcnv_${testName}.sh
+      SCRIPT
+      "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/tpcnv_${testName}.sh"
       PROPERTIES TIMEOUT 600
       POST_EXEC_SCRIPT "post_tpcnvtest.sh ${testName}" ${_env} )
 

DetectorDescription/ReadoutGeometryBase/CMakeLists.txt

+################################################################################
+# Package: ReadoutGeometryBase
+################################################################################
+
+# Declare the package name:
+atlas_subdir( ReadoutGeometryBase )
+
+# External dependencies:
+find_package( CLHEP )
+find_package( Eigen )
+find_package( GeoModelCore )
+
+# Component(s) in the package:
+atlas_add_library( ReadoutGeometryBase
+                   src/*.c*
+                   PUBLIC_HEADERS ReadoutGeometryBase
+                   INCLUDE_DIRS ${CLHEP_INCLUDE_DIRS} ${EIGEN_INCLUDE_DIRS}
+                   DEFINITIONS ${CLHEP_DEFINITIONS}
+                   LINK_LIBRARIES ${CLHEP_LIBRARIES} ${EIGEN_LIBRARIES} ${GEOMODELCORE_LIBRARIES} AthenaKernel SGTools AtlasDetDescr GeoPrimitives Identifier GaudiKernel InDetCondTools InDetIdentifier TrkDetElementBase TrkSurfaces TrkEventPrimitives StoreGateLib SGtests
+                   PRIVATE_LINK_LIBRARIES AthenaPoolUtilities DetDescrConditions IdDictDetDescr TRT_ConditionsData GeoModelUtilities)

DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/DetectorDesign.h

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// DetectorDesign.h
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+
+#ifndef READOUTGEOMETRYBASE_DETECTORDESIGN_H
+#define READOUTGEOMETRYBASE_DETECTORDESIGN_H
+
+// base class
+#include "GeoModelKernel/RCBase.h"
+
+#include "ReadoutGeometryBase/SiDiodesParameters.h"
+#include "ReadoutGeometryBase/InDetDD_Defs.h"
+#include "CLHEP/Geometry/Point3D.h"
+#include "CLHEP/Geometry/Vector3D.h"
+#include "CLHEP/Geometry/Transform3D.h"
+#include "AtlasDetDescr/AtlasDetectorID.h"
+
+#include <list>
+#include <vector>
+
+namespace Trk {
+class SurfaceBounds;
+}
+
+namespace InDetDD {
+class SiReadoutCellId;
+class SiCellId;
+class SiDiode;
+class SiReadoutCell;
+class SiLocalPosition;
+class SiIntersect;
+
+enum DetectorShape {
+  Box=0, Trapezoid, Annulus,Other
+};
+
+/** @class DetectorDesign
+
+   Base class for the detector design classes for ITk and HGTD.
+   These hold the local description of the detector elements which are
+   shared by a number of detector elements.
+
+ */
+
+class DetectorDesign: public RCBase {
+public:
+    enum Axis {
+        xAxis=0, yAxis, zAxis
+    };
+
+    ///////////////////////////////////////////////////////////////////
+    // Public methods:
+    ///////////////////////////////////////////////////////////////////
+public:
+/** Constructor
+         @param thickness: Thickness of sensor
+         @param phiSymmetric, etaSymmetric, depthSymmetric: Flag to indicate if
+          element is symmetric about these axes. ie for rectangular sensor they
+          are all true, for trapezoidal sensor etaSymmetric
+          is false. They can also be used to force element not to swap directions.
+         @param carrierType: Carrier type that drifts to readout
+          (ie electrons for pixels and holes for SCT)
+          @param readoutSide: Readout side, +ve = positive Depth Side, -ve = negative
+             Depth Side */
+    DetectorDesign(double thickness,
+                   bool phiSymmetric,
+                   bool etaSymmetric,
+                   bool depthSymmetric,
+                   InDetDD::CarrierType carrierType,
+                   int readoutSide);
+
+    DetectorDesign(double thickness,
+                   bool phiSymmetric,
+                   bool etaSymmetric,
+                   bool depthSymmetric,
+                   InDetDD::CarrierType carrierType,
+                   int readoutSide,
+                   Axis stripDirection,
+                   Axis depthDirection);
+
+    // Destructor
+    ~DetectorDesign();
+
+    ///////////////////////////////////////////////////////////////////
+    // Const methods:
+    ///////////////////////////////////////////////////////////////////
+    /** Return the centre of a sensor in the local reference frame.
+        For most designs, this is the origin of the local reference frame.
+        For StripStereoAnnulusDesign, this is not the case (coordinate origin is "on the beamline") */
+    //virtual HepGeom::Point3D<double> sensorCenter() const;
+    virtual Amg::Vector3D sensorCenter() const;
+
+    /** Test if point is in the active part of the detector with specified tolerances */
+    SiIntersect inDetector(const SiLocalPosition &localPosition, double phiTol,
+                           double etaTol) const;
+
+    /** Override default symmetries to prevent swapping of axes.
+       NB. Flags can be changed from true to false but not false to true. */
+    void setSymmetry(bool phiSymmetric, bool etaSymmetric, bool depthSymmetric);
+
+    /** local axis corresponding to eta direction: */
+    Axis etaAxis() const;
+
+    /** local axis corresponding to phi direction: */
+    Axis phiAxis() const;
+
+    /** local axis corresponding to depth direction: */
+    Axis depthAxis() const;
+
+    /** Method which returns thickness of the silicon wafer */
+    double thickness() const;
+
+    /** Return carrier type (ie electrons or holes) */
+    InDetDD::CarrierType carrierType() const;
+
+    bool phiSymmetric() const;
+    bool etaSymmetric() const;
+    bool depthSymmetric() const;
+
+    /** ReadoutSide. +1 = postive depth side, -1 = negative depth side. */
+    int readoutSide() const;
+
+    ///////////////////////////////////////////////////////////////////
+    // Pure virtual methods:
+    ///////////////////////////////////////////////////////////////////
+
+    /** Returns distance to nearest detector active edge
+       +ve = inside
+       -ve = outside */
+    virtual void distanceToDetectorEdge(const SiLocalPosition &localPosition,
+                                        double &etaDist, double &phiDist) const = 0;
+
+    /** Shape of element */
+    virtual DetectorShape shape() const;
+
+    /** Method to calculate length of a module */
+    virtual double length() const = 0;
+
+    /** Method to calculate average width of a module */
+    virtual double width() const = 0;
+
+    /** Method to calculate minimum width of a module */
+    virtual double minWidth() const = 0;
+
+    /** Method to calculate maximum width of a module */
+    virtual double maxWidth() const = 0;
+
+    /** Pitch in phi direction */
+    virtual double phiPitch() const = 0;
+
+    /** Pitch in phi direction */
+    virtual double phiPitch(const SiLocalPosition &localPosition) const = 0;
+
+    // ** Pitch in eta direction */
+    virtual double etaPitch() const = 0;
+
+    /** Return true if hit local direction is the same as readout direction. */
+    virtual bool swapHitPhiReadoutDirection() const = 0;
+    virtual bool swapHitEtaReadoutDirection() const = 0;
+
+    /**  Element boundary */
+    virtual const Trk::SurfaceBounds &bounds() const = 0;
+
+    /** Transform from SiHit to GeoModel frame */
+    //virtual const HepGeom::Transform3D SiHitToGeoModel() const;
+    virtual const Amg::Transform3D SiHitToGeoModel() const;
+
+    ///////////////////////////////////////////////////////////
+    //
+    // The following will replace existing methods but are not all implemented yet
+    //
+
+    /** readout or diode id -> position, size */
+    virtual SiDiodesParameters parameters(const SiCellId &cellId) const = 0;
+
+    /** readout or diode id -> position. */
+    virtual SiLocalPosition localPositionOfCell(const SiCellId &cellId) const = 0;
+
+    /** number of connected cells. Generally 1 except for ganged pixels which will be 2.
+      */
+    virtual int numberOfConnectedCells(const SiReadoutCellId &readoutId) const = 0;
+
+    /** readout id -> id of connected diodes.
+       parameter number = 0 will refer to the primary diode and in general the
+       cell number will be the same.
+       NB. SiCellId cellId = connectedCell(readoutId, 0) will in general be equivalent to
+           SiCellId cellId = readoutId */
+    virtual SiCellId connectedCell(const SiReadoutCellId &readoutId,
+                                   int number) const = 0;
+
+    /** diode id -> readout id
+        NB assignment of a SiReadoutCellId to a SiCellId is allowed so you are can
+        pass SiReadoutCellId variables to functions expecting a SiCellId.  */
+    virtual SiReadoutCellId readoutIdOfCell(const SiCellId &cellId) const = 0;
+
+    /** position -> id */
+    virtual SiReadoutCellId readoutIdOfPosition(const SiLocalPosition &localPos) const = 0;
+
+    /** position -> id */
+    virtual SiCellId cellIdOfPosition(const SiLocalPosition &localPos) const = 0;
+
+    /** Get the neighbouring diodes of a given diode:
+         Cell for which the neighbours must be found
+       List of cells which are neighbours of the given one */
+    virtual void neighboursOfCell(const SiCellId &cellId,
+                                  std::vector<SiCellId> &neighbours) const = 0;
+
+    /** Check if cell is in range. Returns the original cellId if it is in range,
+      otherwise it returns an invalid id. */
+    virtual SiCellId cellIdInRange(const SiCellId &cellId) const = 0;
+
+    ///////////////////////////////////////////////////////////////////
+    // Private methods:
+    ///////////////////////////////////////////////////////////////////
+private:
+    DetectorDesign();
+
+    ///////////////////////////////////////////////////////////////////
+    // Private data:
+    ///////////////////////////////////////////////////////////////////
+private:
+    Axis m_etaAxis; // !< local axis corresponding to eta direction
+    Axis m_phiAxis; // !< local axis corresponding to phi direction
+    Axis m_depthAxis; // !< local axis corresponding to depth direction
+    double m_thickness; // !< thickness of silicon sensor
+    InDetDD::CarrierType m_carrierType; // !< carrier type that drifts towards readout
+    // !< (ie holes fro SCT and electrons for pixel)
+    bool m_phiSymmetric;
+    bool m_etaSymmetric;
+    bool m_depthSymmetric;
+
+    bool m_readoutSidePosDepth; // !< Control which side readout is on.
+                                // !< true = positive Depth Side, false = negative Depth
+                                // Side
+
+    // Disallow Copy and assignment;
+    DetectorDesign(const DetectorDesign &design);
+    DetectorDesign &operator = (const DetectorDesign &design);
+};
+
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+inline DetectorDesign::Axis DetectorDesign::etaAxis() const {
+    return m_etaAxis;
+}
+
+inline DetectorDesign::Axis DetectorDesign::phiAxis() const {
+    return m_phiAxis;
+}
+
+inline DetectorDesign::Axis DetectorDesign::depthAxis() const {
+    return m_depthAxis;
+}
+
+inline double DetectorDesign::thickness() const {
+    return m_thickness;
+}
+
+inline InDetDD::CarrierType DetectorDesign::carrierType() const {
+    return m_carrierType;
+}
+
+inline bool DetectorDesign::phiSymmetric() const {
+    return m_phiSymmetric;
+}
+
+inline bool DetectorDesign::etaSymmetric() const {
+    return m_etaSymmetric;
+}
+
+inline bool DetectorDesign::depthSymmetric() const {
+    return m_depthSymmetric;
+}
+
+inline int DetectorDesign::readoutSide() const {
+    return (m_readoutSidePosDepth) ? +1 : -1;
+}
+
+}  // namespace InDetDD
+
+#endif // READOUTGEOMETRYBASE_DETECTORDESIGN_H

InnerDetector/InDetDetDescr/InDetReadoutGeometry/InDetReadoutGeometry/InDetDD_Defs.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/InDetDD_Defs.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////

InnerDetector/InDetDetDescr/PixelReadoutGeometry/PixelReadoutGeometry/PixelDiodeMap.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/PixelDiodeMap.h

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
@@ -8,8 +8,8 @@
 // (c) ATLAS Pixel Detector software
 ///////////////////////////////////////////////////////////////////
 
-#ifndef INDETREADOUTGEOMETRY_PIXELDIODEMAP_H
-#define INDETREADOUTGEOMETRY_PIXELDIODEMAP_H
+#ifndef READOUTGEOMETRYBASE_PIXELDIODEMAP_H
+#define READOUTGEOMETRYBASE_PIXELDIODEMAP_H
 
 // STL classes
 #include <list>
@@ -17,11 +17,11 @@
 #include <vector>
 
 // Data member classes
-#include "PixelReadoutGeometry/PixelDiodeMatrix.h"
+#include "ReadoutGeometryBase/PixelDiodeMatrix.h"
 
 // Input/output classes
-#include "InDetReadoutGeometry/SiCellId.h"
-#include "InDetReadoutGeometry/SiDiodesParameters.h"
+#include "ReadoutGeometryBase/SiCellId.h"
+#include "ReadoutGeometryBase/SiDiodesParameters.h"
 
 namespace InDetDD {
 
@@ -193,4 +193,4 @@ class PixelDiodeMatrix;
 
 } // namespace InDetDD
 
-#endif // INDETREADOUTGEOMETRY_PIXELDIODEMAP_H
+#endif // READOUTGEOMETRYBASE_PIXELDIODEMAP_H

InnerDetector/InDetDetDescr/PixelReadoutGeometry/PixelReadoutGeometry/PixelDiodeMatrix.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/PixelDiodeMatrix.h

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
 // PixelDiodeMatrix.h
 ///////////////////////////////////////////////////////////////////
 
-#ifndef INDETREADOUTGEOMETRY_PIXELDIODEMATRIX_H
-#define INDETREADOUTGEOMETRY_PIXELDIODEMATRIX_H
+#ifndef READOUTGEOMETRYBASE_PIXELDIODEMATRIX_H
+#define READOUTGEOMETRYBASE_PIXELDIODEMATRIX_H
 
-#include "InDetReadoutGeometry/SiCellId.h"
+#include "ReadoutGeometryBase/SiCellId.h"
 #include "GeoPrimitives/GeoPrimitives.h"
 #include "TrkDetElementBase/TrkDetElementBase.h"
 
@@ -199,4 +199,4 @@ namespace InDetDD {
 
 } // end namespace
 
-#endif //INDETREADOUTGEOMETRY_PIXELDIODEMATRIX_H
+#endif //READOUTGEOMETRYBASE_PIXELDIODEMATRIX_H

InnerDetector/InDetDetDescr/PixelReadoutGeometry/PixelReadoutGeometry/PixelMultipleConnection1D.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/PixelMultipleConnection1D.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
@@ -9,8 +9,8 @@
 ///////////////////////////////////////////////////////////////////
 
 
-#ifndef INDETREADOUTGEOMETRY_PIXELMULTIPLECONNECTION1D_H
-#define INDETREADOUTGEOMETRY_PIXELMULTIPLECONNECTION1D_H
+#ifndef READOUTGEOMETRYBASE_PIXELMULTIPLECONNECTION1D_H
+#define READOUTGEOMETRYBASE_PIXELMULTIPLECONNECTION1D_H
 
 #include <vector>
 
@@ -125,4 +125,4 @@ inline int PixelMultipleConnection1D::gangedCell(const int index) const
 
 } // namespace InDetDD
 
-#endif // INDETREADOUTGEOMETRY_PIXELMULTIPLECONNECTION1D_H
+#endif // READOUTGEOMETRYBASE_PIXELMULTIPLECONNECTION1D_H

InnerDetector/InDetDetDescr/PixelReadoutGeometry/PixelReadoutGeometry/PixelReadoutScheme.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/PixelReadoutScheme.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
@@ -8,15 +8,15 @@
 // (c) ATLAS Pixel Detector software
 ///////////////////////////////////////////////////////////////////
 
-#ifndef INDETREADOUTGEOMETRY_PIXELREADOUTSCHEME_H
-#define INDETREADOUTGEOMETRY_PIXELREADOUTSCHEME_H
+#ifndef READOUTGEOMETRYBASE_PIXELREADOUTSCHEME_H
+#define READOUTGEOMETRYBASE_PIXELREADOUTSCHEME_H
 
 // Data member classes
-#include "PixelReadoutGeometry/PixelMultipleConnection1D.h"
+#include "ReadoutGeometryBase/PixelMultipleConnection1D.h"
 
 // Input and output classes
-#include "InDetReadoutGeometry/SiReadoutCellId.h"
-#include "InDetReadoutGeometry/SiCellId.h"
+#include "ReadoutGeometryBase/SiReadoutCellId.h"
+#include "ReadoutGeometryBase/SiCellId.h"
 
 namespace InDetDD {
 
@@ -154,4 +154,4 @@ inline int PixelReadoutScheme::rows() const
 
 } // namespace InDetDD
 
-#endif // INDETREADOUTGEOMETRY_PIXELREADOUTSCHEME_H
+#endif // READOUTGEOMETRYBASE_PIXELREADOUTSCHEME_H

InnerDetector/InDetDetDescr/InDetReadoutGeometry/InDetReadoutGeometry/SiCellId.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/SiCellId.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////

InnerDetector/InDetDetDescr/InDetReadoutGeometry/InDetReadoutGeometry/SiCommonItems.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/SiCommonItems.h

@@ -6,8 +6,8 @@
  * SiCommonItems.h
  */
 
-#ifndef INDETREADOUTGEOMETRY_SICOMMONITEMS_H
-#define INDETREADOUTGEOMETRY_SICOMMONITEMS_H
+#ifndef READOUTGEOMETRYBASE_SICOMMONITEMS_H
+#define READOUTGEOMETRYBASE_SICOMMONITEMS_H
 
 class AtlasDetectorID;
 
@@ -128,4 +128,4 @@ namespace InDetDD {
 
 } // End namespace InDetDD
 
-#endif // INDETREADOUTGEOMETRY_SICOMMONITEMSS_H
+#endif // READOUTGEOMETRYBASE_SICOMMONITEMS_H

InnerDetector/InDetDetDescr/InDetReadoutGeometry/InDetReadoutGeometry/SiDiodesParameters.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/SiDiodesParameters.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
@@ -12,7 +12,7 @@
 #define INDETREADOUTGEOMETRY_SIDIODESPARAMETERS_H
 
 // Data members classes
-#include "InDetReadoutGeometry/SiLocalPosition.h"
+#include "ReadoutGeometryBase/SiLocalPosition.h"
 
 namespace InDetDD {
    

InnerDetector/InDetDetDescr/InDetReadoutGeometry/InDetReadoutGeometry/SiIntersect.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/SiIntersect.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////

InnerDetector/InDetDetDescr/InDetReadoutGeometry/InDetReadoutGeometry/SiLocalPosition.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/SiLocalPosition.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
@@ -36,11 +36,11 @@ namespace InDetDD {
     ///////////////////////////////////////////////////////////////////
   public:
 
-    /** Default constructor: */
+    /** Implicit constructor: */
     SiLocalPosition();
-    
+
     /** Copy constructor: */
-    SiLocalPosition(const SiLocalPosition &position) =  default;
+    SiLocalPosition(const SiLocalPosition &position);
 
     /** This allows one to pass a Amg::Vector2D  to a SiLocalPosition */
     SiLocalPosition(const Amg::Vector2D &position);
@@ -52,14 +52,8 @@ namespace InDetDD {
     SiLocalPosition(const double xEta,const double xPhi,
   		  const double xDepth=0);
 
-    /** Destructor: */
-    ~SiLocalPosition()=default;
-
     /** Assignment operator: */
-    SiLocalPosition &operator=(const SiLocalPosition &) = default;
-    
-    /** Move assignment **/
-    SiLocalPosition &operator=(SiLocalPosition &&) = default;
+    SiLocalPosition &operator=(const SiLocalPosition &position);
 
     ///////////////////////////////////////////////////////////////////
     // Const methods:
@@ -121,7 +115,6 @@ namespace InDetDD {
 ///////////////////////////////////////////////////////////////////
 // Inline methods:
 ///////////////////////////////////////////////////////////////////
-
 inline double SiLocalPosition::xEta() const
 {
   return m_xEta;

InnerDetector/InDetDetDescr/InDetReadoutGeometry/InDetReadoutGeometry/SiReadoutCellId.h → DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/SiReadoutCellId.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
@@ -12,7 +12,7 @@
 #define INDETREADOUTGEOMETRY_SIREADOUTCELLID_H
 
 // Base class
-#include "InDetReadoutGeometry/SiCellId.h"
+#include "ReadoutGeometryBase/SiCellId.h"
 
 namespace InDetDD {
 

DetectorDescription/ReadoutGeometryBase/ReadoutGeometryBase/SolidStateDetectorElementBase.icc

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+ * @file SolidStateDetectorElementBase.icc
+ **/
+
+namespace InDetDD {
+
+  ///////////////////////////////////////////////////////////////////
+  // Inline methods:
+  ///////////////////////////////////////////////////////////////////
+    
+  inline void SolidStateDetectorElementBase::invalidate()
+  {
+    m_cacheValid = false;
+  }
+
+  inline void SolidStateDetectorElementBase::setCache()
+  {
+    updateCache();
+  }
+    
+  inline const SiCommonItems* SolidStateDetectorElementBase::getCommonItems() const
+  {
+    return m_commonItems;
+  }
+
+  inline Identifier SolidStateDetectorElementBase::identify() const
+  {
+    return m_id;
+  }
+
+  inline IdentifierHash SolidStateDetectorElementBase::identifyHash() const
+  {
+    return m_idHash;
+  }
+
+  inline const AtlasDetectorID* SolidStateDetectorElementBase::getIdHelper() const
+  {
+    return m_commonItems->getIdHelper();
+  }
+
+  inline const Trk::Surface& SolidStateDetectorElementBase::surface(const Identifier&) const
+  {
+    return surface();
+  }
+
+  inline const Amg::Transform3D& SolidStateDetectorElementBase::transform(const Identifier&) const
+  {
+    return transform();
+  }
+
+  inline double SolidStateDetectorElementBase::hitDepthDirection() const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return (m_depthDirection) ? 1. : -1.;
+  }
+    
+  inline double SolidStateDetectorElementBase::hitPhiDirection() const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return (m_phiDirection) ? 1. : -1.;
+  }
+    
+  inline double SolidStateDetectorElementBase::hitEtaDirection() const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return (m_etaDirection) ? 1. : -1.;
+  }
+    
+  inline const Amg::Vector3D& SolidStateDetectorElementBase::normal(const Identifier&) const
+  {
+    return normal();
+  }
+
+  inline const Amg::Vector3D& SolidStateDetectorElementBase::center(const Identifier&) const
+  {
+    return center();
+  }
+
+  inline HepGeom::Point3D<double> SolidStateDetectorElementBase::globalPositionHit(const HepGeom::Point3D<double>& simulationLocalPos) const
+  {
+    return Amg::EigenTransformToCLHEP(transformHit())*simulationLocalPos;
+  }
+
+  inline Amg::Vector3D SolidStateDetectorElementBase::globalPositionHit(const Amg::Vector3D& simulationLocalPos) const
+  {
+    return transformHit() * simulationLocalPos;
+  }
+
+  inline HepGeom::Point3D<double> SolidStateDetectorElementBase::globalPosition(const HepGeom::Point3D<double>& localPos) const
+  {
+    return transformCLHEP() * localPos;
+  }
+    
+  inline Amg::Vector3D SolidStateDetectorElementBase::globalPosition(const Amg::Vector3D& localPos) const
+  {
+    return transform() * localPos;
+  }
+    
+  inline HepGeom::Point3D<double> SolidStateDetectorElementBase::globalPositionCLHEP(const Amg::Vector2D& localPos) const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return m_centerCLHEP + localPos[Trk::distEta] * m_etaAxisCLHEP + localPos[Trk::distPhi] * m_phiAxisCLHEP;
+  }
+
+  inline Amg::Vector3D SolidStateDetectorElementBase::globalPosition(const Amg::Vector2D& localPos) const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return m_center + localPos[Trk::distEta] * m_etaAxis + localPos[Trk::distPhi] * m_phiAxis;
+  }
+
+  inline Amg::Vector2D SolidStateDetectorElementBase::localPosition(const HepGeom::Point3D<double>& globalPosition) const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    HepGeom::Vector3D<double> relativePos = globalPosition - m_centerCLHEP;
+    return Amg::Vector2D(relativePos.dot(m_phiAxisCLHEP), relativePos.dot(m_etaAxisCLHEP));
+  }
+
+  inline Amg::Vector2D SolidStateDetectorElementBase::localPosition(const Amg::Vector3D& globalPosition) const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    Amg::Vector3D relativePos = globalPosition - m_center;
+    return Amg::Vector2D(relativePos.dot(m_phiAxis), relativePos.dot(m_etaAxis));
+  }
+
+  inline double SolidStateDetectorElementBase::rMin() const 
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return m_minR;
+  }
+    
+  inline double SolidStateDetectorElementBase::rMax() const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return m_maxR;
+  }
+    
+  inline double SolidStateDetectorElementBase::zMin() const 
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return m_minZ;
+  }
+    
+  inline double SolidStateDetectorElementBase::zMax() const 
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return m_maxZ;
+  }
+    
+  inline double SolidStateDetectorElementBase::phiMin() const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return m_minPhi;
+  }
+    
+  inline double SolidStateDetectorElementBase::phiMax() const
+  {
+    if (!m_cacheValid) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (!m_cacheValid) updateCache();
+    }
+
+    return m_maxPhi;
+  }
+    
+  inline const DetectorDesign& SolidStateDetectorElementBase::design() const
+  {
+    return *m_design;
+  }
+    
+  inline const Trk::SurfaceBounds& SolidStateDetectorElementBase::bounds(const Identifier&) const
+  {
+    return bounds();
+  }
+
+  inline double SolidStateDetectorElementBase::width() const
+  {
+    return m_design->width();
+  }
+    
+  inline double SolidStateDetectorElementBase::minWidth() const
+  {
+    return m_design->minWidth();
+  }
+    
+  inline double SolidStateDetectorElementBase::maxWidth() const
+  {
+    return m_design->maxWidth();
+  }
+    
+  inline double SolidStateDetectorElementBase::length() const
+  {
+    return m_design->length();
+  }
+    
+  inline double SolidStateDetectorElementBase::thickness() const
+  {
+    return m_design->thickness();
+  }
+    
+  inline double SolidStateDetectorElementBase::etaPitch() const
+  {
+    return m_design->etaPitch();
+  }
+    
+  inline double SolidStateDetectorElementBase::phiPitch() const
+  {
+    return m_design->phiPitch();
+  }
+    
+  inline InDetDD::CarrierType SolidStateDetectorElementBase::carrierType() const
+  {
+    return m_design->carrierType();
+  }
+
+  inline bool SolidStateDetectorElementBase::swapPhiReadoutDirection() const
+  {
+    if (m_firstTime) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (m_firstTime) updateCache(); // In order to set m_phiDirection
+    }
+    // equivalent to (m_design->swapHitPhiReadoutDirection() xor !m_phiDirection)
+    return ((!m_design->swapHitPhiReadoutDirection() && !m_phiDirection)
+          || (m_design->swapHitPhiReadoutDirection() &&  m_phiDirection));
+  }
+    
+  inline bool SolidStateDetectorElementBase::swapEtaReadoutDirection() const
+  {
+    if (m_firstTime) {
+      std::lock_guard<std::mutex> lock(m_mutex);
+      if (m_firstTime) updateCache(); // In order to set m_etaDirection
+    }
+    // equivalent to (m_design->swapHitEtaReadoutDirection() xor !m_etaDirection)
+    return ((!m_design->swapHitEtaReadoutDirection() && !m_etaDirection)
+          || (m_design->swapHitEtaReadoutDirection() &&  m_etaDirection));
+  }
+    
+  inline MsgStream& SolidStateDetectorElementBase::msg(MSG::Level lvl) const
+  {
+    return m_commonItems->msg(lvl);
+  }
+
+  inline bool SolidStateDetectorElementBase::msgLvl(MSG::Level lvl) const
+  {
+    return m_commonItems->msgLvl(lvl);
+  }
+
+} // namespace InDetDD

DetectorDescription/ReadoutGeometryBase/src/DetectorDesign.cxx

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "ReadoutGeometryBase/DetectorDesign.h"
+#include "ReadoutGeometryBase/SiIntersect.h"
+
+namespace InDetDD {
+
+// Constructor with parameters:
+DetectorDesign::DetectorDesign(double thickness,
+                               bool phiSymmetric,
+                               bool etaSymmetric,
+                               bool depthSymmetric,
+                               InDetDD::CarrierType carrierType,
+                               int readoutSide):
+    m_etaAxis(zAxis),
+    m_phiAxis(yAxis),
+    m_depthAxis(xAxis),
+    m_thickness(thickness),
+    m_carrierType(carrierType),
+    m_phiSymmetric(phiSymmetric),
+    m_etaSymmetric(etaSymmetric),
+    m_depthSymmetric(depthSymmetric),
+    m_readoutSidePosDepth(readoutSide > 0) {
+}
+
+// Constructor with axis parameters:
+DetectorDesign::DetectorDesign(double thickness,
+                               bool phiSymmetric,
+                               bool etaSymmetric,
+                               bool depthSymmetric,
+                               InDetDD::CarrierType carrierType,
+                               int readoutSide,
+                               Axis stripDirection,
+                               Axis thicknessDirection):
+    m_etaAxis(stripDirection),
+    m_depthAxis(thicknessDirection),
+    m_thickness(thickness),
+    m_carrierType(carrierType),
+    m_phiSymmetric(phiSymmetric),
+    m_etaSymmetric(etaSymmetric),
+    m_depthSymmetric(depthSymmetric),
+    m_readoutSidePosDepth(readoutSide > 0) {
+    if (stripDirection == thicknessDirection) {
+        throw std::runtime_error(
+                  "ERROR: DetectorDesign called with phi and thickness directions equal");
+    }
+    // phiAxis is "the other one"
+    m_phiAxis = static_cast<Axis> ((xAxis + yAxis + zAxis) - (stripDirection + thicknessDirection));
+
+    
+
+}
+
+DetectorDesign::~DetectorDesign(){}
+
+ 
+
+Amg::Vector3D DetectorDesign::sensorCenter() const {
+    return Amg::Vector3D(0., 0., 0.);
+}
+
+//For future: Should update to use appropriate message streams in place of cout
+void DetectorDesign::setSymmetry(bool phiSymmetric, bool etaSymmetric,
+                                 bool depthSymmetric) {
+    // Flags can be changed from true to false but not false to true.
+    if (m_phiSymmetric) {
+        m_phiSymmetric = phiSymmetric;
+    }
+    else if (phiSymmetric) {
+        std::cout <<
+            "SiDetectorDesign: WARNING! Attempt to allow swapping of xPhi axis direction ignored."
+                  << std::endl;
+    }
+
+    if (m_etaSymmetric) {
+        m_etaSymmetric = etaSymmetric;
+    }
+    else if (etaSymmetric) {
+        std::cout <<
+            "SiDetectorDesign: WARNING! Attempt to allow swapping of xEta axis direction ignored."
+                  << std::endl;
+    }
+
+    if (m_depthSymmetric) {
+        m_depthSymmetric = depthSymmetric;
+    }
+    else if (depthSymmetric) {
+        std::cout <<
+            "SiDetectorDesign: WARNING! Attempt to allow swapping of xDepth axis direction ignored."
+                  << std::endl;
+    }
+}
+
+DetectorShape DetectorDesign::shape() const {
+    // Default is Box.
+    return InDetDD::Box;
+}
+
+SiIntersect DetectorDesign::inDetector(const SiLocalPosition &localPosition,
+                                       double phiTol, double etaTol) const {
+    double etaDist = 0;
+    double phiDist = 0;
+
+    distanceToDetectorEdge(localPosition, etaDist, phiDist);
+
+    SiIntersect state;
+
+    if (phiDist < -phiTol || etaDist < -etaTol) {
+        state.setOut();
+        return state;
+    }
+
+    if (phiDist > phiTol && etaDist > etaTol) {
+        state.setIn();
+        return state;
+    }
+
+    // Near boundary.
+    state.setNearBoundary();
+    return state;
+}
+
+  const Amg::Transform3D DetectorDesign::SiHitToGeoModel() const {
+    return Amg::Transform3D::Identity();
+}
+
+} // namespace InDetDD

InnerDetector/InDetDetDescr/PixelReadoutGeometry/src/PixelDiodeMap.cxx → DetectorDescription/ReadoutGeometryBase/src/PixelDiodeMap.cxx

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
 ///////////////////////////////////////////////////////////////////
@@ -12,9 +12,9 @@
 // Modified: Grant Gorfine
 ///////////////////////////////////////////////////////////////////
 
-#include "PixelReadoutGeometry/PixelDiodeMap.h"
-#include "PixelReadoutGeometry/PixelDiodeMatrix.h"
-#include "InDetReadoutGeometry/SiCellId.h"
+#include "ReadoutGeometryBase/PixelDiodeMap.h"
+#include "ReadoutGeometryBase/PixelDiodeMatrix.h"
+#include "ReadoutGeometryBase/SiCellId.h"
 
 #include <cmath>
 #include <algorithm>

InnerDetector/InDetDetDescr/PixelReadoutGeometry/src/PixelDiodeMatrix.cxx → DetectorDescription/ReadoutGeometryBase/src/PixelDiodeMatrix.cxx

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
-#include "PixelReadoutGeometry/PixelDiodeMatrix.h"
-#include "InDetReadoutGeometry/SiCellId.h"
+#include "ReadoutGeometryBase/PixelDiodeMatrix.h"
+#include "ReadoutGeometryBase/SiCellId.h"
 #include "TrkEventPrimitives/ParamDefs.h"
 
 #include <cassert>