Merged hgcal-db-geometry from repository ianna

Conflicts:
	Geometry/HGCalGeometry/interface/HGCalGeometry.h
	Geometry/HGCalGeometry/src/HGCalGeometry.cc

CondCore/GeometryPlugins/plugins/plugin.cc

@@ -11,6 +11,7 @@
 #include "Geometry/Records/interface/PEcalEndcapRcd.h"
 #include "Geometry/Records/interface/PEcalPreshowerRcd.h"
 #include "Geometry/Records/interface/PHcalRcd.h"
+#include "Geometry/Records/interface/PHGCalRcd.h"
 #include "Geometry/Records/interface/PCaloTowerRcd.h"
 #include "Geometry/Records/interface/PZdcRcd.h"
 #include "Geometry/Records/interface/PCastorRcd.h"
@@ -45,6 +46,7 @@ REGISTER_PLUGIN(PEcalBarrelRcd,PCaloGeometry);
 REGISTER_PLUGIN(PEcalEndcapRcd,PCaloGeometry);
 REGISTER_PLUGIN(PEcalPreshowerRcd,PCaloGeometry);
 REGISTER_PLUGIN(PHcalRcd,PCaloGeometry);
+REGISTER_PLUGIN(PHGCalRcd,PCaloGeometry);
 REGISTER_PLUGIN(PHcalParametersRcd,PHcalParameters);
 REGISTER_PLUGIN(HcalParametersRcd,HcalParameters);
 REGISTER_PLUGIN(PCaloTowerRcd,PCaloGeometry);

CondTools/Geometry/plugins/BuildFile.xml

@@ -27,6 +27,7 @@
 <use name="Geometry/GEMGeometryBuilder"/>
 <use name="Geometry/MuonNumbering"/>  
 <use name="CondFormats/Alignment"/>
+<use name="Geometry/HGCalGeometry"/>
 <library file="*.cc" name="CondToolsGeometryPlugins">
  <flags EDM_PLUGIN="1"/>
 </library>

CondTools/Geometry/plugins/PCaloGeometryBuilder.cc

@@ -8,6 +8,7 @@
 #include "Geometry/EcalAlgo/interface/EcalBarrelGeometry.h"
 #include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h"
 #include "Geometry/EcalAlgo/interface/EcalPreshowerGeometry.h"
+#include "Geometry/HGCalGeometry/interface/HGCalGeometry.h"
 #include "Geometry/HcalTowerAlgo/interface/HcalGeometry.h"
 #include "Geometry/HcalTowerAlgo/interface/CaloTowerGeometry.h"
 #include "Geometry/ForwardGeometry/interface/ZdcGeometry.h"
@@ -17,11 +18,21 @@ class PCaloGeometryBuilder : public edm::one::EDAnalyzer<edm::one::WatchRuns>
 {
 public:
 
-  PCaloGeometryBuilder( const edm::ParameterSet& ) {}
+  PCaloGeometryBuilder( const edm::ParameterSet& pset )
+    : m_ecalE( pset.getUntrackedParameter<bool>( "EcalE", true )),
+      m_ecalP( pset.getUntrackedParameter<bool>( "EcalP", true )),
+      m_hgcal( pset.getUntrackedParameter<bool>( "HGCal", false ))
+  {}
 
   void beginRun(edm::Run const& iEvent, edm::EventSetup const&) override;
   void analyze(edm::Event const& iEvent, edm::EventSetup const&) override {}
   void endRun(edm::Run const& iEvent, edm::EventSetup const&) override {}
+
+private:
+
+  bool m_ecalE;
+  bool m_ecalP;
+  bool m_hgcal;
 };
 
 void
@@ -34,16 +45,27 @@ PCaloGeometryBuilder::beginRun( const edm::Run&, edm::EventSetup const& es )
    es.get<EcalBarrelGeometry::AlignedRecord>().get(
       EcalBarrelGeometry::producerTag() + toDB, pGeb ) ;
 
-   std::cout<<"Writing out "<<EcalEndcapGeometry::producerTag()<<std::endl ;
-   edm::ESHandle<CaloSubdetectorGeometry>       pGee   ;
-   es.get<EcalEndcapGeometry::AlignedRecord>().get(
-      EcalEndcapGeometry::producerTag() + toDB, pGee ) ;
+   if( m_ecalE )
+   {
+     std::cout<<"Writing out "<<EcalEndcapGeometry::producerTag()<<std::endl;
+     edm::ESHandle<CaloSubdetectorGeometry> pGee;
+     es.get<EcalEndcapGeometry::AlignedRecord>().get( EcalEndcapGeometry::producerTag() + toDB, pGee );
+   }
 
-   std::cout<<"Writing out "<<EcalPreshowerGeometry::producerTag()<<std::endl ;
-   edm::ESHandle<CaloSubdetectorGeometry>          pGes   ;
-   es.get<EcalPreshowerGeometry::AlignedRecord>().get(
-      EcalPreshowerGeometry::producerTag() + toDB, pGes ) ; 
+   if( m_ecalP )
+   {
+     std::cout<<"Writing out "<<EcalPreshowerGeometry::producerTag()<<std::endl ;
+     edm::ESHandle<CaloSubdetectorGeometry>          pGes   ;
+     es.get<EcalPreshowerGeometry::AlignedRecord>().get( EcalPreshowerGeometry::producerTag() + toDB, pGes ) ; 
+   }
 
+   if( m_hgcal )
+   {
+     std::cout<<"Writing out "<<HGCalGeometry::producerTag()<<std::endl;
+     edm::ESHandle<CaloSubdetectorGeometry> pGee;
+     es.get<HGCalGeometry::AlignedRecord>().get( HGCalGeometry::producerTag() + toDB, pGee );
+   }
+
    std::cout<<"Writing out "<<HcalGeometry::producerTag()<<std::endl ;
    edm::ESHandle<CaloSubdetectorGeometry> pGhcal   ;
    es.get<HcalGeometry::AlignedRecord>().get(

CondTools/Geometry/plugins/calowriters.cc

@@ -8,6 +8,7 @@
 #include "Geometry/ForwardGeometry/interface/ZdcGeometry.h"
 #include "Geometry/ForwardGeometry/interface/CastorGeometry.h"
 #include "Geometry/Records/interface/HcalRecNumberingRecord.h"
+#include "Geometry/HGCalGeometry/interface/HGCalGeometry.h"
 
 template<>
 CaloGeometryDBEP<HcalGeometry, CaloGeometryDBWriter>::PtrType
@@ -320,7 +321,146 @@ CaloGeometryDBEP<CaloTowerGeometry, CaloGeometryDBWriter>::produceAligned( const
 
   return ptr ; 
 }
-
+
+template<>
+CaloGeometryDBEP<HGCalGeometry, CaloGeometryDBWriter>::PtrType
+CaloGeometryDBEP<HGCalGeometry, CaloGeometryDBWriter>::produceAligned( const typename HGCalGeometry::AlignedRecord& iRecord ) 
+{
+  TrVec  tvec ;
+  DimVec dvec ;
+  IVec   ivec ;
+  IVec   dins ;
+
+  std::string name;
+
+  name = "HGCalEESensitive";
+
+  if( CaloGeometryDBWriter::writeFlag() )
+  {
+    edm::ESHandle<HGCalGeometry> geom;
+    iRecord.getRecord<IdealGeometryRecord>().get( name, geom );
+
+    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> hgcalTopology;
+    iRecord.getRecord<IdealGeometryRecord>().get( name, hgcalTopology );
+    // 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() <= hgcalTopology->totalGeomModules() * HGCalGeometry::k_NumberOfParametersPerShape ) ;
+    HGCalGeometry* hcg = new HGCalGeometry( *hgcalTopology );
+    PtrType ptr ( hcg );
+
+    const unsigned int nTrParm ( tvec.size()/hgcalTopology->ncells() ) ;
+
+    ptr->fillDefaultNamedParameters() ;
+
+    ptr->allocateCorners( hgcalTopology->ncells() ) ;
+
+    ptr->allocatePar(    dvec.size() ,
+			 HGCalGeometry::k_NumberOfParametersPerShape ) ;
+
+    for( unsigned int i ( 0 ) ; i < dins.size(); ++i )
+    {
+	const unsigned int nPerShape ( HGCalGeometry::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 ( hgcalTopology->denseId2detId(dins[i]) ) ;
+
+	// const unsigned int iGlob ( 0 == globalPtr ? 0 :
+	// 			   HGcalGeometry::alignmentTransformIndexGlobal( id ) ) ;
+
+	// assert( 0 == globalPtr || iGlob < globalPtr->m_align.size() ) ;
+
+	// const AlignTransform* gt ( 0 == globalPtr ? 0 : &globalPtr->m_align[ iGlob ] ) ;
+
+	// assert( 0 == gt || iGlob == HGcalGeometry::alignmentTransformIndexGlobal( DetId( gt->rawId() ) ) ) ;
+
+	// const unsigned int iLoc ( 0 == alignPtr ? 0 :
+	// 			  HGcalGeometry::alignmentTransformIndexLocal( id ) ) ;
+
+	// assert( 0 == alignPtr || iLoc < alignPtr->m_align.size() ) ;
+
+	// const AlignTransform* at ( 0 == alignPtr ? 0 :
+	// 			   &alignPtr->m_align[ iLoc ] ) ;
+
+	// assert( 0 == at || ( HGcalGeometry::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 ( dins[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 ( 0 == at ? tr :
+	// 		 ( 0 == gt ? at->transform()*tr :
+	// 		   at->transform()*gt->transform()*tr ) ) ;
+	//--------------------------------- done making transform  ---------------
+
+	const Pt3D        gRef ( lRef ) ;
+	const GlobalPoint fCtr ( gRef.x(), gRef.y(), gRef.z() ) ;
+	const Pt3D        gBck ( lBck ) ;
+	const GlobalPoint fBck ( gBck.x(), gBck.y(), gBck.z() ) ;
+	const Pt3D        gCor ( lCor ) ;
+	const GlobalPoint fCor ( gCor.x(), gCor.y(), gCor.z() ) ;
+
+	assert( hgcalTopology->detId2denseId(id) == dins[i] );
+	ptr->newCell(  fCtr, fBck, fCor, myParm, id ) ;
+    }
+
+    ptr->initializeParms() ; // initializations; must happen after cells filled
+
+    return ptr ; 
+}
+
 template class CaloGeometryDBEP< EcalBarrelGeometry    , CaloGeometryDBWriter> ;
 template class CaloGeometryDBEP< EcalEndcapGeometry    , CaloGeometryDBWriter> ;
 template class CaloGeometryDBEP< EcalPreshowerGeometry , CaloGeometryDBWriter> ;
@@ -364,3 +504,8 @@ typedef CaloGeometryDBEP< CastorGeometry , CaloGeometryDBWriter>
 CastorGeometryToDBEP ;
 
 DEFINE_FWK_EVENTSETUP_MODULE(CastorGeometryToDBEP);
+
+typedef CaloGeometryDBEP< HGCalGeometry , CaloGeometryDBWriter> 
+HGCalGeometryToDBEP ;
+
+DEFINE_FWK_EVENTSETUP_MODULE(HGCalGeometryToDBEP);

CondTools/Geometry/test/GeometryTester.cc

@@ -29,6 +29,7 @@
 #include "Geometry/Records/interface/PEcalEndcapRcd.h"
 #include "Geometry/Records/interface/PEcalPreshowerRcd.h"
 #include "Geometry/Records/interface/PHcalRcd.h"
+#include "Geometry/Records/interface/PHGCalRcd.h"
 #include "Geometry/Records/interface/PCaloTowerRcd.h"
 #include "Geometry/Records/interface/PCastorRcd.h"
 #include "Geometry/Records/interface/PZdcRcd.h"
@@ -44,6 +45,7 @@ GeometryTester::GeometryTester(const edm::ParameterSet& iConfig)
   tktest=iConfig.getUntrackedParameter<bool>("TrackerTest", true);
   ecaltest=iConfig.getUntrackedParameter<bool>("EcalTest", true);
   hcaltest=iConfig.getUntrackedParameter<bool>("HcalTest", true);
+  hgcaltest=iConfig.getUntrackedParameter<bool>("HGCalTest", true);
   calotowertest=iConfig.getUntrackedParameter<bool>("CaloTowerTest", true);
   castortest=iConfig.getUntrackedParameter<bool>("CastorTest", true);
   zdctest=iConfig.getUntrackedParameter<bool>("ZDCTest", true);
@@ -204,6 +206,40 @@ GeometryTester::analyze( const edm::Event& iEvent, const edm::EventSetup& iSetup
     } 
     std::cout << "\n";
   }
+
+  if( hgcaltest )
+  {
+    edm::ESHandle<PCaloGeometry> hgcgeo;
+    iSetup.get<PHGCalRcd>().get(hgcgeo);
+    std::cout << "HGCAL\n";
+    std::vector<float> tsh = hgcgeo->getTranslation();
+    std::vector<float> dimh = hgcgeo->getDimension();
+    std::vector<uint32_t> indh = hgcgeo->getIndexes();
+    std::vector<uint32_t> dindh = hgcgeo->getDenseIndices();
+    std::cout << "Translations " << tsh.size() << "\n";
+    std::cout << "Dimensions " << dimh.size() << "\n";
+    std::cout << "Indices " << indh.size() << "\n";
+    std::cout << "Dense Indices " << dindh.size() << "\n";
+    for( std::vector<float>::const_iterator it = tsh.begin(), end = tsh.end(); it != end; ++it )
+    {
+      std::cout << (*it);
+    } 
+    std::cout << "\n";
+    for( std::vector<float>::const_iterator it = dimh.begin(), end = dimh.end(); it != end; ++it )
+    {
+      std::cout << (*it);
+    } 
+    std::cout << "\n";
+    for( std::vector<uint32_t>::const_iterator it = indh.begin(), end = indh.end(); it != end; ++it )
+    {
+      std::cout << (*it);
+    } 
+    for( std::vector<uint32_t>::const_iterator it = dindh.begin(), end = dindh.end(); it != end; ++it )
+    {
+	std::cout << (*it);
+    } 
+    std::cout << "\n";
+  }
 
   if( calotowertest )
   {

CondTools/Geometry/test/GeometryTester.h

@@ -21,7 +21,7 @@ class GeometryTester : public edm::EDAnalyzer {
 
  private:
 
-  bool xmltest, tktest, ecaltest, hcaltest, calotowertest, castortest, zdctest, csctest, dttest, rpctest;
+  bool xmltest, tktest, ecaltest, hcaltest, hgcaltest, calotowertest, castortest, zdctest, csctest, dttest, rpctest;
   std::string geomLabel_;
 };
 

CondTools/Geometry/test/calogeometry2023writer.py

@@ -0,0 +1,42 @@
+import FWCore.ParameterSet.Config as cms
+
+process = cms.Process("CaloGeometryWriter")
+process.load('CondCore.DBCommon.CondDBCommon_cfi')
+process.load('Configuration.Geometry.GeometryExtended2023_cff')
+process.load('Geometry.CaloEventSetup.CaloGeometry2023DBWriter_cfi')
+process.source = cms.Source("EmptyIOVSource",
+                            lastValue = cms.uint64(1),
+                            timetype = cms.string('runnumber'),
+                            firstValue = cms.uint64(1),
+                            interval = cms.uint64(1)
+                            )
+
+process.CaloGeometryWriter = cms.EDAnalyzer("PCaloGeometryBuilder",
+                                            EcalE = cms.untracked.bool(False),
+                                            EcalP = cms.untracked.bool(False),
+                                            HGCal = cms.untracked.bool(True))
+
+process.HcalParametersWriter = cms.EDAnalyzer("HcalParametersDBBuilder")
+##process.prod = cms.EDAnalyzer("HGCalGeometryTester")
+
+process.CondDBCommon.BlobStreamerName = cms.untracked.string('TBufferBlobStreamingService')
+process.CondDBCommon.timetype = cms.untracked.string('runnumber')
+process.CondDBCommon.connect = cms.string('sqlite_file:myfile.db')
+process.PoolDBOutputService = cms.Service("PoolDBOutputService",
+                                          process.CondDBCommon,
+                                          toPut = cms.VPSet(cms.PSet(record = cms.string('PEcalBarrelRcd'),   tag = cms.string('EBRECO_Geometry_Test01')),
+                                                            cms.PSet(record = cms.string('PHGCalRcd'),         tag = cms.string('HGCALRECO_Geometry_Test01')),
+                                                            cms.PSet(record = cms.string('PHcalRcd'),         tag = cms.string('HCALRECO_Geometry_Test01')),
+                                                            cms.PSet(record = cms.string('HcalParametersRcd'), tag = cms.string('HCALParameters_Geometry_Test01')),
+                                                            cms.PSet(record = cms.string('PCaloTowerRcd'),    tag = cms.string('CTRECO_Geometry_Test01')),
+                                                            cms.PSet(record = cms.string('PZdcRcd'),          tag = cms.string('ZDCRECO_Geometry_Test01')),
+                                                            cms.PSet(record = cms.string('PCastorRcd'),       tag = cms.string('CASTORRECO_Geometry_Test01'))
+                                                            )
+                                          )
+
+process.maxEvents = cms.untracked.PSet(
+    input = cms.untracked.int32(1)
+    )
+
+##process.p1 = cms.Path(process.prod)
+process.p1 = cms.Path(process.CaloGeometryWriter*process.HcalParametersWriter)