TestCaloAlignmentEP Class Reference

Inheritance diagram for TestCaloAlignmentEP:

Public Types
using	ReturnAli = std::unique_ptr< Alignments >
using	ReturnAliErr = std::unique_ptr< AlignmentErrors >
typedef AlignTransform::Rotation	Rot
typedef AlignTransform::Translation	Trl

Public Member Functions
ReturnAli	produceCastorAli (const CastorAlignmentRcd &)
ReturnAliErr	produceCastorAliErr (const CastorAlignmentErrorExtendedRcd &)
ReturnAli	produceEBAli (const EBAlignmentRcd &)
ReturnAliErr	produceEBAliErr (const EBAlignmentErrorExtendedRcd &)
ReturnAli	produceEEAli (const EEAlignmentRcd &)
ReturnAliErr	produceEEAliErr (const EEAlignmentErrorExtendedRcd &)
ReturnAli	produceESAli (const ESAlignmentRcd &)
ReturnAliErr	produceESAliErr (const ESAlignmentErrorExtendedRcd &)
ReturnAli	produceHBAli (const HBAlignmentRcd &)
ReturnAliErr	produceHBAliErr (const HBAlignmentErrorExtendedRcd &)
ReturnAli	produceHEAli (const HEAlignmentRcd &)
ReturnAliErr	produceHEAliErr (const HEAlignmentErrorExtendedRcd &)
ReturnAli	produceHFAli (const HFAlignmentRcd &)
ReturnAliErr	produceHFAliErr (const HFAlignmentErrorExtendedRcd &)
ReturnAli	produceHOAli (const HOAlignmentRcd &)
ReturnAliErr	produceHOAliErr (const HOAlignmentErrorExtendedRcd &)
ReturnAli	produceZdcAli (const ZDCAlignmentRcd &)
ReturnAliErr	produceZdcAliErr (const ZDCAlignmentErrorExtendedRcd &)
	TestCaloAlignmentEP (const edm::ParameterSet &)
	~TestCaloAlignmentEP () override
Public Member Functions inherited from edm::ESProducer
	ESProducer ()
	ESProducer (const ESProducer &)=delete
ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const
ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const
bool	hasMayConsumes () const noexcept
size_t	numberOfTokenIndices (unsigned int iIndex) const
ESProducer const &	operator= (const ESProducer &)=delete
SerialTaskQueueChain &	queue ()
template<typename Record >
std::optional< std::vector< ESProxyIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final
	~ESProducer () noexcept(false) override
Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()
	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete
const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete
	~ESProxyFactoryProducer () noexcept(false) override
Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void	createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
	DataProxyProvider ()
	DataProxyProvider (const DataProxyProvider &)=delete
const ComponentDescription &	description () const
void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const
virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
bool	isUsingRecord (const EventSetupRecordKey &key) const
KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)
const DataProxyProvider &	operator= (const DataProxyProvider &)=delete
void	setAppendToDataLabel (const edm::ParameterSet &)
void	setDescription (const ComponentDescription &iDescription)
std::set< EventSetupRecordKey >	usingRecords () const
virtual	~DataProxyProvider () noexcept(false)

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)
Protected Types inherited from edm::ESProxyFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey
Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>
Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T *iThis, const char *iLabel)
template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})
template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)
template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})
template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T *iThis, TReturn(T ::*iMethod)(const TRecord &), const es::Label &iLabel={})
template<typename T , typename TReturn , typename TRecord , typename TArg >
ESConsumesCollectorT< TRecord >	setWhatProduced (T *iThis, TReturn(T ::*iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})
void	usesResources (std::vector< std::string > const &)
Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())
virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())
KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override
Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
template<class T >
void	usingRecord ()
void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

Description: Producer of fake alignment data for calo geometries

Implementation: The alignment objects are filled with fixed alignments.

Definition at line 57 of file TestCaloAlignmentEP.cc.

Member Typedef Documentation

ReturnAli

using TestCaloAlignmentEP::ReturnAli = std::unique_ptr<Alignments>

Definition at line 59 of file TestCaloAlignmentEP.cc.

ReturnAliErr

using TestCaloAlignmentEP::ReturnAliErr = std::unique_ptr<AlignmentErrors>

Definition at line 60 of file TestCaloAlignmentEP.cc.

Rot

typedef AlignTransform::Rotation TestCaloAlignmentEP::Rot

Definition at line 63 of file TestCaloAlignmentEP.cc.

Trl

typedef AlignTransform::Translation TestCaloAlignmentEP::Trl

Definition at line 62 of file TestCaloAlignmentEP.cc.

Constructor & Destructor Documentation

TestCaloAlignmentEP()

TestCaloAlignmentEP::TestCaloAlignmentEP ( const edm::ParameterSet &  )

inline

Definition at line 65 of file TestCaloAlignmentEP.cc.

                                              {
    setWhatProduced(this, &TestCaloAlignmentEP::produceEBAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceEBAliErr);
    setWhatProduced(this, &TestCaloAlignmentEP::produceEEAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceEEAliErr);
    setWhatProduced(this, &TestCaloAlignmentEP::produceESAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceESAliErr);
    setWhatProduced(this, &TestCaloAlignmentEP::produceHBAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceHBAliErr);
    setWhatProduced(this, &TestCaloAlignmentEP::produceHEAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceHEAliErr);
    setWhatProduced(this, &TestCaloAlignmentEP::produceHOAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceHOAliErr);
    setWhatProduced(this, &TestCaloAlignmentEP::produceHFAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceHFAliErr);
    setWhatProduced(this, &TestCaloAlignmentEP::produceZdcAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceZdcAliErr);
    setWhatProduced(this, &TestCaloAlignmentEP::produceCastorAli);
    setWhatProduced(this, &TestCaloAlignmentEP::produceCastorAliErr);
  }

References produceCastorAli(), produceCastorAliErr(), produceEBAli(), produceEBAliErr(), produceEEAli(), produceEEAliErr(), produceESAli(), produceESAliErr(), produceHBAli(), produceHBAliErr(), produceHEAli(), produceHEAliErr(), produceHFAli(), produceHFAliErr(), produceHOAli(), produceHOAliErr(), produceZdcAli(), produceZdcAliErr(), and edm::ESProducer::setWhatProduced().

~TestCaloAlignmentEP()

TestCaloAlignmentEP::~TestCaloAlignmentEP ( )

inlineoverride

Definition at line 86 of file TestCaloAlignmentEP.cc.

{}

Member Function Documentation

produceCastorAli()

ReturnAli TestCaloAlignmentEP::produceCastorAli ( const CastorAlignmentRcd &  )

inline

Definition at line 229 of file TestCaloAlignmentEP.cc.

                                                          {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(CastorGeometry::numberOfAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const HcalCastorDetId id(HcalCastorDetId::EM, false, 1, 1);
      vtr.emplace_back(AlignTransform(Trl(0, 0, 0), Rot(), id));
    }
    return ali;
  }

References HcalCastorDetId::EM, mps_fire::i, triggerObjects_cff::id, and CastorGeometry::numberOfAlignments().

Referenced by TestCaloAlignmentEP().

produceCastorAliErr()

ReturnAliErr TestCaloAlignmentEP::produceCastorAliErr ( const CastorAlignmentErrorExtendedRcd &  )

inline

Definition at line 241 of file TestCaloAlignmentEP.cc.

                                                                             {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().

produceEBAli()

ReturnAli TestCaloAlignmentEP::produceEBAli ( const EBAlignmentRcd &  )

inline

Definition at line 90 of file TestCaloAlignmentEP.cc.

                                                  {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(EcalBarrelGeometry::numberOfAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const EBDetId id(EcalBarrelGeometry::detIdFromLocalAlignmentIndex(i));
      vtr.emplace_back(AlignTransform((1 == id.ism() ? Trl(0, 0, 0) :  //-0.3 ) :
                                           Trl(0, 0, 0)),
                                      Rot(),
                                      id));
    }
    return ali;
  }

References EcalBarrelGeometry::detIdFromLocalAlignmentIndex(), mps_fire::i, triggerObjects_cff::id, ecalpyutils::ism(), and EcalBarrelGeometry::numberOfAlignments().

Referenced by TestCaloAlignmentEP().

produceEBAliErr()

ReturnAliErr TestCaloAlignmentEP::produceEBAliErr ( const EBAlignmentErrorExtendedRcd &  )

inline

Definition at line 105 of file TestCaloAlignmentEP.cc.

                                                                     {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().

produceEEAli()

ReturnAli TestCaloAlignmentEP::produceEEAli ( const EEAlignmentRcd &  )

inline

Definition at line 110 of file TestCaloAlignmentEP.cc.

                                                  {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(EcalEndcapGeometry::numberOfAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const EEDetId id(EcalEndcapGeometry::detIdFromLocalAlignmentIndex(i));
      vtr.emplace_back(AlignTransform((2 > i ? Trl(-0.02, -0.81, -0.94) : Trl(+0.52, -0.81, +0.81)), Rot(), id));
    }
    return ali;
  }

References EcalEndcapGeometry::detIdFromLocalAlignmentIndex(), mps_fire::i, triggerObjects_cff::id, and EcalEndcapGeometry::numberOfAlignments().

Referenced by TestCaloAlignmentEP().

produceEEAliErr()

ReturnAliErr TestCaloAlignmentEP::produceEEAliErr ( const EEAlignmentErrorExtendedRcd &  )

inline

Definition at line 122 of file TestCaloAlignmentEP.cc.

                                                                     {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().

produceESAli()

ReturnAli TestCaloAlignmentEP::produceESAli ( const ESAlignmentRcd &  )

inline

Definition at line 127 of file TestCaloAlignmentEP.cc.

                                                  {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(EcalPreshowerGeometry::numberOfAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const ESDetId id(EcalPreshowerGeometry::detIdFromLocalAlignmentIndex(i));
      vtr.emplace_back(AlignTransform((4 > i ? Trl(-0.02, -0.81, -0.94) : Trl(+0.52, -0.81, +0.81)), Rot(), id));
    }
    return ali;
  }

References EcalPreshowerGeometry::detIdFromLocalAlignmentIndex(), mps_fire::i, triggerObjects_cff::id, and EcalPreshowerGeometry::numberOfAlignments().

Referenced by TestCaloAlignmentEP().

produceESAliErr()

ReturnAliErr TestCaloAlignmentEP::produceESAliErr ( const ESAlignmentErrorExtendedRcd &  )

inline

Definition at line 139 of file TestCaloAlignmentEP.cc.

                                                                     {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().

produceHBAli()

ReturnAli TestCaloAlignmentEP::produceHBAli ( const HBAlignmentRcd &  )

inline

Definition at line 144 of file TestCaloAlignmentEP.cc.

                                                  {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(HcalGeometry::numberOfBarrelAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const HcalDetId id(HcalGeometry::detIdFromBarrelAlignmentIndex(i));
      vtr.emplace_back(AlignTransform(Trl(0, 0, 0), Rot(), id));
    }
    return ali;
  }

References HcalGeometry::detIdFromBarrelAlignmentIndex(), mps_fire::i, triggerObjects_cff::id, and HcalGeometry::numberOfBarrelAlignments().

Referenced by TestCaloAlignmentEP().

produceHBAliErr()

ReturnAliErr TestCaloAlignmentEP::produceHBAliErr ( const HBAlignmentErrorExtendedRcd &  )

inline

Definition at line 156 of file TestCaloAlignmentEP.cc.

                                                                     {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().

produceHEAli()

ReturnAli TestCaloAlignmentEP::produceHEAli ( const HEAlignmentRcd &  )

inline

Definition at line 161 of file TestCaloAlignmentEP.cc.

                                                  {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(HcalGeometry::numberOfEndcapAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const HcalDetId id(HcalGeometry::detIdFromEndcapAlignmentIndex(i));
      vtr.emplace_back(AlignTransform(Trl(0, 0, 0), Rot(), id));
    }
    return ali;
  }

References HcalGeometry::detIdFromEndcapAlignmentIndex(), mps_fire::i, triggerObjects_cff::id, and HcalGeometry::numberOfEndcapAlignments().

Referenced by TestCaloAlignmentEP().

produceHEAliErr()

ReturnAliErr TestCaloAlignmentEP::produceHEAliErr ( const HEAlignmentErrorExtendedRcd &  )

inline

Definition at line 173 of file TestCaloAlignmentEP.cc.

                                                                     {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().

produceHFAli()

ReturnAli TestCaloAlignmentEP::produceHFAli ( const HFAlignmentRcd &  )

inline

Definition at line 195 of file TestCaloAlignmentEP.cc.

                                                  {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(HcalGeometry::numberOfForwardAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const HcalDetId id(HcalGeometry::detIdFromForwardAlignmentIndex(i));
      vtr.emplace_back(AlignTransform(Trl(0, 0, 0), Rot(), id));
    }
    return ali;
  }

References HcalGeometry::detIdFromForwardAlignmentIndex(), mps_fire::i, triggerObjects_cff::id, and HcalGeometry::numberOfForwardAlignments().

Referenced by TestCaloAlignmentEP().

produceHFAliErr()

ReturnAliErr TestCaloAlignmentEP::produceHFAliErr ( const HFAlignmentErrorExtendedRcd &  )

inline

Definition at line 207 of file TestCaloAlignmentEP.cc.

                                                                     {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().

produceHOAli()

ReturnAli TestCaloAlignmentEP::produceHOAli ( const HOAlignmentRcd &  )

inline

Definition at line 178 of file TestCaloAlignmentEP.cc.

                                                  {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(HcalGeometry::numberOfOuterAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const HcalDetId id(HcalGeometry::detIdFromOuterAlignmentIndex(i));
      vtr.emplace_back(AlignTransform(Trl(0, 0, 0), Rot(), id));
    }
    return ali;
  }

References HcalGeometry::detIdFromOuterAlignmentIndex(), mps_fire::i, triggerObjects_cff::id, and HcalGeometry::numberOfOuterAlignments().

Referenced by TestCaloAlignmentEP().

produceHOAliErr()

ReturnAliErr TestCaloAlignmentEP::produceHOAliErr ( const HOAlignmentErrorExtendedRcd &  )

inline

Definition at line 190 of file TestCaloAlignmentEP.cc.

                                                                     {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().

produceZdcAli()

ReturnAli TestCaloAlignmentEP::produceZdcAli ( const ZDCAlignmentRcd &  )

inline

Definition at line 212 of file TestCaloAlignmentEP.cc.

                                                    {
    ReturnAli ali = std::make_unique<Alignments>();
    std::vector<AlignTransform>& vtr(ali->m_align);
    const unsigned int nA(ZdcGeometry::numberOfAlignments());
    vtr.reserve(nA);
    for (unsigned int i(0); i != nA; ++i) {
      const HcalZDCDetId id(HcalZDCDetId::EM, false, 1);
      vtr.emplace_back(AlignTransform(Trl(0, 0, 0), Rot(), id));
    }
    return ali;
  }

References HcalZDCDetId::EM, mps_fire::i, triggerObjects_cff::id, and ZdcGeometry::numberOfAlignments().

Referenced by TestCaloAlignmentEP().

produceZdcAliErr()

ReturnAliErr TestCaloAlignmentEP::produceZdcAliErr ( const ZDCAlignmentErrorExtendedRcd &  )

inline

Definition at line 224 of file TestCaloAlignmentEP.cc.

                                                                       {
    return std::make_unique<AlignmentErrors>();
  }

Referenced by TestCaloAlignmentEP().