#include <DDHGCalTBModule.h>

Inheritance diagram for DDHGCalTBModule:

Public Member Functions
	DDHGCalTBModule ()

void	execute (DDCompactView &cpv) override

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

	~DDHGCalTBModule () override

Protected Member Functions
void	constructLayers (const DDLogicalPart &, DDCompactView &cpv)

void	positionSensitive (DDLogicalPart &glog, int type, double rin, double rout, DDCompactView &cpv)

double	rMax (double z)

Private Attributes
double	absorbH_

double	absorbW_

std::unordered_set< int >	copies_

std::vector< int >	copyNumber_

std::vector< std::string >	covers_

std::string	idName_

std::string	idNameSpace_

std::vector< int >	layers_

std::vector< int >	layerSense_

std::vector< double >	layerThick_

std::vector< int >	layerType_

std::vector< std::string >	materials_

std::vector< std::string >	names_

double	rMaxFine_

std::vector< double >	rMaxFront_

int	sectors_

std::vector< double >	slopeB_

std::vector< double >	slopeT_

std::vector< double >	thick_

std::vector< std::string >	wafer_

double	waferGap_

double	waferW_

std::vector< double >	zFront_

double	zMinBlock_

Detailed Description

Definition at line 11 of file DDHGCalTBModule.h.

Constructor & Destructor Documentation

DDHGCalTBModule::DDHGCalTBModule ( )

Definition at line 17 of file DDHGCalTBModule.cc.

References gather_cfg::cout.

                                  {
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule info: Creating an instance" << std::endl;
 #endif
 }

DDHGCalTBModule::~DDHGCalTBModule ( )

override

Definition at line 23 of file DDHGCalTBModule.cc.

23 {}

Member Function Documentation

void DDHGCalTBModule::constructLayers	(	const DDLogicalPart &	module,
		DDCompactView &	cpv
	)

protected

Definition at line 125 of file DDHGCalTBModule.cc.

References absorbH_, absorbW_, DDSolidFactory::box(), popcon2dropbox::copy(), copyNumber_, gather_cfg::cout, DDBase< N, C >::ddname(), DDSplit(), plotBeamSpotDB::first, mps_fire::i, idNameSpace_, cuy::ii, layers_, layerSense_, layerThick_, layerType_, materials_, dataset::name, DDBase< N, C >::name(), names_, DDCompactView::position(), positionSensitive(), diffTwoXMLs::r1, rMax(), makeMuonMisalignmentScenario::rot, edm::second(), slopeB_, AlCaHLTBitMon_QueryRunRegistry::string, thick_, DDSolidFactory::tubs(), zMinBlock_, and geometryCSVtoXML::zz.

Referenced by execute().

                                           {
   
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule test: \t\tInside Layers" << std::endl;
 #endif
   double       zi(zMinBlock_);
   int          laymin(0);
   for (unsigned int i=0; i<layers_.size(); i++) {
     double  zo     = zi + layerThick_[i];
     double  routF  = rMax(zi);
     int     laymax = laymin+layers_[i];
     double  zz     = zi;
     double  thickTot(0);
     for (int ly=laymin; ly<laymax; ++ly) {
       int     ii     = layerType_[ly];
       int     copy   = copyNumber_[ii];
       double  rinB   = (layerSense_[ly] == 0) ? (zo*slopeB_[0]) : (zo*slopeB_[1]);
       zz            += (0.5*thick_[ii]);
       thickTot      += thick_[ii];
 
       std::string name = "HGCal"+names_[ii]+std::to_string(copy);
 #ifdef EDM_ML_DEBUG
       std::cout << "DDHGCalTBModule test: Layer " << ly << ":" << ii 
         << " Front " << zi << ", " << routF << " Back " << zo << ", " 
         << rinB << " superlayer thickness " << layerThick_[i] 
         << std::endl;
 #endif
       DDName matName(DDSplit(materials_[ii]).first, 
              DDSplit(materials_[ii]).second);
       DDMaterial matter(matName);
       DDLogicalPart glog;
       if (layerSense_[ly] == 0) {
     DDSolid solid = DDSolidFactory::box(DDName(name, idNameSpace_),
                         absorbW_, absorbH_, 0.5*thick_[ii]);
     glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
     std::cout << "DDHGCalTBModule test: " << solid.name() 
           << " box of dimension " << absorbW_ << ":" << absorbH_
           << ":" << 0.5*thick_[ii] << std::endl;
 #endif
       } else {
     DDSolid solid = DDSolidFactory::tubs(DDName(name, idNameSpace_), 
                          0.5*thick_[ii], rinB, routF, 0.0,
                          CLHEP::twopi);
     glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
     std::cout << "DDHGCalTBModule test: " << solid.name()
           << " Tubs made of " << matName << " of dimensions " << rinB 
           << ", " << routF << ", " << 0.5*thick_[ii] << ", 0.0, "
           << CLHEP::twopi/CLHEP::deg << std::endl;
 #endif
     positionSensitive(glog,layerSense_[ly],rinB,routF,cpv);
       }
       DDTranslation r1(0,0,zz);
       DDRotation rot;
       cpv.position(glog, module, copy, r1, rot);
       ++copyNumber_[ii];
 #ifdef EDM_ML_DEBUG
       std::cout << "DDHGCalTBModule test: " << glog.name() << " number "
         << copy << " positioned in " << module.name() << " at " << r1 
         << " with " << rot << std::endl;
 #endif
       zz += (0.5*thick_[ii]);
     } // End of loop over layers in a block
     zi     = zo;
     laymin = laymax;
     if (fabs(thickTot-layerThick_[i]) < 0.00001) {
     } else if (thickTot > layerThick_[i]) {
       edm::LogError("HGCalGeom") << "Thickness of the partition " << layerThick_[i]
                  << " is smaller than thickness " << thickTot
                  << " of all its components **** ERROR ****\n";
     } else if (thickTot < layerThick_[i]) {
       edm::LogWarning("HGCalGeom") << "Thickness of the partition " 
                    << layerThick_[i] << " does not match with "
                    << thickTot << " of the components\n";
     }
   }   // End of loop over blocks
 }

void DDHGCalTBModule::execute ( DDCompactView & cpv )

override

Definition at line 109 of file DDHGCalTBModule.cc.

References constructLayers(), copies_, gather_cfg::cout, and class-composition::parent.

                                                 {
   
 #ifdef EDM_ML_DEBUG
   std::cout << "==>> Constructing DDHGCalTBModule..." << std::endl;
 #endif
   copies_.clear();
   constructLayers (parent(), cpv);
 #ifdef EDM_ML_DEBUG
   std::cout << copies_.size() << " different wafer copy numbers" << std::endl;
 #endif
   copies_.clear();
 #ifdef EDM_ML_DEBUG
   std::cout << "<<== End of DDHGCalTBModule construction ..." << std::endl;
 #endif
 }

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

override

Definition at line 25 of file DDHGCalTBModule.cc.

References absorbH_, absorbW_, copyNumber_, gather_cfg::cout, covers_, dbl_to_int(), mps_fire::i, idNameSpace_, createfilelist::int, layers_, layerSense_, layerThick_, layerType_, materials_, names_, DDCurrentNamespace::ns(), rMaxFine_, rMaxFront_, sectors_, slopeB_, slopeT_, thick_, wafer_, waferGap_, waferW_, zFront_, and zMinBlock_.

                                                        {
   
   wafer_        = vsArgs["WaferName"];
   covers_       = vsArgs["CoverName"];
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule: " << wafer_.size() << " wafers" << std::endl;
   unsigned int i(0);
   for (auto wafer : wafer_) {
     std::cout << "Wafer[" << i << "] " << wafer << std::endl; ++i;}
   std::cout << "DDHGCalTBModule: " << covers_.size() << " covers" << std::endl;
   i = 0;
   for (auto cover : covers_) {
     std::cout << "Cover[" << i << "] " << cover << std::endl; ++i;}
 #endif
   materials_    = vsArgs["MaterialNames"];
   names_        = vsArgs["VolumeNames"];
   thick_        = vArgs["Thickness"];
   for (unsigned int i=0; i<materials_.size(); ++i) {
     copyNumber_.emplace_back(1);
   }
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule: " << materials_.size()
         << " types of volumes" << std::endl;
   for (unsigned int i=0; i<names_.size(); ++i)
     std::cout << "Volume [" << i << "] " << names_[i] << " of thickness " 
           << thick_[i] << " filled with " << materials_[i]
           << " first copy number " << copyNumber_[i] << std::endl;
 #endif
   layers_       = dbl_to_int(vArgs["Layers"]);
   layerThick_   = vArgs["LayerThick"];
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule: " << layers_.size() << " blocks" <<std::endl;
   for (unsigned int i=0; i<layers_.size(); ++i)
     std::cout << "Block [" << i << "] of thickness "  << layerThick_[i] 
           << " with " << layers_[i] << " layers" << std::endl;
 #endif
   layerType_    = dbl_to_int(vArgs["LayerType"]);
   layerSense_   = dbl_to_int(vArgs["LayerSense"]);
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule: " << layerType_.size() << " layers" 
         << std::endl;
   for (unsigned int i=0; i<layerType_.size(); ++i)
     std::cout << "Layer [" << i << "] with material type "  << layerType_[i]
           << " sensitive class " << layerSense_[i] << std::endl;
 #endif
   zMinBlock_    = nArgs["zMinBlock"];
   rMaxFine_     = nArgs["rMaxFine"];
   waferW_       = nArgs["waferW"];
   waferGap_     = nArgs["waferGap"];
   absorbW_      = nArgs["absorberW"];
   absorbH_      = nArgs["absorberH"];
   sectors_      = (int)(nArgs["Sectors"]);
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule: zStart " << zMinBlock_ << " rFineCoarse " 
         << rMaxFine_ << " wafer width " << waferW_ << " gap among wafers "
         << waferGap_ << " absorber width " << absorbW_ <<" absorber height "
         << absorbH_ << " sectors " << sectors_ << std::endl;
 #endif
   slopeB_       = vArgs["SlopeBottom"];
   slopeT_       = vArgs["SlopeTop"];
   zFront_       = vArgs["ZFront"];
   rMaxFront_    = vArgs["RMaxFront"];
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule: Bottom slopes " << slopeB_[0] << ":" 
         << slopeB_[1] << " and " << slopeT_.size() << " slopes for top" 
         << std::endl;
   for (unsigned int i=0; i<slopeT_.size(); ++i)
     std::cout << "Block [" << i << "] Zmin " << zFront_[i] << " Rmax "
           << rMaxFront_[i] << " Slope " << slopeT_[i] << std::endl;
 #endif
   idNameSpace_  = DDCurrentNamespace::ns();
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule: NameSpace " << idNameSpace_ << std::endl;
 #endif
 }

void DDHGCalTBModule::positionSensitive	(	DDLogicalPart &	glog,
		int	type,
		double	rin,
		double	rout,
		DDCompactView &	cpv
	)

protected

Definition at line 223 of file DDHGCalTBModule.cc.

References copies_, popcon2dropbox::copy(), gather_cfg::cout, covers_, DDBase< N, C >::ddname(), DDSplit(), PVValHelper::dx, PVValHelper::dy, plotBeamSpotDB::first, createfilelist::int, gen::k, dataset::name, create_public_lumi_plots::ncol, DDCompactView::position(), rMaxFine_, idealTransformation::rotation, findQualityFiles::rr, edm::second(), mathSSE::sqrt(), funct::tan(), wafer_, waferGap_, and waferW_.

Referenced by constructLayers().

                                         {
   double ww   = (waferW_+waferGap_);
   double dx   = 0.5*ww;
   double dy   = 3.0*dx*tan(30.0*CLHEP::deg);
   double rr   = 2.0*dx*tan(30.0*CLHEP::deg);
   int    ncol = (int)(2.0*rout/ww) + 1;
   int    nrow = (int)(rout/(ww*tan(30.0*CLHEP::deg))) + 1;
   int    incm(0), inrm(0), kount(0);
   double xc[6], yc[6];
 #ifdef EDM_ML_DEBUG
   std::cout << glog.ddname() << " rout " << rout << " Row " << nrow 
         << " Column " << ncol << std::endl; 
 #endif
   for (int nr=-nrow; nr <= nrow; ++nr) {
     int inr = (nr >= 0) ? nr : -nr;
     for (int nc=-ncol; nc <= ncol; ++nc) {
       int inc = (nc >= 0) ? nc : -nc;
       if (inr%2 == inc%2) {
     double xpos = nc*dx;
     double ypos = nr*dy;
         xc[0] = xpos+dx; yc[0] = ypos-0.5*rr;
         xc[1] = xpos+dx; yc[1] = ypos+0.5*rr;
         xc[2] = xpos;    yc[2] = ypos+rr;
         xc[3] = xpos-dx; yc[3] = ypos+0.5*rr;
         xc[4] = xpos+dx; yc[4] = ypos-0.5*rr;
         xc[5] = xpos;    yc[5] = ypos-rr;
         bool cornerAll(true);
         for (int k=0; k<6; ++k) {
           double rpos = std::sqrt(xc[k]*xc[k]+yc[k]*yc[k]);
           if (rpos < rin || rpos > rout) cornerAll = false;
         }
     if (cornerAll) {
           double rpos = std::sqrt(xpos*xpos+ypos*ypos);
       DDTranslation tran(xpos, ypos, 0.0);
       DDRotation rotation;
       int copy = inr*100 + inc;
       if (nc < 0) copy += 10000;
       if (nr < 0) copy += 100000;
       DDName name;
       if (type == 1) {
         name = (rpos < rMaxFine_) ? 
           DDName(DDSplit(wafer_[0]).first, DDSplit(wafer_[0]).second) : 
           DDName(DDSplit(wafer_[1]).first, DDSplit(wafer_[1]).second);
       } else {
         name = DDName(DDSplit(covers_[type-2]).first, 
               DDSplit(covers_[type-2]).second); 
       }
       cpv.position(name, glog.ddname(), copy, tran, rotation);
       if (inc > incm) incm = inc;
       if (inr > inrm) inrm = inr;
       kount++;
       if (copies_.count(copy) == 0 && type == 1)
         copies_.insert(copy);
 #ifdef EDM_ML_DEBUG
       std::cout << "DDHGCalTBModule: " << name << " number " << copy
             << " positioned in " << glog.ddname() << " at " << tran 
             << " with " << rotation << std::endl;
 #endif
     }
       }
     }
   }
 #ifdef EDM_ML_DEBUG
   std::cout << "DDHGCalTBModule: # of columns " << incm << " # of rows " 
         << inrm << " and " << kount << " wafers for " << glog.ddname()
         << std::endl;
 #endif
 }

double DDHGCalTBModule::rMax ( double z )

protected

Definition at line 205 of file DDHGCalTBModule.cc.

References gather_cfg::cout, gen::k, alignCSCRings::r, rMaxFront_, slopeT_, and zFront_.

Referenced by constructLayers().

                                      {
   double r(0);
 #ifdef EDM_ML_DEBUG
   unsigned int ik(0);
 #endif
   for (unsigned int k=0; k<slopeT_.size(); ++k) {
     if (z < zFront_[k]) break;
     r  = rMaxFront_[k] + (z - zFront_[k]) * slopeT_[k];
 #ifdef EDM_ML_DEBUG
     ik = k;
 #endif
   }
 #ifdef EDM_ML_DEBUG
   std::cout << "rMax : " << z << ":" << ik << ":" << r << std::endl;
 #endif
   return r;
 }