MuonAlignmentOutputXML Class Reference

#include <Alignment/MuonAlignment/interface/MuonAlignmentOutputXML.h>

Public Member Functions
	MuonAlignmentOutputXML (const edm::ParameterSet &iConfig)
void	write (AlignableMuon *alignableMuon, const edm::EventSetup &iSetup) const
virtual	~MuonAlignmentOutputXML ()

Private Member Functions
	MuonAlignmentOutputXML (const MuonAlignmentOutputXML &)=delete
const MuonAlignmentOutputXML &	operator= (const MuonAlignmentOutputXML &)=delete
void	writeComponents (align::Alignables &alignables, align::Alignables &ideals, std::map< align::ID, CLHEP::HepSymMatrix > &errors, std::ofstream &outputFile, bool DT, const AlignableObjectId &) const

Private Attributes
std::string	idealGeometryLabel
bool	m_eulerAngles
std::string	m_fileName
int	m_precision
bool	m_rawIds
int	m_relativeto
bool	m_suppressCSCChambers
bool	m_suppressCSCEndcaps
bool	m_suppressCSCLayers
bool	m_suppressCSCRings
bool	m_suppressCSCStations
bool	m_suppressDTBarrel
bool	m_suppressDTChambers
bool	m_suppressDTLayers
bool	m_suppressDTStations
bool	m_suppressDTSuperLayers
bool	m_suppressDTWheels
bool	m_survey

Detailed Description

Description: <one line="" class="" summary>="">

Usage: <usage>

Definition at line 35 of file MuonAlignmentOutputXML.h.

Constructor & Destructor Documentation

MuonAlignmentOutputXML() [1/2]

MuonAlignmentOutputXML::MuonAlignmentOutputXML

(

const edm::ParameterSet &

iConfig

)

Definition at line 42 of file MuonAlignmentOutputXML.cc.

    : m_fileName(iConfig.getParameter<std::string>("fileName")),
      m_survey(iConfig.getParameter<bool>("survey")),
      m_rawIds(iConfig.getParameter<bool>("rawIds")),
      m_eulerAngles(iConfig.getParameter<bool>("eulerAngles")),
      m_precision(iConfig.getParameter<int>("precision")),
      m_suppressDTBarrel(iConfig.getUntrackedParameter<bool>("suppressDTBarrel", false)),
      m_suppressDTWheels(iConfig.getUntrackedParameter<bool>("suppressDTWheels", false)),
      m_suppressDTStations(iConfig.getUntrackedParameter<bool>("suppressDTStations", false)),
      m_suppressDTChambers(iConfig.getUntrackedParameter<bool>("suppressDTChambers", false)),
      m_suppressDTSuperLayers(iConfig.getUntrackedParameter<bool>("suppressDTSuperLayers", false)),
      m_suppressDTLayers(iConfig.getUntrackedParameter<bool>("suppressDTLayers", false)),
      m_suppressCSCEndcaps(iConfig.getUntrackedParameter<bool>("suppressCSCEndcaps", false)),
      m_suppressCSCStations(iConfig.getUntrackedParameter<bool>("suppressCSCStations", false)),
      m_suppressCSCRings(iConfig.getUntrackedParameter<bool>("suppressCSCRings", false)),
      m_suppressCSCChambers(iConfig.getUntrackedParameter<bool>("suppressCSCChambers", false)),
      m_suppressCSCLayers(iConfig.getUntrackedParameter<bool>("suppressCSCLayers", false)),
      idealGeometryLabel("idealForOutputXML") {
  std::string str_relativeto = iConfig.getParameter<std::string>("relativeto");
 
  if (str_relativeto == std::string("none")) {
    m_relativeto = 0;
  } else if (str_relativeto == std::string("ideal")) {
    m_relativeto = 1;
  } else if (str_relativeto == std::string("container")) {
    m_relativeto = 2;
  } else {
    throw cms::Exception("BadConfig") << "relativeto must be \"none\", \"ideal\", or \"container\"" << std::endl;
  }
}

References Exception, edm::ParameterSet::getParameter(), m_relativeto, and AlCaHLTBitMon_QueryRunRegistry::string.

~MuonAlignmentOutputXML()

MuonAlignmentOutputXML::~MuonAlignmentOutputXML ( )

virtual

Definition at line 78 of file MuonAlignmentOutputXML.cc.

{}

MuonAlignmentOutputXML() [2/2]

MuonAlignmentOutputXML::MuonAlignmentOutputXML ( const MuonAlignmentOutputXML &  )

privatedelete

Member Function Documentation

operator=()

const MuonAlignmentOutputXML& MuonAlignmentOutputXML::operator= ( const MuonAlignmentOutputXML &  )

privatedelete

write()

void MuonAlignmentOutputXML::write	(	AlignableMuon *	alignableMuon,
		const edm::EventSetup &	iSetup
	)		const

Definition at line 96 of file MuonAlignmentOutputXML.cc.

                                                                                                  {
  std::ofstream outputFile(m_fileName.c_str());
  outputFile << std::setprecision(m_precision) << std::fixed;
 
  outputFile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
  outputFile << "<?xml-stylesheet type=\"text/xml\" href=\"MuonAlignment.xsl\"?>" << std::endl;
  outputFile << "<MuonAlignment>" << std::endl << std::endl;
 
  std::map<align::ID, CLHEP::HepSymMatrix> errors;
  AlignmentErrorsExtended *dtErrors = alignableMuon->dtAlignmentErrorsExtended();
  AlignmentErrorsExtended *cscErrors = alignableMuon->cscAlignmentErrorsExtended();
  for (std::vector<AlignTransformErrorExtended>::const_iterator dtError = dtErrors->m_alignError.begin();
       dtError != dtErrors->m_alignError.end();
       ++dtError) {
    errors[dtError->rawId()] = dtError->matrix();
  }
  for (std::vector<AlignTransformErrorExtended>::const_iterator cscError = cscErrors->m_alignError.begin();
       cscError != cscErrors->m_alignError.end();
       ++cscError) {
    errors[cscError->rawId()] = cscError->matrix();
  }
 
  align::Alignables barrels = alignableMuon->DTBarrel();
  align::Alignables endcaps = alignableMuon->CSCEndcaps();
 
  if (m_relativeto == 1) {
    edm::ESHandle<DTGeometry> dtGeometry;
    edm::ESHandle<CSCGeometry> cscGeometry;
    edm::ESHandle<GEMGeometry> gemGeometry;
    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, dtGeometry);
    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, cscGeometry);
    iSetup.get<MuonGeometryRecord>().get(idealGeometryLabel, gemGeometry);
 
    AlignableMuon ideal_alignableMuon(&(*dtGeometry), &(*cscGeometry), &(*gemGeometry));
 
    align::Alignables ideal_barrels = ideal_alignableMuon.DTBarrel();
    align::Alignables ideal_endcaps = ideal_alignableMuon.CSCEndcaps();
 
    writeComponents(barrels, ideal_barrels, errors, outputFile, true, alignableMuon->objectIdProvider());
    writeComponents(endcaps, ideal_endcaps, errors, outputFile, false, alignableMuon->objectIdProvider());
  } else {
    align::Alignables empty1, empty2;
 
    writeComponents(barrels, empty1, errors, outputFile, true, alignableMuon->objectIdProvider());
    writeComponents(endcaps, empty2, errors, outputFile, false, alignableMuon->objectIdProvider());
  }
 
  outputFile << "</MuonAlignment>" << std::endl;
}

References AlignableMuon::cscAlignmentErrorsExtended(), AlignableMuon::CSCEndcaps(), AlignableMuon::dtAlignmentErrorsExtended(), AlignableMuon::DTBarrel(), debug_messages_cfi::errors, alignBH_cfg::fixed, gemGeometry_cff::gemGeometry, edm::EventSetup::get(), get, idealGeometryLabel, AlignmentErrorsExtended::m_alignError, m_fileName, m_precision, m_relativeto, AlignableMuon::objectIdProvider(), download_sqlite_cfg::outputFile, and writeComponents().

Referenced by pkg.AbstractPkg::generate(), querying.connection::write_and_commit(), and MuonAlignment::writeXML().

writeComponents()

void MuonAlignmentOutputXML::writeComponents ( align::Alignables &  alignables, align::Alignables &  ideals, std::map< align::ID, CLHEP::HepSymMatrix > &  errors, std::ofstream &  outputFile, bool  DT, const AlignableObjectId &  objectIdProvider  ) const

private

Definition at line 146 of file MuonAlignmentOutputXML.cc.

                                                                                              {
  align::Alignables::const_iterator ideal = ideals.begin();
  for (align::Alignables::const_iterator alignable = alignables.begin(); alignable != alignables.end(); ++alignable) {
    if (m_survey && (*alignable)->survey() == nullptr) {
      throw cms::Exception("Alignment") << "SurveyDets must all be defined when writing to XML" << std::endl;
    }  // now I can assume it's okay everywhere
 
    align::StructureType alignableObjectId = (*alignable)->alignableObjectId();
 
    if ((alignableObjectId == align::AlignableDTBarrel && !m_suppressDTBarrel) ||
        (alignableObjectId == align::AlignableDTWheel && !m_suppressDTWheels) ||
        (alignableObjectId == align::AlignableDTStation && !m_suppressDTStations) ||
        (alignableObjectId == align::AlignableDTChamber && !m_suppressDTChambers) ||
        (DT && alignableObjectId == align::AlignableDTSuperLayer && !m_suppressDTSuperLayers) ||
        (DT && alignableObjectId == align::AlignableDetUnit && !m_suppressDTLayers) ||
        (alignableObjectId == align::AlignableCSCEndcap && !m_suppressCSCEndcaps) ||
        (alignableObjectId == align::AlignableCSCStation && !m_suppressCSCStations) ||
        (alignableObjectId == align::AlignableCSCRing && !m_suppressCSCRings) ||
        (alignableObjectId == align::AlignableCSCChamber && !m_suppressCSCChambers) ||
        (!DT && alignableObjectId == align::AlignableDetUnit && !m_suppressCSCLayers)) {
      unsigned int rawId = (*alignable)->geomDetId().rawId();
      outputFile << "<operation>" << std::endl;
 
      if (DT) {
        if (m_rawIds && rawId != 0) {
          std::string typeName = objectIdProvider.idToString(alignableObjectId);
          if (alignableObjectId == align::AlignableDTSuperLayer)
            typeName = std::string("DTSuperLayer");
          if (alignableObjectId == align::AlignableDetUnit)
            typeName = std::string("DTLayer");
          outputFile << "  <" << typeName << " rawId=\"" << rawId << "\" />" << std::endl;
        } else {
          if (alignableObjectId == align::AlignableDetUnit) {
            DTLayerId id(rawId);
            outputFile << "  <DTLayer wheel=\"" << id.wheel() << "\" station=\"" << id.station() << "\" sector=\""
                       << id.sector() << "\" superlayer=\"" << id.superlayer() << "\" layer=\"" << id.layer() << "\" />"
                       << std::endl;
          } else if (alignableObjectId == align::AlignableDTSuperLayer) {
            DTSuperLayerId id(rawId);
            outputFile << "  <DTSuperLayer wheel=\"" << id.wheel() << "\" station=\"" << id.station() << "\" sector=\""
                       << id.sector() << "\" superlayer=\"" << id.superlayer() << "\" />" << std::endl;
          } else if (alignableObjectId == align::AlignableDTChamber) {
            DTChamberId id(rawId);
            outputFile << "  <DTChamber wheel=\"" << id.wheel() << "\" station=\"" << id.station() << "\" sector=\""
                       << id.sector() << "\" />" << std::endl;
          }
 
          else {
            DTChamberId id((*alignable)->id());
            if (alignableObjectId == align::AlignableDTStation) {
              outputFile << "  <DTStation wheel=\"" << id.wheel() << "\" station=\"" << id.station() << "\" />"
                         << std::endl;
            } else if (alignableObjectId == align::AlignableDTWheel) {
              outputFile << "  <DTWheel wheel=\"" << id.wheel() << "\" />" << std::endl;
            } else if (alignableObjectId == align::AlignableDTBarrel) {
              outputFile << "  <DTBarrel />" << std::endl;
            } else
              throw cms::Exception("Alignment") << "Unknown DT Alignable StructureType" << std::endl;
          }
 
        }  // end if not rawId
      }    // end if DT
 
      else {  // CSC
        if (m_rawIds && rawId != 0) {
          std::string typeName = objectIdProvider.idToString(alignableObjectId);
          if (alignableObjectId == align::AlignableDetUnit)
            typeName = std::string("CSCLayer");
          outputFile << "  <" << typeName << " rawId=\"" << rawId << "\" />" << std::endl;
        } else {
          if (alignableObjectId == align::AlignableDetUnit) {
            CSCDetId id(rawId);
            outputFile << "  <CSCLayer endcap=\"" << id.endcap() << "\" station=\"" << id.station() << "\" ring=\""
                       << id.ring() << "\" chamber=\"" << id.chamber() << "\" layer=\"" << id.layer() << "\" />"
                       << std::endl;
          } else if (alignableObjectId == align::AlignableCSCChamber) {
            CSCDetId id(rawId);
            outputFile << "  <CSCChamber endcap=\"" << id.endcap() << "\" station=\"" << id.station() << "\" ring=\""
                       << id.ring() << "\" chamber=\"" << id.chamber() << "\" />" << std::endl;
          } else {
            CSCDetId id((*alignable)->id());
            if (alignableObjectId == align::AlignableCSCRing) {
              outputFile << "  <CSCRing endcap=\"" << id.endcap() << "\" station=\"" << id.station() << "\" ring=\""
                         << id.ring() << "\" />" << std::endl;
            } else if (alignableObjectId == align::AlignableCSCStation) {
              outputFile << "  <CSCStation endcap=\"" << id.endcap() << "\" station=\"" << id.station() << "\" />"
                         << std::endl;
            } else if (alignableObjectId == align::AlignableCSCEndcap) {
              outputFile << "  <CSCEndcap endcap=\"" << id.endcap() << "\" />" << std::endl;
            } else
              throw cms::Exception("Alignment") << "Unknown CSC Alignable StructureType" << std::endl;
          }
 
        }  // end if not rawId
      }    // end if CSC
 
      align::PositionType pos = (*alignable)->globalPosition();
      align::RotationType rot = (*alignable)->globalRotation();
 
      if (m_survey) {
        pos = (*alignable)->survey()->position();
        rot = (*alignable)->survey()->rotation();
      }
 
      std::string str_relativeto;
      if (m_relativeto == 0) {
        str_relativeto = std::string("none");
      }
 
      else if (m_relativeto == 1) {
        if (ideal == ideals.end() || (*ideal)->alignableObjectId() != alignableObjectId ||
            (*ideal)->id() != (*alignable)->id()) {
          throw cms::Exception("Alignment") << "AlignableMuon and ideal_AlignableMuon are out of sync!" << std::endl;
        }
 
        align::PositionType idealPosition = (*ideal)->globalPosition();
        align::RotationType idealRotation = (*ideal)->globalRotation();
 
        pos = align::PositionType(idealRotation * (pos.basicVector() - idealPosition.basicVector()));
        rot = rot * idealRotation.transposed();
 
        str_relativeto = std::string("ideal");
 
        bool csc_debug = false;
        if (csc_debug && !DT) {
          CSCDetId id(rawId);
          if (id.endcap() == 1 && id.station() == 1 && id.ring() == 1 && id.chamber() == 33) {
            std::cout << " investigating " << id << std::endl
                      << (*alignable)->globalRotation() << std::endl
                      << std::endl
                      << idealRotation.transposed() << std::endl
                      << std::endl
                      << rot << std::endl
                      << std::endl;
            double phix = atan2(rot.yz(), rot.zz());
            double phiy = asin(-rot.xz());
            double phiz = atan2(rot.xy(), rot.xx());
 
            std::cout << "phix=\"" << phix << "\" phiy=\"" << phiy << "\" phiz=\"" << phiz << std::endl;
 
            align::EulerAngles eulerAngles = align::toAngles((*alignable)->globalRotation());
            std::cout << "alpha=\"" << eulerAngles(1) << "\" beta=\"" << eulerAngles(2) << "\" gamma=\""
                      << eulerAngles(3) << std::endl;
            eulerAngles = align::toAngles(idealRotation);
            std::cout << "alpha=\"" << eulerAngles(1) << "\" beta=\"" << eulerAngles(2) << "\" gamma=\""
                      << eulerAngles(3) << std::endl;
            eulerAngles = align::toAngles(rot);
            std::cout << "alpha=\"" << eulerAngles(1) << "\" beta=\"" << eulerAngles(2) << "\" gamma=\""
                      << eulerAngles(3) << std::endl;
          }
        }
      }
 
      else if (m_relativeto == 2 && (*alignable)->mother() != nullptr) {
        align::PositionType globalPosition = (*alignable)->mother()->globalPosition();
        align::RotationType globalRotation = (*alignable)->mother()->globalRotation();
 
        pos = align::PositionType(globalRotation * (pos.basicVector() - globalPosition.basicVector()));
        rot = rot * globalRotation.transposed();
 
        str_relativeto = std::string("container");
      }
 
      else
        assert(false);  // can't happen: see constructor
 
      outputFile << "  <setposition relativeto=\"" << str_relativeto << "\" "
                 << "x=\"" << pos.x() << "\" y=\"" << pos.y() << "\" z=\"" << pos.z() << "\" ";
 
      if (m_eulerAngles) {
        align::EulerAngles eulerAngles = align::toAngles(rot);
        outputFile << "alpha=\"" << eulerAngles(1) << "\" beta=\"" << eulerAngles(2) << "\" gamma=\"" << eulerAngles(3)
                   << "\" />" << std::endl;
      }
 
      else {
        // the angle convention originally used in alignment, also known as "non-standard Euler angles with a Z-Y-X convention"
        // this also gets the sign convention right
        double phix = atan2(rot.yz(), rot.zz());
        double phiy = asin(-rot.xz());
        double phiz = atan2(rot.xy(), rot.xx());
 
        outputFile << "phix=\"" << phix << "\" phiy=\"" << phiy << "\" phiz=\"" << phiz << "\" />" << std::endl;
      }
 
      if (m_survey) {
        align::ErrorMatrix err = (*alignable)->survey()->errors();
 
        outputFile << "  <setsurveyerr"
                   << " xx=\"" << err(0, 0) << "\" xy=\"" << err(0, 1) << "\" xz=\"" << err(0, 2) << "\" xa=\""
                   << err(0, 3) << "\" xb=\"" << err(0, 4) << "\" xc=\"" << err(0, 5) << "\" yy=\"" << err(1, 1)
                   << "\" yz=\"" << err(1, 2) << "\" ya=\"" << err(1, 3) << "\" yb=\"" << err(1, 4) << "\" yc=\""
                   << err(1, 5) << "\" zz=\"" << err(2, 2) << "\" za=\"" << err(2, 3) << "\" zb=\"" << err(2, 4)
                   << "\" zc=\"" << err(2, 5) << "\" aa=\"" << err(3, 3) << "\" ab=\"" << err(3, 4) << "\" ac=\""
                   << err(3, 5) << "\" bb=\"" << err(4, 4) << "\" bc=\"" << err(4, 5) << "\" cc=\"" << err(5, 5)
                   << "\" />" << std::endl;
      }
 
      else if (rawId != 0) {
        CLHEP::HepSymMatrix err = errors[(*alignable)->id()];
 
        outputFile << "  <setape xx=\"" << err(1, 1) << "\" xy=\"" << err(1, 2) << "\" xz=\"" << err(1, 3) << "\" xa=\""
                   << err(1, 4) << "\" xb=\"" << err(1, 5) << "\" xc=\"" << err(1, 6) << "\" yy=\"" << err(2, 2)
                   << "\" yz=\"" << err(2, 3) << "\" ya=\"" << err(2, 4) << "\" yb=\"" << err(2, 5) << "\" yc=\""
                   << err(2, 6) << "\" zz=\"" << err(3, 3) << "\" za=\"" << err(3, 4) << "\" zb=\"" << err(3, 5)
                   << "\" zc=\"" << err(3, 6) << "\" aa=\"" << err(4, 4) << "\" ab=\"" << err(4, 5) << "\" ac=\""
                   << err(4, 6) << "\" bb=\"" << err(5, 5) << "\" bc=\"" << err(5, 6) << "\" cc=\"" << err(6, 6)
                   << "\" />" << std::endl;
      }
 
      outputFile << "</operation>" << std::endl << std::endl;
 
    }  // end if not suppressed
 
    // write superstructures before substructures: this is important because <setape> overwrites all substructures' APEs
    if (ideal != ideals.end()) {
      align::Alignables components = (*alignable)->components();
      align::Alignables ideal_components = (*ideal)->components();
      writeComponents(components, ideal_components, errors, outputFile, DT, objectIdProvider);
      ++ideal;  // important for synchronization in the "for" loop!
    } else {
      align::Alignables components = (*alignable)->components();
      align::Alignables dummy;
      writeComponents(components, dummy, errors, outputFile, DT, objectIdProvider);
    }
 
  }  // end loop over alignables
}

References align::AlignableCSCChamber, align::AlignableCSCEndcap, align::AlignableCSCRing, align::AlignableCSCStation, align::AlignableDetUnit, align::AlignableDTBarrel, align::AlignableDTChamber, align::AlignableDTStation, align::AlignableDTSuperLayer, align::AlignableDTWheel, cms::cuda::assert(), PV3DBase< T, PVType, FrameType >::basicVector(), relativeConstraints::chamber, makeMuonMisalignmentScenario::components, gather_cfg::cout, GeomDetEnumerators::DT, makeMuonMisalignmentScenario::endcap, submitPVResolutionJobs::err, Exception, triggerObjects_cff::id, AlignableObjectId::idToString(), m_eulerAngles, m_rawIds, m_relativeto, m_suppressCSCChambers, m_suppressCSCEndcaps, m_suppressCSCLayers, m_suppressCSCRings, m_suppressCSCStations, m_suppressDTBarrel, m_suppressDTChambers, m_suppressDTLayers, m_suppressDTStations, m_suppressDTSuperLayers, m_suppressDTWheels, m_survey, download_sqlite_cfg::outputFile, relativeConstraints::ring, makeMuonMisalignmentScenario::rot, relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, align::toAngles(), TkRotation< T >::transposed(), and dqmiodumpindices::typeName.

Referenced by write().

Member Data Documentation

idealGeometryLabel

std::string MuonAlignmentOutputXML::idealGeometryLabel

private

Definition at line 68 of file MuonAlignmentOutputXML.h.

Referenced by write().

m_eulerAngles

bool MuonAlignmentOutputXML::m_eulerAngles

private

Definition at line 63 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_fileName

std::string MuonAlignmentOutputXML::m_fileName

private

Definition at line 61 of file MuonAlignmentOutputXML.h.

Referenced by write().

m_precision

int MuonAlignmentOutputXML::m_precision

private

Definition at line 64 of file MuonAlignmentOutputXML.h.

Referenced by write().

m_rawIds

bool MuonAlignmentOutputXML::m_rawIds

private

Definition at line 63 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_relativeto

int MuonAlignmentOutputXML::m_relativeto

private

Definition at line 62 of file MuonAlignmentOutputXML.h.

Referenced by MuonAlignmentOutputXML(), write(), and writeComponents().

m_suppressCSCChambers

bool MuonAlignmentOutputXML::m_suppressCSCChambers

private

Definition at line 67 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressCSCEndcaps

bool MuonAlignmentOutputXML::m_suppressCSCEndcaps

private

Definition at line 67 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressCSCLayers

bool MuonAlignmentOutputXML::m_suppressCSCLayers

private

Definition at line 67 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressCSCRings

bool MuonAlignmentOutputXML::m_suppressCSCRings

private

Definition at line 67 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressCSCStations

bool MuonAlignmentOutputXML::m_suppressCSCStations

private

Definition at line 67 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressDTBarrel

bool MuonAlignmentOutputXML::m_suppressDTBarrel

private

Definition at line 65 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressDTChambers

bool MuonAlignmentOutputXML::m_suppressDTChambers

private

Definition at line 65 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressDTLayers

bool MuonAlignmentOutputXML::m_suppressDTLayers

private

Definition at line 65 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressDTStations

bool MuonAlignmentOutputXML::m_suppressDTStations

private

Definition at line 65 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressDTSuperLayers

bool MuonAlignmentOutputXML::m_suppressDTSuperLayers

private

Definition at line 65 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_suppressDTWheels

bool MuonAlignmentOutputXML::m_suppressDTWheels

private

Definition at line 65 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().

m_survey

bool MuonAlignmentOutputXML::m_survey

private

Definition at line 63 of file MuonAlignmentOutputXML.h.

Referenced by writeComponents().