MuonGM::sTGC Class Reference

#include <sTGC.h>

Inheritance diagram for MuonGM::sTGC:

Collaboration diagram for MuonGM::sTGC:

Public Member Functions
	sTGC (Component *s)
GeoFullPhysVol *	build (StoredMaterialManager &matManager, int minimalgeo)
GeoFullPhysVol *	build (StoredMaterialManager &matManager, int minimalgeo, int cutoutson, const std::vector< Cutout * > &)
virtual void	print () const override
void	setLogVolName (const std::string &str)

Public Attributes
double	width {0.}
double	length {0.}
double	thickness {0.}
double	longWidth {0.}
double	yCutout {0.}
double	yCutoutCathode {0.}
int	index {0}
std::string	name {}
std::string	logVolName {}

Private Attributes
sTGCComponent *	m_component {nullptr}

Detailed Description

Definition at line 20 of file sTGC.h.

Constructor & Destructor Documentation

sTGC()

MuonGM::sTGC::sTGC

(

Component *

s

)

Definition at line 40 of file sTGC.cxx.

                            : DetectorElement(ss->name) {
        sTGCComponent *s = static_cast<sTGCComponent *>(ss);
        m_component = s;
        width = s->dx1;
        longWidth = s->dx2;
        yCutout = s->yCutout;
        yCutoutCathode = s->yCutoutCathode;
        length = s->dy;
        name = s->name;
        index = s->index;
    }

Member Function Documentation

build() [1/2]

GeoFullPhysVol * MuonGM::sTGC::build	(	StoredMaterialManager &	matManager,
		int	minimalgeo )

Definition at line 52 of file sTGC.cxx.

                                                {
        std::vector<Cutout *> vcutdef;
        int cutoutson = 0;
        return build(matManager, minimalgeo, cutoutson, vcutdef);
    }

build() [2/2]

GeoFullPhysVol * MuonGM::sTGC::build	(	StoredMaterialManager &	matManager,
		int	minimalgeo,
		int	cutoutson,
		const std::vector< Cutout * > &	)

Definition at line 60 of file sTGC.cxx.

                                                            {
        sTGCDetectorHelper stgcHelper;
        IAGDDtoGeoSvc::LockedController c = stgcHelper.Get_Controller();
        AGDDDetectorStore& ds = c->GetDetectorStore();
        sTGCDetectorDescription *stgc_descr = stgcHelper.Get_sTGCDetectorSubType(m_component->subType);
 
        sTGC_Technology *t = static_cast<sTGC_Technology *>(ds.GetTechnology(name));
        thickness = t->Thickness();
        double gasTck = t->gasThickness;
        // Defining PCB thickness based on quadruplet type
        bool isQS1 = (m_component->subType == "QS1P" || m_component->subType == "QS1C");
        bool isQL1 = (m_component->subType == "QL1P" || m_component->subType == "QL1C");
        double pcbTck = (isQS1 || isQL1) ? t->pcbThickness150 : t->pcbThickness200;
        // Resolves backward compatibility issues where pcbTck150 and pcbTck200
        // Are not defined in previous XML versions
        if(pcbTck == 0)
          pcbTck = t->pcbThickness;
 
        double coverTck = t->coverThickness;
        double f4 = stgc_descr->ylFrame();
        double f5 = stgc_descr->ysFrame();
        double f6 = stgc_descr->xFrame();
 
        // Evaluate honeycomb thickness
        double chamberTck = gasTck + pcbTck; // Note: pcbTck is the xml value and is the combined thickness of 2 pcbs.
        double honeycombTck = (thickness - 4 * chamberTck - 2 * coverTck) / 5;
        double pcbActualTck = pcbTck / 2;
 
        minimalgeo = t->geoLevel;
 
        // Build sTGC mother volume out of honeycomb material
        GeoSimplePolygonBrep *solid;
        solid = new GeoSimplePolygonBrep(thickness / 2.);
        solid->addVertex(longWidth / 2., length / 2.);
        solid->addVertex(-longWidth / 2., length / 2.);
        if (yCutout)
            solid->addVertex(-longWidth / 2., length / 2. - yCutout);
        solid->addVertex(-width / 2., -length / 2.);
        solid->addVertex(width / 2., -length / 2.);
        if (yCutout)
            solid->addVertex(longWidth / 2., length / 2. - yCutout);
 
        // Transform the mother volume to the correct position
        GeoTrf::Transform3D rot = GeoTrf::RotateZ3D(M_PI / 2.) * GeoTrf::RotateX3D(M_PI / 2.);
        const GeoShape *strd = new GeoShapeShift(solid, rot);
 
        logVolName = name;
        if (!(m_component->subType).empty())
            logVolName += ("-" + m_component->subType);
        const GeoMaterial *mtrd = matManager.getMaterial("muo::Honeycomb");
        GeoLogVol *ltrd = new GeoLogVol(logVolName, strd, mtrd);
        GeoFullPhysVol *ptrd = new GeoFullPhysVol(ltrd);
 
        if (!minimalgeo)
            return ptrd;
 
        double newpos = -thickness / 2.;
        ptrd->add(new GeoSerialIdentifier(0));
 
        int igl = 0;
       
        // Loop over sTGC layers
        for (int i = 0; i < t->nlayers; i++) {
            double widthActive;
            double longWidthActive;
            double lengthActive;
 
            igl++;
            ptrd->add(new GeoIdentifierTag(igl));
 
            widthActive = width;
            longWidthActive = longWidth;
            lengthActive = length;
 
            double newXPos;
            double pcbpos;
            if (i == 0)
                newXPos = newpos + chamberTck / 2 + honeycombTck + coverTck;
            else
                newXPos = newpos + chamberTck + honeycombTck;
 
            // Build chamber volume (gas + pcb) out of gas
            GeoSimplePolygonBrep *sGasVolume = new GeoSimplePolygonBrep(chamberTck / 2.);
            sGasVolume->addVertex(longWidthActive / 2., lengthActive / 2.);
            sGasVolume->addVertex(-longWidthActive / 2., lengthActive / 2.);
            if (yCutout)
                sGasVolume->addVertex(-longWidthActive / 2., lengthActive / 2. - yCutout);
            sGasVolume->addVertex(-widthActive / 2., -lengthActive / 2.);
            sGasVolume->addVertex(widthActive / 2., -lengthActive / 2.);
            if (yCutout)
                sGasVolume->addVertex(longWidthActive / 2., lengthActive / 2. - yCutout);
 
            // Transform gas volume
            GeoTrf::Transform3D rot = GeoTrf::RotateZ3D(M_PI / 2.) * GeoTrf::RotateX3D(M_PI / 2.);
            const GeoShape *sGasVolume1 = new GeoShapeShift(sGasVolume, rot);
            GeoLogVol *ltrdgas = new GeoLogVol("sTGC_Sensitive", sGasVolume1, matManager.getMaterial("muo::TGCGas"));
            GeoPhysVol *ptrdgas = new GeoPhysVol(ltrdgas);
            GeoNameTag *gastag = new GeoNameTag(name + "muo::TGCGas");
            GeoTransform *chamberpos = new GeoTransform(GeoTrf::TranslateX3D(newXPos));
 
            // Build two pcb volumes and add them to the gas at -chamberTck/2 and at +chamberTck/2
            for (int i = 0; i < 2; i++) {
                if (i == 0) {
                    // This becomes the zero reference point for the pcb at -chamberTck/2
                    pcbpos = -chamberTck / 2 + pcbActualTck / 2;
                } else {
                    // This becomes the zero reference point for the pcb at +chamberTck/2. Alternatively,
                    // we can say pcbpos = +chamberTck/2 - pcbActualTck/2 ???
                    pcbpos = -chamberTck / 2 + pcbActualTck + gasTck + pcbActualTck / 2;
                }
 
                // Build pcb volume out of G10 material
                GeoSimplePolygonBrep *sPcbVolume = new GeoSimplePolygonBrep(pcbActualTck / 2.);
                sPcbVolume->addVertex(longWidthActive / 2., lengthActive / 2.);
                sPcbVolume->addVertex(-longWidthActive / 2., lengthActive / 2.);
                if (yCutout)
                    sPcbVolume->addVertex(-longWidthActive / 2., lengthActive / 2. - yCutout);
                sPcbVolume->addVertex(-widthActive / 2., -lengthActive / 2.);
                sPcbVolume->addVertex(widthActive / 2., -lengthActive / 2.);
                if (yCutout)
                    sPcbVolume->addVertex(longWidthActive / 2., lengthActive / 2. - yCutout);
 
                // Transform PCB volume
                GeoTrf::Transform3D rott = GeoTrf::RotateZ3D(M_PI / 2.) * GeoTrf::RotateX3D(M_PI / 2.);
                const GeoShape *sPcbVolume1 = new GeoShapeShift(sPcbVolume, rott);
 
                const GeoMaterial *mtrdC = matManager.getMaterial("std::G10");
                GeoLogVol *ltrdC = new GeoLogVol(logVolName, sPcbVolume1, mtrdC);
                GeoPhysVol *ptrdPcb = new GeoPhysVol(ltrdC);
                GeoNameTag *ntrdtmpC = new GeoNameTag(name + "std::G10");
 
                GeoTransform *ttrdtmpC = new GeoTransform(GeoTrf::TranslateX3D(pcbpos));
 
                // Place pcb volume inside chamber volume
                ptrdgas->add(ntrdtmpC); // nametag
                ptrdgas->add(ttrdtmpC); // shift
                ptrdgas->add(ptrdPcb);  // volume
            }                           // Close loop on pcb volumes
 
            // Place chamber volume inside the mother volume (honeycomb volume)
            ptrd->add(gastag);
            ptrd->add(chamberpos);
            ptrd->add(ptrdgas);
 
            // Cutouts
            if (!yCutout) {
                double lW = longWidth / 2. - ((longWidth - width) / 2.) * f4 / length;
                double W = width / 2. + ((longWidth - width) / 2.) * f5 / length;
                const GeoShape *trd1 = new GeoTrd(gasTck / 2, gasTck / 2, width / 2, longWidth / 2, length / 2);
                const GeoShape *trd2 = new GeoTrd(gasTck, gasTck, W - f6, lW - f6, length / 2 - (f4 + f5) / 2.);
                GeoTrf::Translate3D c(0, 0, (f5 - f4) / 2.);
                trd1 = &(trd1->subtract((*trd2) << c));
                GeoLogVol *ltrdframe = new GeoLogVol("sTGC_Frame", trd1, matManager.getMaterial("std::Aluminium"));
                GeoPhysVol *ptrdframe = new GeoPhysVol(ltrdframe);
 
                ptrdgas->add(ptrdframe);
            } else {
                double W = width / 2. + ((longWidth - width) / 2.) * f5 / (length);
                // This describes the active area
                GeoSimplePolygonBrep *sGasV = new GeoSimplePolygonBrep(gasTck / 2.);
                sGasV->addVertex(longWidthActive / 2. - f6, lengthActive / 2. - f4);
                sGasV->addVertex(-longWidthActive / 2. + f6, lengthActive / 2. - f4);
                sGasV->addVertex(-longWidthActive / 2. + f6, lengthActive / 2. - f4 - yCutoutCathode);
                sGasV->addVertex(-W + f6, -lengthActive / 2. + f5);
                sGasV->addVertex(W - f6, -lengthActive / 2. + f5);
                sGasV->addVertex(longWidthActive / 2. - f6, lengthActive / 2. - f4 - yCutoutCathode);
 
                // This describes the enveloppe (active area + frames)
                GeoSimplePolygonBrep *sGasV2 = new GeoSimplePolygonBrep(gasTck / 2.);
                sGasV2->addVertex(longWidth / 2., length / 2.);
                sGasV2->addVertex(-longWidth / 2., length / 2.);
                sGasV2->addVertex(-longWidth / 2., length / 2. - yCutout);
                sGasV2->addVertex(-width / 2., -length / 2.);
                sGasV2->addVertex(width / 2., -length / 2.);
                sGasV2->addVertex(longWidth / 2., length / 2. - yCutout);
 
                // define the final geo shapes
                const GeoShape *sGasV1 = new GeoShapeShift(sGasV, rot);
                const GeoShape *sGasV3 = new GeoShapeShift(sGasV2, rot);
                // Remove active from active+frames to only get frames
                sGasV3 = &(sGasV3->subtract((*sGasV1)));
 
                GeoLogVol *ltrdframe = new GeoLogVol("sTGC_Frame", sGasV3, matManager.getMaterial("std::Aluminium"));
                GeoPhysVol *ptrdframe = new GeoPhysVol(ltrdframe);
 
                // Add frame volume to QL3
                ptrdgas->add(ptrdframe);
            }
           
            newpos = newXPos;
        } // Loop over stgc layers
 
        return ptrd;
    }

print()

void MuonGM::sTGC::print ( ) const

overridevirtual

Implements MuonGM::DetectorElement.

Definition at line 257 of file sTGC.cxx.

                           {
        MsgStream log(Athena::getMessageSvc(), "MuGM::sTGC");
        log << MSG::INFO << " sTGC " << name << " :" << endmsg;
    }

setLogVolName()

void MuonGM::DetectorElement::setLogVolName ( const std::string & str )

inlineinherited

Definition at line 22 of file DetectorElement.h.

{ logVolName = str; }

Member Data Documentation

index

int MuonGM::sTGC::index {0}

Definition at line 29 of file sTGC.h.

{0};

length

double MuonGM::sTGC::length {0.}

Definition at line 24 of file sTGC.h.

{0.};

logVolName

std::string MuonGM::DetectorElement::logVolName {}

inherited

Definition at line 18 of file DetectorElement.h.

{};

longWidth

double MuonGM::sTGC::longWidth {0.}

Definition at line 26 of file sTGC.h.

{0.};      // for trapezoidal layers

m_component

sTGCComponent* MuonGM::sTGC::m_component {nullptr}

private

Definition at line 40 of file sTGC.h.

{nullptr};

name

std::string MuonGM::DetectorElement::name {}

inherited

Definition at line 17 of file DetectorElement.h.

{};

thickness

double MuonGM::sTGC::thickness {0.}

Definition at line 25 of file sTGC.h.

{0.};

width

double MuonGM::sTGC::width {0.}

Definition at line 23 of file sTGC.h.

{0.};

yCutout

double MuonGM::sTGC::yCutout {0.}

Definition at line 27 of file sTGC.h.

{0.};        // for Hexagonal layer

yCutoutCathode

double MuonGM::sTGC::yCutoutCathode {0.}

Definition at line 28 of file sTGC.h.

{0.}; // for Hexagonal layer

---

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

• sTGC.h
• sTGC.cxx