Skip to content

Commit

Permalink
Merge pull request #26815 from cms-sw/code-format-geometry-115fcc
Browse files Browse the repository at this point in the history 
Running code-format for geometry
  • Loading branch information
@cmsbuild
cmsbuild committed May 24, 2019
2 parents 7087b99 + a08fde0 commit 472998f
Show file tree
Hide file tree
Showing 41 changed files with 2,610 additions and 3,190 deletions.
283 changes: 131 additions & 152 deletions Geometry/CaloEventSetup/interface/CaloGeometryDBEP.h
View file
Expand Up @@ -37,7 +37,8 @@ namespace calogeometryDBEPimpl {
using TokenType = edm::ESGetToken<CaloSubdetectorGeometry, typename T::AlignedRecord>;

static TokenType makeToken(edm::ESConsumesCollectorT<typename T::AlignedRecord>& cc) {
return cc.template consumes<CaloSubdetectorGeometry>(edm::ESInputTag{"", T::producerTag() + std::string("_master")});
return cc.template consumes<CaloSubdetectorGeometry>(
edm::ESInputTag{"", T::producerTag() + std::string("_master")});
}
};

Expand All @@ -54,15 +55,16 @@ namespace calogeometryDBEPimpl {
//
// SFINAE tricks to detect if T::AlignmentRecord exists. Note that
// the declarations of the following are sufficient.
template <typename T> std::false_type has_AlignmentRecord(...);
template <typename T> std::true_type has_AlignmentRecord(typename T::AlignmentRecord *);
template <typename T>
std::false_type has_AlignmentRecord(...);
template <typename T>
std::true_type has_AlignmentRecord(typename T::AlignmentRecord*);

template <typename T>
struct HasAlignmentRecord {
static constexpr bool value = std::is_same<decltype(has_AlignmentRecord<T>(nullptr)), std::true_type>::value;
};


// Then define tokens from alignment record
template <typename T, bool = HasAlignmentRecord<T>::value>
struct AlignmentTokens {
Expand All @@ -72,200 +74,177 @@ namespace calogeometryDBEPimpl {
template <typename T>
struct AlignmentTokens<T, false> {};


// Some partial specializations need additional tokens...
template <typename T>
struct AdditionalTokens {
void makeTokens(edm::ESConsumesCollectorT<typename T::AlignedRecord>& cc) {}
};
}
} // namespace calogeometryDBEPimpl

template <class T, class U>
class CaloGeometryDBEP : public edm::ESProducer
{
public:

typedef CaloCellGeometry::CCGFloat CCGFloat ;
typedef CaloCellGeometry::Pt3D Pt3D ;
typedef CaloCellGeometry::Pt3DVec Pt3DVec ;
typedef CaloCellGeometry::Tr3D Tr3D ;

using PtrType = std::unique_ptr<CaloSubdetectorGeometry >;
typedef CaloSubdetectorGeometry::TrVec TrVec ;
typedef CaloSubdetectorGeometry::DimVec DimVec ;
typedef CaloSubdetectorGeometry::IVec IVec ;

CaloGeometryDBEP<T,U>( const edm::ParameterSet& ps ) :
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);
class CaloGeometryDBEP : public edm::ESProducer {
public:
typedef CaloCellGeometry::CCGFloat CCGFloat;
typedef CaloCellGeometry::Pt3D Pt3D;
typedef CaloCellGeometry::Pt3DVec Pt3DVec;
typedef CaloCellGeometry::Tr3D Tr3D;

using PtrType = std::unique_ptr<CaloSubdetectorGeometry>;
typedef CaloSubdetectorGeometry::TrVec TrVec;
typedef CaloSubdetectorGeometry::DimVec DimVec;
typedef CaloSubdetectorGeometry::IVec IVec;

CaloGeometryDBEP<T, U>(const edm::ParameterSet& ps) : 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);

~CaloGeometryDBEP<T,U>() override {}

PtrType produceAligned( const typename T::AlignedRecord& iRecord )
{
const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);
additionalTokens_.makeTokens(cc);
}

TrVec tvec ;
DimVec dvec ;
IVec ivec ;
std::vector<uint32_t> dins;
~CaloGeometryDBEP<T, U>() override {}

if constexpr ( U::writeFlag() )
{
const auto& pG = iRecord.get( geometryToken_ ) ;
PtrType produceAligned(const typename T::AlignedRecord& iRecord) {
const auto [alignPtr, globalPtr] = getAlignGlobal(iRecord);

pG.getSummary( tvec, ivec, dvec, dins ) ;
TrVec tvec;
DimVec dvec;
IVec ivec;
std::vector<uint32_t> dins;

U::write( tvec, dvec, ivec, T::dbString() ) ;
}
else
{
const auto& pG = iRecord.get( geometryToken_ ) ;
if constexpr (U::writeFlag()) {
const auto& pG = iRecord.get(geometryToken_);

tvec = pG.getTranslation() ;
dvec = pG.getDimension() ;
ivec = pG.getIndexes() ;
}
//*********************************************************************************************
pG.getSummary(tvec, ivec, dvec, dins);

const unsigned int nTrParm ( tvec.size()/T::k_NumberOfCellsForCorners ) ;
U::write(tvec, dvec, ivec, T::dbString());
} else {
const auto& pG = iRecord.get(geometryToken_);

assert( dvec.size() == T::k_NumberOfShapes * T::k_NumberOfParametersPerShape ) ;
tvec = pG.getTranslation();
dvec = pG.getDimension();
ivec = pG.getIndexes();
}
//*********************************************************************************************

PtrType ptr = std::make_unique<T>();
const unsigned int nTrParm(tvec.size() / T::k_NumberOfCellsForCorners);

ptr->fillDefaultNamedParameters() ;
assert(dvec.size() == T::k_NumberOfShapes * T::k_NumberOfParametersPerShape);

ptr->allocateCorners( T::k_NumberOfCellsForCorners ) ;
PtrType ptr = std::make_unique<T>();

ptr->allocatePar( dvec.size() ,
T::k_NumberOfParametersPerShape ) ;
ptr->fillDefaultNamedParameters();

for( unsigned int i ( 0 ) ; i != T::k_NumberOfCellsForCorners ; ++i )
{
const unsigned int nPerShape ( T::k_NumberOfParametersPerShape ) ;
DimVec dims ;
dims.reserve( nPerShape ) ;
ptr->allocateCorners(T::k_NumberOfCellsForCorners);

const unsigned int indx ( ivec.size()==1 ? 0 : i ) ;
ptr->allocatePar(dvec.size(), T::k_NumberOfParametersPerShape);

DimVec::const_iterator dsrc ( dvec.begin() + ivec[indx]*nPerShape ) ;
for (unsigned int i(0); i != T::k_NumberOfCellsForCorners; ++i) {
const unsigned int nPerShape(T::k_NumberOfParametersPerShape);
DimVec dims;
dims.reserve(nPerShape);

for( unsigned int j ( 0 ) ; j != nPerShape ; ++j )
{
dims.emplace_back( *dsrc ) ;
++dsrc ;
}
const unsigned int indx(ivec.size() == 1 ? 0 : i);

const CCGFloat* myParm ( CaloCellGeometry::getParmPtr( dims,
ptr->parMgr(),
ptr->parVecVec() ) ) ;
DimVec::const_iterator dsrc(dvec.begin() + ivec[indx] * nPerShape);

for (unsigned int j(0); j != nPerShape; ++j) {
dims.emplace_back(*dsrc);
++dsrc;
}

const DetId id ( T::DetIdType::detIdFromDenseIndex( i ) ) ;

const unsigned int iGlob ( nullptr == globalPtr ? 0 :
T::alignmentTransformIndexGlobal( id ) ) ;
const CCGFloat* myParm(CaloCellGeometry::getParmPtr(dims, ptr->parMgr(), ptr->parVecVec()));

assert( nullptr == globalPtr || iGlob < globalPtr->m_align.size() ) ;
const DetId id(T::DetIdType::detIdFromDenseIndex(i));

const AlignTransform* gt ( nullptr == globalPtr ? nullptr : &globalPtr->m_align[ iGlob ] ) ;
const unsigned int iGlob(nullptr == globalPtr ? 0 : T::alignmentTransformIndexGlobal(id));

assert( nullptr == gt || iGlob == T::alignmentTransformIndexGlobal( DetId( gt->rawId() ) ) ) ;
assert(nullptr == globalPtr || iGlob < globalPtr->m_align.size());

const unsigned int iLoc ( nullptr == alignPtr ? 0 :
T::alignmentTransformIndexLocal( id ) ) ;
const AlignTransform* gt(nullptr == globalPtr ? nullptr : &globalPtr->m_align[iGlob]);

assert( nullptr == alignPtr || iLoc < alignPtr->m_align.size() ) ;
assert(nullptr == gt || iGlob == T::alignmentTransformIndexGlobal(DetId(gt->rawId())));

const AlignTransform* at ( nullptr == alignPtr ? nullptr :
&alignPtr->m_align[ iLoc ] ) ;
const unsigned int iLoc(nullptr == alignPtr ? 0 : T::alignmentTransformIndexLocal(id));

assert( nullptr == at || ( T::alignmentTransformIndexLocal( DetId( at->rawId() ) ) == iLoc ) ) ;
assert(nullptr == alignPtr || iLoc < alignPtr->m_align.size());

const CaloGenericDetId gId ( id ) ;
const AlignTransform* at(nullptr == alignPtr ? nullptr : &alignPtr->m_align[iLoc]);

Pt3D lRef ;
Pt3DVec lc ( 8, Pt3D(0,0,0) ) ;
T::localCorners( lc, &dims.front(), i, lRef ) ;
assert(nullptr == at || (T::alignmentTransformIndexLocal(DetId(at->rawId())) == iLoc));

const Pt3D lBck ( 0.25*(lc[4]+lc[5]+lc[6]+lc[7] ) ) ; // ctr rear face in local
const Pt3D lCor ( lc[0] ) ;
const CaloGenericDetId gId(id);

//----------------------------------- 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) );
Pt3D lRef;
Pt3DVec lc(8, Pt3D(0, 0, 0));
T::localCorners(lc, &dims.front(), i, lRef);

// 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 lBck(0.25 * (lc[4] + lc[5] + lc[6] + lc[7])); // ctr rear face in local
const Pt3D lCor(lc[0]);

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() ) ;
//----------------------------------- 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));

ptr->newCell( fCtr, fBck, fCor, myParm, id ) ;
}
// 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 ---------------

ptr->initializeParms() ; // initializations; must happen after cells filled
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;
}

return ptr ;
}

private:
std::tuple<const Alignments *, const Alignments *> getAlignGlobal(const typename T::AlignedRecord& iRecord) const {
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);
std::tuple<const Alignments*, const Alignments*> getAlignGlobal(const typename T::AlignedRecord& iRecord) const {
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);
}

typename calogeometryDBEPimpl::AlignmentTokens<T> alignmentTokens_;
typename calogeometryDBEPimpl::GeometryTraits<T, U::writeFlag()>::TokenType geometryToken_;
typename calogeometryDBEPimpl::AdditionalTokens<T> additionalTokens_;
bool applyAlignment_ ;
typename calogeometryDBEPimpl::AlignmentTokens<T> alignmentTokens_;
typename calogeometryDBEPimpl::GeometryTraits<T, U::writeFlag()>::TokenType geometryToken_;
typename calogeometryDBEPimpl::AdditionalTokens<T> additionalTokens_;
bool applyAlignment_;
};

#endif
27 changes: 11 additions & 16 deletions Geometry/CaloEventSetup/interface/CaloGeometryDBReader.h
View file
Expand Up @@ -3,26 +3,21 @@

#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h"

class CaloGeometryDBReader
{
class CaloGeometryDBReader {
public:
typedef CaloSubdetectorGeometry::TrVec TrVec;
typedef CaloSubdetectorGeometry::DimVec DimVec;
typedef CaloSubdetectorGeometry::IVec IVec;

typedef CaloSubdetectorGeometry::TrVec TrVec ;
typedef CaloSubdetectorGeometry::DimVec DimVec ;
typedef CaloSubdetectorGeometry::IVec IVec ;
static void write(TrVec& /*tvec*/, DimVec& /*dvec*/, IVec& /*ivec*/, const std::string& /*str*/) {}

static void write( TrVec& /*tvec*/,
DimVec& /*dvec*/,
IVec& /*ivec*/,
const std::string& /*str*/ ) {}
static void writeIndexed(const TrVec& /*tvec*/,
const DimVec& /*dvec*/,
const IVec& /*ivec*/,
const std::vector<uint32_t>& /*dins*/,
const std::string& /*tag*/) {}

static void writeIndexed( const TrVec& /*tvec*/,
const DimVec& /*dvec*/,
const IVec& /*ivec*/,
const std::vector<uint32_t>& /*dins*/,
const std::string& /*tag*/ ) {}

static constexpr bool writeFlag() { return false ; }
static constexpr bool writeFlag() { return false; }

CaloGeometryDBReader() {}
virtual ~CaloGeometryDBReader() {}
Expand Down

0 comments on commit 472998f

Please sign in to comment.