#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

typedef std::shared_ptr< CaloSubdetectorGeometry >	PtrType

typedef CaloCellGeometry::Tr3D	Tr3D

typedef CaloSubdetectorGeometry::TrVec	TrVec

Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair< DataKey, edm::propagate_const< std::shared_ptr< DataProxy > > > >	KeyedProxies

typedef std::vector< EventSetupRecordKey >	Keys

typedef std::map< EventSetupRecordKey, KeyedProxies >	RecordProxies

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< 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)

	~CaloGeometryDBEP () override

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

	~ESProducer ()(false) override

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

void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval) override
	overrides DataProxyProvider method More...

	~ESProxyFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Private Attributes
bool	m_applyAlignment

const edm::ParameterSet	m_pSet

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

Protected Member Functions inherited from edm::ESProducer
	ESProducer (const ESProducer &)=delete

ESProducer const &	operator= (const ESProducer &)=delete

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

template<typename T >
void	setWhatProduced (T iThis, const char iLabel)

template<typename T >
void	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
void	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel=es::Label())

template<typename T , typename TReturn , typename TRecord >
void	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel=es::Label())

template<typename T , typename TReturn , typename TRecord , typename TArg >
void	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel=es::Label())

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 eventsetup::EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList) override
	override DataProxyProvider method More...

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

Detailed Description

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

Definition at line 36 of file CaloGeometryDBEP.h.

Member Typedef Documentation

template<class T, class U>

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

Definition at line 40 of file CaloGeometryDBEP.h.

template<class T, class U>

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

Definition at line 47 of file CaloGeometryDBEP.h.

template<class T, class U>

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

Definition at line 48 of file CaloGeometryDBEP.h.

template<class T, class U>

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

Definition at line 41 of file CaloGeometryDBEP.h.

template<class T, class U>

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

Definition at line 42 of file CaloGeometryDBEP.h.

template<class T, class U>

typedef std::shared_ptr<CaloSubdetectorGeometry > CaloGeometryDBEP< T, U >::PtrType

Definition at line 45 of file CaloGeometryDBEP.h.

template<class T, class U>

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

Definition at line 43 of file CaloGeometryDBEP.h.

template<class T, class U>

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

Definition at line 46 of file CaloGeometryDBEP.h.

Constructor & Destructor Documentation

template<class T, class U>

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

inline

Definition at line 50 of file CaloGeometryDBEP.h.

References edm::ESProducer::setWhatProduced().

                                                          :
       m_applyAlignment ( ps.getParameter<bool>("applyAlignment") ),
       m_pSet( ps )
 
       {
      setWhatProduced( this,
               &CaloGeometryDBEP<T,U>::produceAligned,
               edm::es::Label( T::producerTag() ) ) ;//+std::string("TEST") ) ) ;
       }

template<class T, class U>

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

inlineoverride

Definition at line 60 of file CaloGeometryDBEP.h.

60 {}

Member Function Documentation

template<>

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

Definition at line 7 of file moduleDB.cc.

References gather_cfg::cout, FlatHexagon::createCorners(), HGCalGeometry::dbString(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, HGCalTopology::encode(), relativeConstraints::geom, HGCalTopology::geomDenseId2decId(), PCaloGeometry::getDenseIndices(), PCaloGeometry::getDimension(), PCaloGeometry::getIndexes(), CaloCellGeometry::getParmPtr(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HGCalGeometry::getSummary(), PCaloGeometry::getTranslation(), findQualityFiles::jj, HGCalGeometry::k_NumberOfParametersPerShape, HGCalGeometry::k_NumberOfShapes, PV3DBase< T, PVType, FrameType >::mag2(), dataset::name, CaloSubdetectorTopology::ncells(), FlatHexagon::ncorner_, FlatHexagon::ncornerBy2_, FlatHexagon::oneBySix_, edm::ESHandle< T >::product(), AlCaHLTBitMon_QueryRunRegistry::string, std::swap(), ecaldqm::topology(), HGCalTopology::totalGeomModules(), CaloGeometryDBReader::writeFlag(), CaloGeometryDBReader::writeIndexed(), vertices_cff::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;
 
   std::string name;
 
   name = "HGCalEESensitive";
   std::cout << "Reading HGCalGeometry " << name.c_str() << "\n";
   if( CaloGeometryDBReader::writeFlag() )
   {
     edm::ESHandle<HGCalGeometry> geomHandle;
     iRecord.getRecord<IdealGeometryRecord>().get( name, geomHandle );
      
     const HGCalGeometry* geom = geomHandle.product();
     geom->getSummary( tvec, ivec, dvec, dins ) ;
 
     CaloGeometryDBReader::writeIndexed( tvec, dvec, ivec, dins, HGCalGeometry::dbString() ) ;
   }
   else
   {
     edm::ESHandle<PCaloGeometry> pG ;
     iRecord.getRecord<typename HGCalGeometry::PGeometryRecord >().get( pG ) ; 
     
     tvec = pG->getTranslation() ;
     dvec = pG->getDimension() ;
     ivec = pG->getIndexes() ;
     dins = pG->getDenseIndices();
   }  
   //*********************************************************************************************
   edm::ESHandle<HGCalTopology> topology;
   iRecord.getRecord<IdealGeometryRecord>().get( name, 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 ; 
 }

template<>

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

Definition at line 10 of file moduleDB.cc.

References HcalGeometry::alignmentTransformIndexGlobal(), HcalGeometry::alignmentTransformIndexLocal(), HcalGeometry::dbString(), HcalTopology::denseId2detId(), HcalTopology::detId2denseId(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::EventSetupRecord::get(), PCaloGeometry::getDenseIndices(), PCaloGeometry::getDimension(), HcalTopology::getHFSize(), PCaloGeometry::getIndexes(), HcalTopology::getNumberOfShapes(), CaloCellGeometry::getParmPtr(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), CaloSubdetectorGeometry::getSummary(), PCaloGeometry::getTranslation(), mps_fire::i, triggerObjects_cff::id, edm::ESHandleBase::isValid(), findQualityFiles::jj, HcalGeometry::k_NumberOfParametersPerShape, Alignments::m_align, HcalTopology::ncells(), HcalGeometry::numberOfAlignments(), HcalGeometry::producerTag(), edm::ESHandle< T >::product(), AlCaHLTBitMon_QueryRunRegistry::string, CaloGeometryDBReader::writeFlag(), CaloGeometryDBReader::writeIndexed(), geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

                                                                                                                         {
   const Alignments* alignPtr  ( nullptr ) ;
   const Alignments* globalPtr ( nullptr ) ;
   if( m_applyAlignment ) {// get ptr if necessary
     edm::ESHandle< Alignments >                                      alignments ;
     iRecord.getRecord< typename HcalGeometry::AlignmentRecord >().get( alignments ) ;
     
     assert( alignments.isValid() && // require valid alignments and expected size
         ( alignments->m_align.size() == HcalGeometry::numberOfAlignments() ) ) ;
     alignPtr = alignments.product() ;
 
     edm::ESHandle< Alignments >                          globals   ;
     iRecord.getRecord<GlobalPositionRcd>().get( globals ) ;
 
     assert( globals.isValid() ) ;
     globalPtr = globals.product() ;
   }
 
   TrVec  tvec ;
   DimVec dvec ;
   IVec   ivec ;
   IVec   dins ;
 
   if( CaloGeometryDBReader::writeFlag() ) {
     edm::ESHandle<CaloSubdetectorGeometry> pG ;
     iRecord.get( HcalGeometry::producerTag() + std::string("_master"), pG ) ; 
 
     const CaloSubdetectorGeometry* pGptr ( pG.product() ) ;
 
     pGptr->getSummary( tvec, ivec, dvec, dins ) ;
 
     CaloGeometryDBReader::writeIndexed( tvec, dvec, ivec, dins, HcalGeometry::dbString() ) ;
   } else {
     edm::ESHandle<PCaloGeometry> pG ;
     iRecord.getRecord<typename HcalGeometry::PGeometryRecord >().get( pG ) ; 
 
     tvec = pG->getTranslation() ;
     dvec = pG->getDimension() ;
     ivec = pG->getIndexes() ;
     dins = pG->getDenseIndices();
   }  
   //*********************************************************************************************
 
   edm::ESHandle<HcalTopology> hcalTopology;
   iRecord.getRecord<HcalRecNumberingRecord>().get( hcalTopology );
 
   // 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; 
 }

template<>

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

Definition at line 15 of file calowriters.cc.

References HcalGeometry::alignmentTransformIndexGlobal(), HcalGeometry::alignmentTransformIndexLocal(), HcalGeometry::dbString(), HcalTopology::denseId2detId(), HcalTopology::detId2denseId(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, edm::eventsetup::EventSetupRecord::get(), PCaloGeometry::getDenseIndices(), PCaloGeometry::getDimension(), HcalTopology::getHFSize(), PCaloGeometry::getIndexes(), HcalTopology::getNumberOfShapes(), CaloCellGeometry::getParmPtr(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), CaloSubdetectorGeometry::getSummary(), PCaloGeometry::getTranslation(), mps_fire::i, triggerObjects_cff::id, edm::ESHandleBase::isValid(), findQualityFiles::jj, HcalGeometry::k_NumberOfParametersPerShape, Alignments::m_align, HcalTopology::ncells(), HcalGeometry::numberOfAlignments(), HcalGeometry::producerTag(), edm::ESHandle< T >::product(), AlCaHLTBitMon_QueryRunRegistry::string, CaloGeometryDBWriter::writeFlag(), CaloGeometryDBWriter::writeIndexed(), geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

 {
     const Alignments* alignPtr( nullptr );
     const Alignments* globalPtr( nullptr );
     if( m_applyAlignment ) // get ptr if necessary
     {
       edm::ESHandle< Alignments > alignments;
       iRecord.getRecord< typename HcalGeometry::AlignmentRecord >().get( alignments );
       
       assert( alignments.isValid() && // require valid alignments and expected size
           ( alignments->m_align.size() == HcalGeometry::numberOfAlignments()));
       alignPtr = alignments.product();
       
       edm::ESHandle< Alignments > globals;
       iRecord.getRecord<GlobalPositionRcd>().get( globals );
       
       assert( globals.isValid());
       globalPtr = globals.product();
     }
 
     TrVec  tvec;
     DimVec dvec;
     IVec   ivec;
     IVec   dins;
 
     if( CaloGeometryDBWriter::writeFlag())
     {
       edm::ESHandle<CaloSubdetectorGeometry> pG;
       iRecord.get( HcalGeometry::producerTag() + std::string("_master"), pG ); 
 
       const CaloSubdetectorGeometry* pGptr(pG.product());
       
       pGptr->getSummary( tvec, ivec, dvec, dins );
     
       CaloGeometryDBWriter::writeIndexed( tvec, dvec, ivec, dins, HcalGeometry::dbString());
     }
     else
     {
       edm::ESHandle<PCaloGeometry> pG;
       iRecord.getRecord<typename HcalGeometry::PGeometryRecord >().get( pG ); 
 
       tvec = pG->getTranslation();
       dvec = pG->getDimension();
       ivec = pG->getIndexes();
       dins = pG->getDenseIndices();
     }    
     //*********************************************************************************************
 
     edm::ESHandle<HcalTopology> hcalTopology;
     iRecord.getRecord<HcalRecNumberingRecord>().get( hcalTopology );
 
     // 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; 
 }

template<class T, class U>

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

inline

Definition at line 62 of file CaloGeometryDBEP.h.

References PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, PCaloGeometry::getDimension(), PCaloGeometry::getIndexes(), CaloCellGeometry::getParmPtr(), CaloSubdetectorGeometry::getSummary(), PCaloGeometry::getTranslation(), mps_fire::i, triggerObjects_cff::id, edm::ESHandleBase::isValid(), findQualityFiles::jj, Alignments::m_align, CaloGeometryDBEP< T, U >::m_applyAlignment, edm::ESHandle< T >::product(), AlCaHLTBitMon_QueryRunRegistry::string, TriggerAnalyzer::write(), geometryCSVtoXML::xx, geometryCSVtoXML::xy, geometryCSVtoXML::xz, geometryCSVtoXML::yy, geometryCSVtoXML::yz, and geometryCSVtoXML::zz.

       {
      const Alignments* alignPtr  ( nullptr ) ;
      const Alignments* globalPtr ( nullptr ) ;
      if( m_applyAlignment ) // get ptr if necessary
      {
         edm::ESHandle< Alignments >                                      alignments ;
         iRecord.template getRecord< typename T::AlignmentRecord >().get( alignments ) ;
 
         assert( alignments.isValid() && // require valid alignments and expected size
             ( alignments->m_align.size() == T::numberOfAlignments() ) ) ;
         alignPtr = alignments.product() ;
 
         edm::ESHandle< Alignments >                          globals   ;
         iRecord.template getRecord<GlobalPositionRcd>().get( globals ) ;
 
         assert( globals.isValid() ) ;
         globalPtr = globals.product() ;
      }
 
      TrVec  tvec ;
      DimVec dvec ;
      IVec   ivec ;
      std::vector<uint32_t> dins;
 
      if( U::writeFlag() )
      {
         edm::ESHandle<CaloSubdetectorGeometry> pG ;
         iRecord.get( T::producerTag() + std::string("_master"), pG ) ; 
 
         const CaloSubdetectorGeometry* pGptr ( pG.product() ) ;
 
         pGptr->getSummary( tvec, ivec, dvec, dins ) ;
 
         U::write( tvec, dvec, ivec, T::dbString() ) ;
      }
      else
      {
         edm::ESHandle<PCaloGeometry> pG ;
         iRecord.template getRecord<typename T::PGeometryRecord >().get( pG ) ; 
 
         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 ( new 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 ; 
       }

template<>

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

Definition at line 164 of file moduleDB.cc.

                                                                                                                                   {
 
   const Alignments* alignPtr  ( nullptr ) ;
   const Alignments* globalPtr ( nullptr ) ;
   if( m_applyAlignment ) { // get ptr if necessary
     edm::ESHandle< Alignments >                                      alignments ;
     iRecord.getRecord< typename CaloTowerGeometry::AlignmentRecord >().get( alignments ) ;
 
     assert( alignments.isValid() && // require valid alignments and expected sizet
         ( alignments->m_align.size() == CaloTowerGeometry::numberOfAlignments() ) ) ;
     alignPtr = alignments.product() ;
 
     edm::ESHandle< Alignments >                          globals   ;
     iRecord.getRecord<GlobalPositionRcd>().get( globals ) ;
 
     assert( globals.isValid() ) ;
     globalPtr = globals.product() ;
   }
 
   TrVec  tvec ;
   DimVec dvec ;
   IVec   ivec ;
   IVec   dins ;
   
   if( CaloGeometryDBReader::writeFlag() ) {
     edm::ESHandle<CaloSubdetectorGeometry> pG ;
     iRecord.get( CaloTowerGeometry::producerTag() + std::string("_master"), pG ) ; 
 
     const CaloSubdetectorGeometry* pGptr ( pG.product() ) ;
 
     pGptr->getSummary( tvec, ivec, dvec, dins ) ;
     
     CaloGeometryDBReader::writeIndexed( tvec, dvec, ivec, dins, CaloTowerGeometry::dbString() ) ;
   } else {
     edm::ESHandle<PCaloGeometry> pG ;
     iRecord.getRecord<typename CaloTowerGeometry::PGeometryRecord >().get( pG ) ; 
 
     tvec = pG->getTranslation() ;
     dvec = pG->getDimension() ;
     ivec = pG->getIndexes() ;
     dins = pG->getDenseIndices();
   }  
 //*********************************************************************************************
 
   edm::ESHandle<CaloTowerTopology> caloTopology;
   iRecord.getRecord<HcalRecNumberingRecord>().get( caloTopology );
 
 
   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 ; 
 }

template<>

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

Definition at line 171 of file calowriters.cc.

                                                                                                                                   {
 
   const Alignments* alignPtr  ( nullptr ) ;
   const Alignments* globalPtr ( nullptr ) ;
   if( m_applyAlignment ) { // get ptr if necessary
     edm::ESHandle< Alignments >                                      alignments ;
     iRecord.getRecord< typename CaloTowerGeometry::AlignmentRecord >().get( alignments ) ;
 
     assert( alignments.isValid() && // require valid alignments and expected sizet
         ( alignments->m_align.size() == CaloTowerGeometry::numberOfAlignments() ) ) ;
     alignPtr = alignments.product() ;
 
     edm::ESHandle< Alignments >                          globals   ;
     iRecord.getRecord<GlobalPositionRcd>().get( globals ) ;
 
     assert( globals.isValid() ) ;
     globalPtr = globals.product() ;
   }
 
   TrVec  tvec ;
   DimVec dvec ;
   IVec   ivec ;
   IVec   dins ;
   
   if( CaloGeometryDBWriter::writeFlag() ) {
     edm::ESHandle<CaloSubdetectorGeometry> pG ;
     iRecord.get( CaloTowerGeometry::producerTag() + std::string("_master"), pG ) ; 
 
     const CaloSubdetectorGeometry* pGptr(pG.product());
 
     pGptr->getSummary( tvec, ivec, dvec, dins ) ;
     
     CaloGeometryDBWriter::writeIndexed( tvec, dvec, ivec, dins, CaloTowerGeometry::dbString() ) ;
   } else {
     edm::ESHandle<PCaloGeometry> pG ;
     iRecord.getRecord<typename CaloTowerGeometry::PGeometryRecord >().get( pG ) ; 
 
     tvec = pG->getTranslation() ;
     dvec = pG->getDimension() ;
     ivec = pG->getIndexes() ;
     dins = pG->getDenseIndices();
   }  
 //*********************************************************************************************
 
   edm::ESHandle<CaloTowerTopology> caloTopology;
   iRecord.getRecord<HcalRecNumberingRecord>().get( caloTopology );
 
 
   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 ; 
 }

template<>

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

Definition at line 325 of file calowriters.cc.

References FlatHexagon::createCorners(), HGCalGeometry::dbString(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, HGCalTopology::encode(), relativeConstraints::geom, HGCalTopology::geomDenseId2decId(), PCaloGeometry::getDenseIndices(), PCaloGeometry::getDimension(), PCaloGeometry::getIndexes(), CaloCellGeometry::getParmPtr(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HGCalGeometry::getSummary(), PCaloGeometry::getTranslation(), findQualityFiles::jj, HGCalGeometry::k_NumberOfParametersPerShape, HGCalGeometry::k_NumberOfShapes, PV3DBase< T, PVType, FrameType >::mag2(), dataset::name, CaloSubdetectorTopology::ncells(), FlatHexagon::ncorner_, FlatHexagon::ncornerBy2_, FlatHexagon::oneBySix_, edm::ESHandle< T >::product(), AlCaHLTBitMon_QueryRunRegistry::string, std::swap(), ecaldqm::topology(), HGCalTopology::totalGeomModules(), CaloGeometryDBWriter::writeFlag(), CaloGeometryDBWriter::writeIndexed(), vertices_cff::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
 
   std::string name;
 
   name = "HGCalEESensitive";
   
   if( CaloGeometryDBWriter::writeFlag() )
   {
     edm::ESHandle<HGCalGeometry> geomH;
     iRecord.getRecord<IdealGeometryRecord>().get( name, geomH );
     const HGCalGeometry* geom = geomH.product();
     
     geom->getSummary( tvec, ivec, dvec, dins ) ;
     
     CaloGeometryDBWriter::writeIndexed( tvec, dvec, ivec, dins, HGCalGeometry::dbString() ) ;
   }
   else
   {
     edm::ESHandle<PCaloGeometry> pG ;
     iRecord.getRecord<typename HGCalGeometry::PGeometryRecord >().get( pG ) ; 
     
     tvec = pG->getTranslation() ;
     dvec = pG->getDimension() ;
     ivec = pG->getIndexes() ;
     dins = pG->getDenseIndices();
   }  
   //*********************************************************************************************
 
   edm::ESHandle<HGCalTopology> topology;
   iRecord.getRecord<IdealGeometryRecord>().get( name, 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;
 }

Member Data Documentation

template<class T, class U>

bool CaloGeometryDBEP< T, U >::m_applyAlignment

private

Definition at line 212 of file CaloGeometryDBEP.h.

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

template<class T, class U>

const edm::ParameterSet CaloGeometryDBEP< T, U >::m_pSet

private

Definition at line 213 of file CaloGeometryDBEP.h.

Public Types

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

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

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

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