MuonGM::Csc Class Reference

#include <Csc.h>

Inheritance diagram for MuonGM::Csc:

Collaboration diagram for MuonGM::Csc:

Public Member Functions
	Csc (const MYSQL &mysql, Component *s)
	~Csc ()=default
GeoFullPhysVol *	build (StoredMaterialManager &matManager, const MYSQL &mysql, int minimalgeo)
GeoFullPhysVol *	build (StoredMaterialManager &matManager, const MYSQL &mysql, 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	excent {0.}
double	physicalLength {0.}
double	maxwLength {0.}
double	upWidth {0.}
int	index {0}
std::unique_ptr< CscMultiLayer >	layer {nullptr}
std::string	name {}
std::string	logVolName {}

Private Attributes
CscComponent *	m_component {nullptr}

Detailed Description

Definition at line 23 of file Csc.h.

Constructor & Destructor Documentation

Csc()

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

Definition at line 33 of file Csc.cxx.

                                              : DetectorElement(ss->name) {
        CscComponent *s = static_cast<CscComponent *>(ss);
        m_component = s;
        width = s->dx1;
        longWidth = s->dx2;
        thickness = s->GetThickness(mysql);
        maxwLength = s->maxwdy;
        excent = s->excent;
        physicalLength = s->dy;
        length = physicalLength;
        double num = longWidth * (excent - physicalLength);
        if (std::abs(num) < 1e-10) {
            upWidth = 0;
        } else {
            upWidth = num / (excent - maxwLength);
        }
 
        layer = std::make_unique<CscMultiLayer>(mysql, s->name);
        layer->width = width;
        layer->longWidth = longWidth;
        layer->upWidth = upWidth;
        layer->excent = excent;
        layer->length = length;
        layer->physicalLength = physicalLength;
        layer->maxwLength = maxwLength;
 
        index = s->index;
    }

~Csc()

MuonGM::Csc::~Csc ( )

default

Member Function Documentation

build() [1/2]

GeoFullPhysVol * MuonGM::Csc::build	(	StoredMaterialManager &	matManager,
		const MYSQL &	mysql,
		int	minimalgeo
	)

Definition at line 63 of file Csc.cxx.

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

build() [2/2]

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

Definition at line 71 of file Csc.cxx.

                                                                   {
        GeoFullPhysVol *pcsc = nullptr;
        GeoLogVol *lcsc = nullptr;
        const GeoMaterial *mcsc = matManager.getMaterial("std::Air");
 
        if (excent == length) {
            // CSC is a simple traezoid
            const GeoShape *sCSS = new GeoTrd(thickness / 2., thickness / 2., width / 2., longWidth / 2., length / 2.);
            lcsc = new GeoLogVol(logVolName, sCSS, mcsc);
 
        } else {
            // CSC is a union of two trapezoids
            GeoTrd *downTrd = new GeoTrd(thickness / 2., thickness / 2., width / 2., longWidth / 2., maxwLength / 2.);
            GeoTrd *upTrd = new GeoTrd(thickness / 2., thickness / 2., longWidth / 2., upWidth / 2., (physicalLength - maxwLength) / 2.);
            const GeoShape *sCSL = &((downTrd->add((*upTrd) << GeoTrf::TranslateZ3D(physicalLength / 2.))) << GeoTrf::TranslateZ3D((maxwLength - physicalLength) / 2.));
            lcsc = new GeoLogVol(logVolName, sCSL, mcsc);
        }
 
        pcsc = new GeoFullPhysVol(lcsc);
        if (minimalgeo == 1)
            return pcsc;
 
        GeoVPhysVol *lay = layer->build(matManager, mysql, cutoutson, vcutdef);
        if (!skip_csc)
            pcsc->add(lay);
 
        return pcsc;
    }

print()

void MuonGM::Csc::print ( ) const

overridevirtual

Implements MuonGM::DetectorElement.

Definition at line 103 of file Csc.cxx.

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

excent

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

Definition at line 30 of file Csc.h.

index

int MuonGM::Csc::index {0}

Definition at line 35 of file Csc.h.

layer

std::unique_ptr<CscMultiLayer> MuonGM::Csc::layer {nullptr}

Definition at line 37 of file Csc.h.

length

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

Definition at line 27 of file Csc.h.

logVolName

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

inherited

Definition at line 18 of file DetectorElement.h.

longWidth

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

Definition at line 29 of file Csc.h.

m_component

CscComponent* MuonGM::Csc::m_component {nullptr}

private

Definition at line 52 of file Csc.h.

maxwLength

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

Definition at line 32 of file Csc.h.

name

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

inherited

Definition at line 17 of file DetectorElement.h.

physicalLength

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

Definition at line 31 of file Csc.h.

thickness

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

Definition at line 28 of file Csc.h.

upWidth

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

Definition at line 33 of file Csc.h.

width

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

Definition at line 26 of file Csc.h.

---

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

• Csc.h
• Csc.cxx