Writes the GeoModel muon geometry to an XML file for use with Atlantis. More...

#include <MuonGeometryWriter.h>

Inheritance diagram for JiveXML::MuonGeometryWriter:

Collaboration diagram for JiveXML::MuonGeometryWriter:

Public Member Functions
	MuonGeometryWriter (const std::string &t, const std::string &n, const IInterface *p)
	Constructor. More...

virtual StatusCode	writeGeometry ()
	Writes the geometry of the ATLAS muon spectrometer to an XML file for use with Atlantis. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	writeHeader (std::ofstream &out) const
	Writes the header of the XML file to a stream. More...

void	writeStations (std::ofstream &out) const
	Retrieves all stations from GeoModel and writes the corresponding XML elements to a stream. More...

void	processNSW (std::ofstream &out)
	process the geometry of New Small Wheel More...

void	writeFooter (std::ofstream &out) const
	Writes the footer of the XML file to a stream. More...

void	writeATrd (std::ofstream &out, const std::string &stationTech, const std::string &stationName, double zi, double zo, double ri, double ro, double wi, double wo, int eta, const std::string &phiString, double dphi, double shift, double alpha) const
	Writes a trapezoid station in XML to a stream. More...

HepGeom::Point3D< double >	getPosition (const MuonGM::MuonStation *station, int maxPhi) const
	Returns the global position of the station, rotated to sector 1. More...

double	getDeltaPhi (const HepGeom::Point3D< double > &pos, int maxPhi) const
	Returns the rotation of the station with respect to the center of the sector. More...

double	getShift (const HepGeom::Point3D< double > &pos, double dphi) const
	Returns the shift of the station with respect to the center of the sector. More...

double	getAlpha (const HepGeom::Transform3D &trans) const
	Returns the forward tilt angle of a station (for CSCs). More...

HepGeom::Point3D< double >	getPositionNSW (Amg::Vector3D pos, int maxPhi) const
	Returns the global position of the NSW station, rotated to sector 1. More...

int	getPhiIndex (double phi, int maxPhi) const
	Returns phi index of the sector. More...

void	readNSWMMPars (const GeoVolumeCursor *pv, int maxPhi, std::string &chamberName, HepGeom::Point3D< double > &pos_rot, double &zi, double &zo, double &ri, double &ro, double &wi, double &wo, double &dphi, double &shift, int &phiIndex) const
	Reads the geometry parameters of a NSW Micromegas chamber. More...

void	readNSWSTGCPars (const GeoVolumeCursor pv, int maxPhi, std::string &chamberName, HepGeom::Point3D< double > &pos_rot, const GeoSimplePolygonBrep &theBrep, int &nvtx, double &dz, double &dphi, double &shift, int &phiIndex) const
	Reads the geometry parameters of a NSW sTGC chamber. More...

void	readBrepAsATrd (const GeoSimplePolygonBrep theBrep, double rho, const int vtx, double &ri, double &ro, double &wi, double &wo) const
	Takes four vetecies of a GeoSimplePolygonBrep to form a trapezoid shape and reads the parameters of the trapezoid shape. More...

bool	equalAngle (double a, double b) const
	Compares two angles. More...

bool	equalLength (double a, double b) const
	Compares two coordinates or lenghts. More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
const MuonGM::MuonDetectorManager *	m_muon_manager
	Pointer to the muon detector manager (GeoModel) More...

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Static Private Attributes
static const double	m_smallAngle = 0.05
	Maximum deviation from the reference value before the station is considered different. More...

static const double	m_smallDistance = 100.

Detailed Description

Writes the GeoModel muon geometry to an XML file for use with Atlantis.

Definition at line 28 of file MuonGeometryWriter.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ MuonGeometryWriter()

JiveXML::MuonGeometryWriter::MuonGeometryWriter	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

inline

Constructor.

Parameters

detStore	pointer to the detector store service
log	log message stream

Definition at line 37 of file MuonGeometryWriter.h.

37 :

38 AthAlgTool(t,n,p){declareInterface<IGeometryWriter>(this);};

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ equalAngle()

bool JiveXML::MuonGeometryWriter::equalAngle	(	double	a,
		double	b
	)		const

private

Compares two angles.

Returns: true if the difference is within a precision defined by m_smallAngle

Definition at line 750 of file MuonGeometryWriter.cxx.

                                                               {
      return std::abs(a - b) < m_smallAngle;
   }

◆ equalLength()

bool JiveXML::MuonGeometryWriter::equalLength	(	double	a,
		double	b
	)		const

private

Compares two coordinates or lenghts.

Returns: true if the difference is within a precision defined by m_smallDistance

Definition at line 754 of file MuonGeometryWriter.cxx.

                                                                {
      return std::abs(a - b) < m_smallDistance;
   }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ getAlpha()

double JiveXML::MuonGeometryWriter::getAlpha ( const HepGeom::Transform3D & trans ) const

private

Returns the forward tilt angle of a station (for CSCs).

Parameters

trans local to global coordinates transformation matrix

Returns: forward tilt angle (radians)

Definition at line 327 of file MuonGeometryWriter.cxx.

                                                                            {
  
     // Extract the rotation from the transformation.
     CLHEP::HepRotation rot = trans.getRotation();
  
     // The theta component is what we're interested in.
     return M_PI/2. - rot.getTheta();
   }

◆ getDeltaPhi()

double JiveXML::MuonGeometryWriter::getDeltaPhi	(	const HepGeom::Point3D< double > &	pos,
		int	maxPhi
	)		const

private

Returns the rotation of the station with respect to the center of the sector.

Parameters

pos	position of the station rotated to sector 1.
maxPhi	maximum phi index for this station type

Returns: rotation of the station

Definition at line 312 of file MuonGeometryWriter.cxx.

                                                                                             {
  
     if (maxPhi > 8) {
       // For TGCs there is no shift, so we can just return the angle.
       return pos.phi();
     } else if (std::abs(pos.phi() - M_PI/8.) < M_PI/16.) {
       // For the others, rotate to the next sector if it's reasonably close to pi/8. 
       // Any further deviation will be put in as a shift.
       return M_PI/8.;
     } else {
       // No rotation at all.
       return 0.;
     }
   }

◆ getPhiIndex()

int JiveXML::MuonGeometryWriter::getPhiIndex	(	double	phi,
		int	maxPhi
	)		const

private

Returns phi index of the sector.

Parameters

phi	phi of the sector
maxPhi	maximum phi index for this station type

Returns: phi index of the sector

Definition at line 675 of file MuonGeometryWriter.cxx.

                                                                   {
      if (phi<0) phi += 2.*M_PI;
      int phiIndex = std::round(phi * maxPhi / (2.*M_PI) - 0.1) + 1;
      return phiIndex;
   }

◆ getPosition()

HepGeom::Point3D< double > JiveXML::MuonGeometryWriter::getPosition	(	const MuonGM::MuonStation *	station,
		int	maxPhi
	)		const

private

Returns the global position of the station, rotated to sector 1.

Parameters

station	under consideration
maxPhi	maximum phi index for this station type

Returns: position of the station

Definition at line 300 of file MuonGeometryWriter.cxx.

                                                                                                            {
  
     // Take the position of the station.
     HepGeom::Point3D<double> pos = Amg::EigenTransformToCLHEP(station->getTransform()) * HepGeom::Point3D<double>(0., 0., 0.);
  
     double phi = 2.*M_PI * ((double) station->getPhiIndex()-1.) / maxPhi;
  
     // Rotate it to sector 1.
     //return HepGeom::RotateZ3D((1-phi) * M_PI/4.) * pos;
     return HepGeom::RotateZ3D(-phi) * pos;
   }

◆ getPositionNSW()

HepGeom::Point3D< double > JiveXML::MuonGeometryWriter::getPositionNSW	(	Amg::Vector3D	pos,
		int	maxPhi
	)		const

private

Returns the global position of the NSW station, rotated to sector 1.

Parameters

position	of the station under consideration
maxPhi	maximum phi index for this station type

Returns: position of the station after rotation

Definition at line 681 of file MuonGeometryWriter.cxx.

                                                                                              {
      // get phi index of the sector
      int phiIndex = getPhiIndex(pos.phi(), maxPhi);
      // calculate phi of the sector center
      double sectorPhi = 2.*M_PI * ((double) phiIndex-1.) / maxPhi;
      // rotate to first sector
      HepGeom::Point3D<double> pos_rot = HepGeom::RotateZ3D(-sectorPhi) * HepGeom::Point3D<double>(pos.x(), pos.y(), pos.z());
  
      return pos_rot;
   }

◆ getShift()

double JiveXML::MuonGeometryWriter::getShift	(	const HepGeom::Point3D< double > &	pos,
		double	dphi
	)		const

private

Returns the shift of the station with respect to the center of the sector.

Parameters

pos	position of the station rotated to sector 1
dphi	rotation of the station with respect to the center of the sector

Returns: shift of the station

Definition at line 336 of file MuonGeometryWriter.cxx.

                                                                                           {
  
     HepGeom::Point3D<double> rotpos;
  
     // First we remove the shift caused by the rotation over dphi.
     if (std::abs(dphi) < m_smallAngle) {
       rotpos = pos;
     } else {
       rotpos = HepGeom::RotateZ3D(-dphi) * pos;
     }
  
     // Then we return what is left as the shift.
     if (std::abs(rotpos.y()) < m_smallDistance) {
       return 0.;
     } else {
       return rotpos.y();
     }
   }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

const InterfaceID & JiveXML::IGeometryWriter::interfaceID ( )

inlinestaticinherited

Definition at line 27 of file IGeometryWriter.h.

27 { return IID_IGeometryWriter; }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ processNSW()

void JiveXML::MuonGeometryWriter::processNSW ( std::ofstream & out )

private

process the geometry of New Small Wheel

Definition at line 391 of file MuonGeometryWriter.cxx.

                                                       {
  
      int maxPhi = 8;
  
      // Check if NSW exists in the GeoModel tree, and process it if exists
      const GeoModelExperiment * theExpt = nullptr;
      if (detStore()->retrieve(theExpt, "ATLAS").isFailure()) {
         ATH_MSG_ERROR( "Could not retrieve the ATLAS GeoModelExperiment from detector store" );
         return;
      }
  
      PVConstLink world(theExpt->getPhysVol());
      GeoVolumeCursor av(world);
      while (!av.atEnd()) {
         if ( av.getName()=="Muon") {
            GeoVolumeCursor pv(av.getVolume());
            while (!pv.atEnd()) { // Loop over Muon stations
               if (pv.getVolume()->getLogVol()->getName()=="NewSmallWheel") {
                  ATH_MSG_INFO( "Found New Small Wheel geometry." );
                  GeoVolumeCursor pvnsw(pv.getVolume());
  
                  while (!pvnsw.atEnd()){
                     std::string stationName = pvnsw.getVolume()->getLogVol()->getName();
  
                     // Process MicroMegas chambers
                     if (stationName=="NSW_MM"){
                        ATH_MSG_DEBUG( "Processing NSW micromegas chambers." );
  
                        GeoVolumeCursor pvnswsub(pvnsw.getVolume());
                        bool newChamber = true;
                        std::string phiString = "";
                        std::string phiString_mirrorEta = "";
                        double dphi=0, shift=0, zi=0, zo=0, ri=0, ro=0, wi=0, wo=0;
                        std::string chamberName="";
                        HepGeom::Point3D<double> pos_rot;
  
                        while (!pvnswsub.atEnd()){
                           if (((pvnswsub.getVolume()->getLogVol())->getShape())->typeID() == GeoTrd::getClassTypeID() ) { // MicroMega
  
                              if (newChamber){
  
                                 int phiIndex;
                                 readNSWMMPars(&pvnswsub, maxPhi, chamberName, pos_rot, zi, zo, ri, ro, wi, wo, dphi, shift, phiIndex);
                                 phiString = DataType(phiIndex).toString();
  
                                 newChamber = false;
                                 pvnswsub.next();
                              } // end of processing the first chamber
  
                              else{
                                 std::string chamberName2;
                                 HepGeom::Point3D<double> pos_rot2;
                                 double zi2, zo2, ri2, ro2, wi2, wo2, dphi2, shift2;
                                 int phiIndex2;
                                 readNSWMMPars(&pvnswsub, maxPhi, chamberName2, pos_rot2, zi2, zo2, ri2, ro2, wi2, wo2, dphi2, shift2, phiIndex2);
  
                                 if (chamberName != chamberName2
                                       || !equalAngle(dphi, dphi2)
                                       || !equalLength(shift, shift2)
                                       || !equalLength(ri, ri2)
                                       || !equalLength(ro, ro2)
                                       || !equalLength(wi, wi2)
                                       || !equalLength(wo, wo2)) {
                                    // This is a different chamber.
                                    // Reset the new chamber flag so that it can be processed as a new chamber in the next loop
                                    newChamber = true;
                                 }
                                 else if (pos_rot.distance(pos_rot2) < m_smallDistance
                                       && equalLength(zi, zi2)
                                       && equalLength(zo, zo2)
                                       ) {
                                    // same chamber in different phi sector, add it to the existing phi index list
                                    std::string stationPhi = DataType(phiIndex2).toString();
                                    if (phiString.find(stationPhi) == std::string::npos) phiString += " " + stationPhi;
                                    pvnswsub.next();
                                 }
                                 else if (pos_rot.distance(HepGeom::Point3D<double>(pos_rot2.x(), pos_rot2.y(), -pos_rot2.z())) < m_smallDistance
                                       && equalLength(zi, -zi2)
                                       && equalLength(zo, -zo2)
                                       ) {
                                    // same chamber in oppposite eta region, add it to a separate phi index list
                                    std::string stationPhi = DataType(phiIndex2).toString();
                                    if (phiString_mirrorEta.find(stationPhi) == std::string::npos){
                                       if (not phiString_mirrorEta.empty()) phiString_mirrorEta += " ";
                                       phiString_mirrorEta += stationPhi;
                                    }
                                    pvnswsub.next();
                                 }
                                 else {
                                    // This is a different chamber.
                                    // Reset the new chamber flag so that it can be processed as a new chamber in the next loop
                                    newChamber = true;
                                 }
  
                              } // end of processing another chamber and comparing it to the first chamber
  
  
                              if (phiString!="" && (newChamber || pvnswsub.atEnd())){
                                 // if the next chamber is a different chamber, or this is the last chamber, write the geometry to output
                                 ATH_MSG_DEBUG( "Writing " << chamberName );
  
                                 std::string stationTech = "MM";
                                 std::string stationName = "MM"+chamberName.substr(7,1); // MMS: small sector. MML: large sector
                                 int eta = std::stoi(chamberName.substr(8,1));
                                 writeATrd(out, stationTech, stationName, zi, zo, ri, ro, wi, wo, eta, phiString, dphi, shift, 0);
                                 if (phiString_mirrorEta!="") {
                                    writeATrd(out, stationTech, stationName, -zi, -zo, ri, ro, wi, wo, -eta, phiString_mirrorEta, dphi, shift, 0);
                                 }
  
                                 phiString = ""; // reset for new chambers
                                 phiString_mirrorEta = ""; // reset for new chambers
                              }
                           }
                           else { // not MicroMegas; Move to the next chamber
                              pvnswsub.next();
                           }
  
                        }
                     }
  
                     // Process sTGC chambers
                     else if (stationName=="NSW_sTGC"){
  
                        ATH_MSG_DEBUG( "Processing NSW sTGC chambers." );
  
                        GeoVolumeCursor pvnswsub(pvnsw.getVolume());
                        bool newChamber = true;
                        std::string phiString = "";
                        std::string phiString_mirrorEta = "";
                        int nvtx=0;
                        double dz=0, dphi=0, shift=0;
                        std::string chamberName="";
                        HepGeom::Point3D<double> pos_rot;
                        const GeoSimplePolygonBrep* theBrep = nullptr;
  
                        while (!pvnswsub.atEnd()){
                           if (((pvnswsub.getVolume()->getLogVol())->getShape())->typeID() == GeoShapeShift::getClassTypeID() ) {// sTGC
  
  
                              if (newChamber){
  
                                 int phiIndex;
                                 readNSWSTGCPars(&pvnswsub, maxPhi, chamberName, pos_rot, theBrep, nvtx, dz, dphi, shift, phiIndex);
                                 phiString = DataType(phiIndex).toString();
  
                                 newChamber = false;
                                 pvnswsub.next();
                              } // end of processing the first chamber
  
                              else{
  
                                 std::string chamberName2;
                                 HepGeom::Point3D<double> pos_rot2;
                                 const GeoSimplePolygonBrep* theBrep2;
                                 int nvtx2, phiIndex2;
                                 double dz2, dphi2, shift2;
                                 readNSWSTGCPars(&pvnswsub, maxPhi, chamberName2, pos_rot2, theBrep2, nvtx2, dz2, dphi2, shift2, phiIndex2);
  
                                 // Check if it is the same shape as the first chamber
                                 bool isSameShape = true;
                                 if (nvtx == nvtx2 && equalLength(dz, dz2) ) { // Same Nvtx and thickness. Check vertices coordinates.
                                    for (int i=0; i<nvtx; ++i){
                                       if ( !equalLength(theBrep->getXVertex(i), theBrep2->getXVertex(i))
                                             || !equalLength(theBrep->getYVertex(i), theBrep2->getYVertex(i)) )
                                       {
                                          isSameShape = false;
                                       }
                                    }
                                 }
                                 else { // Different Nvtx or thickness
                                    isSameShape = false;
                                 }
  
                                 // Check if it has the same name, offset and shape as the first chamber
                                 if (chamberName != chamberName2
                                       || !equalAngle(dphi, dphi2)
                                       || !equalLength(shift, shift2)
                                       || !isSameShape)
                                 {
                                    // This is a different chamber.
                                    // Reset the new chamber flag so that it can be processed as a new chamber in the next loop
                                    newChamber = true;
                                 }
                                 // check chamber position
                                 else if (pos_rot.distance(pos_rot2) < m_smallDistance) {
                                    // same chamber in different phi sector, add it to the existing phi index list
                                    std::string stationPhi = DataType(phiIndex2).toString();
                                    if (phiString.find(stationPhi) == std::string::npos) phiString += " " + stationPhi;
                                    pvnswsub.next();
                                 }
                                 else if (pos_rot.distance(HepGeom::Point3D<double>(pos_rot2.x(), pos_rot2.y(), -pos_rot2.z())) < m_smallDistance) {
                                    // same chamber in oppposite eta region, add it to a separate phi index list
                                    std::string stationPhi = DataType(phiIndex2).toString();
                                    if (phiString_mirrorEta.find(stationPhi) == std::string::npos) {
                                       if (not phiString_mirrorEta.empty()) phiString_mirrorEta += " ";
                                       phiString_mirrorEta += stationPhi;
                                    }
                                    pvnswsub.next();
                                 }
                                 else {
                                    // This is a different chamber.
                                    // Reset the new chamber flag so that it can be processed as a new chamber in the next loop
                                    newChamber = true;
                                 }
                              } // end of processing another chamber and comparing it to the first chamber
  
  
                              if (phiString!="" && (newChamber || pvnswsub.atEnd())){
                                 // if the next chamber is a different chamber, or this is the last chamber, write the geometry to output
                                 ATH_MSG_DEBUG( "Writing " << chamberName );
  
                                 std::string stationTech = "STGC";
                                 std::string stationName = "ST"+chamberName.substr(8,1); // STS: small sector. STL: large sector
                                 int eta = std::stoi(chamberName.substr(9,1));
                                 double signed_dz = dz;
                                 if (pos_rot.z()<0) dz *= -1;
                                 double zi = pos_rot.z() - signed_dz;
                                 double zo = pos_rot.z() + signed_dz;
                                 double rho = pos_rot.perp();
                                 double ri, ro, wi, wo;
  
                                 if (nvtx==4){ // write as a single ATrd
                                    // vtx1-----vtx0 (outer)
                                    //   \       /
                                    //  vtx2--vtx3 (inner)
                                    const int vtxList[] = {0, 1, 2, 3};
                                    readBrepAsATrd(theBrep, rho, vtxList, ri, ro, wi, wo);
                                    writeATrd(out, stationTech, stationName, zi, zo, ri, ro, wi, wo, eta, phiString, dphi, shift, 0);
                                    if (phiString_mirrorEta!="") {
                                       writeATrd(out, stationTech, stationName, -zi, -zo, ri, ro, wi, wo, -eta, phiString_mirrorEta, dphi, shift, 0);
                                    }
                                 }
  
                                 else if (nvtx==6){ // print as two ATrds
                                    // vtx1-----vtx0 (outer)
                                    //  |         |
                                    // vtx2     vtx5
                                    //   \       /
                                    //  vtx3--vtx4 (inner)
  
                                    // First ATrd (inner part): vertex 2, 3, 4, 5
                                    const int vtxList1[] = {5, 2, 3, 4};
                                    readBrepAsATrd(theBrep, rho, vtxList1, ri, ro, wi, wo);
                                    writeATrd(out, stationTech, stationName, zi, zo, ri, ro, wi, wo, eta, phiString, dphi, shift, 0);
                                    if (phiString_mirrorEta!="") {
                                       writeATrd(out, stationTech, stationName, -zi, -zo, ri, ro, wi, wo, -eta, phiString_mirrorEta, dphi, shift, 0);
                                    }
  
                                    // Second ATrd (outter part): vertex 0, 1, 2, 5
                                    const int vtxList2[] = {0, 1, 2, 5};
                                    readBrepAsATrd(theBrep, rho, vtxList2, ri, ro, wi, wo);
                                    writeATrd(out, stationTech, stationName, zi, zo, ri, ro, wi, wo, eta, phiString, dphi, shift, 0);
                                    if (phiString_mirrorEta!="") {
                                       writeATrd(out, stationTech, stationName, -zi, -zo, ri, ro, wi, wo, -eta, phiString_mirrorEta, dphi, shift, 0);
                                    }
  
                                 }
  
                                 else{
                                    ATH_MSG_ERROR( "Shape not supported by GeometryJiveXML: polygon shape with "<<nvtx <<" verticies in NSW sTGC." );
                                 }
                                 phiString = ""; // reset for new chambers
                                 phiString_mirrorEta = ""; // reset for new chambers
                              }
  
                           }
                           else { // not sTGC; Move to the next chamber
                              pvnswsub.next();
                           }
  
                        }
                     }
                     pvnsw.next();
                  }
                  return; // Done with NSW. Skip other subdetectors
               }
  
               pv.next();
            }
         }
         av.next(); // increment volume cursor.
      }
   }

◆ readBrepAsATrd()

void JiveXML::MuonGeometryWriter::readBrepAsATrd	(	const GeoSimplePolygonBrep *	theBrep,
		double	rho,
		const int *	vtx,
		double &	ri,
		double &	ro,
		double &	wi,
		double &	wo
	)		const

private

Takes four vetecies of a GeoSimplePolygonBrep to form a trapezoid shape and reads the parameters of the trapezoid shape.

Parameters

theBrep	pointer to the GeoSimplePolygonBrep
rho	radius of the center of the GeoSimplePolygonBrep for calculating the inner and outer radius (ri and ro)
vtx	a list of the indecies of the four verticies of GeoSimplePolygonBrep to be used in drawing the trapezoid other parameters are used to store the retrieved parameters

Definition at line 738 of file MuonGeometryWriter.cxx.

                                                               {
      // vtx1-----vtx0 (outer)
      //   \       /
      //  vtx2--vtx3 (inner)
      ri = rho + theBrep->getYVertex(vtx[3]);
      ro = rho + theBrep->getYVertex(vtx[0]);
      wi = theBrep->getXVertex(vtx[3]) - theBrep->getXVertex(vtx[2]);
      wo = theBrep->getXVertex(vtx[0]) - theBrep->getXVertex(vtx[1]);
      return;
   }

◆ readNSWMMPars()

void JiveXML::MuonGeometryWriter::readNSWMMPars	(	const GeoVolumeCursor *	pv,
		int	maxPhi,
		std::string &	chamberName,
		HepGeom::Point3D< double > &	pos_rot,
		double &	zi,
		double &	zo,
		double &	ri,
		double &	ro,
		double &	wi,
		double &	wo,
		double &	dphi,
		double &	shift,
		int &	phiIndex
	)		const

private

Reads the geometry parameters of a NSW Micromegas chamber.

Parameters

pv	pointer to the detector volume considered
maxPhi	maximum number of phi sectors (=8 for NSW) other parameters are used to store the retrieved parameters

Definition at line 692 of file MuonGeometryWriter.cxx.

                                                                                                                                   {
  
      chamberName = pv->getVolume()->getLogVol()->getName();
      const GeoTrd* theTrd = dynamic_cast<const GeoTrd*> ((pv->getVolume()->getLogVol())->getShape());
      Amg::Vector3D pos = pv->getTransform().translation();
  
      pos_rot = getPositionNSW(pos, maxPhi);
      dphi = getDeltaPhi(pos_rot, maxPhi);
      shift = getShift(pos_rot, dphi);
      double signed_dz = theTrd->getXHalfLength1();
      if (pos_rot.z()<0) signed_dz *= -1;
  
      zi = pos_rot.z() - signed_dz;
      zo = pos_rot.z() + signed_dz;
      ri = pos_rot.perp() - theTrd->getZHalfLength();
      ro = pos_rot.perp() + theTrd->getZHalfLength();
      wi = 2.0 * theTrd->getYHalfLength1();
      wo = 2.0 * theTrd->getYHalfLength2();
  
      phiIndex = getPhiIndex(pos.phi(), maxPhi);
  
      return;
   }

◆ readNSWSTGCPars()

void JiveXML::MuonGeometryWriter::readNSWSTGCPars	(	const GeoVolumeCursor *	pv,
		int	maxPhi,
		std::string &	chamberName,
		HepGeom::Point3D< double > &	pos_rot,
		const GeoSimplePolygonBrep *&	theBrep,
		int &	nvtx,
		double &	dz,
		double &	dphi,
		double &	shift,
		int &	phiIndex
	)		const

private

Reads the geometry parameters of a NSW sTGC chamber.

Parameters

pv	pointer to the detector volume considered
maxPhi	maximum number of phi sectors (=8 for NSW) other parameters are used to store the retrieved parameters

Definition at line 717 of file MuonGeometryWriter.cxx.

                                                                                  {
  
      chamberName = pv->getVolume()->getLogVol()->getName();
  
      const GeoShapeShift* theShift = dynamic_cast<const GeoShapeShift*> ((pv->getVolume()->getLogVol())->getShape());
      theBrep = dynamic_cast<const GeoSimplePolygonBrep*> (theShift->getOp());
      nvtx = theBrep->getNVertices();
      dz = theBrep->getDZ();
  
      Amg::Vector3D pos = pv->getTransform().translation();
      pos_rot = getPositionNSW(pos, maxPhi);
      dphi = getDeltaPhi(pos_rot, maxPhi);
      shift = getShift(pos_rot, dphi);
  
      phiIndex = getPhiIndex(pos.phi(), maxPhi);
  
      return;
   }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

◆ writeATrd()

void JiveXML::MuonGeometryWriter::writeATrd	(	std::ofstream &	out,
		const std::string &	stationTech,
		const std::string &	stationName,
		double	zi,
		double	zo,
		double	ri,
		double	ro,
		double	wi,
		double	wo,
		int	eta,
		const std::string &	phiString,
		double	dphi,
		double	shift,
		double	alpha
	)		const

private

Writes a trapezoid station in XML to a stream.

Parameters

out	stream where the XML fragment is written to

Definition at line 361 of file MuonGeometryWriter.cxx.

                                                        {
  
      out << "<ATrd n=\"" << stationTech << "_" << stationName << std::abs(eta) << "\""
         << " zi=\"" << zi/10. << "\"" << " zo=\"" << zo/10. << "\""
         << " ri=\"" << ri/10. << "\"" << " ro=\"" << ro/10. << "\""
         << " wi=\"" << wi/10. << "\"" << " wo=\"" << wo/10. << "\""
         << " eta=\"" << eta << "\""
         << " phi=\"" << phiString << "\"";
  
      // A rotation with respect to the large sector.
      if (std::abs(dphi) > m_smallAngle)
         out << " dphi=\"" << 180/M_PI * dphi << "\"";
  
      // A shift perpendicular to r in the xy-plane.
      if (std::abs(shift) > m_smallDistance)
         out << " sh=\"" << shift/10. << "\"";
  
      // A tilt in the rz-plane, for the CSCs.
      if (std::abs(alpha) > m_smallAngle)
         out << " a=\"" << 180/M_PI * alpha << "\"";
  
      out << " />" << std::endl;
  
  
   }

◆ writeFooter()

void JiveXML::MuonGeometryWriter::writeFooter ( std::ofstream & out ) const

private

Writes the footer of the XML file to a stream.

Parameters

out	stream where the XML fragment is written to

Definition at line 355 of file MuonGeometryWriter.cxx.

                                                              {
  
     out << "</AMuonGeometry>" << std::endl;
  
   }

◆ writeGeometry()

StatusCode JiveXML::MuonGeometryWriter::writeGeometry ( )

virtual

Writes the geometry of the ATLAS muon spectrometer to an XML file for use with Atlantis.

Implements JiveXML::IGeometryWriter.

Definition at line 30 of file MuonGeometryWriter.cxx.

                                                {
  
     ATH_MSG_DEBUG( "writeGeometry()" );
  
     std::ofstream outputFile("AMuonGeometry.xml");
     writeHeader(outputFile);
  
     if ( detStore()->retrieve(m_muon_manager).isFailure() ) {
       ATH_MSG_ERROR( "Could not retrieve MuonGM::MuonDetectorManager" );
       m_muon_manager = 0;
       return StatusCode::FAILURE;
     } else {
       writeStations(outputFile);
     }
  
     processNSW(outputFile);
  
     writeFooter(outputFile);
     outputFile.close();
  
     return StatusCode::SUCCESS;
   }

◆ writeHeader()

void JiveXML::MuonGeometryWriter::writeHeader ( std::ofstream & out ) const

private

Writes the header of the XML file to a stream.

Parameters

out	stream where the XML fragment is written to

Definition at line 53 of file MuonGeometryWriter.cxx.

                                                              {
  
     out << "<?xml version=\"1.0\"?>"                               << std::endl
     << "<!DOCTYPE AMuonGeometry ["                             << std::endl
     << "<!ELEMENT AMuonGeometry (ABox | ATBx | ATrd)*>"        << std::endl
     << "<!ELEMENT ABox   EMPTY >"                              << std::endl
     << "<!ATTLIST ABox"                                        << std::endl
     << "          n          CDATA #REQUIRED"                  << std::endl
     << "          zi         CDATA #REQUIRED"                  << std::endl
     << "          zo         CDATA #REQUIRED"                  << std::endl
     << "          ri         CDATA #REQUIRED"                  << std::endl
     << "          ro         CDATA #REQUIRED"                  << std::endl
     << "          w          CDATA #REQUIRED"                  << std::endl
     << "          eta        CDATA #REQUIRED"                  << std::endl
     << "          phi        CDATA #REQUIRED"                  << std::endl
     << "          dphi       CDATA \"0\""                      << std::endl
     << "          sh         CDATA \"0\""                      << std::endl
     << "          RPCi       CDATA \"0\""                      << std::endl
     << "          RPCo       CDATA \"0\">"                     << std::endl
     << "<!ELEMENT ATBx   EMPTY >"                              << std::endl
     << "<!ATTLIST ATBx"                                        << std::endl
     << "          n          CDATA #REQUIRED"                  << std::endl
     << "          zi         CDATA #REQUIRED"                  << std::endl
     << "          zo         CDATA #REQUIRED"                  << std::endl
     << "          ri         CDATA #REQUIRED"                  << std::endl
     << "          ro         CDATA #REQUIRED"                  << std::endl
     << "          w          CDATA #REQUIRED"                  << std::endl
     << "          eta        CDATA #REQUIRED"                  << std::endl
     << "          phi        CDATA #REQUIRED"                  << std::endl
     << "          sh         CDATA \"0\""                      << std::endl
     << "          dphi       CDATA \"0\""                      << std::endl
     << "          RPCi       CDATA \"0\""                      << std::endl
     << "          RPCo       CDATA \"0\""                      << std::endl
     << "          zis        CDATA #REQUIRED"                  << std::endl
     << "          zos        CDATA #REQUIRED"                  << std::endl
     << "          ws         CDATA #REQUIRED"                  << std::endl
     << "          or         CDATA \"0\">"                     << std::endl
     << "<!ELEMENT ATrd   EMPTY >"                              << std::endl
     << "<!ATTLIST ATrd"                                        << std::endl
     << "          n          CDATA #REQUIRED"                  << std::endl
     << "          zi         CDATA #REQUIRED"                  << std::endl
     << "          zo         CDATA #REQUIRED"                  << std::endl
     << "          ri         CDATA #REQUIRED"                  << std::endl
     << "          ro         CDATA #REQUIRED"                  << std::endl
     << "          wi         CDATA #REQUIRED"                  << std::endl
     << "          wo         CDATA #REQUIRED"                  << std::endl
     << "          eta        CDATA #REQUIRED"                  << std::endl
     << "          phi        CDATA #REQUIRED"                  << std::endl
     << "          dphi       CDATA \"0\""                      << std::endl
     << "          sh         CDATA \"0\""                      << std::endl
     << "          a          CDATA \"0\">"                     << std::endl
     << "]>"                                                    << std::endl
     << "<AMuonGeometry>"                                       << std::endl;
   }

◆ writeStations()

void JiveXML::MuonGeometryWriter::writeStations ( std::ofstream & out ) const

private

Retrieves all stations from GeoModel and writes the corresponding XML elements to a stream.

Parameters

out	stream where the XML fragment is written to

Definition at line 108 of file MuonGeometryWriter.cxx.

                                                                {
  
     // While we retrieve the MdtIdHelper, we use the functionality provided by its parent class MuonIdHelper 
     // this is not MDT specific and any of the other IdHelpers would have worked as well.
     const MdtIdHelper *mdtIdHelper = m_muon_manager->mdtIdHelper();
     int snMax = mdtIdHelper->stationNameIndexMax();
  
     ATH_MSG_DEBUG( " Station types: " << snMax );
  
     // Loop over all station types.
     for (int sn=0; sn<=snMax; sn++) {
       std::string stationName = mdtIdHelper->stationNameString(sn);
       // some stationNames no longer exist
       if (!stationName.compare(MuonIdHelper::BAD_NAME)) continue;
  
       // Determine the type of chamber from the stationName string.
       std::string stationTech;
       switch(stationName[0]) {
       case 'B':
       case 'E':
     stationTech = "MDT";
     break;
       case 'C':
     stationTech = "CSC";
     break;
       case 'T':
     stationTech = "TGC";
     break;
       default:
     stationTech = "???";
     break;
       }
  
       // The TGCs contain several stations in one sector. As this would create several stations with the same 
       // identifier, people apparently chose to let the phi index of the stations continue up to 3 or even 6 
       // times the "real" maximum value. We need to determine this maximum value in order to calculate the real
       // phi index.
       int maxPhi;
       if (stationTech == "TGC") {
     if (stationName[2] == 'E' && stationName[1] != '4') {
       maxPhi = 48;
     } else {
       maxPhi = 24;
     }
       } else {
     maxPhi = 8;
       }
  
       // Loop over all eta values.
       for (int eta=-16; eta<=16; eta++) {
     std::vector<const MuonGM::MuonStation *> *stations = new std::vector<const MuonGM::MuonStation *>;
  
     // And loop over all possible phi values.
     for (int phi=maxPhi; phi>0; phi--) {
  
       // Try to retrieve the station, it might not exist, but this seems to be the most 
       // reliable way to find out.
       const MuonGM::MuonStation *station = m_muon_manager->getMuonStation(stationName, eta, phi);
  
       // If station != 0, the station exists and we add it to our vector.
       if (station) stations->push_back(station);
     }
  
     // While there are stations that haven't been written to XML, stay in this loop.
     while (stations->size() > 0) {
  
       // Take the parameters of a station and store them in the variables with the "1" suffix.
       const MuonGM::MuonStation *station1 = *(stations->end()-1);
  
       HepGeom::Point3D<double> pos1 = getPosition(station1, maxPhi);
       int phi1 = station1->getPhiIndex();
       double dphi1 = getDeltaPhi(pos1, maxPhi);
       double shift1 = getShift(pos1, dphi1);
       double alpha1 = getAlpha(Amg::EigenTransformToCLHEP(station1->getTransform()));
  
       // Now determine the dimensions of a station of this station.
       double signed_dz = station1->Zsize()/2.;
       if (pos1.z()<0) signed_dz *= -1;
       double zi1 = pos1.z() - signed_dz;    // inner z
       double zo1 = pos1.z() + signed_dz;    // outer z
       double ri1 = pos1.perp() - station1->Rsize()/2.; // inner r
       double ro1 = pos1.perp() + station1->Rsize()/2.; // outer r
       double wi1 = station1->Ssize();                  // width at inner r
       double wo1 = station1->LongSsize();              // width at outer r
  
       // Create the string containing the phi sectors this station is in.
       std::string phiString = DataType(phi1).toString();
  
       // Remove this station from the to-be-processed list.
       stations->erase(stations->end()-1, stations->end());
  
       // Now loop over the other stations and see if any of them have the same parameters. Do 
       // this in reverse order to allow the current station to be erased from the vector.
       std::vector<const MuonGM::MuonStation *>::iterator it;
       for (it=stations->end()-1; it>=stations->begin(); --it) {
         HepGeom::Point3D<double> pos2 = getPosition(*it, maxPhi);
         int phi2 = (*it)->getPhiIndex();
         double dphi2 = getDeltaPhi(pos2, maxPhi);
         double shift2 = getShift(pos2, dphi2);
         double alpha2 = getAlpha(Amg::EigenTransformToCLHEP((*it)->getTransform()));
  
         double signed_dz2 = (*it)->Zsize()/2.;
         if (pos2.z()<0) signed_dz2 *= -1;
         double zi2 = pos2.z() - signed_dz2;    // inner z
         double zo2 = pos2.z() + signed_dz2;    // outer z
         double ri2 = pos2.perp() - (*it)->Rsize()/2.; // inner r
         double ro2 = pos2.perp() + (*it)->Rsize()/2.; // outer r
         double wi2 = (*it)->Ssize();                  // width at inner r
         double wo2 = (*it)->LongSsize();              // width at outer r
  
         // If the parameters are indeed the same (within reasonable limits), then we 
         // can simply add this chamber to the sectors attribute of the first one.
         if (pos1.distance(pos2) < m_smallDistance
         && equalAngle(dphi1, dphi2)
         && equalLength(shift1, shift2)
         && equalAngle(alpha1, alpha2)
         && equalLength(zi1, zi2)
         && equalLength(zo1, zo2)
         && equalLength(ri1, ri2)
         && equalLength(ro1, ro2)
         && equalLength(wi1, wi2)
         && equalLength(wo1, wo2)) {
  
           // Add the station to the phi sector string and remove it from the 
           // to-be-processed list.
           phiString += " " + DataType(phi2).toString();
  
           stations->erase(it, it+1);
         }
       }
  
       // From here onwards we need to treat barrel chambers and endcap chambers differently.
       if (stationName[0] == 'B') {
  
         // Barrel chambers can have inner and/or outer RPCs.
         // Let's take a default of 0. (no RPCs).
         double rpci = 0.;
         double rpco = 0.;
  
         // Determine the thickness of the RPC layer on this station.
         if (stationName[1] == 'M') {
           // Middle (BM*) stations have RPCs on both sides.
           rpci = rpco = 15.;
         } else if (stationName[1] == 'O') {
           // Outer (BO*) stations have RPCs on one side.
           if (stationName[2] == 'S') {
         // On the side facing the IP for small sectors (BOS).
         rpci = 15.;
           } else {
         // On the outside for large sectors (BOL, BOF, BOG, BOH).
         rpco = 15.;
           }
         } else if (stationName[1] == 'I' && eta==7 && wi1>1800) {
         // Run3 BIS7/8 stations have RPCs on the inner side and they are wider than the Run2 BIS7 and BIS8 stations.
         rpci = 4.;
         }
  
         // Barrel chambers are written as <ABox> elements.
         out << "<ABox n=\"" << stationTech << "_" << stationName << "\""
         << " zi=\"" << zi1/10. << "\"" << " zo=\"" << zo1/10. << "\""
         << " ri=\"" << ri1/10. << "\"" << " ro=\"" << ro1/10. << "\""
         << " w=\"" << wi1/10. << "\""
         << " eta=\"" << eta << "\""
         << " phi=\"" << phiString << "\"";
  
         // A rotation with respect to the large sector.
         if (std::abs(dphi1) > m_smallAngle)
           out << " dphi=\"" << 180/M_PI * dphi1 << "\"";
  
         // A shift perpendicular to r in the xy-plane.
         if (std::abs(shift1) > m_smallDistance)
           out << " sh=\"" << shift1/10. << "\"";
  
         // RPCs.
         if (rpci > 0.)
           out << " RPCi=\"" << rpci << "\"";
         if (rpco > 0.)
           out << " RPCo=\"" << rpco << "\"";
         out << " />" << std::endl;
  
       } else {
  
         // Endcap chambers are written as <ATrd> elements, parameters are similar to <ABox>.
         writeATrd(out, stationTech, stationName, zi1, zo1, ri1, ro1, wi1, wo1, eta, phiString, dphi1, shift1, alpha1);
       }
     }
  
     delete stations;
       }
     }
   }

Member Data Documentation

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_muon_manager

const MuonGM::MuonDetectorManager* JiveXML::MuonGeometryWriter::m_muon_manager

private

Pointer to the muon detector manager (GeoModel)

Definition at line 170 of file MuonGeometryWriter.h.

◆ m_smallAngle

const double JiveXML::MuonGeometryWriter::m_smallAngle = 0.05

staticprivate

Maximum deviation from the reference value before the station is considered different.

Definition at line 173 of file MuonGeometryWriter.h.

◆ m_smallDistance

const double JiveXML::MuonGeometryWriter::m_smallDistance = 100.

staticprivate

Definition at line 173 of file MuonGeometryWriter.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MuonGeometryWriter()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ equalAngle()

◆ equalLength()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ getAlpha()

◆ getDeltaPhi()

◆ getPhiIndex()

◆ getPosition()

◆ getPositionNSW()

◆ getShift()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ processNSW()

◆ readBrepAsATrd()

◆ readNSWMMPars()

◆ readNSWSTGCPars()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ writeATrd()

◆ writeFooter()

◆ writeGeometry()

◆ writeHeader()

◆ writeStations()

Member Data Documentation

◆ m_detStore

◆ m_evtStore

◆ m_muon_manager

◆ m_smallAngle

◆ m_smallDistance

◆ m_varHandleArraysDeclared

◆ m_vhka