#include <DDHGCalNoTaperEndcap.h>

Inheritance diagram for DDHGCalNoTaperEndcap:

Public Member Functions
	DDHGCalNoTaperEndcap (void)

void	execute (DDCompactView &cpv)

void	initialize (const DDNumericArguments &nArgs, const DDVectorArguments &vArgs, const DDMapArguments &mArgs, const DDStringArguments &sArgs, const DDStringVectorArguments &vsArgs)

virtual	~DDHGCalNoTaperEndcap (void)

Private Member Functions
int	createQuarter (DDCompactView &cpv, int xQuadrant, int yQuadrant, int startCopyNo)

Private Attributes
std::string	m_childName

std::string	m_idNameSpace

int	m_incrCopyNo

int	m_invert

int	m_n

double	m_rMax

double	m_rMin

double	m_startAngle

int	m_startCopyNo

double	m_tiltAngle

double	m_xyoffset

double	m_zoffset

Detailed Description

Definition at line 9 of file DDHGCalNoTaperEndcap.h.

Constructor & Destructor Documentation

DDHGCalNoTaperEndcap::DDHGCalNoTaperEndcap ( void )

Definition at line 17 of file DDHGCalNoTaperEndcap.cc.

                                            {
   edm::LogInfo("HGCalGeom") << "DDHGCalNoTaperEndcap test: Creating an instance";
 }

DDHGCalNoTaperEndcap::~DDHGCalNoTaperEndcap ( void )

virtual

Definition at line 21 of file DDHGCalNoTaperEndcap.cc.

21 {}

Member Function Documentation

int DDHGCalNoTaperEndcap::createQuarter	(	DDCompactView &	cpv,
		int	xQuadrant,
		int	yQuadrant,
		int	startCopyNo
	)

private

Definition at line 52 of file DDHGCalNoTaperEndcap.cc.

References funct::abs(), gather_cfg::cout, DDcreateRotationMatrix(), DDrot(), m_childName, m_idNameSpace, m_incrCopyNo, m_rMax, m_rMin, m_tiltAngle, m_xyoffset, m_zoffset, class-composition::parent, DDCompactView::position(), idealTransformation::rotation, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, and theta().

Referenced by execute().

                                                                                                        {
   int copyNo       = startCopyNo;
   double tiltAngle = m_tiltAngle;
   double xphi      = xQuadrant*tiltAngle;
   double yphi      = yQuadrant*tiltAngle;
   double theta     = 90.*CLHEP::deg;
   double phiX      = 0.0;
   double phiY      = theta;
   double phiZ      = 3*theta; 
   double offsetZ   = m_zoffset;
   double offsetXY  = m_xyoffset;
 
   double offsetX   = xQuadrant*0.5*offsetXY;
   double offsetY   = yQuadrant*0.5*offsetXY;
   
 #ifdef EDM_ML_DEBUG
   int rowmax(0), column(0);
 #endif
   while (std::abs(offsetX) < m_rMax) {
 #ifdef EDM_ML_DEBUG
     column++;
     int row(0);
 #endif
     while (std::abs(offsetY) < m_rMax) {
 #ifdef EDM_ML_DEBUG
       row++;
 #endif
       double limit1 = sqrt((offsetX+0.5*xQuadrant*offsetXY)*
                (offsetX+0.5*xQuadrant*offsetXY) + 
                (offsetY+0.5*yQuadrant*offsetXY)*
                (offsetY+0.5*yQuadrant*offsetXY) );
       double limit2 = sqrt((offsetX-0.5*xQuadrant*offsetXY)*
                (offsetX-0.5*xQuadrant*offsetXY) + 
                (offsetY-0.5*yQuadrant*offsetXY)*
                (offsetY-0.5*yQuadrant*offsetXY) );
       // Make sure we do not add supermodules in rMin area
       if (limit2 > m_rMin && limit1 < m_rMax) {
 #ifdef EDM_ML_DEBUG
     std::cout << m_childName << " copyNo = " << copyNo << " (" << column 
           << "," << row << "): offsetX,Y = " << offsetX << "," 
           << offsetY << " limit=" << limit1 << ":" << limit2 
           << " rMin, rMax = " << m_rMin << "," << m_rMax << std::endl;
 #endif
     DDRotation rotation;
     std::string rotstr( "NULL" );
 
     // Check if we've already created the rotation matrix
     rotstr   = "R"; 
     rotstr  += std::to_string(copyNo);
     rotation = DDRotation(DDName(rotstr));
     if (!rotation) {
       rotation = DDrot(DDName(rotstr, m_idNameSpace),
                new DDRotationMatrix( *DDcreateRotationMatrix( theta, phiX, theta + yphi, phiY, -yphi, phiZ )
                          * ( *DDcreateRotationMatrix( theta + xphi, phiX, 90.*CLHEP::deg, 90.*CLHEP::deg, xphi, 0.0 ))));
     }
       
 
     DDTranslation tran(offsetX, offsetY, offsetZ);
     edm::LogInfo("HGCalGeom") << "Module " << copyNo << ": location = "
                   << tran << " Rotation " << rotation;
 
     DDName parentName = parent().name(); 
     cpv.position(DDName(m_childName), parentName, copyNo, tran, rotation);
 
     copyNo += m_incrCopyNo;
       } else {
 #ifdef EDM_ML_DEBUG
     std::cout << " (" << column << "," << row << "): offsetX,Y = " 
           << offsetX << "," << offsetY << " is out of limit=" << limit1
           << ":" << limit2 << " rMin, rMax = " << m_rMin << "," 
           << m_rMax << std::endl;
 #endif
       }
 
       yphi += yQuadrant*2.*tiltAngle;
       offsetY += yQuadrant*offsetXY;
 
     }
 #ifdef EDM_ML_DEBUG
     if (row > rowmax) rowmax = row;
 #endif
     xphi    += xQuadrant*2.*tiltAngle;
     yphi     =  yQuadrant*tiltAngle;
     offsetY  = yQuadrant*0.5*offsetXY;
     offsetX += xQuadrant*offsetXY;
 
   }
 #ifdef EDM_ML_DEBUG
   std::cout << rowmax << " rows and " << column << " columns in quadrant " 
         << xQuadrant << ":" << yQuadrant << std::endl;
 #endif
   return copyNo;
 }

void DDHGCalNoTaperEndcap::execute ( DDCompactView & cpv )

Definition at line 43 of file DDHGCalNoTaperEndcap.cc.

References createQuarter(), and m_startCopyNo.

                                                        {
   int lastCopyNo = m_startCopyNo;
   lastCopyNo = createQuarter( cpv,  1,  1, lastCopyNo );
   lastCopyNo = createQuarter( cpv, -1,  1, lastCopyNo );
   lastCopyNo = createQuarter( cpv, -1, -1, lastCopyNo );
   createQuarter( cpv,  1, -1, lastCopyNo );
 }

void DDHGCalNoTaperEndcap::initialize	(	const DDNumericArguments &	nArgs,
		const DDVectorArguments &	vArgs,
		const DDMapArguments &	mArgs,
		const DDStringArguments &	sArgs,
		const DDStringVectorArguments &	vsArgs
	)

Definition at line 23 of file DDHGCalNoTaperEndcap.cc.

References createfilelist::int, m_childName, m_idNameSpace, m_incrCopyNo, m_invert, m_n, m_rMax, m_rMin, m_startCopyNo, m_tiltAngle, m_xyoffset, m_zoffset, DDCurrentNamespace::ns(), and class-composition::parent.

                                                         {
   m_tiltAngle   = nArgs["tiltAngle"];
   m_invert      = int( nArgs["invert"] );
   m_rMin        = int( nArgs["rMin"] );
   m_rMax        = int( nArgs["rMax"] );
   m_zoffset     = nArgs["zoffset"];
   m_xyoffset    = nArgs["xyoffset"];
   m_n           = int( nArgs["n"] );
   m_startCopyNo = int( nArgs["startCopyNo"] );
   m_incrCopyNo  = int( nArgs["incrCopyNo"] );
   m_childName   = sArgs["ChildName"];
   m_idNameSpace = DDCurrentNamespace::ns();
   edm::LogInfo("HGCalGeom") << "DDHGCalNoTaperEndcap: NameSpace " << m_idNameSpace 
                 << "\tParent " << parent().name();
 }