ISF::G4PolyconeGeoIDSvc Class Reference

#include <G4PolyconeGeoIDSvc.h>

Inheritance diagram for ISF::G4PolyconeGeoIDSvc:

Collaboration diagram for ISF::G4PolyconeGeoIDSvc:

Public Member Functions
	G4PolyconeGeoIDSvc (const std::string &name, ISvcLocator *svc)
	Constructor with parameters.
	~G4PolyconeGeoIDSvc ()
	Destructor.
StatusCode	initialize ()
AtlasDetDescr::AtlasRegion	identifyGeoID (const Amg::Vector3D &pos) const
	A static filter that returns the AtlasRegion of the given position.
ISF::InsideType	inside (const Amg::Vector3D &pos, AtlasDetDescr::AtlasRegion geoID) const
	Checks if the given position (ISFParticle) is inside a given AtlasRegion.
AtlasDetDescr::AtlasRegion	identifyNextGeoID (const Amg::Vector3D &pos, const Amg::Vector3D &dir) const
	Find the AtlasRegion that the particle will enter with its next infinitesimal step along the given direction.

Private Member Functions
StatusCode	fillDimensions ()
	Retrieve and fill in the dimensions for the different AtlasRegion.
void	pushDimension (AtlasDetDescr::AtlasRegion geoID, double rin, double rou, double z)
void	pushDimension (AtlasDetDescr::AtlasRegion geoID, double r, double z)
StatusCode	createVolume (AtlasDetDescr::AtlasRegion geoID)
	Retrieve and fill in the dimensions for the different AtlasRegion.

Private Attributes
ServiceHandle< IEnvelopeDefSvc >	m_envDefSvc {this, "EnvelopeDefSvc", "AtlasGeometry_EnvelopeDefSvc"}
	service providing the envelope dimensions for the different sub-detectors
G4VSolid *	m_volume [AtlasDetDescr::fNumAtlasRegions]
ISF::InsideType	m_typeConverter [ISF::fNumInsideTypes]
	a quick way to convert G4 enum EInside to ISF::InsideType

Detailed Description

Todo

Author

Elmar.Ritsch -at- cern.ch

Definition at line 39 of file G4PolyconeGeoIDSvc.h.

Constructor & Destructor Documentation

G4PolyconeGeoIDSvc()

ISF::G4PolyconeGeoIDSvc::G4PolyconeGeoIDSvc	(	const std::string &	name,
		ISvcLocator *	svc )

Constructor with parameters.

Constructor.

Definition at line 33 of file G4PolyconeGeoIDSvc.cxx.

                                                                                :
  base_class(name,svc),
  m_volume(),
  m_typeConverter()
{
}

~G4PolyconeGeoIDSvc()

ISF::G4PolyconeGeoIDSvc::~G4PolyconeGeoIDSvc

(

)

Destructor.

Definition at line 42 of file G4PolyconeGeoIDSvc.cxx.

{
}

Member Function Documentation

createVolume()

StatusCode ISF::G4PolyconeGeoIDSvc::createVolume ( AtlasDetDescr::AtlasRegion geoID )

private

Retrieve and fill in the dimensions for the different AtlasRegion.

Definition at line 132 of file G4PolyconeGeoIDSvc.cxx.

{
 
  // ensure a proper numeric value for geoID
  assert(validAtlasRegion(geoID));
 
  ATH_MSG_INFO( "Building envelope volume for '" << AtlasDetDescr::AtlasRegionHelper::getName(geoID)
                << "' (GeoID="<< geoID << ").");
 
  // resetting volume for current geoID
  m_volume[geoID] = 0;
 
  // volume definitions
  const double phimin    = 0.;
  const double deltaphi  = 360.*CLHEP::deg;
  const std::string volumeName( AtlasDetDescr::AtlasRegionHelper::getName(geoID));
 
  {
    // retrieve the vector of (r,z) values from the EnvelopeDefSvc
    const RZPairVector &rz = m_envDefSvc->getRZBoundary( geoID );
 
    // entries in the database table
    size_t curVolNumPoints = rz.size();
    if ( !curVolNumPoints)
      {
        ATH_MSG_ERROR("No entries for " << AtlasDetDescr::AtlasRegionHelper::getName(geoID) << " envelope in envelope definition service. Unable to build envelope.");
        // resources cleanup
        return StatusCode::FAILURE;
      }
 
    // arrays of (r,z) coordinates of the current envelope volume
    double *z = new double[curVolNumPoints];
    double *r = new double[curVolNumPoints];
 
    // convert vector of pairs into two arrays
    RZPairVector::const_iterator rzIt = rz.begin();
    for ( size_t i=0; i<curVolNumPoints; ++i)
      {
        r[i] = rzIt->first;
        z[i] = rzIt->second;
 
        ++rzIt;
      }
 
    // create a G4Polycone volume with the given dimensions
    std::stringstream curName;
    curName << volumeName;
    // store it in the m_volume array
    m_volume[geoID] = new G4Polycone( curName.str(), phimin, deltaphi, curVolNumPoints, r, z);
    // set the volume name
    m_volume[geoID]->SetName( volumeName);
 
    // cleanup
    delete[] r;
    delete[] z;
  }
 
  return StatusCode::SUCCESS;
}

fillDimensions()

StatusCode ISF::G4PolyconeGeoIDSvc::fillDimensions ( )

private

Retrieve and fill in the dimensions for the different AtlasRegion.

identifyGeoID()

AtlasDetDescr::AtlasRegion ISF::G4PolyconeGeoIDSvc::identifyGeoID

(

const Amg::Vector3D &

pos

)

const

A static filter that returns the AtlasRegion of the given position.

Definition at line 94 of file G4PolyconeGeoIDSvc.cxx.

{
  // loop over geoIDs
  for (unsigned short geoID=AtlasDetDescr::fFirstAtlasRegion; geoID<AtlasDetDescr::fNumAtlasRegions; ++geoID)
    {
      // point inside given geoID -> return geoID
      if ( inside(pos, AtlasDetDescr::AtlasRegion(geoID))==ISF::fInside)
        {
          return AtlasDetDescr::AtlasRegion(geoID);
        }
    }
  // point is not inside any of the registered geoIDs
  return AtlasDetDescr::fUndefinedAtlasRegion;
}

identifyNextGeoID()

AtlasDetDescr::AtlasRegion ISF::G4PolyconeGeoIDSvc::identifyNextGeoID	(	const Amg::Vector3D &	pos,
		const Amg::Vector3D &	dir ) const

Find the AtlasRegion that the particle will enter with its next infinitesimal step along the given direction.

Definition at line 110 of file G4PolyconeGeoIDSvc.cxx.

{
 
  // if position inside a volume -> return that volume as the next geoID
  AtlasDetDescr::AtlasRegion geoID = identifyGeoID(pos);
  if (validAtlasRegion(geoID))
    {
      return geoID;
    }
  //not inside - make a step towards the p direction and check if inside again
  const Amg::Vector3D &dirUnit = dir.unit();
  const Amg::Vector3D &posStep = pos+dirUnit;
  AtlasDetDescr::AtlasRegion closestGeoID = identifyGeoID(posStep);
  if (validAtlasRegion(closestGeoID))
    {
      return closestGeoID;
    }
  return AtlasDetDescr::fUndefinedAtlasRegion;
}

initialize()

StatusCode ISF::G4PolyconeGeoIDSvc::initialize

(

)

Definition at line 48 of file G4PolyconeGeoIDSvc.cxx.

{
  ATH_MSG_VERBOSE("initialize()");
 
  // retrieve envelope definition service
  ATH_CHECK( m_envDefSvc.retrieve() );
 
  // create internal volume representations for the given dimensions
  for (int geoID=AtlasDetDescr::fFirstAtlasRegion; geoID<AtlasDetDescr::fNumAtlasRegions; ++geoID)
    {
      if ( createVolume( AtlasDetDescr::AtlasRegion(geoID)).isFailure())
        {
          ATH_MSG_ERROR("Unable to create volume representation for geoID="<<geoID);
        }
    }
 
  // setup the converter for: G4 enum to ISF::InsideType
  m_typeConverter[kOutside] = ISF::fOutside;
  m_typeConverter[kSurface] = ISF::fSurface;
  m_typeConverter[kInside]  = ISF::fInside;
 
  return StatusCode::SUCCESS;
}

inside()

ISF::InsideType ISF::G4PolyconeGeoIDSvc::inside	(	const Amg::Vector3D &	pos,
		AtlasDetDescr::AtlasRegion	geoID ) const

Checks if the given position (ISFParticle) is inside a given AtlasRegion.

Definition at line 73 of file G4PolyconeGeoIDSvc.cxx.

{
  // initialized with default return value
  InsideType where = ISF::fOutside;
 
  // check for volume to be present
  G4VSolid *curVol = m_volume[geoID];
  if (curVol)
    {
      G4ThreeVector posG4( pos.x(), pos.y(), pos.z() );
      EInside g4Where = curVol->Inside( posG4 );
 
      // use this trick to quickly convert G4 type to ISF::InsideType
      where = m_typeConverter[g4Where];
    }
 
  // hand back the position information
  return where;
}

pushDimension() [1/2]

void ISF::G4PolyconeGeoIDSvc::pushDimension ( AtlasDetDescr::AtlasRegion geoID, double r, double z )

private

Todo

pushDimension() [2/2]

void ISF::G4PolyconeGeoIDSvc::pushDimension ( AtlasDetDescr::AtlasRegion geoID, double rin, double rou, double z )

private

Todo

Member Data Documentation

m_envDefSvc

ServiceHandle<IEnvelopeDefSvc> ISF::G4PolyconeGeoIDSvc::m_envDefSvc {this, "EnvelopeDefSvc", "AtlasGeometry_EnvelopeDefSvc"}

private

service providing the envelope dimensions for the different sub-detectors

Definition at line 74 of file G4PolyconeGeoIDSvc.h.

{this, "EnvelopeDefSvc", "AtlasGeometry_EnvelopeDefSvc"};

m_typeConverter

ISF::InsideType ISF::G4PolyconeGeoIDSvc::m_typeConverter[ISF::fNumInsideTypes]

private

a quick way to convert G4 enum EInside to ISF::InsideType

Definition at line 80 of file G4PolyconeGeoIDSvc.h.

m_volume

G4VSolid* ISF::G4PolyconeGeoIDSvc::m_volume[AtlasDetDescr::fNumAtlasRegions]

private

Todo

:

Definition at line 77 of file G4PolyconeGeoIDSvc.h.

---

The documentation for this class was generated from the following files:

• G4PolyconeGeoIDSvc.h
• G4PolyconeGeoIDSvc.cxx