Commit 7d145dec authored by Matthew Scott Rudolph's avatar Matthew Scott Rudolph Committed by Graeme Stewart
Browse files

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

parent 456cbf65
/*
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
/*
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
/*
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
/*
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
/*
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
/*
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
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRTHit_h
#define TRTHit_h