#include <CaloGeometryDBEP.h>

Inheritance diagram for CaloGeometryDBEP< T, U >:

Public Types
typedef CaloCellGeometry::CCGFloat	CCGFloat

typedef CaloSubdetectorGeometry::DimVec	DimVec

typedef CaloSubdetectorGeometry::IVec	IVec

typedef CaloCellGeometry::Pt3D	Pt3D

typedef CaloCellGeometry::Pt3DVec	Pt3DVec

using	PtrType = std::unique_ptr< CaloSubdetectorGeometry >

typedef CaloCellGeometry::Tr3D	Tr3D

typedef CaloSubdetectorGeometry::TrVec	TrVec

Public Member Functions
	CaloGeometryDBEP (const edm::ParameterSet &ps)

template<>
CaloGeometryDBEP< HGCalGeometry, CaloGeometryDBReader >::PtrType	produceAligned (const typename HGCalGeometry::AlignedRecord &iRecord)

template<>
CaloGeometryDBEP< HcalGeometry, CaloGeometryDBReader >::PtrType	produceAligned (const typename HcalGeometry::AlignedRecord &iRecord)

template<>
CaloGeometryDBEP< ZdcGeometry, CaloGeometryDBReader >::PtrType	produceAligned (const typename ZdcGeometry::AlignedRecord &iRecord)

template<>
CaloGeometryDBEP< HcalGeometry, CaloGeometryDBWriter >::PtrType	produceAligned (const typename HcalGeometry::AlignedRecord &iRecord)

PtrType	produceAligned (const typename T::AlignedRecord &iRecord)

template<>
CaloGeometryDBEP< CaloTowerGeometry, CaloGeometryDBReader >::PtrType	produceAligned (const typename CaloTowerGeometry::AlignedRecord &iRecord)

template<>
CaloGeometryDBEP< CaloTowerGeometry, CaloGeometryDBWriter >::PtrType	produceAligned (const typename CaloTowerGeometry::AlignedRecord &iRecord)

template<>
CaloGeometryDBEP< HGCalGeometry, CaloGeometryDBWriter >::PtrType	produceAligned (const typename HGCalGeometry::AlignedRecord &iRecord)

template<>
CaloGeometryDBEP< ZdcGeometry, CaloGeometryDBWriter >::PtrType	produceAligned (const typename ZdcGeometry::AlignedRecord &iRecord)

	~CaloGeometryDBEP () override

Public Member Functions inherited from edm::ESProducer
	ESProducer ()

	ESProducer (const ESProducer &)=delete

	ESProducer (ESProducer &&)=delete

ESResolverIndex 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 &	operator= (const ESProducer &)=delete

ESProducer &	operator= (ESProducer &&)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProductResolverFactoryProducer
	ESProductResolverFactoryProducer ()

	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete

const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete

	~ESProductResolverFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () noexcept(false)

Private Member Functions
std::tuple< const Alignments , const Alignments >	getAlignGlobal (const typename T::AlignedRecord &iRecord) const

Private Attributes
calogeometryDBEPimpl::AdditionalTokens< T >	additionalTokens_

calogeometryDBEPimpl::AlignmentTokens< T >	alignmentTokens_

bool	applyAlignment_

calogeometryDBEPimpl::GeometryTraits< T, U::writeFlag()>::TokenType	geometryToken_

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)

Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>

Protected Member Functions inherited from edm::ESProducer
ESConsumesInfo *	consumesInfoPushBackNew ()

unsigned int	consumesInfoSize () const

template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList , const TRecord iRecord, const es::Label &iLabel)

template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null , const TRecord , const es::Label &)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char 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 TDecorator >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
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::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Detailed Description

template<class T, class U>
class CaloGeometryDBEP< T, U >

Definition at line 85 of file CaloGeometryDBEP.h.

Member Typedef Documentation

◆ CCGFloat

template<class T, class U>

typedef CaloCellGeometry::CCGFloat CaloGeometryDBEP< T, U >::CCGFloat

Definition at line 87 of file CaloGeometryDBEP.h.

◆ DimVec

template<class T, class U>

typedef CaloSubdetectorGeometry::DimVec CaloGeometryDBEP< T, U >::DimVec

Definition at line 94 of file CaloGeometryDBEP.h.

◆ IVec

template<class T, class U>

typedef CaloSubdetectorGeometry::IVec CaloGeometryDBEP< T, U >::IVec

Definition at line 95 of file CaloGeometryDBEP.h.

◆ Pt3D

template<class T, class U>

typedef CaloCellGeometry::Pt3D CaloGeometryDBEP< T, U >::Pt3D

Definition at line 88 of file CaloGeometryDBEP.h.

◆ Pt3DVec

template<class T, class U>

typedef CaloCellGeometry::Pt3DVec CaloGeometryDBEP< T, U >::Pt3DVec

Definition at line 89 of file CaloGeometryDBEP.h.

◆ PtrType

template<class T, class U>

using CaloGeometryDBEP< T, U >::PtrType = std::unique_ptr<CaloSubdetectorGeometry>

Definition at line 92 of file CaloGeometryDBEP.h.

◆ Tr3D

template<class T, class U>

typedef CaloCellGeometry::Tr3D CaloGeometryDBEP< T, U >::Tr3D

Definition at line 90 of file CaloGeometryDBEP.h.

◆ TrVec

template<class T, class U>

typedef CaloSubdetectorGeometry::TrVec CaloGeometryDBEP< T, U >::TrVec

Definition at line 93 of file CaloGeometryDBEP.h.

Constructor & Destructor Documentation

◆ CaloGeometryDBEP()

template<class T, class U>

CaloGeometryDBEP< T, U >::CaloGeometryDBEP ( const edm::ParameterSet & ps )

inline

Definition at line 97 of file CaloGeometryDBEP.h.

References CaloGeometryDBEP< T, U >::additionalTokens_, calogeometryDBEPimpl::AlignmentTokens< T, bool >::alignments, CaloGeometryDBEP< T, U >::alignmentTokens_, CaloGeometryDBEP< T, U >::applyAlignment_, gpuPixelDoublets::cc, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), CaloGeometryDBEP< T, U >::geometryToken_, calogeometryDBEPimpl::AlignmentTokens< T, bool >::globals, and edm::ESProducer::setWhatProduced().

                                               : applyAlignment_(ps.getParameter<bool>("applyAlignment")) {
     auto cc = setWhatProduced(this,
                               &CaloGeometryDBEP<T, U>::produceAligned,
                               edm::es::Label(T::producerTag()));  //+std::string("TEST") ) ) ;
 
     if constexpr (calogeometryDBEPimpl::HasAlignmentRecord<T>::value) {
       if (applyAlignment_) {
         alignmentTokens_.alignments =
             cc.template consumesFrom<Alignments, typename T::AlignmentRecord>(edm::ESInputTag{});
         alignmentTokens_.globals = cc.template consumesFrom<Alignments, GlobalPositionRcd>(edm::ESInputTag{});
       }
     }
     geometryToken_ = calogeometryDBEPimpl::GeometryTraits<T, U::writeFlag()>::makeToken(cc);
 
     additionalTokens_.makeTokens(cc);
   }

◆ ~CaloGeometryDBEP()

template<class T, class U>

CaloGeometryDBEP< T, U >::~CaloGeometryDBEP ( )

inlineoverride

Definition at line 114 of file CaloGeometryDBEP.h.

114 {}

Member Function Documentation

◆ getAlignGlobal()

template<class T, class U>

std::tuple<const Alignments*, const Alignments*> CaloGeometryDBEP< T, U >::getAlignGlobal ( const typename T::AlignedRecord & iRecord ) const

inlineprivate

Definition at line 226 of file CaloGeometryDBEP.h.

References calogeometryDBEPimpl::AlignmentTokens< T, bool >::alignments, CaloGeometryDBEP< T, U >::alignmentTokens_, CaloGeometryDBEP< T, U >::applyAlignment_, cms::cuda::assert(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), and calogeometryDBEPimpl::AlignmentTokens< T, bool >::globals.

Referenced by CaloGeometryDBEP< T, U >::produceAligned().

                                                                                                               {
     const Alignments* alignPtr(nullptr);
     const Alignments* globalPtr(nullptr);
     if constexpr (calogeometryDBEPimpl::HasAlignmentRecord<T>::value) {
       if (applyAlignment_)  // get ptr if necessary
       {
         const auto& alignments = iRecord.get(alignmentTokens_.alignments);
         // require expected size
         assert(alignments.m_align.size() == T::numberOfAlignments());
         alignPtr = &alignments;
 
         const auto& globals = iRecord.get(alignmentTokens_.globals);
         globalPtr = &globals;
       }
     }
     return std::make_tuple(alignPtr, globalPtr);
   }

◆ produceAligned() [1/9]

template<>

CaloGeometryDBEP< HGCalGeometry, CaloGeometryDBReader >::PtrType CaloGeometryDBEP< HGCalGeometry, CaloGeometryDBReader >::produceAligned ( const typename HGCalGeometry::AlignedRecord & iRecord )

Definition at line 9 of file moduleDB.cc.

References cms::cuda::assert(), FlatHexagon::createCorners(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CaloCellGeometry::getParmPtr(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, findQualityFiles::jj, HGCalGeometry::k_NumberOfParametersPerShape, HGCalGeometry::k_NumberOfShapes, nano_mu_digi_cff::layer, PV3DBase< T, PVType, FrameType >::mag2(), calogeometryDBEPimpl::nameHGCal, FlatHexagon::ncorner_, FlatHexagon::ncornerBy2_, FlatHexagon::oneBySix_, hcal_runs::rt, edm::swap(), HLT_2024v14_cff::topology, x, geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, detailsBasic3DVector::y, geometryCSVtoXML::yy, geometryCSVtoXML::yz, detailsBasic3DVector::z, and geometryCSVtoXML::zz.

                                                         {
   TrVec tvec;
   DimVec dvec;
   IVec ivec;
   IVec dins;
 
   edm::LogVerbatim("HGCalGeom") << "Reading HGCalGeometry " << calogeometryDBEPimpl::nameHGCal;
   const auto& pG = iRecord.get(geometryToken_);
 
   tvec = pG.getTranslation();
   dvec = pG.getDimension();
   ivec = pG.getIndexes();
   dins = pG.getDenseIndices();
   //*********************************************************************************************
   const auto& topology = iRecord.get(additionalTokens_.topology);
 
   assert(dvec.size() <= topology.totalGeomModules() * HGCalGeometry::k_NumberOfParametersPerShape);
   HGCalGeometry* hcg = new HGCalGeometry(topology);
   PtrType ptr(hcg);
 
   ptr->allocateCorners(topology.ncells());
   ptr->allocatePar(HGCalGeometry::k_NumberOfShapes, HGCalGeometry::k_NumberOfParametersPerShape);
 
   const unsigned int nTrParm(ptr->numberOfTransformParms());
   const unsigned int nPerShape(HGCalGeometry::k_NumberOfParametersPerShape);
 
   for (auto it : dins) {
     DetId id = topology.encode(topology.geomDenseId2decId(it));
     // get layer
     int layer = ivec[it];
 
     // get transformation
     const unsigned int jj(it * nTrParm);
     Tr3D tr;
     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                   : ROOT::Math::EulerAngles());
     const ROOT::Math::Transform3D rt(ea, tl);
     double xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz;
     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
     // get parameters
     DimVec dims;
     dims.reserve(nPerShape);
 
     DimVec::const_iterator dsrc(dvec.begin() + layer * nPerShape);
     for (unsigned int j(0); j != nPerShape; ++j) {
       dims.emplace_back(*dsrc);
       ++dsrc;
     }
 
     std::vector<GlobalPoint> corners(FlatHexagon::ncorner_);
 
     FlatHexagon::createCorners(dims, tr, corners);
 
     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
     GlobalPoint front(
         FlatHexagon::oneBySix_ *
             (corners[0].x() + corners[1].x() + corners[2].x() + corners[3].x() + corners[4].x() + corners[5].x()),
         FlatHexagon::oneBySix_ *
             (corners[0].y() + corners[1].y() + corners[2].y() + corners[3].y() + corners[4].y() + corners[5].y()),
         FlatHexagon::oneBySix_ *
             (corners[0].z() + corners[1].z() + corners[2].z() + corners[3].z() + corners[4].z() + corners[5].z()));
 
     GlobalPoint back(
         FlatHexagon::oneBySix_ *
             (corners[6].x() + corners[7].x() + corners[8].x() + corners[9].x() + corners[10].x() + corners[11].x()),
         FlatHexagon::oneBySix_ *
             (corners[6].y() + corners[7].y() + corners[8].y() + corners[9].y() + corners[10].y() + corners[11].y()),
         FlatHexagon::oneBySix_ *
             (corners[6].z() + corners[7].z() + corners[8].z() + corners[9].z() + corners[10].z() + corners[11].z()));
 
     if (front.mag2() > back.mag2()) {  // front should always point to the center, so swap front and back
       std::swap(front, back);
       std::swap_ranges(
           corners.begin(), corners.begin() + FlatHexagon::ncornerBy2_, corners.begin() + FlatHexagon::ncornerBy2_);
     }
 
     ptr->newCell(front, back, corners[0], myParm, id);
   }
 
   ptr->initializeParms();  // initializations; must happen after cells filled
 
   return ptr;
 }

◆ produceAligned() [2/9]

template<>

CaloGeometryDBEP< HcalGeometry, CaloGeometryDBReader >::PtrType CaloGeometryDBEP< HcalGeometry, CaloGeometryDBReader >::produceAligned ( const typename HcalGeometry::AlignedRecord & iRecord )

Definition at line 12 of file moduleDB.cc.

References HcalGeometry::alignmentTransformIndexGlobal(), HcalGeometry::alignmentTransformIndexLocal(), cms::cuda::assert(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CaloCellGeometry::getParmPtr(), submitPVValidationJobs::gt, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, findQualityFiles::jj, HcalGeometry::k_NumberOfParametersPerShape, hcal_runs::rt, geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

                                                        {
   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
 
   TrVec tvec;
   DimVec dvec;
   IVec ivec;
   IVec dins;
 
   const auto& pG = iRecord.get(geometryToken_);
 
   tvec = pG.getTranslation();
   dvec = pG.getDimension();
   ivec = pG.getIndexes();
   dins = pG.getDenseIndices();
   //*********************************************************************************************
 
   const auto& hcalTopology = iRecord.get(additionalTokens_.topology);
 
   // We know that the numer of shapes chanes with changing depth
   // so, this check is temporary disabled. We need to implement
   // a way either to store or calculate the number of shapes or be able
   // to deal with only max numer of shapes.
   // assert( dvec.size() == hcalTopology.getNumberOfShapes() * HcalGeometry::k_NumberOfParametersPerShape ) ;
   assert(dvec.size() <= hcalTopology.getNumberOfShapes() * HcalGeometry::k_NumberOfParametersPerShape);
   HcalGeometry* hcg = new HcalGeometry(hcalTopology);
 
   PtrType ptr(hcg);
 
   const unsigned int nTrParm(hcg->numberOfTransformParms());
 
   ptr->fillDefaultNamedParameters();
   ptr->allocateCorners(hcalTopology.ncells() + hcalTopology.getHFSize());
   ptr->allocatePar(dvec.size(), HcalGeometry::k_NumberOfParametersPerShape);
 
   for (unsigned int i(0); i < dins.size(); ++i) {
     const unsigned int nPerShape(HcalGeometry::k_NumberOfParametersPerShape);
     DimVec dims;
     dims.reserve(nPerShape);
 
     const unsigned int indx(ivec.size() == 1 ? 0 : i);
 
     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
 
     for (unsigned int j(0); j != nPerShape; ++j) {
       dims.emplace_back(*dsrc);
       ++dsrc;
     }
 
     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
 
     const DetId id(hcalTopology.denseId2detId(dins[i]));
 
     const unsigned int iGlob(nullptr == globalPtr ? 0 : HcalGeometry::alignmentTransformIndexGlobal(id));
 
     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
 
     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
 
     assert(nullptr == gt || iGlob == HcalGeometry::alignmentTransformIndexGlobal(DetId(gt->rawId())));
 
     const unsigned int iLoc(nullptr == alignPtr ? 0 : HcalGeometry::alignmentTransformIndexLocal(id));
 
     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
 
     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
 
     assert(nullptr == at || (HcalGeometry::alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
 
     Pt3D lRef;
     Pt3DVec lc(8, Pt3D(0, 0, 0));
     hcg->localCorners(lc, &dims.front(), dins[i], lRef);
 
     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
     const Pt3D lCor(lc[0]);
 
     //----------------------------------- create transform from 6 numbers ---
     const unsigned int jj(i * nTrParm);  // Note: Dence indices are not sorted and
                                          // parameters stored according to order of a cell creation
     Tr3D tr;
     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                   : ROOT::Math::EulerAngles());
     const ROOT::Math::Transform3D rt(ea, tl);
     double xx, xy, xz, dx;
     double yx, yy, yz, dy;
     double zx, zy, zz, dz;
     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
     // now prepend alignment(s) for final transform
     const Tr3D atr(nullptr == at ? tr
                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
     //--------------------------------- done making transform  ---------------
 
     const Pt3D gRef(atr * lRef);
     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
     const Pt3D gBck(atr * lBck);
     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
     const Pt3D gCor(atr * lCor);
     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
 
     assert(hcalTopology.detId2denseId(id) == dins[i]);
 
     ptr->newCell(fCtr, fBck, fCor, myParm, id);
   }
 
   ptr->initializeParms();  // initializations; must happen after cells filled
 
   return ptr;
 }

◆ produceAligned() [3/9]

template<>

CaloGeometryDBEP< ZdcGeometry, CaloGeometryDBReader >::PtrType CaloGeometryDBEP< ZdcGeometry, CaloGeometryDBReader >::produceAligned ( const typename ZdcGeometry::AlignedRecord & iRecord )

Definition at line 15 of file moduleDB.cc.

References ZdcGeometry::alignmentTransformIndexGlobal(), ZdcGeometry::alignmentTransformIndexLocal(), cms::cuda::assert(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CaloCellGeometry::getParmPtr(), submitPVValidationJobs::gt, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, findQualityFiles::jj, ZdcGeometry::k_NumberOfParametersPerShape, ZdcGeometry::k_NumberOfShapes, hcal_runs::rt, geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

                                                                                                                     {
   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
 
   TrVec tvec;
   DimVec dvec;
   IVec ivec;
   IVec dins;
 
   const auto& pG = iRecord.get(geometryToken_);
 
   tvec = pG.getTranslation();
   dvec = pG.getDimension();
   ivec = pG.getIndexes();
   dins = pG.getDenseIndices();
   //*********************************************************************************************
 
   const auto& zdcTopology = iRecord.get(additionalTokens_.topology);
 
   assert(dvec.size() <= ZdcGeometry::k_NumberOfShapes * ZdcGeometry::k_NumberOfParametersPerShape);
   ZdcGeometry* zdcGeometry = new ZdcGeometry(&zdcTopology);
   PtrType ptr(zdcGeometry);
 
   const unsigned int nTrParm(tvec.size() / zdcTopology.kSizeForDenseIndexing());
 
   assert(dvec.size() == ZdcGeometry::k_NumberOfShapes * ZdcGeometry::k_NumberOfParametersPerShape);
 
   ptr->fillDefaultNamedParameters();
 
   ptr->allocateCorners(zdcTopology.kSizeForDenseIndexing());
   ptr->allocatePar(zdcGeometry->numberOfShapes(), ZdcGeometry::k_NumberOfParametersPerShape);
 
   for (unsigned int i(0); i < dins.size(); ++i) {
     const unsigned int nPerShape(ZdcGeometry::k_NumberOfParametersPerShape);
     DimVec dims;
     dims.reserve(nPerShape);
 
     const unsigned int indx(ivec.size() == 1 ? 0 : i);
 
     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
 
     for (unsigned int j(0); j != nPerShape; ++j) {
       dims.emplace_back(*dsrc);
       ++dsrc;
     }
 
     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
 
     const DetId id(zdcTopology.denseId2detId(dins[i]));
 
     const unsigned int iGlob(nullptr == globalPtr ? 0 : ZdcGeometry::alignmentTransformIndexGlobal(id));
 
     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
 
     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
 
     assert(nullptr == gt || iGlob == ZdcGeometry::alignmentTransformIndexGlobal(DetId(gt->rawId())));
 
     const unsigned int iLoc(nullptr == alignPtr ? 0 : ZdcGeometry::alignmentTransformIndexLocal(id));
 
     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
 
     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
 
     assert(nullptr == at || (ZdcGeometry::alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
 
     const CaloGenericDetId gId(id);
 
     Pt3D lRef;
     Pt3DVec lc(8, Pt3D(0, 0, 0));
     zdcGeometry->localCorners(lc, &dims.front(), dins[i], lRef);
 
     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
     const Pt3D lCor(lc[0]);
 
     //----------------------------------- create transform from 6 numbers ---
     const unsigned int jj(i * nTrParm);
     Tr3D tr;
     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                   : ROOT::Math::EulerAngles());
     const ROOT::Math::Transform3D rt(ea, tl);
     double xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz;
     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
     // now prepend alignment(s) for final transform
     const Tr3D atr(nullptr == at ? tr
                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
     //--------------------------------- done making transform  ---------------
 
     const Pt3D gRef(atr * lRef);
     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
     const Pt3D gBck(atr * lBck);
     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
     const Pt3D gCor(atr * lCor);
     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
 
     assert(zdcTopology.detId2denseId(id) == dins[i]);
 
     ptr->newCell(fCtr, fBck, fCor, myParm, id);
   }
   ptr->initializeParms();  // initializations; must happen after cells filled
 
   return ptr;
 }

◆ produceAligned() [4/9]

template<>

CaloGeometryDBEP< HcalGeometry, CaloGeometryDBWriter >::PtrType CaloGeometryDBEP< HcalGeometry, CaloGeometryDBWriter >::produceAligned ( const typename HcalGeometry::AlignedRecord & iRecord )

Definition at line 20 of file calowriters.cc.

References HcalGeometry::alignmentTransformIndexGlobal(), HcalGeometry::alignmentTransformIndexLocal(), cms::cuda::assert(), HcalGeometry::dbString(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CaloCellGeometry::getParmPtr(), submitPVValidationJobs::gt, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, findQualityFiles::jj, HcalGeometry::k_NumberOfParametersPerShape, hcal_runs::rt, CaloGeometryDBWriter::writeIndexed(), geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

                                                        {
   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
 
   TrVec tvec;
   DimVec dvec;
   IVec ivec;
   IVec dins;
 
   const auto& pG = iRecord.get(geometryToken_);
 
   pG.getSummary(tvec, ivec, dvec, dins);
 
   CaloGeometryDBWriter::writeIndexed(tvec, dvec, ivec, dins, HcalGeometry::dbString());
   //*********************************************************************************************
 
   const auto& hcalTopology = iRecord.get(additionalTokens_.topology);
 
   // We know that the numer of shapes chanes with changing depth
   // so, this check is temporary disabled. We need to implement
   // a way either to store or calculate the number of shapes or be able
   // to deal with only max numer of shapes.
   assert(dvec.size() <= hcalTopology.getNumberOfShapes() * HcalGeometry::k_NumberOfParametersPerShape);
   HcalGeometry* hcalGeometry = new HcalGeometry(hcalTopology);
   PtrType ptr(hcalGeometry);
 
   const unsigned int nTrParm(hcalGeometry->numberOfTransformParms());
 
   ptr->fillDefaultNamedParameters();
   ptr->allocateCorners(hcalTopology.ncells() + hcalTopology.getHFSize());
   ptr->allocatePar(hcalGeometry->numberOfShapes(), HcalGeometry::k_NumberOfParametersPerShape);
 
   for (unsigned int i(0); i < dins.size(); ++i) {
     const unsigned int nPerShape(HcalGeometry::k_NumberOfParametersPerShape);
     DimVec dims;
     dims.reserve(nPerShape);
 
     const unsigned int indx(ivec.size() == 1 ? 0 : i);
 
     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
 
     for (unsigned int j(0); j != nPerShape; ++j) {
       dims.push_back(*dsrc);
       ++dsrc;
     }
 
     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
 
     const DetId id(hcalTopology.denseId2detId(dins[i]));
 
     const unsigned int iGlob(nullptr == globalPtr ? 0 : HcalGeometry::alignmentTransformIndexGlobal(id));
 
     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
 
     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
 
     assert(nullptr == gt || iGlob == HcalGeometry::alignmentTransformIndexGlobal(DetId(gt->rawId())));
 
     const unsigned int iLoc(nullptr == alignPtr ? 0 : HcalGeometry::alignmentTransformIndexLocal(id));
 
     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
 
     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
 
     assert(nullptr == at || (HcalGeometry::alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
 
     Pt3D lRef;
     Pt3DVec lc(8, Pt3D(0, 0, 0));
     hcalGeometry->localCorners(lc, &dims.front(), dins[i], lRef);
 
     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
     const Pt3D lCor(lc[0]);
 
     //----------------------------------- create transform from 6 numbers ---
     const unsigned int jj(i * nTrParm);
 
     Tr3D tr;
     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                   : ROOT::Math::EulerAngles());
     const ROOT::Math::Transform3D rt(ea, tl);
     double xx, xy, xz, dx;
     double yx, yy, yz, dy;
     double zx, zy, zz, dz;
     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
     // now prepend alignment(s) for final transform
     const Tr3D atr(nullptr == at ? tr
                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
     //--------------------------------- done making transform  ---------------
 
     const Pt3D gRef(atr * lRef);
     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
     const Pt3D gBck(atr * lBck);
     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
     const Pt3D gCor(atr * lCor);
     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
 
     assert(hcalTopology.detId2denseId(id) == dins[i]);
     ptr->newCell(fCtr, fBck, fCor, myParm, id);
   }
 
   ptr->initializeParms();  // initializations; must happen after cells filled
 
   return ptr;
 }

◆ produceAligned() [5/9]

template<class T, class U>

PtrType CaloGeometryDBEP< T, U >::produceAligned ( const typename T::AlignedRecord & iRecord )

inline

Definition at line 116 of file CaloGeometryDBEP.h.

References cms::cuda::assert(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, CaloGeometryDBEP< T, U >::geometryToken_, CaloGeometryDBEP< T, U >::getAlignGlobal(), CaloCellGeometry::getParmPtr(), submitPVValidationJobs::gt, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, findQualityFiles::jj, hcal_runs::rt, writeEcalDQMStatus::write, geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

                                                                  {
     const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
 
     TrVec tvec;
     DimVec dvec;
     IVec ivec;
     std::vector<uint32_t> dins;
 
     if constexpr (U::writeFlag()) {
       const auto& pG = iRecord.get(geometryToken_);
 
       pG.getSummary(tvec, ivec, dvec, dins);
 
       U::write(tvec, dvec, ivec, T::dbString());
     } else {
       const auto& pG = iRecord.get(geometryToken_);
 
       tvec = pG.getTranslation();
       dvec = pG.getDimension();
       ivec = pG.getIndexes();
     }
     //*********************************************************************************************
 
     const unsigned int nTrParm(tvec.size() / T::k_NumberOfCellsForCorners);
 
     assert(dvec.size() == T::k_NumberOfShapes * T::k_NumberOfParametersPerShape);
 
     PtrType ptr = std::make_unique<T>();
 
     ptr->fillDefaultNamedParameters();
 
     ptr->allocateCorners(T::k_NumberOfCellsForCorners);
 
     ptr->allocatePar(dvec.size(), T::k_NumberOfParametersPerShape);
 
     for (unsigned int i(0); i != T::k_NumberOfCellsForCorners; ++i) {
       const unsigned int nPerShape(T::k_NumberOfParametersPerShape);
       DimVec dims;
       dims.reserve(nPerShape);
 
       const unsigned int indx(ivec.size() == 1 ? 0 : i);
 
       DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
 
       for (unsigned int j(0); j != nPerShape; ++j) {
         dims.emplace_back(*dsrc);
         ++dsrc;
       }
 
       const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
 
       const DetId id(T::DetIdType::detIdFromDenseIndex(i));
 
       const unsigned int iGlob(nullptr == globalPtr ? 0 : T::alignmentTransformIndexGlobal(id));
 
       assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
 
       const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
 
       assert(nullptr == gt || iGlob == T::alignmentTransformIndexGlobal(DetId(gt->rawId())));
 
       const unsigned int iLoc(nullptr == alignPtr ? 0 : T::alignmentTransformIndexLocal(id));
 
       assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
 
       const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
 
       assert(nullptr == at || (T::alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
 
       const CaloGenericDetId gId(id);
 
       Pt3D lRef;
       Pt3DVec lc(8, Pt3D(0, 0, 0));
       T::localCorners(lc, &dims.front(), i, lRef);
 
       const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
       const Pt3D lCor(lc[0]);
 
       //----------------------------------- create transform from 6 numbers ---
       const unsigned int jj(i * nTrParm);
       Tr3D tr;
       const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
       const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                     : ROOT::Math::EulerAngles());
       const ROOT::Math::Transform3D rt(ea, tl);
       double xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz;
       rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
       tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
       // now prepend alignment(s) for final transform
       const Tr3D atr(nullptr == at ? tr
                                    : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
       //--------------------------------- done making transform  ---------------
 
       const Pt3D gRef(atr * lRef);
       const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
       const Pt3D gBck(atr * lBck);
       const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
       const Pt3D gCor(atr * lCor);
       const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
 
       ptr->newCell(fCtr, fBck, fCor, myParm, id);
     }
 
     ptr->initializeParms();  // initializations; must happen after cells filled
 
     return ptr;
   }

◆ produceAligned() [6/9]

template<>

CaloGeometryDBEP< CaloTowerGeometry, CaloGeometryDBReader >::PtrType CaloGeometryDBEP< CaloTowerGeometry, CaloGeometryDBReader >::produceAligned ( const typename CaloTowerGeometry::AlignedRecord & iRecord )

Definition at line 126 of file moduleDB.cc.

References CaloTowerGeometry::alignmentTransformIndexGlobal(), CaloTowerGeometry::alignmentTransformIndexLocal(), cms::cuda::assert(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CaloCellGeometry::getParmPtr(), submitPVValidationJobs::gt, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, findQualityFiles::jj, CaloTowerGeometry::k_NumberOfParametersPerShape, CaloTowerGeometry::localCorners(), CaloTowerGeometry::numberOfCellsForCorners(), CaloTowerGeometry::numberOfParametersPerShape(), CaloTowerGeometry::numberOfShapes(), hcal_runs::rt, geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

                                                             {
   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
 
   TrVec tvec;
   DimVec dvec;
   IVec ivec;
   IVec dins;
 
   const auto& pG = iRecord.get(geometryToken_);
 
   tvec = pG.getTranslation();
   dvec = pG.getDimension();
   ivec = pG.getIndexes();
   dins = pG.getDenseIndices();
   //*********************************************************************************************
 
   const auto& caloTopology = iRecord.get(additionalTokens_.topology);
 
   CaloTowerGeometry* ctg = new CaloTowerGeometry(&caloTopology);
 
   const unsigned int nTrParm(tvec.size() / ctg->numberOfCellsForCorners());
 
   assert(dvec.size() == ctg->numberOfShapes() * CaloTowerGeometry::k_NumberOfParametersPerShape);
 
   PtrType ptr(ctg);
 
   ptr->fillDefaultNamedParameters();
 
   ptr->allocateCorners(ctg->numberOfCellsForCorners());
 
   ptr->allocatePar(dvec.size(), CaloTowerGeometry::k_NumberOfParametersPerShape);
 
   for (unsigned int i(0); i < dins.size(); ++i) {
     const unsigned int nPerShape(ctg->numberOfParametersPerShape());
     DimVec dims;
     dims.reserve(nPerShape);
 
     const unsigned int indx(ivec.size() == 1 ? 0 : i);
 
     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
 
     for (unsigned int j(0); j != nPerShape; ++j) {
       dims.emplace_back(*dsrc);
       ++dsrc;
     }
 
     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
 
     const DetId id(caloTopology.detIdFromDenseIndex(dins[i]));
 
     const unsigned int iGlob(nullptr == globalPtr ? 0 : ctg->alignmentTransformIndexGlobal(id));
 
     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
 
     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
 
     assert(nullptr == gt || iGlob == ctg->alignmentTransformIndexGlobal(DetId(gt->rawId())));
 
     const unsigned int iLoc(nullptr == alignPtr ? 0 : ctg->alignmentTransformIndexLocal(id));
 
     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
 
     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
 
     assert(nullptr == at || (ctg->alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
 
     const CaloGenericDetId gId(id);
 
     Pt3D lRef;
     Pt3DVec lc(8, Pt3D(0, 0, 0));
     ctg->localCorners(lc, &dims.front(), dins[i], lRef);
 
     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
     const Pt3D lCor(lc[0]);
 
     //----------------------------------- create transform from 6 numbers ---
     const unsigned int jj(i * nTrParm);
     Tr3D tr;
     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                   : ROOT::Math::EulerAngles());
     const ROOT::Math::Transform3D rt(ea, tl);
     double xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz;
     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
     // now prepend alignment(s) for final transform
     const Tr3D atr(nullptr == at ? tr
                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
     //--------------------------------- done making transform  ---------------
 
     const Pt3D gRef(atr * lRef);
     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
     const Pt3D gBck(atr * lBck);
     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
     const Pt3D gCor(atr * lCor);
     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
 
     assert(caloTopology.denseIndex(id) == dins[i]);
 
     ptr->newCell(fCtr, fBck, fCor, myParm, id);
   }
 
   ptr->initializeParms();  // initializations; must happen after cells filled
 
   return ptr;
 }

◆ produceAligned() [7/9]

template<>

CaloGeometryDBEP< CaloTowerGeometry, CaloGeometryDBWriter >::PtrType CaloGeometryDBEP< CaloTowerGeometry, CaloGeometryDBWriter >::produceAligned ( const typename CaloTowerGeometry::AlignedRecord & iRecord )

Definition at line 130 of file calowriters.cc.

References CaloTowerGeometry::alignmentTransformIndexGlobal(), CaloTowerGeometry::alignmentTransformIndexLocal(), cms::cuda::assert(), CaloTowerGeometry::dbString(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CaloCellGeometry::getParmPtr(), submitPVValidationJobs::gt, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, findQualityFiles::jj, CaloTowerGeometry::k_NumberOfParametersPerShape, CaloTowerGeometry::localCorners(), CaloTowerGeometry::numberOfCellsForCorners(), CaloTowerGeometry::numberOfParametersPerShape(), CaloTowerGeometry::numberOfShapes(), hcal_runs::rt, CaloGeometryDBWriter::writeIndexed(), geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

                                                             {
   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
 
   TrVec tvec;
   DimVec dvec;
   IVec ivec;
   IVec dins;
 
   const auto& pG = iRecord.get(geometryToken_);
 
   pG.getSummary(tvec, ivec, dvec, dins);
 
   CaloGeometryDBWriter::writeIndexed(tvec, dvec, ivec, dins, CaloTowerGeometry::dbString());
   //*********************************************************************************************
 
   const auto& caloTopology = iRecord.get(additionalTokens_.topology);
 
   CaloTowerGeometry* ctg = new CaloTowerGeometry(&caloTopology);
 
   const unsigned int nTrParm(tvec.size() / ctg->numberOfCellsForCorners());
 
   assert(dvec.size() == ctg->numberOfShapes() * CaloTowerGeometry::k_NumberOfParametersPerShape);
 
   PtrType ptr(ctg);
 
   ptr->fillDefaultNamedParameters();
 
   ptr->allocateCorners(ctg->numberOfCellsForCorners());
 
   ptr->allocatePar(dvec.size(), CaloTowerGeometry::k_NumberOfParametersPerShape);
 
   for (unsigned int i(0); i < dins.size(); ++i) {
     const unsigned int nPerShape(ctg->numberOfParametersPerShape());
     DimVec dims;
     dims.reserve(nPerShape);
 
     const unsigned int indx(ivec.size() == 1 ? 0 : i);
 
     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
 
     for (unsigned int j(0); j != nPerShape; ++j) {
       dims.push_back(*dsrc);
       ++dsrc;
     }
 
     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
 
     const DetId id(caloTopology.detIdFromDenseIndex(dins[i]));
 
     const unsigned int iGlob(nullptr == globalPtr ? 0 : ctg->alignmentTransformIndexGlobal(id));
 
     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
 
     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
 
     assert(nullptr == gt || iGlob == ctg->alignmentTransformIndexGlobal(DetId(gt->rawId())));
 
     const unsigned int iLoc(nullptr == alignPtr ? 0 : ctg->alignmentTransformIndexLocal(id));
 
     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
 
     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
 
     assert(nullptr == at || (ctg->alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
 
     const CaloGenericDetId gId(id);
 
     Pt3D lRef;
     Pt3DVec lc(8, Pt3D(0, 0, 0));
     ctg->localCorners(lc, &dims.front(), dins[i], lRef);
 
     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
     const Pt3D lCor(lc[0]);
 
     //----------------------------------- create transform from 6 numbers ---
     const unsigned int jj(i * nTrParm);
     Tr3D tr;
     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                   : ROOT::Math::EulerAngles());
     const ROOT::Math::Transform3D rt(ea, tl);
     double xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz;
     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
     // now prepend alignment(s) for final transform
     const Tr3D atr(nullptr == at ? tr
                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
     //--------------------------------- done making transform  ---------------
 
     const Pt3D gRef(atr * lRef);
     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
     const Pt3D gBck(atr * lBck);
     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
     const Pt3D gCor(atr * lCor);
     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
 
     assert(caloTopology.denseIndex(id) == dins[i]);
 
     ptr->newCell(fCtr, fBck, fCor, myParm, id);
   }
 
   ptr->initializeParms();  // initializations; must happen after cells filled
 
   return ptr;
 }

◆ produceAligned() [8/9]

template<>

CaloGeometryDBEP< HGCalGeometry, CaloGeometryDBWriter >::PtrType CaloGeometryDBEP< HGCalGeometry, CaloGeometryDBWriter >::produceAligned ( const typename HGCalGeometry::AlignedRecord & iRecord )

Definition at line 240 of file calowriters.cc.

References cms::cuda::assert(), FlatHexagon::createCorners(), HGCalGeometry::dbString(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, relativeConstraints::geom, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CaloCellGeometry::getParmPtr(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, findQualityFiles::jj, HGCalGeometry::k_NumberOfParametersPerShape, HGCalGeometry::k_NumberOfShapes, nano_mu_digi_cff::layer, PV3DBase< T, PVType, FrameType >::mag2(), FlatHexagon::ncorner_, FlatHexagon::ncornerBy2_, FlatHexagon::oneBySix_, hcal_runs::rt, edm::swap(), HLT_2024v14_cff::topology, CaloGeometryDBWriter::writeIndexed(), x, geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, detailsBasic3DVector::y, geometryCSVtoXML::yy, geometryCSVtoXML::yz, detailsBasic3DVector::z, and geometryCSVtoXML::zz.

                                                         {
   TrVec tvec;   // transformation
   DimVec dvec;  // parameters
   IVec ivec;    // layers
   IVec dins;    // valid geom ids
 
   const auto& geom = iRecord.get(geometryToken_);
 
   geom.getSummary(tvec, ivec, dvec, dins);
 
   CaloGeometryDBWriter::writeIndexed(tvec, dvec, ivec, dins, HGCalGeometry::dbString());
   //*********************************************************************************************
 
   const auto& topology = iRecord.get(additionalTokens_.topology);
 
   assert(dvec.size() <= topology.totalGeomModules() * HGCalGeometry::k_NumberOfParametersPerShape);
   HGCalGeometry* hcg = new HGCalGeometry(topology);
   PtrType ptr(hcg);
 
   ptr->allocateCorners(topology.ncells());
   ptr->allocatePar(HGCalGeometry::k_NumberOfShapes, HGCalGeometry::k_NumberOfParametersPerShape);
 
   const unsigned int nTrParm(ptr->numberOfTransformParms());
   const unsigned int nPerShape(HGCalGeometry::k_NumberOfParametersPerShape);
 
   for (auto it : dins) {
     DetId id = topology.encode(topology.geomDenseId2decId(it));
     // get layer
     int layer = ivec[it];
 
     // get transformation
     const unsigned int jj(it * nTrParm);
     Tr3D tr;
     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                   : ROOT::Math::EulerAngles());
     const ROOT::Math::Transform3D rt(ea, tl);
     double xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz;
     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
     // get parameters
     DimVec dims;
     dims.reserve(nPerShape);
 
     DimVec::const_iterator dsrc(dvec.begin() + layer * nPerShape);
     for (unsigned int j(0); j != nPerShape; ++j) {
       dims.push_back(*dsrc);
       ++dsrc;
     }
 
     std::vector<GlobalPoint> corners(FlatHexagon::ncorner_);
 
     FlatHexagon::createCorners(dims, tr, corners);
 
     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
     GlobalPoint front(
         FlatHexagon::oneBySix_ *
             (corners[0].x() + corners[1].x() + corners[2].x() + corners[3].x() + corners[4].x() + corners[5].x()),
         FlatHexagon::oneBySix_ *
             (corners[0].y() + corners[1].y() + corners[2].y() + corners[3].y() + corners[4].y() + corners[5].y()),
         FlatHexagon::oneBySix_ *
             (corners[0].z() + corners[1].z() + corners[2].z() + corners[3].z() + corners[4].z() + corners[5].z()));
 
     GlobalPoint back(
         FlatHexagon::oneBySix_ *
             (corners[6].x() + corners[7].x() + corners[8].x() + corners[9].x() + corners[10].x() + corners[11].x()),
         FlatHexagon::oneBySix_ *
             (corners[6].y() + corners[7].y() + corners[8].y() + corners[9].y() + corners[10].y() + corners[11].y()),
         FlatHexagon::oneBySix_ *
             (corners[6].z() + corners[7].z() + corners[8].z() + corners[9].z() + corners[10].z() + corners[11].z()));
 
     if (front.mag2() > back.mag2()) {  // front should always point to the center, so swap front and back
       std::swap(front, back);
       std::swap_ranges(
           corners.begin(), corners.begin() + FlatHexagon::ncornerBy2_, corners.begin() + FlatHexagon::ncornerBy2_);
     }
 
     ptr->newCell(front, back, corners[0], myParm, id);
   }
 
   ptr->initializeParms();  // initializations; must happen after cells filled
 
   return ptr;
 }

◆ produceAligned() [9/9]

template<>

CaloGeometryDBEP< ZdcGeometry, CaloGeometryDBWriter >::PtrType CaloGeometryDBEP< ZdcGeometry, CaloGeometryDBWriter >::produceAligned ( const typename ZdcGeometry::AlignedRecord & iRecord )

Definition at line 329 of file calowriters.cc.

References ZdcGeometry::alignmentTransformIndexGlobal(), ZdcGeometry::alignmentTransformIndexLocal(), cms::cuda::assert(), ZdcGeometry::dbString(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), CaloCellGeometry::getParmPtr(), submitPVValidationJobs::gt, mps_fire::i, l1ctLayer2EG_cff::id, dqmiolumiharvest::j, findQualityFiles::jj, ZdcGeometry::k_NumberOfParametersPerShape, ZdcGeometry::k_NumberOfShapes, hcal_runs::rt, CaloGeometryDBWriter::writeIndexed(), geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

                                                                                                                     {
   const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
 
   TrVec tvec;
   DimVec dvec;
   IVec ivec;
   IVec dins;
 
   const auto& pG = iRecord.get(geometryToken_);
 
   pG.getSummary(tvec, ivec, dvec, dins);
 
   CaloGeometryDBWriter::writeIndexed(tvec, dvec, ivec, dins, ZdcGeometry::dbString());
   //*********************************************************************************************
 
   const auto& zdcTopology = iRecord.get(additionalTokens_.topology);
 
   // We know that the numer of shapes chanes with changing depth
   // so, this check is temporary disabled. We need to implement
   // a way either to store or calculate the number of shapes or be able
   // to deal with only max numer of shapes.
   assert(dvec.size() <= ZdcGeometry::k_NumberOfShapes * ZdcGeometry::k_NumberOfParametersPerShape);
   ZdcGeometry* zdcGeometry = new ZdcGeometry(&zdcTopology);
   PtrType ptr(zdcGeometry);
 
   const unsigned int nTrParm(tvec.size() / zdcTopology.kSizeForDenseIndexing());
 
   ptr->fillDefaultNamedParameters();
   ptr->allocateCorners(zdcTopology.kSizeForDenseIndexing());
   ptr->allocatePar(zdcGeometry->numberOfShapes(), ZdcGeometry::k_NumberOfParametersPerShape);
 
   for (unsigned int i(0); i < dins.size(); ++i) {
     const unsigned int nPerShape(ZdcGeometry::k_NumberOfParametersPerShape);
     DimVec dims;
     dims.reserve(nPerShape);
 
     const unsigned int indx(ivec.size() == 1 ? 0 : i);
 
     DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);
 
     for (unsigned int j(0); j != nPerShape; ++j) {
       dims.push_back(*dsrc);
       ++dsrc;
     }
 
     const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));
 
     const DetId id(zdcTopology.denseId2detId(dins[i]));
 
     const unsigned int iGlob(nullptr == globalPtr ? 0 : ZdcGeometry::alignmentTransformIndexGlobal(id));
 
     assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());
 
     const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);
 
     assert(nullptr == gt || iGlob == ZdcGeometry::alignmentTransformIndexGlobal(DetId(gt->rawId())));
 
     const unsigned int iLoc(nullptr == alignPtr ? 0 : ZdcGeometry::alignmentTransformIndexLocal(id));
 
     assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());
 
     const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);
 
     assert(nullptr == at || (ZdcGeometry::alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));
 
     Pt3D lRef;
     Pt3DVec lc(8, Pt3D(0, 0, 0));
     zdcGeometry->localCorners(lc, &dims.front(), dins[i], lRef);
 
     const Pt3D lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7]));  // ctr rear  face in local
     const Pt3D lCor(lc[0]);
 
     //----------------------------------- create transform from 6 numbers ---
     const unsigned int jj(i * nTrParm);
     Tr3D tr;
     const ROOT::Math::Translation3D tl(tvec[jj], tvec[jj + 1], tvec[jj + 2]);
     const ROOT::Math::EulerAngles ea(6 == nTrParm ? ROOT::Math::EulerAngles(tvec[jj + 3], tvec[jj + 4], tvec[jj + 5])
                                                   : ROOT::Math::EulerAngles());
     const ROOT::Math::Transform3D rt(ea, tl);
     double xx, xy, xz, dx;
     double yx, yy, yz, dy;
     double zx, zy, zz, dz;
     rt.GetComponents(xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
     tr = Tr3D(CLHEP::HepRep3x3(xx, xy, xz, yx, yy, yz, zx, zy, zz), CLHEP::Hep3Vector(dx, dy, dz));
 
     // now prepend alignment(s) for final transform
     const Tr3D atr(nullptr == at ? tr
                                  : (nullptr == gt ? at->transform() * tr : at->transform() * gt->transform() * tr));
     //--------------------------------- done making transform  ---------------
 
     const Pt3D gRef(atr * lRef);
     const GlobalPoint fCtr(gRef.x(), gRef.y(), gRef.z());
     const Pt3D gBck(atr * lBck);
     const GlobalPoint fBck(gBck.x(), gBck.y(), gBck.z());
     const Pt3D gCor(atr * lCor);
     const GlobalPoint fCor(gCor.x(), gCor.y(), gCor.z());
 
     assert(zdcTopology.detId2denseId(id) == dins[i]);
     ptr->newCell(fCtr, fBck, fCor, myParm, id);
   }
 
   ptr->initializeParms();  // initializations; must happen after cells filled
 
   return ptr;
 }

Member Data Documentation

◆ additionalTokens_

template<class T, class U>

calogeometryDBEPimpl::AdditionalTokens<T> CaloGeometryDBEP< T, U >::additionalTokens_

private

Definition at line 246 of file CaloGeometryDBEP.h.

Referenced by CaloGeometryDBEP< T, U >::CaloGeometryDBEP().

◆ alignmentTokens_

template<class T, class U>

calogeometryDBEPimpl::AlignmentTokens<T> CaloGeometryDBEP< T, U >::alignmentTokens_

private

Definition at line 244 of file CaloGeometryDBEP.h.

Referenced by CaloGeometryDBEP< T, U >::CaloGeometryDBEP(), and CaloGeometryDBEP< T, U >::getAlignGlobal().

◆ applyAlignment_

template<class T, class U>

bool CaloGeometryDBEP< T, U >::applyAlignment_

private

Definition at line 247 of file CaloGeometryDBEP.h.

Referenced by CaloGeometryDBEP< T, U >::CaloGeometryDBEP(), and CaloGeometryDBEP< T, U >::getAlignGlobal().

◆ geometryToken_

template<class T, class U>

calogeometryDBEPimpl::GeometryTraits<T, U::writeFlag()>::TokenType CaloGeometryDBEP< T, U >::geometryToken_

private

Definition at line 245 of file CaloGeometryDBEP.h.

Referenced by CaloGeometryDBEP< T, U >::CaloGeometryDBEP(), and CaloGeometryDBEP< T, U >::produceAligned().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<class T, class U> class CaloGeometryDBEP< T, U >

Member Typedef Documentation

◆ CCGFloat

◆ DimVec

◆ IVec

◆ Pt3D

◆ Pt3DVec

◆ PtrType

◆ Tr3D

◆ TrVec

Constructor & Destructor Documentation

◆ CaloGeometryDBEP()

◆ ~CaloGeometryDBEP()

Member Function Documentation

◆ getAlignGlobal()

◆ produceAligned() [1/9]

◆ produceAligned() [2/9]

◆ produceAligned() [3/9]

◆ produceAligned() [4/9]

◆ produceAligned() [5/9]

◆ produceAligned() [6/9]

◆ produceAligned() [7/9]

◆ produceAligned() [8/9]

◆ produceAligned() [9/9]

Member Data Documentation

◆ additionalTokens_

◆ alignmentTokens_

◆ applyAlignment_

◆ geometryToken_

template<class T, class U>
class CaloGeometryDBEP< T, U >