include barrelendcap range extension for dbm dictionaries (InDetSimEvent-00-05-08)

InnerDetector/InDetSimEvent/InDetSimEvent/InDetSimEventDict.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef INDETSIMEVENT_INDETSIMEVENTDICT_H
+#define INDETSIMEVENT_INDETSIMEVENTDICT_H
+
+#include "InDetSimEvent/SiHitCollection.h"
+#include "InDetSimEvent/TRTUncompressedHitCollection.h"
+
+#endif

InnerDetector/InDetSimEvent/InDetSimEvent/SiCharge.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SiCharge.h
+//   Header file for class SiCharge
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class which contains the bare charge deposited by a single process
+///////////////////////////////////////////////////////////////////
+// Version 1.4 08/06/2001 David Calvet
+///////////////////////////////////////////////////////////////////
+
+#ifndef SITRACKEREVENT_SICHARGE_H
+#define SITRACKEREVENT_SICHARGE_H
+
+#include <iostream>
+
+// Member classes
+#include "GeneratorObjects/HepMcParticleLink.h"
+
+class SiCharge {
+
+public:
+  enum Process {no,track,diodeX_Talk,cellX_Talk,noise,extraNoise,cut_track};
+
+  ///////////////////////////////////////////////////////////////////
+  // Public methods:
+  ///////////////////////////////////////////////////////////////////
+public:
+
+  // Copy constructor:
+  SiCharge(const SiCharge &charge);
+
+  // Constructor with parameters:
+  //   deposited charge
+  //   time of deposition
+  //   type of process which produced this charge
+  //   Particle Link to the particle generating the Charge
+  SiCharge(const double& charge,const double& time,
+	   const Process& processType,const HepMcParticleLink& PL);
+
+  SiCharge(const double& charge,const double& time,
+	   const Process& processType);
+
+  // Destructor:
+  ~SiCharge();
+
+  // Assignment operator:
+  SiCharge &operator=(const SiCharge &charge);
+
+  ///////////////////////////////////////////////////////////////////
+  // Const methods:
+  ///////////////////////////////////////////////////////////////////
+
+  // deposited charge:
+  double charge() const;
+
+  // time of deposition:
+  double time() const;
+
+  // type of process which produced this charge:
+  Process processType() const;
+
+  // Barcode of the particle generating the charge:
+  int trackBarcode() const;
+
+  // Particle Link of the particle generating the charge
+  const HepMcParticleLink& particleLink() const;
+
+  ///////////////////////////////////////////////////////////////////
+  // Non-const methods:
+  ///////////////////////////////////////////////////////////////////
+
+  // add another charge, if the process and track are the same:
+  //   returns true if the charge was added
+  bool add(const SiCharge &charge);
+
+  ///////////////////////////////////////////////////////////////////
+  // Private methods:
+  ///////////////////////////////////////////////////////////////////
+private:
+
+  SiCharge();
+
+  ///////////////////////////////////////////////////////////////////
+  // Private data:
+  ///////////////////////////////////////////////////////////////////
+private:
+  double m_charge; // deposited charge
+  double m_time; // time of deposition
+  Process m_processType; // type of process which produced this charge
+  //  int m_trackNumber; // track number in case of track process
+  HepMcParticleLink m_partLink; //Replace the track number with a PL
+};
+
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+inline SiCharge::~SiCharge() 
+{}
+
+inline double SiCharge::charge() const 
+{
+  return m_charge;
+}
+
+inline double SiCharge::time() const 
+{
+  return m_time;
+}
+
+inline SiCharge::Process SiCharge::processType() const 
+{
+  return m_processType;
+}
+
+inline int SiCharge::trackBarcode() const 
+{
+  return m_partLink.barcode();
+}
+
+inline const HepMcParticleLink& SiCharge::particleLink() const 
+{
+  return m_partLink;
+}
+
+///////////////////////////////////////////////////////////////////
+// Input/Output stream functions:
+///////////////////////////////////////////////////////////////////
+std::ostream &operator<<(std::ostream &out,const SiCharge &charge);
+
+#endif // SITRACKEREVENT_SICHARGE_H

InnerDetector/InDetSimEvent/InDetSimEvent/SiHit.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SiHit.h
+//   Header file for class SiHit
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class for the Pixel and SCT hits
+///////////////////////////////////////////////////////////////////
+
+#ifndef SITRACKEREVENT_SIHIT_H
+#define SITRACKEREVENT_SIHIT_H
+
+#include <iostream>
+// Data members classes
+#include "CLHEP/Geometry/Point3D.h"
+#include "GeneratorObjects/HepMcParticleLink.h"
+
+class SiHit  {
+
+  ///////////////////////////////////////////////////////////////////
+  // Public methods:
+  ///////////////////////////////////////////////////////////////////
+public:
+
+  // Constructor with parameters:
+  //   local start position of the energy deposit
+  //   local end position of the energy deposit
+  //   deposited energy
+  //   time of energy deposition
+  //   number of track which released this energy
+  //
+  SiHit(const HepGeom::Point3D<double> &localStartPosition,
+	       const HepGeom::Point3D<double> &localEndPosition,
+	       const double energyLoss,
+	       const double meanTime,
+	       const int trackNumber,
+	       const unsigned int id); 
+
+  SiHit(const HepGeom::Point3D<double> &localStartPosition,
+	       const HepGeom::Point3D<double> &localEndPosition,
+	       const double energyLoss,
+	       const double meanTime,
+	       const int trackNumber,
+	       const int, const int, const int, const int, const int, const int);
+// needed by athenaRoot
+  SiHit();
+
+  // Destructor:
+  virtual ~SiHit(); //temporary make it virtual for Pool!
+
+  ///////////////////////////////////////////////////////////////////
+  // Const methods:
+  ///////////////////////////////////////////////////////////////////
+
+  unsigned int identify() const;
+
+  // local start position of the energy deposit:
+  HepGeom::Point3D<double> localStartPosition() const;
+
+  HepGeom::Point3D<double> localEndPosition() const;
+
+  // deposited energy:
+  double energyLoss() const;
+
+  // time of energy deposition: FIXME name!
+  double meanTime() const;
+
+  // Set the time of energy deposition: FIXME name!
+  void setMeanTime(float meanTime);
+
+  // number of track which released this energy:
+  int trackNumber() const;
+
+  // link to the particle generating the hit
+  const HepMcParticleLink& particleLink() const;
+
+  // Pixel or SCT
+  bool isPixel() const;
+  bool isSCT() const;
+  
+  // Barrel or Endcap
+  int getBarrelEndcap() const;
+
+  // Layer/Disk
+  int getLayerDisk() const;
+  
+  // eta module
+  int getEtaModule() const;
+
+  // phi module
+  int getPhiModule() const;
+  
+  // side
+  int getSide() const;
+
+  // some print-out:
+  void print() const;
+  
+  bool operator < (const SiHit& rhs) const
+    {return m_ID < rhs.m_ID;}
+  
+  ///////////////////////////////////////////////////////////////////
+  // Non-const methods:
+  ///////////////////////////////////////////////////////////////////
+  // Scale the length, used to go from cm to mm, of whatever we like.
+  void ScaleLength(double);
+
+  ///////////////////////////////////////////////////////////////////
+  // copy c'tor made public on 23-5-2008 to allow copy of athenahitsvector<sihit>
+  ///////////////////////////////////////////////////////////////////
+
+
+  ///////////////////////////////////////////////////////////////////
+  // Private data:
+  ///////////////////////////////////////////////////////////////////
+private:
+ 
+  //  HepGeom::Point3D<double> m_localStartPosition; // local start position of the hit
+  //  HepGeom::Point3D<double> m_localEndPosition; // local end position of the hit
+  float m_stX, m_stY, m_stZ;
+  float m_enX, m_enY, m_enZ;
+  float m_energyLoss; // deposited energy
+  float m_meanTime; // time of energy deposition
+  HepMcParticleLink m_partLink;
+  //   int m_trackNumber; // number of track which released this energy
+  unsigned int m_ID;
+ public:
+  enum
+    { xDep = 0, xPhi = 1, xEta = 2};
+};
+
+
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+
+inline unsigned int SiHit::identify() const 
+{
+  return m_ID;
+}
+
+inline double SiHit::energyLoss() const
+{
+  return (double) m_energyLoss;
+}
+
+inline double SiHit::meanTime() const
+{
+  return (double) m_meanTime;
+}
+
+inline void SiHit::setMeanTime(float meanTime) 
+{
+  m_meanTime=meanTime;
+}
+
+inline const HepMcParticleLink& SiHit::particleLink() const
+{
+  return m_partLink;
+}
+
+
+
+///////////////////////////////////////////////////////////////////
+// open functions:
+///////////////////////////////////////////////////////////////////
+
+inline float hitTime(const SiHit& hit)
+{
+  return (float) hit.meanTime();
+}
+
+#endif // SITRACKEREVENT_SITRACKERHIT_H

InnerDetector/InDetSimEvent/InDetSimEvent/SiHitCollection.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef SITRACKEREVENT_SIHITCOLLECTION_H
+#define SITRACKEREVENT_SIHITCOLLECTION_H
+
+#include "InDetSimEvent/SiHit.h"
+#include "HitManagement/AtlasHitsVector.h"
+#include "HitManagement/AthenaHitsVector.h"// for back compatibility
+#ifndef __CINT__
+  #include "CLIDSvc/CLASS_DEF.h"
+#endif
+typedef AthenaHitsVector<SiHit> SiOldHitCollection;
+
+typedef AtlasHitsVector<SiHit> SiHitCollection;
+typedef AtlasHitsVector<SiHit>::iterator SiHitIterator;
+typedef AtlasHitsVector<SiHit>::const_iterator SiHitConstIterator;
+
+#ifndef __CINT__
+  CLASS_DEF(SiHitCollection, 2545 , 1 ) 
+  CLASS_DEF(SiOldHitCollection, 1175907564, 1 ) 
+#endif
+
+#endif // SITRACKEREVENT_SIHITCOLLECTION_H

InnerDetector/InDetSimEvent/InDetSimEvent/SiHitIdHelper.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef INDETSIMEVENT_SIHITIDHELPER
+#define INDETSIMEVENT_SIHITIDHELPER
+
+//
+// This is a helper class to build an identifing integer used by 
+// the simulation. It inherits from HitIdHelper, in order to get
+// all the packing and shifting for free. 
+// The class is a singleton and a static GetHelper() is provided 
+// the constructor calls the Initialize() method which sets all the 
+// field dimensions
+// Methods are provided to get access to the SiTracker Geometry
+// description
+//
+
+
+//
+// Base Class
+#include "HitManagement/HitIdHelper.h"
+
+
+class SiHitIdHelper : HitIdHelper {
+ public:
+  //
+  // Access to the helper
+  static SiHitIdHelper* GetHelper();  
+  //
+  // Info retrieval:
+  // Pixel or SCT
+  bool isPixel(const int& hid);
+  bool isSCT(const int& hid);
+  
+  // Barrel or Endcap
+  int getBarrelEndcap(const int& hid);
+
+  // Layer/Disk
+  int getLayerDisk(const int& hid);
+  
+  // eta module
+  int getEtaModule(const int& hid);
+
+  // phi module&
+  int getPhiModule(const int& hid);
+  
+  // side
+  int getSide(const int& hid);
+  //
+  // Info packing:
+  int buildHitId(const int, const int, const int, const int, const int, const int);
+
+ private:
+  //
+  // private constructor to have a singleton
+  SiHitIdHelper(); 
+  //
+  // Initialize the helper, only called by the constructor
+  void Initialize();  
+ private:
+  //
+  // private data:
+  static SiHitIdHelper* m_help;
+};
+
+#endif // INDETSIMEVENT_SIHITIDHELPER

InnerDetector/InDetSimEvent/InDetSimEvent/SiTotalCharge.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+///////////////////////////////////////////////////////////////////
+// SiTotalCharge.h
+//   Header file for class SiTotalCharge
+///////////////////////////////////////////////////////////////////
+// (c) ATLAS Detector software
+///////////////////////////////////////////////////////////////////
+// Class which contains the sum and the composition of all bare charges
+// corresponding to a single element
+///////////////////////////////////////////////////////////////////
+// Version 1.5 08/06/2001 David Calvet
+///////////////////////////////////////////////////////////////////
+
+#ifndef SITRACKEREVENT_SITOTALCHARGE_H
+#define SITRACKEREVENT_SITOTALCHARGE_H
+
+#include <list>
+#include "InDetSimEvent/SiCharge.h"
+#include "DataModel/tools/ArenaSharedHeapSTLAllocator.h"
+
+class SiTotalCharge {
+
+  ///////////////////////////////////////////////////////////////////
+  // Public methods:
+  ///////////////////////////////////////////////////////////////////
+public:
+
+  typedef SG::ArenaSharedHeapSTLAllocator<SiCharge> alloc_t;
+  typedef std::list<SiCharge, alloc_t> list_t;
+
+  // Implicit constructor:
+  SiTotalCharge(const alloc_t& alloc);
+
+  // Copy constructor:
+  SiTotalCharge(const SiTotalCharge &totalCharge);
+
+  // Destructor:
+  ~SiTotalCharge();
+
+  // Assignment operator:
+  SiTotalCharge &operator=(const SiTotalCharge &totalCharge);
+
+  ///////////////////////////////////////////////////////////////////
+  // Const methods:
+  ///////////////////////////////////////////////////////////////////
+
+  // total deposited charge in this element:
+  double charge() const;
+
+  // list of individual charges:
+  const list_t &chargeComposition() const;
+
+  // return true if the charge composition contains more than one charge:
+  bool complexCharge() const;
+
+  // return true if the main charge comes from a track (track/diodeX_Talk):
+  bool fromTrack() const;
+
+  // return true if the main charge is extraNoise:
+  bool extraNoise() const;
+
+  // return the barcode of the main charge:
+  int trackBarcode() const;
+
+  // returns the HepMcParticleLink of the main charge
+  const HepMcParticleLink& particleLink() const;
+
+  // return the time of the main charge
+  double time() const;
+  ///////////////////////////////////////////////////////////////////
+  // Non-const methods:
+  ///////////////////////////////////////////////////////////////////
+
+  // add another SiCharge:
+  void add(const SiCharge &charge);
+
+  // add another SiTotalCharge:
+  void add(const SiTotalCharge &totalCharge);
+
+  // remove time information of the SiCharge objects:
+  void removeTimeInformation();
+
+  // remove small SiCharge objects:
+  //   minimum charge allowed to keep a SiCharge in the composition list
+  void removeSmallCharges(const double minimumCharge);
+
+  ///////////////////////////////////////////////////////////////////
+  // Private methods:
+  ///////////////////////////////////////////////////////////////////
+private:
+
+  // add another SiCharge to the charge composition (not the total value):
+  void addSiCharge(const SiCharge &charge);
+
+  // return the SiCharge corresponding to the process which deposited
+  // the biggest amount of charge (returns dummy charge if list is empty)
+  // (used to be a public method, but this caused problems if the list was empty):
+  const SiCharge& mainCharge() const;
+
+  ///////////////////////////////////////////////////////////////////
+  // Private data:
+  ///////////////////////////////////////////////////////////////////
+private:
+  double m_charge; // total deposited charge in this element
+  list_t m_chargeComposition; // list of individual charges
+  HepMcParticleLink m_emptyLink;
+};
+
+///////////////////////////////////////////////////////////////////
+// Inline methods:
+///////////////////////////////////////////////////////////////////
+inline SiTotalCharge::~SiTotalCharge()
+{
+}
+
+inline double SiTotalCharge::charge() const 
+{
+  return m_charge;
+}
+
+inline const SiTotalCharge::list_t &SiTotalCharge::chargeComposition() const 
+{
+  return m_chargeComposition;
+}
+
+inline bool SiTotalCharge::complexCharge() const 
+{
+  return (m_chargeComposition.size()>1);
+}
+
+inline bool SiTotalCharge::extraNoise() const 
+{
+  if(m_chargeComposition.empty())
+    {
+      return false;
+    }
+  return (mainCharge().processType()==SiCharge::extraNoise);
+}
+
+inline int SiTotalCharge::trackBarcode() const 
+{
+  if(m_chargeComposition.empty())
+    {
+      return 0;
+    }
+  return mainCharge().trackBarcode();
+}
+
+inline double SiTotalCharge::time() const 
+{
+  if(m_chargeComposition.empty())
+    {
+      return 0.0;
+    }
+  return mainCharge().time();
+}
+
+inline const HepMcParticleLink& SiTotalCharge::particleLink() const
+{
+  if(m_chargeComposition.empty())
+    {
+      return m_emptyLink;
+    }
+  return mainCharge().particleLink();
+}
+
+
+///////////////////////////////////////////////////////////////////
+// Input/Output stream functions:
+///////////////////////////////////////////////////////////////////
+std::ostream &operator<<(std::ostream &out,const SiTotalCharge &totalCharge);
+
+#endif // SITRACKEREVENT_SITOTALCHARGE_H

InnerDetector/InDetSimEvent/InDetSimEvent/TRTHit.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#ifndef TRTHit_h
+#define TRTHit_h