Muon::MdtIntersectGeometry Class Reference

#include <MdtIntersectGeometry.h>

Inheritance diagram for Muon::MdtIntersectGeometry:

Collaboration diagram for Muon::MdtIntersectGeometry:

Public Member Functions
	MdtIntersectGeometry (MsgStream &msg, const Identifier &chid, const IMuonIdHelperSvc *idHelperSvc, const MuonGM::MuonDetectorManager *detMgr, const MdtCondDbData *dbData)
	MdtIntersectGeometry (const MdtIntersectGeometry &right)=delete
MdtIntersectGeometry &	operator= (const MdtIntersectGeometry &right)=delete
virtual	~MdtIntersectGeometry ()
MuonStationIntersect	intersection (const Amg::Vector3D &pos, const Amg::Vector3D &dir) const override
const Amg::Transform3D &	transform () const
std::shared_ptr< const TrkDriftCircleMath::MdtChamberGeometry >	mdtChamberGeometry () const
const Identifier &	chamberId () const

Private Member Functions
double	tubeLength (const int ml, const int layer, const int tube) const
void	init (MsgStream &msg)
void	fillDeadTubes (const MuonGM::MdtReadoutElement *mydetEl, MsgStream &msg)

Private Attributes
Identifier	m_chid {}
Amg::Transform3D	m_transform
std::shared_ptr< TrkDriftCircleMath::MdtChamberGeometry >	m_mdtGeometry {}
const MuonGM::MdtReadoutElement *	m_detElMl0 {nullptr}
const MuonGM::MdtReadoutElement *	m_detElMl1 {nullptr}
const MuonGM::MuonDetectorManager *	m_detMgr {nullptr}
const MdtCondDbData *	m_dbData {nullptr}
const IMuonIdHelperSvc *	m_idHelperSvc {nullptr}
std::set< Identifier >	m_deadTubesML {}
std::vector< Identifier >	m_deadTubes {}

Detailed Description

Definition at line 23 of file MdtIntersectGeometry.h.

Constructor & Destructor Documentation

MdtIntersectGeometry() [1/2]

Muon::MdtIntersectGeometry::MdtIntersectGeometry	(	MsgStream &	msg,
		const Identifier &	chid,
		const IMuonIdHelperSvc *	idHelperSvc,
		const MuonGM::MuonDetectorManager *	detMgr,
		const MdtCondDbData *	dbData
	)

Definition at line 22 of file MdtIntersectGeometry.cxx.

                                                                                                                     :
        m_chid(chid), m_detMgr(detMgr), m_dbData(dbData), m_idHelperSvc(idHelperSvc) {
        init(msg);
    }

MdtIntersectGeometry() [2/2]

Muon::MdtIntersectGeometry::MdtIntersectGeometry ( const MdtIntersectGeometry &  right )

delete

~MdtIntersectGeometry()

Muon::MdtIntersectGeometry::~MdtIntersectGeometry ( )

virtualdefault

Member Function Documentation

chamberId()

const Identifier& Muon::MdtIntersectGeometry::chamberId ( ) const

inline

Definition at line 38 of file MdtIntersectGeometry.h.

{ return m_chid; }

fillDeadTubes()

void Muon::MdtIntersectGeometry::fillDeadTubes ( const MuonGM::MdtReadoutElement *  mydetEl, MsgStream &  msg  )

private

Definition at line 199 of file MdtIntersectGeometry.cxx.

                                                                                                   {
        if ((mydetEl->getStationName()).find("BMG") != std::string::npos) {
            PVConstLink cv = mydetEl->getMaterialGeom();  // it is "Multilayer"
            int nGrandchildren = cv->getNChildVols();
            if (nGrandchildren <= 0) return;
 
            std::vector<int> tubes;
            geoGetIds([&](int id) { tubes.push_back(id); }, &*cv);
            std::sort(tubes.begin(), tubes.end());
 
            Identifier detElId = mydetEl->identify();
 
            int name = m_idHelperSvc->mdtIdHelper().stationName(detElId);
            int eta = m_idHelperSvc->mdtIdHelper().stationEta(detElId);
            int phi = m_idHelperSvc->mdtIdHelper().stationPhi(detElId);
            int ml = m_idHelperSvc->mdtIdHelper().multilayer(detElId);
 
            std::vector<int>::iterator it = tubes.begin();
            for (int layer = 1; layer <= mydetEl->getNLayers(); layer++) {
                for (int tube = 1; tube <= mydetEl->getNtubesperlayer(); tube++) {
                    int want_id = layer * MdtIdHelper::maxNTubesPerLayer + tube;
                    if (it != tubes.end() && *it == want_id) {
                        ++it;
                    } else {
                        it = std::lower_bound(tubes.begin(), tubes.end(), want_id);
                        if (it != tubes.end() && *it == want_id) {
                            ++it;
                        } else {
                            Identifier deadTubeId = m_idHelperSvc->mdtIdHelper().channelID(name, eta, phi, ml, layer, tube);
                            Identifier deadTubeMLId = m_idHelperSvc->mdtIdHelper().multilayerID(deadTubeId);
                            m_deadTubes.push_back(deadTubeId);
                            m_deadTubesML.insert(deadTubeMLId);
                            if (msg.level() == MSG::VERBOSE)
                                msg << MSG::VERBOSE << " MdtIntersectGeometry: adding dead tube (" << tube << "), layer(" << layer
                                    << "), phi(" << phi << "), eta(" << eta << "), name(" << name << ") and adding multilayerId("
                                    << deadTubeMLId << ")." << endmsg;
                        }
                    }
                }
            }
        }
    }

init()

void Muon::MdtIntersectGeometry::init ( MsgStream &  msg )

private

Definition at line 98 of file MdtIntersectGeometry.cxx.

                                                  {
        /* calculate chamber geometry
           it takes as input:
             distance between the first and second tube in the chamber within a layer along the tube layer (tube distance)
             distance between the first tube in the first layer and the first tube in the second layer along the tube layer (tube stagering)
             distance between the first and second layer perpendicular to the tube layers (layer distance)
             position of the first hit in ml 0 and ml 1 (2D in plane)
             total number of multilayers
             total number of layers
             total number of tubes per layer for each multilayer
             an identifier uniquely identifying the chamber
        */
 
        // get id
        int eta = m_idHelperSvc->mdtIdHelper().stationEta(m_chid);
        int phi = m_idHelperSvc->mdtIdHelper().stationPhi(m_chid);
        int name = m_idHelperSvc->mdtIdHelper().stationName(m_chid);
        // get detEL for first ml (always there)
        Identifier firstIdml0 = m_idHelperSvc->mdtIdHelper().channelID(name, eta, phi, 1, 1, 1);
        Identifier firstIdml1;
 
        m_detElMl0 = m_detMgr->getMdtReadoutElement(firstIdml0);
        m_detElMl1 = nullptr;
 
        if (!m_detElMl0) {
            msg << MSG::WARNING << "MdtIntersectGeometry::init() - failed to get readout element for ML0" << endmsg;
            return;
        }
 
        // number of multilayers in chamber
        int nml = m_detElMl0->nMDTinStation();
 
        // treament of chambers with two ml
        if (nml == 2) {
            firstIdml1 = m_idHelperSvc->mdtIdHelper().channelID(name, eta, phi, 2, 1, 1);
            m_detElMl1 = m_detMgr->getMdtReadoutElement(firstIdml1);
        }
 
        // if one of the two ml is dead treat the chamber as a single ML station
        // if both are dead give a WARNING
        // check status of the two multilayers using the MdtCondDbData if it exists
        // otherwise (i.e. online) they are treated as both good by default
        bool goodMl0{false}, goodMl1{false};
        if (m_dbData) {
            goodMl0 = m_dbData->isGoodMultilayer(firstIdml0);
            goodMl1 = m_detElMl1 ? m_dbData->isGoodMultilayer(firstIdml1) : false;
        } else {
            goodMl0 = true;
            goodMl1 = true;
        }
        int firstMlIndex = 1;
        if (goodMl0 && !goodMl1) {
            nml = 1;
            m_detElMl1 = nullptr;
        } else if (!goodMl0 && goodMl1) {
            nml = 1;
            // swap detEl1 and detEl0
            m_detElMl0 = m_detElMl1;
            m_detElMl1 = nullptr;
            firstIdml0 = firstIdml1;
            firstMlIndex = 2;
        } else if (!goodMl0 && !goodMl1) {
            msg << MSG::WARNING << "MdtIntersectGeometry::init() - neither multilayer is good" << endmsg;
            return;
        }
        m_transform = m_detElMl0->GlobalToAmdbLRSTransform();
 
        // number of layers and tubes
        int nlay = m_detElMl0->getNLayers();
        int ntube0 = m_detElMl0->getNtubesperlayer();
        int ntube1 = m_detElMl1 ? m_detElMl1->getNtubesperlayer() : 0;
 
        // position first tube in ml 0 and 1
        Amg::Vector3D firstTubeMl0 = transform() * (m_detElMl0->tubePos(firstIdml0));
        Amg::Vector3D firstTubeMl1 = m_detElMl1 ? transform() * (m_detElMl1->tubePos(firstIdml1)) : Amg::Vector3D{0., 0., 0.};
 
        TrkDriftCircleMath::LocVec2D firstTube0(firstTubeMl0.y(), firstTubeMl0.z());
        TrkDriftCircleMath::LocVec2D firstTube1(firstTubeMl1.y(), firstTubeMl1.z());
 
        // position second tube in ml 0
        Identifier secondIdml0 = m_idHelperSvc->mdtIdHelper().channelID(name, eta, phi, firstMlIndex, 1, 2);
        Amg::Vector3D secondTubeMl0 = transform() * (m_detElMl0->tubePos(secondIdml0));
 
                        fillDeadTubes(m_detElMl0, msg);
        if (m_detElMl1) fillDeadTubes(m_detElMl1, msg);
 
        // position first tube in second layer ml 0
        Identifier firstIdml0lay1 = m_idHelperSvc->mdtIdHelper().channelID(name, eta, phi, firstMlIndex, 2, 1);
        Amg::Vector3D firstTubeMl0lay1 = transform() * (m_detElMl0->tubePos(firstIdml0lay1));
 
        double tubeDist = (secondTubeMl0 - firstTubeMl0).y();      // distance between tube in a given layer
        double tubeStage = (firstTubeMl0lay1 - firstTubeMl0).y();  // tube stagering distance
        double layDist = (firstTubeMl0lay1 - firstTubeMl0).z();    // distance between layers
 
        m_mdtGeometry = std::make_unique<TrkDriftCircleMath::MdtChamberGeometry>(
            m_chid, m_idHelperSvc, nml, nlay, ntube0, ntube1, firstTube0, firstTube1, tubeDist, tubeStage, layDist, m_detElMl0->center().theta());
 
        // finally if the first ml is dead, configure the MdtChamberGeometry accordingly
        if (!goodMl0 && goodMl1) m_mdtGeometry->isSecondMultiLayer(true);
    }

intersection()

MuonStationIntersect Muon::MdtIntersectGeometry::intersection ( const Amg::Vector3D &  pos, const Amg::Vector3D &  dir  ) const

overridevirtual

Implements Muon::MuonIntersectGeometry.

Definition at line 30 of file MdtIntersectGeometry.cxx.

                                                                                                                {
        MuonStationIntersect intersect;
        if (!m_mdtGeometry) {
            MsgStream log(Athena::getMessageSvc(), "MdtIntersectGeometry");
            log << MSG::WARNING << "MdtIntersectGeometry::intersection() - MdtIntersectGeometry not correctly initialized "
                << m_idHelperSvc->mdtIdHelper().print_to_string(m_chid) << endmsg;
            return intersect;
        }
 
        Amg::Vector3D lpos = transform() * pos;
        Amg::Vector3D ldir = (transform().linear() * dir).unit();
 
        double dxdy = std::abs(ldir.y()) > 0.001 ? ldir.x() / ldir.y() : 1000.;
 
        double lineAngle = std::atan2(ldir.z(), ldir.y());
        TrkDriftCircleMath::LocVec2D linePos(lpos.y(), lpos.z());
        TrkDriftCircleMath::Line line(linePos, lineAngle);
        const TrkDriftCircleMath::DCVec dcs = m_mdtGeometry->tubesPassedByLine(line);
 
        MuonStationIntersect::TubeIntersects intersects;
 
        TrkDriftCircleMath::DCCit dit = dcs.begin();
        TrkDriftCircleMath::DCCit dit_end = dcs.end();
        for (; dit != dit_end; ++dit) {
            const TrkDriftCircleMath::MdtId& mdtId = dit->id();
 
            double xint = dxdy * (dit->position().x() - lpos.y()) + lpos.x();
            Identifier tubeid = m_idHelperSvc->mdtIdHelper().channelID(m_chid, mdtId.ml() + 1, mdtId.lay() + 1, mdtId.tube() + 1);
            if (m_deadTubesML.find(m_idHelperSvc->mdtIdHelper().multilayerID(tubeid)) != m_deadTubesML.end()) {
                if (std::find(m_deadTubes.begin(), m_deadTubes.end(), tubeid) != m_deadTubes.end()) continue;
            }
            double distWall = std::abs(xint) - 0.5 * tubeLength(mdtId.ml(), mdtId.lay(), mdtId.tube());
            intersects.emplace_back(tubeid, dit->dr(), distWall);
        }
        intersect.setTubeIntersects(std::move(intersects));
 
        return intersect;
    }

mdtChamberGeometry()

std::shared_ptr< const TrkDriftCircleMath::MdtChamberGeometry > Muon::MdtIntersectGeometry::mdtChamberGeometry

(

)

const

Definition at line 198 of file MdtIntersectGeometry.cxx.

{ return m_mdtGeometry; }

operator=()

MdtIntersectGeometry& Muon::MdtIntersectGeometry::operator= ( const MdtIntersectGeometry &  right )

delete

transform()

const Amg::Transform3D& Muon::MdtIntersectGeometry::transform ( ) const

inline

Definition at line 35 of file MdtIntersectGeometry.h.

{ return m_transform; }

tubeLength()

double Muon::MdtIntersectGeometry::tubeLength ( const int  ml, const int  layer, const int  tube  ) const

private

Definition at line 69 of file MdtIntersectGeometry.cxx.

                                                                                               {
#ifndef NDEBUG
        if (ml < 0 || ml > 1){
            std::stringstream sstr{};
            sstr<<__FILE__<<":"<<__LINE__<<" "<<__func__<<"() got called with ml="<<ml<<" which is definetly out of range";
            throw std::runtime_error(sstr.str());
        }
        if (layer < 0 || layer > 3) {
            std::stringstream sstr{};
            sstr<<__FILE__<<":"<<__LINE__<<" "<<__func__<<"() got called with layer="<<layer<<" which is definetly out of range";
            throw std::runtime_error(sstr.str());
        }  
        if (tube < 0 || tube >= int(MdtIdHelper::maxNTubesPerLayer)){
            std::stringstream sstr{};
            sstr<<__FILE__<<":"<<__LINE__<<" "<<__func__<<"() got called with tube="<<tube<<" which is definetly out of range";
            throw std::runtime_error(sstr.str());
        }
#endif
        // shift by one to account for MuonGeoModel scheme
        int theTube = tube + 1;
        int theLayer = layer + 1;
        // handle case where first ml is dead
        if (ml == 1 && !m_detElMl1) return m_detElMl0->getActiveTubeLength(theLayer, theTube);
        if (ml == 0)
            return m_detElMl0->getActiveTubeLength(theLayer, theTube);
        else
            return m_detElMl1->getActiveTubeLength(theLayer, theTube);
    }

Member Data Documentation

m_chid

Identifier Muon::MdtIntersectGeometry::m_chid {}

private

Definition at line 45 of file MdtIntersectGeometry.h.

m_dbData

const MdtCondDbData* Muon::MdtIntersectGeometry::m_dbData {nullptr}

private

Definition at line 51 of file MdtIntersectGeometry.h.

m_deadTubes

std::vector<Identifier> Muon::MdtIntersectGeometry::m_deadTubes {}

private

Definition at line 54 of file MdtIntersectGeometry.h.

m_deadTubesML

std::set<Identifier> Muon::MdtIntersectGeometry::m_deadTubesML {}

private

Definition at line 53 of file MdtIntersectGeometry.h.

m_detElMl0

const MuonGM::MdtReadoutElement* Muon::MdtIntersectGeometry::m_detElMl0 {nullptr}

private

Definition at line 48 of file MdtIntersectGeometry.h.

m_detElMl1

const MuonGM::MdtReadoutElement* Muon::MdtIntersectGeometry::m_detElMl1 {nullptr}

private

Definition at line 49 of file MdtIntersectGeometry.h.

m_detMgr

const MuonGM::MuonDetectorManager* Muon::MdtIntersectGeometry::m_detMgr {nullptr}

private

Definition at line 50 of file MdtIntersectGeometry.h.

m_idHelperSvc

const IMuonIdHelperSvc* Muon::MdtIntersectGeometry::m_idHelperSvc {nullptr}

private

Definition at line 52 of file MdtIntersectGeometry.h.

m_mdtGeometry

std::shared_ptr<TrkDriftCircleMath::MdtChamberGeometry> Muon::MdtIntersectGeometry::m_mdtGeometry {}

private

Definition at line 47 of file MdtIntersectGeometry.h.

m_transform

Amg::Transform3D Muon::MdtIntersectGeometry::m_transform

private

Definition at line 46 of file MdtIntersectGeometry.h.

---

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

• MdtIntersectGeometry.h
• MdtIntersectGeometry.cxx