MuonGM::Rpc Class Reference

#include <Rpc.h>

Inheritance diagram for MuonGM::Rpc:

Collaboration diagram for MuonGM::Rpc:

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

Public Attributes
double	width {0.}
double	length {0.}
double	thickness {0.}
double	longWidth {0.}
double	idiv {0.}
double	jdiv {0.}
float	y_translation {0.f}
float	z_translation {0.f}
std::string	name {}
std::string	logVolName {}

Private Attributes
RpcComponent *	m_component {nullptr}
unsigned int	m_nlayers {0}

Detailed Description

Definition at line 20 of file Rpc.h.

Constructor & Destructor Documentation

Rpc()

MuonGM::Rpc::Rpc	(	const MYSQL &	mysql,
		Component *	s )

Definition at line 41 of file Rpc.cxx.

                                              : DetectorElement(ss->name) {
        double tol = 1.e-3;
        RpcComponent *s = static_cast<RpcComponent *>(ss);
        width = s->dx1;
        longWidth = s->dx2;
        thickness = s->GetThickness(mysql);
        length = s->dy - tol;
        m_component = s;
        idiv = s->ndivy;
        jdiv = s->ndivz;
        y_translation = 0;
        z_translation = 0;
        m_nlayers = 2;
        // the BI RPCs are the only ones with 3 gas gaps
        if (std::find(std::begin(biRpcs), std::end(biRpcs), ss->name) != std::end(biRpcs))
            m_nlayers = 3;
    }

Member Function Documentation

build() [1/2]

GeoIntrusivePtr< GeoFullPhysVol > MuonGM::Rpc::build	(	StoredMaterialManager &	matManager,
		const MYSQL &	mysql,
		int	minimalgeo )

Definition at line 59 of file Rpc.cxx.

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

build() [2/2]

GeoIntrusivePtr< GeoFullPhysVol > MuonGM::Rpc::build	(	StoredMaterialManager &	matManager,
		const MYSQL &	mysql,
		int	minimalgeo,
		int	cutoutson,
		const std::vector< Cutout * > &	vcutdef )

Definition at line 67 of file Rpc.cxx.

                                                                   {
        MsgStream log(Athena::getMessageSvc(), "MuonGM::Rpc::build");
 
        std::string geometry_version = mysql.getGeometryVersion();
        const RPC *r = dynamic_cast<const RPC*>(mysql.GetTechnology(name));
 
        // Retrieve geometrical information, these are for middle and outer alyers ("standard" RPCs)
        double thickness = r->maxThickness;
        width = width / idiv;
        longWidth = longWidth / idiv;
        length = length / jdiv;
 
        double extSupThick = r->externalSupPanelThickness;
        double extAlSupThick = r->externalAlSupPanelThickness;
        double rpcLayerThickness = r->rpcLayerThickness;
        double centSupThick = r->centralSupPanelThickness;
        double centAlSupThick = r->centralAlSupPanelThickness;
 
        // Geometrical information to be overwritten for BI chambers (having 3 gas gaps)
        if (m_nlayers == 3) {
            // width, longWidth, length are taken from geometry DB
            thickness = rpc3GapMaxThickness;
            rpcLayerThickness = rpc3GapLayerThickness;
        }
 
        if (RPCprint) {
            log << MSG::VERBOSE << " RPC build: " << name << " has thickness = " << thickness << " long width = " << longWidth << " width = " << width << " length = " << length
                << endmsg;
        }
 
        const GeoShape *srpc = new GeoTrd(thickness / 2, thickness / 2, width / 2, longWidth / 2, length / 2);
        // Apply cutouts to mother volume
 
        if (cutoutson && !vcutdef.empty()) {
            Cutout *cut = nullptr;
            GeoShape *cutoutShape = nullptr;
            GeoTrf::Transform3D cutTrans{GeoTrf::Transform3D::Identity()};
            for (unsigned i = 0; i < vcutdef.size(); i++) {
                cut = vcutdef[i];
                cutoutShape = new GeoTrd(thickness / 2. + 1., thickness / 2. + 1., cut->widthXs / 2., cut->widthXl / 2., cut->lengthY / 2.);
                cutTrans = GeoTrf::Translate3D(0.0, cut->dx, -length / 2 + cut->dy + cut->lengthY / 2.);
                srpc = &(srpc->subtract((*cutoutShape) << cutTrans));
            }
        }
 
        const GeoMaterial *mrpc = matManager.getMaterial("std::Air");
        GeoLogVol *lrpc = new GeoLogVol(logVolName, srpc, mrpc);
        GeoIntrusivePtr<GeoFullPhysVol> prpc = new GeoFullPhysVol(lrpc);
 
        if (minimalgeo == 1)
            return prpc;
 
        if (geometry_version.compare(0, 1,"M") != 0) {
            // here layout P and following (hopefully!)
            if (idiv * jdiv != 1)
                assert(0);
 
            // Note: the standard RPC (iswap != -1) has DED at the top:
            // from bottom to top it consists of the external support panel
            // and then the RPC doublet
 
            double newpos = -thickness / 2.;
 
            // here the bottom/external/pre-bent support panel
            // shape of the al skin of the support panel
            GeoTrd *slpan = new GeoTrd(extSupThick / 2, extSupThick / 2, width / 2, longWidth / 2, length / 2);
            GeoTrd *sholpan =
                new GeoTrd(extSupThick / 2 - extAlSupThick, extSupThick / 2 - extAlSupThick, width / 2 - extAlSupThick, longWidth / 2 - extAlSupThick, length / 2 - extAlSupThick);
            const GeoShape *sallpan = slpan;
            const GeoShape *sholpan2 = sholpan;
            const GeoMaterial *mallpan = matManager.getMaterial("std::Aluminium");
            GeoLogVol *lallpan = new GeoLogVol("RPC_AL_extsuppanel", sallpan, mallpan);
            PVLink  pallpan = new GeoPhysVol(lallpan);
            const GeoMaterial *mholpan = matManager.getMaterial("muo::RpcAlHonC");
            GeoLogVol *lholpan = new GeoLogVol("RPC_honeyc_extsuppanel", sholpan2, mholpan);
            PVLink pholpan = new GeoPhysVol(lholpan);
            pallpan->add(pholpan); // this way the honeycomb is a child of its al skin
 
            // Apply cutouts
            if (cutoutson && !vcutdef.empty()) {
                Cutout *cut = nullptr;
                GeoTrf::Transform3D cutTrans{GeoTrf::Transform3D::Identity()};
                for (unsigned i = 0; i < vcutdef.size(); i++) {
                    cut = vcutdef[i];
                    GeoRef<GeoTrd> cutoutShape (new GeoTrd (thickness / 2. + 1., thickness / 2. + 1., cut->widthXs / 2., cut->widthXl / 2., cut->lengthY / 2.));
                    cutTrans = GeoTrf::Translate3D(0.0, cut->dx, -length / 2 + cut->dy + cut->lengthY / 2.);
 
                    GeoCutVolAction cutAction(*cutoutShape, cutTrans);
                    pallpan->apply(&cutAction);
                    pallpan = cutAction.getPV();
                }
            }
 
            if (m_nlayers == 2) { // only to be done for standard (non-BI) RPCs
                newpos += extSupThick / 2.;
                GeoTransform *tlpan = new GeoTransform(GeoTrf::TranslateX3D(newpos));
                if (RPCprint) {
                    log << MSG::VERBOSE << " Rpc:: put ext.sup panel at " << newpos << " from centre" << endmsg;
                }
                if (!skip_rpc) {
                    prpc->add(tlpan);
                    prpc->add(pallpan);
                }
 
                // The first layer is support for RPCs with 2 gaps, is a layer for 3 gaps (BI chambers, no supports)
                newpos += extSupThick / 2.;
            }
 
            // bottom RpcLayer
            std::unique_ptr<RpcLayer> rl = std::make_unique<RpcLayer>(name, this);
            PVLink plowergg;
            if (cutoutson && !vcutdef.empty()) {
                plowergg = rl->build(matManager, mysql, cutoutson, vcutdef);
            } else {
                plowergg = rl->build(matManager, mysql);
            }
 
            newpos += rpcLayerThickness / 2.;
            GeoTransform *tlgg = new GeoTransform(GeoTrf::TranslateX3D(newpos));
            if (RPCprint) {
                log << MSG::VERBOSE << " Rpc:: put lower RPC layer at " << newpos << " from centre " << endmsg;
            }
            if (!skip_rpc) {
                prpc->add(new GeoIdentifierTag(1));
                prpc->add(tlgg);
                prpc->add(plowergg);
            }
 
            // central support panel
            newpos += rpcLayerThickness / 2.;
            GeoTrd *scpan = new GeoTrd(centSupThick / 2, centSupThick / 2, width / 2, longWidth / 2, length / 2);
            GeoTrd *shocpan = new GeoTrd(centSupThick / 2 - centAlSupThick, centSupThick / 2 - centAlSupThick, width / 2 - centAlSupThick, longWidth / 2 - centAlSupThick,
                                         length / 2 - centAlSupThick);
 
            const GeoShape *salcpan = scpan;
            const GeoShape *shocpan2 = shocpan;
            GeoLogVol *lalcpan = new GeoLogVol("RPC_AL_midsuppanel", salcpan, mallpan);
            PVLink  palcpan = new GeoPhysVol(lalcpan);
            const GeoMaterial *mhocpan = matManager.getMaterial("muo::RpcPapHonC");
            GeoLogVol *lhocpan = new GeoLogVol("RPC_honeyc_midsuppanel", shocpan2, mhocpan);
            PVLink phocpan = new GeoPhysVol(lhocpan);
            palcpan->add(phocpan); // this way the honeycomb is a child of its al skin
 
            // Apply cutouts
            if (cutoutson && !vcutdef.empty()) {
                Cutout *cut = nullptr;
                GeoTrf::Transform3D cutTrans{GeoTrf::Transform3D::Identity()};
                for (unsigned i = 0; i < vcutdef.size(); i++) {
                    cut = vcutdef[i];
                    GeoRef<GeoTrd> cutoutShape (new GeoTrd (thickness / 2. + 1., thickness / 2. + 1., cut->widthXs / 2., cut->widthXl / 2., cut->lengthY / 2.));
                    cutTrans = GeoTrf::Translate3D(0.0, cut->dx, -length / 2 + cut->dy + cut->lengthY / 2.);
 
                    GeoCutVolAction cutAction(*cutoutShape, cutTrans);
                    palcpan->apply(&cutAction);
                    palcpan = cutAction.getPV();
                }
            }
 
            if (m_nlayers == 2) { // only to be done for standard (non-BI) RPCs
                newpos += centSupThick / 2.;
                GeoTransform *tcpan = new GeoTransform(GeoTrf::TranslateX3D(newpos));
                if (RPCprint) {
                    log << MSG::VERBOSE << " Rpc:: put central sup panel at " << newpos << " from centre" << endmsg;
                }
                if (!skip_rpc) {
                    prpc->add(tcpan);
                    prpc->add(palcpan);
                }
                newpos += centSupThick / 2.;
            }
 
            // top RpcLayer
            std::unique_ptr<RpcLayer> ru = std::make_unique<RpcLayer>(name, this);
            PVLink puppergg;
            if (cutoutson && !vcutdef.empty()) {
                // This code required to take into account the various
                // 180 degree rotations of RPC panels in BMS chambers
                int subtype = 0;
                int ijob = 0;
                for (unsigned int i = 0; i < vcutdef.size(); i++) {
                    subtype = vcutdef[i]->subtype;
                    ijob = vcutdef[i]->ijob;
 
                    // For BMS2, BMS13
                    if (name == "RPC06" && ijob == 3) {
                        if (subtype == 2) {
                            vcutdef[i]->dy = 0;
                        } else if (subtype == 13) {
                            vcutdef[i]->dy = this->length - vcutdef[i]->lengthY;
                        }
                    }
 
                    // For BMS5, BMS9
                    if (name == "RPC07") {
                        if (subtype == 5) { // BMS5
                            if (ijob == 24)
                                vcutdef[i]->dy = this->length - vcutdef[i]->lengthY;
                            if (ijob == 32)
                                vcutdef[i]->dy = 0.;
                        } else if (subtype == 9) { // BMS9
                            if (ijob == 32)
                                vcutdef[i]->dy = this->length - vcutdef[i]->lengthY;
                            if (ijob == 24)
                                vcutdef[i]->dy = 0.;
                        }
                    }
 
                    // For BMS6, BMS11
                    if (subtype == 6) {
                        if (ijob == 29 && name == "RPC07")
                            vcutdef[i]->dy = this->length - vcutdef[i]->lengthY;
                        if (ijob == 21 && name == "RPC08")
                            vcutdef[i]->dy = 0;
                    } else if (subtype == 11) {
                        if (ijob == 29 && name == "RPC07")
                            vcutdef[i]->dy = 0;
                        if (ijob == 21 && name == "RPC08")
                            vcutdef[i]->dy = this->length - vcutdef[i]->lengthY - vcutdef[i]->dy;
                    }
                }
 
                puppergg = ru->build(matManager, mysql, cutoutson, vcutdef);
            } else {
                puppergg = ru->build(matManager, mysql);
            }
 
            newpos += rpcLayerThickness / 2.;
            GeoTransform *tugg = new GeoTransform(GeoTrf::TranslateX3D(newpos));
            if (RPCprint) {
                log << MSG::VERBOSE << " Rpc:: put upper RPC layer at " << newpos << " from centre " << endmsg;
            }
            if (!skip_rpc) {
                prpc->add(new GeoIdentifierTag(2));
                prpc->add(tugg);
                if (m_nlayers == 2) {
                    GeoTransform *rugg = new GeoTransform(GeoTrf::RotateY3D(180 * Gaudi::Units::deg));
                    prpc->add(rugg); // only to be done for standard (non-BI) RPCs
                }
                prpc->add(puppergg);
            }
 
            // additional RpcLayer for BI (3 gaps)
            if (m_nlayers == 3) {
                newpos += rpcLayerThickness / 2.;
                RpcLayer rthird (name, this);
                PVLink pthirdgg;
                if (cutoutson && !vcutdef.empty()) {
                    pthirdgg = rthird.build(matManager, mysql, cutoutson, vcutdef);
                } else {
                    pthirdgg = rthird.build(matManager, mysql);
                }
 
                newpos += rpcLayerThickness / 2.;
                GeoTransform *tthirdgg = new GeoTransform(GeoTrf::TranslateX3D(newpos));
                if (RPCprint)
                    log << MSG::VERBOSE << " Rpc:: put upper RPC layer at " << newpos << " from centre " << endmsg;
                if (!skip_rpc) {
                    prpc->add(new GeoIdentifierTag(3));
                    prpc->add(tthirdgg);
                    prpc->add(pthirdgg);
                }
            }
        }
        return prpc;
    }

nGasGaps()

unsigned int MuonGM::Rpc::nGasGaps ( ) const

inline

Definition at line 48 of file Rpc.h.

{ return m_nlayers; }

print()

void MuonGM::Rpc::print ( ) const

overridevirtual

Implements MuonGM::DetectorElement.

Definition at line 336 of file Rpc.cxx.

                          {
        MsgStream log(Athena::getMessageSvc(), "MuonGM::Rpc::build");
        log << MSG::INFO << "Rpc " << name.c_str() << " :" << endmsg;
    }

setLogVolName()

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

inlineinherited

Definition at line 22 of file DetectorElement.h.

{ logVolName = str; }

Member Data Documentation

idiv

double MuonGM::Rpc::idiv {0.}

Definition at line 27 of file Rpc.h.

{0.};

jdiv

double MuonGM::Rpc::jdiv {0.}

Definition at line 28 of file Rpc.h.

{0.};

length

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

Definition at line 24 of file Rpc.h.

{0.};

logVolName

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

inherited

Definition at line 18 of file DetectorElement.h.

{};

longWidth

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

Definition at line 26 of file Rpc.h.

{0.}; // for trapezoidal layers

m_component

RpcComponent* MuonGM::Rpc::m_component {nullptr}

private

Definition at line 45 of file Rpc.h.

{nullptr};

m_nlayers

unsigned int MuonGM::Rpc::m_nlayers {0}

private

Definition at line 46 of file Rpc.h.

{0};

name

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

inherited

Definition at line 17 of file DetectorElement.h.

{};

thickness

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

Definition at line 25 of file Rpc.h.

{0.};

width

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

Definition at line 23 of file Rpc.h.

{0.};

y_translation

float MuonGM::Rpc::y_translation {0.f}

Definition at line 29 of file Rpc.h.

{0.f};

z_translation

float MuonGM::Rpc::z_translation {0.f}

Definition at line 30 of file Rpc.h.

{0.f};

---

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

• Rpc.h
• Rpc.cxx