CastorHardcodeGeometryLoader.cc

Go to the documentation of this file.

#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h"
#include "Geometry/ForwardGeometry/interface/CastorHardcodeGeometryLoader.h"
#include "Geometry/ForwardGeometry/interface/IdealCastorTrapezoid.h"
#include "Geometry/ForwardGeometry/interface/CastorGeometry.h"
#include "Geometry/ForwardGeometry/src/CastorGeometryData.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <algorithm>
#include <utility>

typedef CaloCellGeometry::CCGFloat CCGFloat ;

CastorHardcodeGeometryLoader::CastorHardcodeGeometryLoader() :
   theTopology ( new CastorTopology ) ,
   extTopology ( theTopology )
{
   init();
}

CastorHardcodeGeometryLoader::CastorHardcodeGeometryLoader( const CastorTopology& ht ) : 
   theTopology( nullptr ) , 
   extTopology ( &ht )
{
   init();
}

void CastorHardcodeGeometryLoader::init() 
{
   theEMSectiondX = 2.*dXEMPlate;
   theEMSectiondY = 2.*dYEMPlate;
   theEMSectiondZ = 101.0;
   theHADSectiondX = 2.*dXHADPlate; 
   theHADSectiondY = 2.*dYHADPlate;
   theHADSectiondZ = 1212.;
}

std::unique_ptr<CaloSubdetectorGeometry> 
CastorHardcodeGeometryLoader::load( DetId::Detector /*det*/, 
                    int             subdet)
{
   std::unique_ptr<CaloSubdetectorGeometry> hg(new CastorGeometry( extTopology ));
   if( subdet == HcalCastorDetId::SubdetectorId )
   {
      fill( HcalCastorDetId::EM,  hg.get() ) ;
      fill( HcalCastorDetId::HAD, hg.get() ) ;
   }
   return std::move(hg);
}

std::unique_ptr<CaloSubdetectorGeometry> 
CastorHardcodeGeometryLoader::load() 
{
   std::unique_ptr<CaloSubdetectorGeometry> hg
      ( new CastorGeometry( extTopology ) ) ;
   fill( HcalCastorDetId::EM,  hg.get() ) ;
   fill( HcalCastorDetId::HAD, hg.get() ) ;
   return std::move(hg);
}

void 
CastorHardcodeGeometryLoader::fill( HcalCastorDetId::Section section , 
                    CaloSubdetectorGeometry* geom      ) 
{
   if( geom->cornersMgr() == nullptr ) geom->allocateCorners(
      HcalCastorDetId::kSizeForDenseIndexing ) ;
   if( geom->parMgr()     == nullptr ) geom->allocatePar( 
      CastorGeometry::k_NumberOfShapes*
      CastorGeometry::k_NumberOfParametersPerShape,
      CastorGeometry::k_NumberOfParametersPerShape ) ;

   // start by making the new HcalDetIds
   std::vector<HcalCastorDetId> castorIds ;

   const int firstCell ( extTopology->firstCell( section ) ) ;
   const int lastCell  ( extTopology->lastCell(  section ) );

   for( int imodule ( firstCell ) ; imodule <= lastCell ; ++imodule ) 
   {
      for( int isector ( 1 ) ;
       isector <= HcalCastorDetId::kNumberSectorsPerEnd ; ++isector ) 
      {
     const HcalCastorDetId id ( section, false, isector, imodule ) ;
     if( extTopology->valid( id ) )  castorIds.emplace_back( id ) ;
      }
   }
//   edm::LogInfo("CastorHardcodeGeometry") 
//      << "Number of Castor DetIds made: " << section 
//      << " " << castorIds.size();
 
   // for each new HcalCastorDetId, make a CaloCellGeometry

   for( std::vector<HcalCastorDetId>::const_iterator 
       castorIdItr ( castorIds.begin() ) ;
    castorIdItr != castorIds.end() ; ++castorIdItr )
   {
      makeCell( *castorIdItr, geom ) ;
   }
}

void
CastorHardcodeGeometryLoader::makeCell( const HcalCastorDetId&   detId , 
                    CaloSubdetectorGeometry* geom   ) const 
{
   const double                   zside   ( 1.0*detId.zside()  ) ;
   const HcalCastorDetId::Section section ( detId.section()    ) ;
   const int                      module  ( detId.module()     ) ;
   const int                      isect   ( detId.sector()     ) ;
   const double                   sector  ( 1.0*isect          ) ;

// length units are cm


   const double sign ( 0 == isect%2 ? -1 : 1 ) ;

//********* HERE ARE HARDWIRED GEOMETRY NUMBERS ACTUALLY USED *****

   static const double an     ( atan( 1.)); //angle of cant w.r.t. beam
   static const double can    ( cos( an ));
   static const double san    ( sin( an ));
   static const double dxlEM  ( 1.55/2. ) ; //halflength of side near beam
   static const double dxhEM  ( 5.73/2. ) ; //halflength of side away from beam
   static const double dhEM   ( 14.26/2. ); //halflength of 2nd longest side
   static const double dR     ( 0.1 + 2.*dhEM*san*dxlEM/( dxhEM-dxlEM ) ) ;
   static const double dhHAD  ( 19.88/2. ); //halflength of 2nd longest side 

   static const double dxhHAD ( dxhEM*( 2.*dhHAD*san + dR )/
                ( 2.*dhEM*san + dR ) ) ; //halflength of side away from beam
   static const double zm     ( 1439.0  ) ;  //z of start of EM
   static const double dzEM   ( 5.45/2 ) ;   // halflength in z of EM
   static const double dzHAD  ( 10.075/2 ) ; // halflength in z of HAD

//*****************************************************************

   const double dxl ( sign*dxlEM ) ; // same for EM and HAD

   const double dxh ( sign*( section == HcalCastorDetId::EM ?
                 dxhEM : dxhHAD ) ) ;
   const double dh  ( section == HcalCastorDetId::EM ?
              dhEM : dhHAD ) ;
   const double dz  ( section == HcalCastorDetId::EM ?
              dzEM : dzHAD ) ;

   const double delz  ( dh*can ) ;
   const double dy  ( dh*san ) ;
   const double dx  ( ( dxl + dxh )/2. ) ;
   const double leg ( dR + dy ) ;
   const double len ( sqrt( leg*leg + dx*dx ) ) ;

   static const double dphi 
      ( 2.*M_PI/(1.0*HcalCastorDetId::kNumberSectorsPerEnd ) ) ;

   const double fphi ( atan( dx/( dR + dy ) ) ) ;

   const double phi  ( 0==isect%2 ? (sector-1.)*dphi - fphi :
               sector*dphi - fphi ) ;

   const double sphi ( sin( phi ) ) ;
   const double cphi ( cos( phi ) ) ;

   const double xc ( len*cphi ) ;
   const double yc ( len*sphi ) ; 
   const double zc ( zside*( zm + delz + 
                 ( module<3 ? ( 1.*module - 1.0 )*2.*dzEM :
                   4.*dzEM +  ( 1.*(module-2) - 1 )*2.*dzHAD ) ) ) ;

   const GlobalPoint fc ( xc, yc, zc ) ;

   std::vector<CCGFloat> zz ;
   zz.reserve( CastorGeometry::k_NumberOfParametersPerShape ) ;
   zz.emplace_back( dxl ) ;
   zz.emplace_back( dxh ) ;
   zz.emplace_back( dh ) ;
   zz.emplace_back( dz ) ;
   zz.emplace_back( an ) ;
   zz.emplace_back( dR ) ;

   geom->newCell( fc, fc, fc, 
          CaloCellGeometry::getParmPtr( zz, 
                        geom->parMgr(), 
                        geom->parVecVec() ),
          detId ) ;
}