.gitignore

+# Ignore the most common extra files that can
+# be produced while developing
+*~
+*.sw?
+#*
+.DS_Store
+.pydevproject
+.project
+*.pyc
+.asetup*
+.cproject
+*.kdevelop
+#Binary formats
+*.so*
+*.out
+*.exe*
+*.a
+*.la
+*.lib
+*.root
+tmp.*

AsgExternal/Asg_Test/CMakeLists.txt

+# $Id: CMakeLists.txt 782126 2016-11-03 13:55:04Z krasznaa $
+
+# The name of the package:
+atlas_subdir( Asg_Test )
+
+# Read in the settings of the package from the files under cmt/:
+file( READ ${CMAKE_CURRENT_SOURCE_DIR}/cmt/ReleaseSeries.txt
+   ROOTCORE_RELEASE_SERIES )
+string( STRIP "${ROOTCORE_RELEASE_SERIES}" ROOTCORE_RELEASE_SERIES )
+file( READ ${CMAKE_CURRENT_SOURCE_DIR}/cmt/TestFileData.txt
+   ASG_TEST_FILE_DATA )
+string( STRIP "${ASG_TEST_FILE_DATA}" ASG_TEST_FILE_DATA )
+file( READ ${CMAKE_CURRENT_SOURCE_DIR}/cmt/TestFileMC.txt
+   ASG_TEST_FILE_MC )
+string( STRIP "${ASG_TEST_FILE_MC}" ASG_TEST_FILE_MC )
+file( READ ${CMAKE_CURRENT_SOURCE_DIR}/cmt/TestFileMCAFII.txt
+   ASG_TEST_FILE_MC_AFII )
+string( STRIP "${ASG_TEST_FILE_MC_AFII}" ASG_TEST_FILE_MC_AFII )
+set( ROOTCORE_TEST_FILE ${ASG_TEST_FILE_MC} )
+get_filename_component( ROOTCORE_TEST_DATA ${ROOTCORE_TEST_FILE} PATH )
+
+# Create the CMake file that will be used to generate the environment config:
+configure_file( 
+   ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Asg_TestEnvironmentConfig.cmake.in
+   ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Asg_TestEnvironmentConfig.cmake
+   @ONLY )
+set( Asg_TestEnvironment_DIR
+   ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}
+   CACHE PATH "Location of Asg_TestEnvironmentConfig.cmake" FORCE )
+
+# Now find it:
+find_package( Asg_TestEnvironment )

AsgExternal/Asg_Test/cmake/Asg_TestEnvironmentConfig.cmake.in

+# $Id: Asg_TestEnvironmentConfig.cmake.in 782126 2016-11-03 13:55:04Z krasznaa $
+#
+# File configuring the ASG environment variables.
+#
+
+# Set the environment variables:
+set( ASG_TESTENVIRONMENT_ENVIRONMENT
+   FORCESET ROOTCORE_RELEASE_SERIES @ROOTCORE_RELEASE_SERIES@
+   FORCESET ASG_TEST_FILE_DATA    @ASG_TEST_FILE_DATA@
+   FORCESET ASG_TEST_FILE_MC      @ASG_TEST_FILE_MC@
+   FORCESET ASG_TEST_FILE_MC_AFII @ASG_TEST_FILE_MC_AFII@
+   FORCESET ROOTCORE_TEST_FILE @ROOTCORE_TEST_FILE@
+   FORCESET ROOTCORE_TEST_DATA @ROOTCORE_TEST_DATA@ )
+
+# Signal that the module was found:
+set( ASG_TESTENVIRONMENT_FOUND TRUE )

AsgExternal/Asg_Test/cmt/ReleaseSeries.txt

+25

AsgExternal/Asg_Test/cmt/TestFileData.txt

+/afs/cern.ch/atlas/project/PAT/xAODs/r9264/data16_13TeV.00311321.physics_Main.recon.AOD.r9264/AOD.11038520._000001.pool.root.1

AsgExternal/Asg_Test/cmt/TestFileMC.txt

+/afs/cern.ch/atlas/project/PAT/xAODs/r9315/mc16_13TeV.410501.PowhegPythia8EvtGen_A14_ttbar_hdamp258p75_nonallhad.merge.AOD.e5458_s3126_r9364_r9315/AOD.11182705._000001.pool.root.1

AsgExternal/Asg_Test/cmt/TestFileMCAFII.txt

+/afs/cern.ch/user/a/asgbase/patspace/xAODs/a818/mc15_13TeV.410000.PowhegPythiaEvtGen_P2012_ttbar_hdamp172p5_nonallhad.merge.AOD.e3698_a766_a818_r7676/AOD.07919492._000100.pool.root.1

AsgExternal/Asg_Test/cmt/setup_external.RootCore.csh

+Asg_Test_Dir=`dirname $1`
+setenv ROOTCORE_RELEASE_SERIES `cat $Asg_Test_Dir/ReleaseSeries.txt`
+setenv ASG_TEST_FILE_DATA `cat $Asg_Test_Dir/TestFileData.txt`
+setenv ASG_TEST_FILE_MC `cat $Asg_Test_Dir/TestFileMC.txt`
+setenv ASG_TEST_FILE_MC_AFII `cat $Asg_Test_Dir/TestFileMCAFII.txt`
+setenv ROOTCORE_TEST_FILE `cat $Asg_Test_Dir/TestFileMC.txt`
+setenv ROOTCORE_TEST_DATA "`dirname $ROOTCORE_TEST_FILE | xargs dirname`"

AsgExternal/Asg_Test/cmt/setup_external.RootCore.sh

+Asg_Test_Dir=`dirname $1`
+export ROOTCORE_RELEASE_SERIES=`cat $Asg_Test_Dir/ReleaseSeries.txt`
+export ASG_TEST_FILE_DATA=`cat $Asg_Test_Dir/TestFileData.txt`
+export ASG_TEST_FILE_MC=`cat $Asg_Test_Dir/TestFileMC.txt`
+export ASG_TEST_FILE_MC_AFII=`cat $Asg_Test_Dir/TestFileMCAFII.txt`
+export ROOTCORE_TEST_FILE=`cat $Asg_Test_Dir/TestFileMC.txt`
+export ROOTCORE_TEST_DATA="`dirname $ROOTCORE_TEST_FILE | xargs dirname`"

AtlasGeometryCommon/BeamPipeGeoModel/BeamPipeGeoModel/BeamPipeDetectorManager.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef BeamPipeDetectorManager_h
+#define BeamPipeDetectorManager_h 1
+
+#include "GeoModelKernel/GeoVPhysVol.h"
+#include "GeoModelKernel/GeoVDetectorManager.h"
+
+#include <vector>
+
+class BeamPipeDetectorManager : public GeoVDetectorManager  
+{
+ public:
+
+  // Constructor
+  BeamPipeDetectorManager();
+
+  // Destructor
+  ~BeamPipeDetectorManager();
+
+  // Access to raw geometry:
+  virtual unsigned int getNumTreeTops() const;
+  
+  // Access to raw geometry:
+  virtual PVConstLink getTreeTop(unsigned int i) const;
+
+  // Add a Tree top:
+  void addTreeTop(PVLink);
+
+ private:  
+
+  const BeamPipeDetectorManager & operator=(const BeamPipeDetectorManager &right);
+  BeamPipeDetectorManager(const BeamPipeDetectorManager &right);
+  
+  std::vector<PVLink> m_volume;  
+
+};
+
+#ifndef GAUDI_NEUTRAL
+#include "AthenaKernel/CLASS_DEF.h"
+CLASS_DEF(BeamPipeDetectorManager, 119561103, 1)
+#endif
+
+#endif
+
+

AtlasGeometryCommon/BeamPipeGeoModel/CMakeLists.txt

+################################################################################
+# Package: BeamPipeGeoModel
+################################################################################
+
+# Declare the package name:
+atlas_subdir( BeamPipeGeoModel )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+                          Database/RDBAccessSvc
+                          DetectorDescription/GeoModel/GeoModelKernel
+                          DetectorDescription/GeoModel/GeoModelUtilities
+                          PRIVATE
+                          Control/SGTools
+                          Control/StoreGate
+                          Control/AthenaKernel
+                          DetectorDescription/GeoModel/GeoModelInterfaces
+                          GaudiKernel )
+
+# External dependencies:
+find_package( Boost COMPONENTS filesystem thread system )
+find_package( CORAL COMPONENTS CoralBase CoralKernel RelationalAccess )
+
+# Component(s) in the package:
+atlas_add_library( BeamPipeGeoModelLib
+                   src/*.cxx
+                   PUBLIC_HEADERS BeamPipeGeoModel
+                   INCLUDE_DIRS ${Boost_INCLUDE_DIRS} ${CORAL_INCLUDE_DIRS}
+                   LINK_LIBRARIES ${Boost_LIBRARIES} ${CORAL_LIBRARIES} GeoModelKernel GeoModelUtilities StoreGateLib SGtests
+                   PRIVATE_LINK_LIBRARIES SGTools AthenaKernel GaudiKernel )
+
+atlas_add_component( BeamPipeGeoModel
+                     src/components/*.cxx
+                     INCLUDE_DIRS ${Boost_INCLUDE_DIRS} ${CORAL_INCLUDE_DIRS}
+                     LINK_LIBRARIES ${Boost_LIBRARIES} ${CORAL_LIBRARIES} GeoModelKernel GeoModelUtilities SGTools StoreGateLib SGtests GaudiKernel BeamPipeGeoModelLib )
+

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorFactory.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "BeamPipeDetectorFactory.h"
+
+
+#include "GeoModelInterfaces/AbsMaterialManager.h"
+#include "GeoModelKernel/GeoMaterial.h"  
+#include "GeoModelKernel/GeoPcon.h"  
+#include "GeoModelKernel/GeoTube.h"  
+#include "GeoModelKernel/GeoCons.h"
+#include "GeoModelKernel/GeoLogVol.h"  
+#include "GeoModelKernel/GeoNameTag.h"  
+#include "GeoModelKernel/GeoPhysVol.h"  
+#include "GeoModelKernel/GeoFullPhysVol.h"  
+#include "GeoModelKernel/GeoTransform.h"  
+
+#include "StoreGate/StoreGateSvc.h"
+
+
+#include "GeoModelInterfaces/StoredMaterialManager.h"
+
+#include "RDBAccessSvc/IRDBRecord.h"
+#include "RDBAccessSvc/IRDBRecordset.h"
+#include "RDBAccessSvc/IRDBAccessSvc.h"
+
+#include "AthenaKernel/getMessageSvc.h"
+#include "GaudiKernel/MsgStream.h"
+
+#include <iomanip>
+#include <vector>
+
+
+BeamPipeDetectorFactory::BeamPipeDetectorFactory(StoreGateSvc *detStore,
+				       IRDBAccessSvc *pAccess)
+  :m_detectorManager(0),
+   m_materialManager(0),
+   m_detectorStore(detStore),
+   m_access(pAccess),
+   m_centralRegionZMax(1500*CLHEP::mm)
+{}
+
+BeamPipeDetectorFactory::~BeamPipeDetectorFactory()
+{
+}
+
+void BeamPipeDetectorFactory::create(GeoPhysVol *world)
+{
+  m_detectorManager=new BeamPipeDetectorManager();
+
+  const StoredMaterialManager * materialManagerTmp = 0;
+  if (StatusCode::SUCCESS != m_detectorStore->retrieve(materialManagerTmp, std::string("MATERIALS"))) {
+    return; 
+  } 
+  m_materialManager = materialManagerTmp;
+  
+  IRDBRecordset_ptr atlasMother = m_access->getRecordsetPtr("AtlasMother",m_versionTag,m_versionNode);
+  IRDBRecordset_ptr bpipeGeneral = m_access->getRecordsetPtr("BPipeGeneral",m_versionTag,m_versionNode);
+  IRDBRecordset_ptr bpipeEnvelope = m_access->getRecordsetPtr("BPipeEnvelope",m_versionTag,m_versionNode);
+  IRDBRecordset_ptr bpipePosition = m_access->getRecordsetPtr("BPipePosition",m_versionTag,m_versionNode);
+
+  // Get the materials  
+  const GeoMaterial *air        = m_materialManager->getMaterial("std::Air");
+
+  // Create beam pipe top level envelopes
+  // It is split into 3 sections. 
+  // left, right and central. This is to allow different truth scoring in the different regions.
+  
+  m_centralRegionZMax = 1500 * CLHEP::mm; // For backward compatibility in DB.
+  if (bpipeGeneral->size() != 0) m_centralRegionZMax = (*bpipeGeneral)[0]->getDouble("CENTRALZMAX") * CLHEP::mm;
+
+  EnvelopeShapes envelopes;
+
+  if (bpipeEnvelope->size() != 0) {
+    envelopes = makeEnvelope(bpipeEnvelope);
+  } else {
+    envelopes = makeEnvelopeOld(atlasMother);
+  }
+
+  GeoLogVol* lvMotherCentral = new GeoLogVol("BeamPipeCentral",envelopes.centralShape,air);
+  GeoPhysVol* pvMotherCentral = new GeoPhysVol(lvMotherCentral);
+
+
+  // The treetops need to have unique physical volumes so
+  // we create pvMotherFwdMinus which is identical pvMotherFwdPlus. 
+  GeoLogVol* lvMotherFwd = new GeoLogVol("BeamPipeFwd",envelopes.fwdShape,air);
+  GeoPhysVol* pvMotherFwdPlus = new GeoPhysVol(lvMotherFwd);
+  GeoPhysVol* pvMotherFwdMinus = new GeoPhysVol(lvMotherFwd);
+
+
+  // Add sections
+  addSections(pvMotherCentral, 0);
+  addSections(pvMotherFwdPlus, 1);
+  addSections(pvMotherFwdMinus, 1);
+
+  // We have to give them all the name "BeamPipe"
+  // This is the name used by HepVis viewer
+  GeoNameTag *tag = new GeoNameTag("BeamPipe");
+
+  double beamx = 0.0;
+  double beamy = 0.0;
+  double beamz = 0.0;
+  if (bpipePosition->size() != 0) {
+    beamx = (*bpipePosition)[0]->getDouble("POSX") * CLHEP::mm;
+    beamy = (*bpipePosition)[0]->getDouble("POSY") * CLHEP::mm;
+    beamz = (*bpipePosition)[0]->getDouble("POSZ") * CLHEP::mm;
+  }
+
+  // Only shift the central section
+
+  // Central
+  world->add(tag);
+  world->add(new GeoTransform(HepGeom::Translate3D(beamx,beamy,beamz)));
+  world->add(pvMotherCentral);
+  m_detectorManager->addTreeTop(pvMotherCentral);                                                                  //
+
+  // FwdPlus
+  world->add(tag);
+  world->add(pvMotherFwdPlus);
+  m_detectorManager->addTreeTop(pvMotherFwdPlus);
+
+  // FwdMinus
+  world->add(tag);
+  world->add(new GeoTransform(HepGeom::RotateY3D(180*CLHEP::degree)));
+  world->add(pvMotherFwdMinus);
+  m_detectorManager->addTreeTop(pvMotherFwdMinus);
+
+
+}
+
+void BeamPipeDetectorFactory::addSections(GeoPhysVol* parent, int region)
+{
+
+  IRDBRecordset_ptr bpipeSections = m_access->getRecordsetPtr("BPipeSections",m_versionTag,m_versionNode);  
+  
+  bool central = (region == 0); 
+
+  // Sections 2 & 3 are placed in section 1. 
+  // pvMotherSection will point to section 1.
+  GeoPhysVol* pvMotherSection = 0;
+  bool addToFirstSection = true;
+  double rminSec1 = 0;
+  double rmaxSec1 = 0;
+  double zminSec1 = 0;
+  double zmaxSec1 = 0;
+  
+  for (unsigned int itemp=0; itemp<bpipeSections->size(); itemp++)
+  {
+    std::string material = (*bpipeSections)[itemp]->getString("MATERIAL");
+    double rMin1 = (*bpipeSections)[itemp]->getDouble("RMIN1") * CLHEP::mm;
+    double rMax1 = (*bpipeSections)[itemp]->getDouble("RMAX1") * CLHEP::mm;
+    double rMin2 = (*bpipeSections)[itemp]->getDouble("RMIN2") * CLHEP::mm;
+    double rMax2 = (*bpipeSections)[itemp]->getDouble("RMAX2") * CLHEP::mm;
+    double z = (*bpipeSections)[itemp]->getDouble("Z") * CLHEP::mm;
+    double dZ = (*bpipeSections)[itemp]->getDouble("DZ") * CLHEP::mm;
+    int secNum = (*bpipeSections)[itemp]->getInt("SECNUM");
+      
+    double zmin = z - dZ;
+    double zmax = z + dZ;
+
+    
+    // Check if in central or fwd region or if it is split.
+    // We assume it is left/right symmetric. 
+    if (central) { 
+      if (zmin > m_centralRegionZMax) continue;
+      if (zmax > m_centralRegionZMax) zmax = m_centralRegionZMax;
+      if (zmax < -m_centralRegionZMax) continue;
+      if (zmin < -m_centralRegionZMax) zmin = -m_centralRegionZMax;
+    } else {
+      if (zmax < m_centralRegionZMax) continue; 
+      if (zmin < m_centralRegionZMax) zmin = m_centralRegionZMax;
+    }
+
+
+    double znew  =  0.5 * (zmin + zmax);
+    double dZnew  = 0.5 * (zmax - zmin);
+      
+    std::ostringstream os; 
+    if (central) {
+      os << "SectionC"; 
+    } else {
+      os << "SectionF"; 
+    }
+    os << std::setw(2) << std::setfill('0') << secNum;
+    std::string name = os.str(); 
+
+    //std::cout << "Adding section: " << name 
+    //	      << " rmin1,rmin2,rmax1,rmax2,z,dz = "
+    //	      << rMin1 << ", " 
+    //	      << rMin2 << ", " 
+    //	      << rMax1 << ", " 
+    //	      << rMax2 << ", " 
+    //	      << znew << ", " 
+    //	      << dZnew << ", "
+    //	      << material << std::endl;
+
+    bool isTube = true;
+    GeoShape* shape;
+    if((rMin1==rMin2)&&(rMax1==rMax2)) {
+      shape = new GeoTube(rMin1,rMax1,dZnew);
+      isTube = true;
+    } else {
+      shape = new GeoCons(rMin1,rMin2,
+			  rMax1,rMax2,
+			  dZnew,
+			  0*CLHEP::deg,360*CLHEP::deg);
+      isTube = false;
+    }
+
+    const GeoMaterial* mat = m_materialManager->getMaterial(material);
+    if (mat == 0) {
+      // For backward compatibility - older geometry versions didn't specify the
+      // material namespace
+      // std::cout << "Material """ << material << """ not found. Trying  std::" << material << std::endl;
+      mat = m_materialManager->getMaterial("std::"+material);
+    }
+
+    GeoLogVol* lvSection = new GeoLogVol(name,shape,mat);
+    GeoPhysVol* pvSection = new GeoPhysVol(lvSection);
+    pvSection->ref();
+    
+    // Determine if this is a geometry where the first section can act as the mother of the following
+    // sections. The following sections are only added to this if their ave CLHEP::radius is within the CLHEP::radial
+    // extent and their ave z is within the z extent. 
+    // As soon as one section fails to meet this the latter sections are not considered.
+    if(secNum==1) {
+      pvMotherSection = pvSection;
+      rminSec1 = rMin1;
+      rmaxSec1 = rMax1;
+      zminSec1 = zmin;
+      zmaxSec1 = zmax;
+    }
+
+    if (addToFirstSection && secNum != 1) {
+      double rAve = 0.5*(rMin1+rMax1);
+      addToFirstSection = (znew > zminSec1 && znew < zmaxSec1 &&
+			   rAve > rminSec1 && rAve < rmaxSec1);
+    }
+	     
+
+    GeoTransform* tfSection = 0;
+    if (znew != 0 && (secNum==1 || !addToFirstSection)) tfSection = new GeoTransform(HepGeom::TranslateZ3D(znew));
+    GeoNameTag* ntSection = new GeoNameTag(name);
+    ntSection->ref();
+
+    if (addToFirstSection && secNum!=1) {
+      if (!pvMotherSection) {
+        MsgStream gLog(Athena::getMessageSvc(), "BeamPipeDetectorFactory");
+        gLog << MSG::ERROR << "Logic error building beam pipe." << endmsg;
+      }
+      else {
+        //std::cout << "Placing section " << secNum << " in Section1" << std::endl;
+        pvMotherSection->add(ntSection);
+        pvMotherSection->add(pvSection);
+      }
+    } else {
+      //std::cout << "Placing section " << secNum << " in mother envelope" << std::endl;
+      parent->add(ntSection);
+      if (tfSection) parent->add(tfSection);
+      parent->add(pvSection);
+    }
+
+    // Not needed, but just in case in the future we have +/- sections in central region
+    if(central && z!=0.) {
+      // add rotated section as well
+      GeoTransform* tfSectionRot = 0;
+      if (isTube) { 
+	// No need for rotation.
+	tfSectionRot = new GeoTransform(HepGeom::TranslateZ3D(-znew));
+      } else {
+	// For cone we need to rotate around Y axis.
+	tfSectionRot = new GeoTransform(HepGeom::TranslateZ3D(-znew)*HepGeom::RotateY3D(180*CLHEP::deg));
+      }
+      parent->add(ntSection);
+      parent->add(tfSectionRot);
+      parent->add(pvSection);
+    }
+
+    pvSection->unref();
+    ntSection->unref();
+  }
+}
+
+const BeamPipeDetectorManager * BeamPipeDetectorFactory::getDetectorManager() const
+{
+  return m_detectorManager;
+}
+
+void BeamPipeDetectorFactory::setTagNode(std::string tag, std::string node)
+{
+  m_versionTag = tag;
+  m_versionNode = node;
+}
+
+
+BeamPipeDetectorFactory::EnvelopeShapes
+BeamPipeDetectorFactory::makeEnvelope(IRDBRecordset_ptr bpipeEnvelope)
+{
+  EnvelopeShapes envelopes;
+
+  std::vector<EnvelopeEntry> centralEntry;
+  std::vector<EnvelopeEntry> fwdEntry;
+
+  for (unsigned int i=0; i<bpipeEnvelope->size(); i++) {
+    double z = (*bpipeEnvelope)[i]->getDouble("Z") * CLHEP::mm;
+    double r = (*bpipeEnvelope)[i]->getDouble("R") * CLHEP::mm;
+    EnvelopeEntry entry(z,r);
+    if (z < m_centralRegionZMax) {
+      centralEntry.push_back(entry);
+    } else {
+      fwdEntry.push_back(entry);
+    }
+  }
+
+  double rFwd = 0;
+  if (fwdEntry.size()) {
+    rFwd = fwdEntry[0].r();    
+  } else if (centralEntry.size()) {
+    rFwd = centralEntry[0].r();    
+  } else {
+    std::cout << "Unexpected condition when building beam pipe." << std::endl;
+  }
+ 
+  // central
+  if (centralEntry.size() == 0) {
+    envelopes.centralShape  = new GeoTube(0, rFwd, m_centralRegionZMax);
+  } else {
+    // This case probably will never get used and is untested.
+    GeoPcon* pcone = new GeoPcon(0, 360*CLHEP::deg);
+
+    pcone->addPlane(-m_centralRegionZMax,0,rFwd);
+    for (int i=centralEntry.size()-1; i>=0; i--) {  
+      double z = centralEntry[i].z();
+      double r = centralEntry[i].r();
+      pcone->addPlane(-z,0,r);
+    }
+    for (unsigned int i=0; i<centralEntry.size(); i++) {  
+      double z = centralEntry[i].z();
+      double r = centralEntry[i].r();
+      pcone->addPlane(z,0,r);
+    }
+    pcone->addPlane(m_centralRegionZMax,0,rFwd);
+    envelopes.centralShape = pcone;
+  }
+
+  
+  // forward
+  {
+    GeoPcon* pcone = new GeoPcon(0, 360*CLHEP::deg);
+    pcone->addPlane(m_centralRegionZMax,0,rFwd);
+    if (fwdEntry.size() == 0) { 
+      // Unlikely case but for completeness
+      // we make small fwd region if everything is in central region.
+      pcone->addPlane(m_centralRegionZMax+0.1*CLHEP::mm,0,rFwd);
+    }
+    for (unsigned int i=0; i<fwdEntry.size(); i++) {  
+      double z = fwdEntry[i].z();
+      double r = fwdEntry[i].r();
+      pcone->addPlane(z,0,r);
+    }
+    envelopes.fwdShape = pcone;
+  }
+
+  return envelopes;
+
+}
+
+
+BeamPipeDetectorFactory::EnvelopeShapes
+BeamPipeDetectorFactory::makeEnvelopeOld(IRDBRecordset_ptr atlasMother)
+{
+
+  double iir = (*atlasMother)[0]->getDouble("IDETIR")*CLHEP::cm;
+  double cir = (*atlasMother)[0]->getDouble("CALOIR")*CLHEP::cm;
+  double mir = (*atlasMother)[0]->getDouble("MUONIR")*CLHEP::cm;
+  double totlen = (*atlasMother)[0]->getDouble("ZMAX")*CLHEP::cm;
+  double ilen = (*atlasMother)[0]->getDouble("IDETZMX")*CLHEP::cm;
+  double clen = (*atlasMother)[0]->getDouble("CALOZMX")*CLHEP::cm;
+
+  // Central Section.
+  GeoTube * bpipeCentralShape = new GeoTube(0, iir, m_centralRegionZMax);
+
+  // Left/Right section. We create this once (as the +ve z section) and
+  // place th -ve section by doing a rotation.
+
+  // Right section (+ve z)
+
+  GeoPcon* bpipeEnvPcone = new GeoPcon(0, 360*CLHEP::deg);
+  bpipeEnvPcone->addPlane(m_centralRegionZMax,0,iir);
+  bpipeEnvPcone->addPlane(ilen,0,iir);
+  bpipeEnvPcone->addPlane(ilen,0,cir); 
+  bpipeEnvPcone->addPlane(clen,0,cir);
+  bpipeEnvPcone->addPlane(clen,0,mir);
+  bpipeEnvPcone->addPlane(totlen,0,mir);
+
+  // These get returned.
+  EnvelopeShapes envelopes;
+  envelopes.centralShape = bpipeCentralShape;
+  envelopes.fwdShape =  bpipeEnvPcone;
+  
+  return envelopes;
+}    
+
+

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorFactory.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef BeamPipeDetectorFactory_h
+#define BeamPipeDetectorFactory_h 1
+
+#include "GeoModelKernel/GeoVDetectorFactory.h"
+#include "BeamPipeGeoModel/BeamPipeDetectorManager.h"
+#include "RDBAccessSvc/IRDBAccessSvc.h"
+#include <string>
+
+class StoreGateSvc;
+class AbsMaterialManager;
+class GeoShape;
+
+class BeamPipeDetectorFactory : public GeoVDetectorFactory  
+{
+ public:
+  
+  // Constructor:
+  BeamPipeDetectorFactory(StoreGateSvc  *pDetStore,
+			  IRDBAccessSvc *pAccess);
+  
+  // Destructor:
+  ~BeamPipeDetectorFactory();
+  
+  // Creation of geometry:
+  virtual void create(GeoPhysVol *world);
+  
+  // Access to the results:
+  virtual const BeamPipeDetectorManager * getDetectorManager() const;
+  
+  // Set version Tag and Node
+  void setTagNode(std::string tag, std::string node);
+
+  void addSections(GeoPhysVol* parent, int region);
+
+ private:  
+
+  // small helper class
+  class EnvelopeEntry {
+  public:
+    EnvelopeEntry() :  m_z(0), m_r(0) {}
+    EnvelopeEntry(double z, double r) : m_z(z), m_r(r) {}
+    double z() const {return m_z;}
+    double r() const {return m_r;}
+  private:
+    double m_z;
+    double m_r;
+  };
+
+  class EnvelopeShapes {
+  public:
+    EnvelopeShapes() : centralShape(0), fwdShape(0) {} 
+    GeoShape * centralShape;
+    GeoShape * fwdShape;
+  };
+
+
+  EnvelopeShapes makeEnvelope(IRDBRecordset_ptr bpipeEnvelope);
+  EnvelopeShapes makeEnvelopeOld(IRDBRecordset_ptr atlasMother);
+
+
+  // Illegal operations:
+  const BeamPipeDetectorFactory & operator=(const BeamPipeDetectorFactory &right);
+  BeamPipeDetectorFactory(const BeamPipeDetectorFactory &right);
+  
+  // The manager:
+  BeamPipeDetectorManager     * m_detectorManager;
+   
+  const AbsMaterialManager * m_materialManager;
+
+  StoreGateSvc             * m_detectorStore;
+  IRDBAccessSvc            * m_access;
+  std::string              m_versionTag;
+  std::string              m_versionNode;
+
+  double m_centralRegionZMax;
+};
+
+// Class BeamPipeDetectorFactory 
+#endif
+
+

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorManager.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "BeamPipeGeoModel/BeamPipeDetectorManager.h"
+
+BeamPipeDetectorManager::BeamPipeDetectorManager()
+{
+  setName("BeamPipe");
+}
+
+
+BeamPipeDetectorManager::~BeamPipeDetectorManager()
+{
+  for (unsigned int i = 0; i < m_volume.size(); i++) {
+    m_volume[i]->unref();
+  }
+}
+
+
+unsigned int BeamPipeDetectorManager::getNumTreeTops() const
+{
+  return m_volume.size();
+}
+
+PVConstLink BeamPipeDetectorManager::getTreeTop(unsigned int i) const
+{
+  return m_volume[i];
+}
+
+void  BeamPipeDetectorManager::addTreeTop(PVLink vol)
+{
+  vol->ref();
+  m_volume.push_back(vol);
+}
+
+
+

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorTool.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "BeamPipeDetectorTool.h"
+#include "BeamPipeDetectorFactory.h" 
+#include "BeamPipeGeoModel/BeamPipeDetectorManager.h" 
+
+#include "GeoModelInterfaces/IGeoDbTagSvc.h"
+#include "GeoModelUtilities/GeoModelExperiment.h"
+#include "GaudiKernel/IService.h"
+#include "GaudiKernel/ISvcLocator.h"
+#include "GaudiKernel/MsgStream.h"
+
+#include "StoreGate/StoreGateSvc.h"
+
+#include "RDBAccessSvc/IRDBAccessSvc.h"
+#include "AthenaKernel/ClassID_traits.h"
+#include "SGTools/DataProxy.h"
+
+BeamPipeDetectorTool::BeamPipeDetectorTool( const std::string& type, 
+					    const std::string& name, 
+					    const IInterface* parent ): 
+  GeoModelTool(type,name,parent),
+  m_manager(0)
+{
+}
+
+BeamPipeDetectorTool::~BeamPipeDetectorTool()
+{
+}
+
+
+StatusCode BeamPipeDetectorTool::create()
+{ 
+  MsgStream log(msgSvc(), name()); 
+
+  log << MSG::INFO << "Building Beam Pipe" << endmsg;
+
+  IGeoDbTagSvc *geoDbTag;
+  StatusCode sc = service ("GeoDbTagSvc",geoDbTag);
+  if (sc.isFailure()) {
+    log << MSG::FATAL << "Could not locate GeoDbTagSvc" << endmsg;
+    return StatusCode::FAILURE;
+  }
+    
+
+  std::string atlasVersion = geoDbTag->atlasVersion();
+  if(atlasVersion == "AUTO")
+    atlasVersion = "ATLAS-00";
+  std::string versionNode = "ATLAS";
+
+  GeoModelExperiment * theExpt; 
+  if (StatusCode::SUCCESS != detStore()->retrieve( theExpt, "ATLAS" )) { 
+    log << MSG::ERROR 
+	<< "Could not find GeoModelExperiment ATLAS" 
+	<< endmsg; 
+    return (StatusCode::FAILURE); 
+  } 
+
+  if ( 0 == m_detector ) 
+  {
+    GeoPhysVol *world=&*theExpt->getPhysVol();
+
+    IRDBAccessSvc* raccess = 0;
+    sc = service("RDBAccessSvc",raccess);
+    if (sc.isFailure()) {
+      log << MSG::FATAL << "Could not locate RDBAccessSvc" << endmsg;
+      return StatusCode::FAILURE;
+    }
+
+    // Check we have the beampipe and print its version
+    // Print the  version tag:
+    std::string beampipeVersionTag;
+    beampipeVersionTag = raccess->getChildTag("BeamPipe", atlasVersion,versionNode);
+    log << MSG::DEBUG << "Beampipe Version: " << beampipeVersionTag << endmsg;
+
+
+    if (beampipeVersionTag.empty()) { 
+      log << MSG::INFO << "No BeamPipe Version. Beam pipe will not be built." << endmsg;
+      
+    } else {
+      
+      BeamPipeDetectorFactory theBeamPipeFactory(detStore().operator->(),raccess);
+      theBeamPipeFactory.setTagNode(atlasVersion,versionNode);
+      theBeamPipeFactory.create(world);
+
+      m_manager = theBeamPipeFactory.getDetectorManager();
+      theExpt->addManager(m_manager);
+      sc = detStore()->record(m_manager,
+			    m_manager->getName());
+    
+
+      if (sc.isFailure()) {
+	log << MSG::ERROR << "Could not register BeamPipe detector manager" << endmsg;
+	return (StatusCode::FAILURE); 
+      }
+    }
+    return StatusCode::SUCCESS;
+  }
+  return StatusCode::FAILURE;
+}
+
+StatusCode BeamPipeDetectorTool::clear()
+{
+  SG::DataProxy* proxy = detStore()->proxy(ClassID_traits<BeamPipeDetectorManager>::ID(),m_manager->getName());
+  if(proxy) {
+    proxy->reset();
+    m_manager = 0;
+  }
+  return StatusCode::SUCCESS;
+}

AtlasGeometryCommon/BeamPipeGeoModel/src/BeamPipeDetectorTool.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef BEAMPIPEDETECTORTOOL_H
+#define BEAMPIPEDETECTORTOOL_H
+
+#include "GeoModelUtilities/GeoModelTool.h"
+class BeamPipeDetectorManager;
+
+class BeamPipeDetectorTool : public GeoModelTool 
+{
+ public:
+
+  // Standard Constructor
+  BeamPipeDetectorTool( const std::string& type, const std::string& name, const IInterface* parent );
+
+  // Standard Destructor
+  virtual ~BeamPipeDetectorTool() override final;
+
+  virtual StatusCode create() override final;
+  virtual StatusCode clear() override final;
+ private:
+  const BeamPipeDetectorManager* m_manager;
+};
+
+#endif 

AtlasGeometryCommon/BeamPipeGeoModel/src/components/BeamPipeGeoModel_entries.cxx

+#include "../BeamPipeDetectorTool.h"
+
+DECLARE_COMPONENT( BeamPipeDetectorTool )
+

AtlasGeometryCommon/CavernInfraGeoModel/CMakeLists.txt

+################################################################################
+# Package: CavernInfraGeoModel
+################################################################################
+
+# Declare the package name:
+atlas_subdir( CavernInfraGeoModel )
+
+# Declare the package's dependencies:
+atlas_depends_on_subdirs( PUBLIC
+                          Control/AthenaKernel
+                          Database/RDBAccessSvc
+                          DetectorDescription/GeoModel/GeoModelKernel
+                          DetectorDescription/GeoModel/GeoModelUtilities
+                          PRIVATE
+                          Control/StoreGate
+                          DetectorDescription/GeoModel/GeoModelInterfaces
+                          GaudiKernel )
+
+# External dependencies:
+find_package( Boost COMPONENTS filesystem thread system )
+find_package( CLHEP )
+find_package( CORAL COMPONENTS CoralBase CoralKernel RelationalAccess )
+
+# Component(s) in the package:
+atlas_add_component( CavernInfraGeoModel
+                     src/*.cxx
+                     src/components/*.cxx
+                     INCLUDE_DIRS ${Boost_INCLUDE_DIRS} ${CORAL_INCLUDE_DIRS} ${CLHEP_INCLUDE_DIRS}
+                     LINK_LIBRARIES ${Boost_LIBRARIES} ${CORAL_LIBRARIES} ${CLHEP_LIBRARIES} GeoModelKernel GeoModelUtilities StoreGateLib SGtests GaudiKernel )
+
+# Install files from the package:
+atlas_install_headers( CavernInfraGeoModel )
+

AtlasGeometryCommon/CavernInfraGeoModel/CavernInfraGeoModel/CavernInfraDetectorManager.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef CavernInfraDetectorManager_h
+#define CavernInfraDetectorManager_h 1
+
+#include "GeoModelKernel/GeoVPhysVol.h"
+#include "GeoModelKernel/GeoVDetectorManager.h"
+#include <vector>
+
+class CavernInfraDetectorManager : public GeoVDetectorManager  
+{
+ public:
+
+  // Constructor
+  CavernInfraDetectorManager();
+
+  // Destructor
+  ~CavernInfraDetectorManager();
+
+  // Access to raw geometry:
+  virtual unsigned int getNumTreeTops() const;
+  virtual PVConstLink getTreeTop(unsigned int i) const;
+ 
+  void addTreeTop(PVLink);      // Add a Tree top:
+
+ private:  
+
+  const CavernInfraDetectorManager & operator=(const CavernInfraDetectorManager &right);
+  CavernInfraDetectorManager(const CavernInfraDetectorManager &right);
+  
+  // Tree Tops
+  std::vector<PVLink> m_treeTops;
+};
+
+#ifndef GAUDI_NEUTRAL
+#include "AthenaKernel/CLASS_DEF.h" 
+CLASS_DEF(CavernInfraDetectorManager, 1500000300, 1)
+#endif
+
+#endif
+
+