MuonGM::CscMultiLayer Class Reference

#include <CscMultiLayer.h>

Inheritance diagram for MuonGM::CscMultiLayer:

Collaboration diagram for MuonGM::CscMultiLayer:

Public Member Functions
	CscMultiLayer (const MYSQL &mysql, const std::string &n)
GeoVPhysVol *	build (StoredMaterialManager &matManager, const MYSQL &mysql)
GeoVPhysVol *	build (StoredMaterialManager &matManager, const MYSQL &mysql, int cutoutson, const std::vector< Cutout * > &vcutdef)
virtual void	print () const override
void	setLogVolName (const std::string &str)

Public Attributes
int	nrOfLayers {0}
double	width {0.}
double	longWidth {0.}
double	upWidth {0.}
double	excent {0.}
double	length {0.}
double	physicalLength {0.}
double	maxwLength {0.}
double	thickness {0.}
double	cscthickness {0.}
std::array< double, 8 >	dim {}
std::string	name {}
std::string	logVolName {}

Detailed Description

Definition at line 19 of file CscMultiLayer.h.

Constructor & Destructor Documentation

CscMultiLayer()

MuonGM::CscMultiLayer::CscMultiLayer	(	const MYSQL &	mysql,
		const std::string &	n
	)

Definition at line 39 of file CscMultilayer.cxx.

                                                                       : DetectorElement(n) {
        const CSC *md = dynamic_cast<const CSC*>(mysql.GetTechnology(name));
        nrOfLayers = md->numOfLayers;
        cscthickness = md->totalThickness;
        thickness = cscthickness;
    }

Member Function Documentation

build() [1/2]

GeoVPhysVol * MuonGM::CscMultiLayer::build	(	StoredMaterialManager &	matManager,
		const MYSQL &	mysql
	)

Definition at line 46 of file CscMultilayer.cxx.

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

build() [2/2]

GeoVPhysVol * MuonGM::CscMultiLayer::build	(	StoredMaterialManager &	matManager,
		const MYSQL &	mysql,
		int	cutoutson,
		const std::vector< Cutout * > &	vcutdef
	)

Definition at line 53 of file CscMultilayer.cxx.

                                                                    {
        const CSC *md = dynamic_cast<const CSC*>(mysql.GetTechnology(name));
 
        // define the chamber volumes --- for CSS and CSL
 
        //-------------internal CSC layer structure-------------4 layers ------
 
        // The dimensions of the panel
        double hon_thick = md->honeycombthick;
        double gasThickness = 2.0 * md->anocathodist;
        double newpos = cscthickness / 2.;
        double g10thi = (2. * md->g10thick + md->honeycombthick);
 
        // define the volumes
        // g10, honeycomb, and the gas
        // gas mixture: 80% Ar + 20% CO2:
        // at 1 atmosphere, 20 deg. Celcius:
        // density Ar = 1.699 g cm-3
        // density CO2 = 1.902 g cm-3
        // density of mixture = 0.8 d1 + 0.2 d2 = 1.740 gcm-3
 
        // Create CSC layer envelope made of air
        const GeoShape *sml = new GeoTrd(thickness / 2., thickness / 2., width / 2., longWidth / 2., maxwLength / 2.);
        if (excent != length) {
            const GeoShape *smlt = new GeoTrd(thickness / 2., thickness / 2., longWidth / 2., upWidth / 2., (physicalLength - maxwLength) / 2.);
            sml = &((sml->add((*smlt) << GeoTrf::TranslateZ3D(physicalLength / 2.))) << GeoTrf::TranslateZ3D((maxwLength - physicalLength) / 2.));
        }
 
        const GeoMaterial *mhon = matManager.getMaterial("muo::Honeycomb");
        const GeoLogVol *lml = new GeoLogVol("CscMultilayer", sml, mhon);
        GeoPhysVol *pml = new GeoPhysVol(lml);
 
        // Create G10 and honeycomb volumes
        const GeoShape *shon = new GeoTrd(hon_thick / 2., hon_thick / 2., width / 2., longWidth / 2., maxwLength / 2.);
        const GeoShape *sg10hon = new GeoTrd(g10thi / 2., g10thi / 2., width / 2., longWidth / 2., maxwLength / 2.);
        if (excent != length) {
            const GeoShape *shont = new GeoTrd(hon_thick / 2., hon_thick / 2., longWidth / 2., upWidth / 2., (physicalLength - maxwLength) / 2.);
            shon = &((shon->add((*shont) << GeoTrf::TranslateZ3D(physicalLength / 2.))) << GeoTrf::TranslateZ3D((maxwLength - physicalLength) / 2.));
            const GeoShape *sg10hont = new GeoTrd(g10thi / 2., g10thi / 2., longWidth / 2., upWidth / 2., (physicalLength - maxwLength) / 2.);
            sg10hon = &((sg10hon->add((*sg10hont) << GeoTrf::TranslateZ3D(physicalLength / 2.))) << GeoTrf::TranslateZ3D((maxwLength - physicalLength) / 2.));
        }
 
        const GeoLogVol *lhon = new GeoLogVol("Honeycomb", shon, mhon);
        GeoPhysVol *phon = new GeoPhysVol(lhon);
 
        const GeoMaterial *mg10 = matManager.getMaterial("std::G10");
        const GeoLogVol *lg10hon = new GeoLogVol("G10", sg10hon, mg10);
        GeoPhysVol *pg10hon = new GeoPhysVol(lg10hon);
        // Put honeycomb inside G10
        pg10hon->add(phon);
 
        // Create gas volume
        const GeoShape *sgas = nullptr;
        double beta = atan((longWidth - width) / (2. * maxwLength));
        double gShortWidth = width - 2 * md->fullwirefixbarwidth * (1 - sin(beta)) / cos(beta);
        double gLongWidth = longWidth - 2 * md->fullwirefixbarwidth * (1 + sin(beta)) / cos(beta);
        if (excent == length) {
            double gLength = maxwLength - 2 * md->fullwirefixbarwidth;
            sgas = new GeoTrd(gasThickness / 2., gasThickness / 2., gShortWidth / 2., gLongWidth / 2., gLength / 2.);
        } else {
            double alpha = atan((excent - maxwLength) / (longWidth / 2.));
            double gmaxwLength = maxwLength - md->fullwirefixbarwidth;
            double gLength = length - 2. * md->fullwirefixbarwidth;
            double gupWidth = upWidth - 2 * md->fullwirefixbarwidth * (1 - cos(alpha)) / sin(alpha);
 
            sgas = new GeoTrd(gasThickness / 2., gasThickness / 2., gShortWidth / 2., gLongWidth / 2., gmaxwLength / 2.);
            const GeoShape *sgast = new GeoTrd(gasThickness / 2., gasThickness / 2., gLongWidth / 2., gupWidth / 2., (gLength - gmaxwLength) / 2.);
            sgas = &((sgas->add((*sgast) << GeoTrf::TranslateZ3D(gLength / 2.))) << GeoTrf::TranslateZ3D((gmaxwLength - gLength) / 2.));
        }
        const GeoMaterial *mgas = matManager.getMaterial("muo::CscArCO2");
        const GeoLogVol *lgas = nullptr;
 
        // Place G10/honeycomb and gas volumes in CSC envelop, starting at top
        //   G10 - gas - G10 - gas - G10 - gas - G10 - gas - G10
        for (int i = 0; i < nrOfLayers + 1; i++) {
            GeoNameTag *np = new GeoNameTag("panel");
            GeoTransform *xp = new GeoTransform(GeoTrf::TranslateX3D(newpos - g10thi / 2.));
            pml->add(new GeoIdentifierTag(i));
            pml->add(np);
            pml->add(xp);
            pml->add(pg10hon);
            newpos -= g10thi;
 
            if (i < nrOfLayers) {
                lgas = new GeoLogVol("CscArCO2", sgas, mgas);
                GeoPhysVol *pgas = new GeoPhysVol(lgas);
                // the gas Gap
                // correct the position within the chamber
                GeoNameTag *ng = new GeoNameTag("CscArCO2");
                GeoTransform *xg = new GeoTransform(GeoTrf::TranslateX3D(newpos - gasThickness / 2.));
                pml->add(new GeoIdentifierTag(i));
                pml->add(ng);
                pml->add(xg);
                pml->add(pgas);
                newpos -= gasThickness;
            }
        }
 
        return pml;
    }

print()

void MuonGM::CscMultiLayer::print ( ) const

overridevirtual

Implements MuonGM::DetectorElement.

Definition at line 157 of file CscMultilayer.cxx.

                                    {
        MsgStream log(Athena::getMessageSvc(), "MuonGM::CscMultiLayer");
        log << MSG::INFO << "CscMulti Layer:: CscMulti Layer " << 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

cscthickness

double MuonGM::CscMultiLayer::cscthickness {0.}

Definition at line 34 of file CscMultiLayer.h.

dim

std::array<double, 8> MuonGM::CscMultiLayer::dim {}

Definition at line 35 of file CscMultiLayer.h.

excent

double MuonGM::CscMultiLayer::excent {0.}

Definition at line 28 of file CscMultiLayer.h.

length

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

Definition at line 29 of file CscMultiLayer.h.

logVolName

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

inherited

Definition at line 18 of file DetectorElement.h.

longWidth

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

Definition at line 25 of file CscMultiLayer.h.

maxwLength

double MuonGM::CscMultiLayer::maxwLength {0.}

Definition at line 31 of file CscMultiLayer.h.

name

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

inherited

Definition at line 17 of file DetectorElement.h.

nrOfLayers

int MuonGM::CscMultiLayer::nrOfLayers {0}

Definition at line 22 of file CscMultiLayer.h.

physicalLength

double MuonGM::CscMultiLayer::physicalLength {0.}

Definition at line 30 of file CscMultiLayer.h.

thickness

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

Definition at line 33 of file CscMultiLayer.h.

upWidth

double MuonGM::CscMultiLayer::upWidth {0.}

Definition at line 26 of file CscMultiLayer.h.

width

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

Definition at line 24 of file CscMultiLayer.h.

---

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

• CscMultiLayer.h
• CscMultilayer.cxx