#include <Alignment/MuonAlignment/plugins/MuonGeometrySanityCheck.cc>

Inheritance diagram for MuonGeometrySanityCheck:

Public Member Functions
	MuonGeometrySanityCheck (const edm::ParameterSet &iConfig)

	~MuonGeometrySanityCheck ()

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &iConfig) override

Private Attributes
std::map< std::string, const MuonGeometrySanityCheckCustomFrame * >	m_frames

std::vector < MuonGeometrySanityCheckPoint >	m_points

std::string	prefix

std::string	printout

double	tolerance

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

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

Implementation: <Notes on="" implementation>="">

Definition at line 95 of file MuonGeometrySanityCheck.cc.

Constructor & Destructor Documentation

MuonGeometrySanityCheck::MuonGeometrySanityCheck ( const edm::ParameterSet & iConfig )

explicit

Definition at line 122 of file MuonGeometrySanityCheck.cc.

References Exception, edm::ParameterSet::getParameter(), m_frames, m_points, mergeVDriftHistosByStation::name, point, prefix, printout, AlCaHLTBitMon_QueryRunRegistry::string, and tolerance.

                                                                                {
    printout = iConfig.getParameter<std::string>("printout");
    if (printout != std::string("all")  &&  printout != std::string("bad")) {
       throw cms::Exception("BadConfig") << "Printout must be \"all\" or \"bad\"." << std::endl;
    }
 
    tolerance = iConfig.getParameter<double>("tolerance");
    if (tolerance <= 0) {
       throw cms::Exception("BadConfig") << "Tolerance must be positive." << std::endl;
    }
 
    prefix = iConfig.getParameter<std::string>("prefix");
 
    std::vector<edm::ParameterSet> frames = iConfig.getParameter<std::vector<edm::ParameterSet> >("frames");
    for (std::vector<edm::ParameterSet>::const_iterator frame = frames.begin();  frame != frames.end();  ++frame) {
       std::string name = frame->getParameter<std::string>("name");
       if (m_frames.find(name) != m_frames.end()) {
      throw cms::Exception("BadConfig") << "Custom frame \"" << name << "\" has been defined twice." << std::endl;
       }
       m_frames[name] = new MuonGeometrySanityCheckCustomFrame(*frame, name);
    }
 
    std::vector<edm::ParameterSet> points = iConfig.getParameter<std::vector<edm::ParameterSet> >("points");
    for (std::vector<edm::ParameterSet>::const_iterator point = points.begin();  point != points.end();  ++point) {
       m_points.push_back(MuonGeometrySanityCheckPoint(*point, m_frames));
    }
 }

MuonGeometrySanityCheck::~MuonGeometrySanityCheck ( )

Definition at line 150 of file MuonGeometrySanityCheck.cc.

References m_frames.

                                                   {
    for (std::map<std::string,const MuonGeometrySanityCheckCustomFrame*>::iterator iter = m_frames.begin();  iter != m_frames.end();  ++iter) {
       delete iter->second;
    }
 }

Member Function Documentation

void MuonGeometrySanityCheck::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iConfig
	)

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 557 of file MuonGeometrySanityCheck.cc.

References assert(), CSCDetId::chamber(), gather_cfg::cout, MuonSubdetId::CSC, MuonSubdetId::DT, dt, CSCDetId::endcap(), edm::EventSetup::get(), MuonGeometrySanityCheckPoint::kChamber, MuonGeometrySanityCheckPoint::kCustom, MuonGeometrySanityCheckPoint::kGlobal, MuonGeometrySanityCheckPoint::kLocal, m_points, convertSQLitetoXML_cfg::output, point, prefix, printout, mps_fire::result, CSCDetId::ring(), CSCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, tolerance, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                     {
    edm::ESHandle<DTGeometry> dtGeometry;
    iSetup.get<MuonGeometryRecord>().get(dtGeometry);
 
    edm::ESHandle<CSCGeometry> cscGeometry;
    iSetup.get<MuonGeometryRecord>().get(cscGeometry);
 
    int num_transformed = 0;
    int num_tested = 0;
    int num_bad = 0;
    for (std::vector<MuonGeometrySanityCheckPoint>::const_iterator point = m_points.begin();  point != m_points.end();  ++point) {
       num_transformed++;
 
       bool dt = (point->detector.subdetId() == MuonSubdetId::DT);
 
       // convert the displacement vector into the chosen coordinate system and add it to the chamber's position
       GlobalPoint chamberPos;
       if (dt) chamberPos = dtGeometry->idToDet(point->detector)->surface().toGlobal(LocalPoint(0., 0., 0.));
       else chamberPos = cscGeometry->idToDet(point->detector)->surface().toGlobal(LocalPoint(0., 0., 0.));
 
       GlobalPoint result;
       if (point->frame == MuonGeometrySanityCheckPoint::kGlobal) {
      result = GlobalPoint(chamberPos.x() + point->displacement.x(), chamberPos.y() + point->displacement.y(), chamberPos.z() + point->displacement.z());
       }
 
       else if (point->frame == MuonGeometrySanityCheckPoint::kLocal) {
      if (dt) result = dtGeometry->idToDet(point->detector)->surface().toGlobal(LocalPoint(point->displacement.x(), point->displacement.y(), point->displacement.z()));
      else result = cscGeometry->idToDet(point->detector)->surface().toGlobal(LocalPoint(point->displacement.x(), point->displacement.y(), point->displacement.z()));
       }
 
       else if (point->frame == MuonGeometrySanityCheckPoint::kChamber) {
      if (point->detector.subdetId() == MuonSubdetId::DT) {
         DTChamberId id(point->detector);
         if (dt) result = dtGeometry->idToDet(id)->surface().toGlobal(LocalPoint(point->displacement.x(), point->displacement.y(), point->displacement.z()));
         else result = cscGeometry->idToDet(id)->surface().toGlobal(LocalPoint(point->displacement.x(), point->displacement.y(), point->displacement.z()));
      }
      else if (point->detector.subdetId() == MuonSubdetId::CSC) {
         CSCDetId cscid(point->detector);
         CSCDetId id(cscid.endcap(), cscid.station(), cscid.ring(), cscid.chamber());
         if (dt) result = dtGeometry->idToDet(id)->surface().toGlobal(LocalPoint(point->displacement.x(), point->displacement.y(), point->displacement.z()));
         else result = cscGeometry->idToDet(id)->surface().toGlobal(LocalPoint(point->displacement.x(), point->displacement.y(), point->displacement.z()));
      }
      else { assert(false); }
       }
 
       else if (point->frame == MuonGeometrySanityCheckPoint::kCustom) {
         GlobalPoint transformed = point->customFrame->transform(point->displacement);
         result = GlobalPoint(chamberPos.x() + transformed.x(), chamberPos.y() + transformed.y(), chamberPos.z() + transformed.z());
       }
 
       else { assert(false); }
 
       // convert the result into the chosen output coordinate system
       if (point->outputFrame == MuonGeometrySanityCheckPoint::kGlobal) { }
 
       else if (point->outputFrame == MuonGeometrySanityCheckPoint::kLocal) {
         LocalPoint transformed;
         if (dt) transformed = dtGeometry->idToDet(point->detector)->surface().toLocal(result);
         else transformed = cscGeometry->idToDet(point->detector)->surface().toLocal(result);
         result = GlobalPoint(transformed.x(), transformed.y(), transformed.z());
       }
 
       else if (point->outputFrame == MuonGeometrySanityCheckPoint::kChamber) {
      if (point->detector.subdetId() == MuonSubdetId::DT) {
         DTChamberId id(point->detector);
         LocalPoint transformed;
         if (dt) transformed = dtGeometry->idToDet(id)->surface().toLocal(result);
         else transformed = cscGeometry->idToDet(id)->surface().toLocal(result);
         result = GlobalPoint(transformed.x(), transformed.y(), transformed.z());
      }
      else if (point->detector.subdetId() == MuonSubdetId::CSC) {
         CSCDetId cscid(point->detector);
         CSCDetId id(cscid.endcap(), cscid.station(), cscid.ring(), cscid.chamber());
         LocalPoint transformed;
         if (dt) transformed = dtGeometry->idToDet(id)->surface().toLocal(result);
         else transformed = cscGeometry->idToDet(id)->surface().toLocal(result);
         result = GlobalPoint(transformed.x(), transformed.y(), transformed.z());
      }
      else { assert(false); }
       }
 
       else if (point->outputFrame == MuonGeometrySanityCheckPoint::kCustom) {
      result = point->outputCustomFrame->transformInverse(result);
       }
 
       std::stringstream output;
       output << prefix << " " << point->name << " " << point->detName() << " " << result.x() << " " << result.y() << " " << result.z();
 
       bool bad = false;
       if (point->has_expectation) {
      num_tested++;
      double residx = result.x() - point->expectation.x();
      double residy = result.y() - point->expectation.y();
      double residz = result.z() - point->expectation.z();
 
      if (fabs(residx) > tolerance  ||  fabs(residy) > tolerance  ||  fabs(residz) > tolerance) {
         num_bad++;
         bad = true;
         output << " BAD " << residx << " " << residy << " " << residz << std::endl;
      }
      else {
         output << " GOOD " << residx << " " << residy << " " << residz << std::endl;
      }
       }
       else {
      output << " UNTESTED 0 0 0" << std::endl;
       }
 
       if (printout == std::string("all")  ||  (printout == std::string("bad")  &&  bad)) {
      std::cout << output.str();
       }
    }
 
    std::cout << std::endl << "SUMMARY transformed: " << num_transformed << " tested: " << num_tested << " bad: " << num_bad << " good: " << (num_tested - num_bad) << std::endl;
 }