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

Inheritance diagram for MuonGeometrySanityCheck:

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

	~MuonGeometrySanityCheck () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

Private Attributes
const edm::ESGetToken < CSCGeometry, MuonGeometryRecord >	cscGeomToken_

const edm::ESGetToken < DTGeometry, MuonGeometryRecord >	dtGeomToken_

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::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

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

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

Definition at line 84 of file MuonGeometrySanityCheck.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 114 of file MuonGeometrySanityCheck.cc.

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

     : dtGeomToken_(esConsumes<edm::Transition::BeginRun>()), cscGeomToken_(esConsumes<edm::Transition::BeginRun>()) {
   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 ( )

override

Definition at line 143 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::one::EDAnalyzerBase.

Definition at line 586 of file MuonGeometrySanityCheck.cc.

References cms::cuda::assert(), CSCDetId::chamber(), gather_cfg::cout, MuonSubdetId::CSC, cscGeomToken_, MuonSubdetId::DT, dt, dtGeomToken_, CSCDetId::endcap(), edm::EventSetup::getData(), gpuClustering::id, DTGeometry::idToDet(), CSCGeometry::idToDet(), 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, GeomDet::surface(), Surface::toGlobal(), tolerance, GloballyPositioned< T >::toLocal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                          {
   const DTGeometry *dtGeometry = &iSetup.getData(dtGeomToken_);
   const CSCGeometry *cscGeometry = &iSetup.getData(cscGeomToken_);
 
   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;
 }