#include <DDHGCalEEAlgo.h>

Inheritance diagram for DDHGCalEEAlgo:

Public Member Functions
	DDHGCalEEAlgo ()

void	execute (DDCompactView &cpv) override

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

	~DDHGCalEEAlgo () override

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

void	positionSensitive (const DDLogicalPart &glog, double rin, double rout, double zpos, int layertype, DDCompactView &cpv)

Private Attributes
int	choiceType_

std::unordered_set< int >	copies_

std::vector< int >	copyNumber_

int	firstLayer_

double	fracAreaMin_

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_

std::string	nameSpace_

int	nCutRadPar_

std::vector< double >	rad100to200_

std::vector< double >	rad200to300_

std::vector< double >	rMaxFront_

std::vector< double >	rMinFront_

int	sectors_

std::vector< double >	slopeB_

std::vector< double >	slopeT_

std::vector< double >	thick_

std::vector< std::string >	wafers_

double	waferSepar_

double	waferSize_

std::unique_ptr< HGCalWaferType >	waferType_

std::vector< double >	zFrontB_

std::vector< double >	zFrontT_

double	zMinBlock_

double	zMinRadPar_

Detailed Description

Definition at line 15 of file DDHGCalEEAlgo.h.

Constructor & Destructor Documentation

DDHGCalEEAlgo::DDHGCalEEAlgo ( )

Definition at line 19 of file DDHGCalEEAlgo.cc.

                              {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: Creating an instance";
 #endif
 }

DDHGCalEEAlgo::~DDHGCalEEAlgo ( )

override

Definition at line 25 of file DDHGCalEEAlgo.cc.

25 { }

Member Function Documentation

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

protected

Definition at line 164 of file DDHGCalEEAlgo.cc.

References funct::abs(), alpha, popcon2dropbox::copy(), copyNumber_, funct::cos(), DDBase< N, C >::ddname(), DDSplit(), plotBeamSpotDB::first, mps_fire::i, cuy::ii, gen::k, layers_, layerSense_, layerThick_, layerType_, materials_, dataset::name, DDBase< N, C >::name(), names_, nameSpace_, pi, DDSolidFactory::polyhedra(), DDCompactView::position(), positionSensitive(), diffTwoXMLs::r1, HGCalGeomTools::radius(), rMaxFront_, rMinFront_, makeMuonMisalignmentScenario::rot, edm::second(), sectors_, slopeB_, slopeT_, AlCaHLTBitMon_QueryRunRegistry::string, thick_, DDSolidFactory::tubs(), zFrontB_, zFrontT_, zMinBlock_, and geometryCSVtoXML::zz.

Referenced by execute().

                                         {
   
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: \t\tInside Layers";
 #endif
   double       zi(zMinBlock_);
   int          laymin(0);
   const double tol(0.01);
   for (unsigned int i=0; i<layers_.size(); i++) {
     double  zo     = zi + layerThick_[i];
     double  routF  = HGCalGeomTools::radius(zi,zFrontT_,rMaxFront_,slopeT_);
     int     laymax = laymin+layers_[i];
     double  zz     = zi;
     double  thickTot(0);
     std::vector<double> pgonZ(2), pgonRin(2), pgonRout(2);
     for (int ly=laymin; ly<laymax; ++ly) {
       int     ii     = layerType_[ly];
       int     copy   = copyNumber_[ii];
       double  hthick = 0.5*thick_[ii];
       double  rinB   = HGCalGeomTools::radius(zo,zFrontB_,rMinFront_,slopeB_);
       zz            += hthick;
       thickTot      += thick_[ii];
 
       std::string name = names_[ii]+std::to_string(copy);
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: Layer " << ly << ":" 
                     << ii << " Front " << zi << ", " << routF
                     << " Back " << zo << ", " << rinB 
                     << " superlayer thickness "
                     << layerThick_[i];
 #endif
       DDName matName(DDSplit(materials_[ii]).first, 
              DDSplit(materials_[ii]).second);
       DDMaterial matter(matName);
       DDLogicalPart glog;
       if (layerSense_[ly] == 0) {
     double alpha = CLHEP::pi/sectors_;
     double rmax  = routF*cos(alpha) - tol;
     pgonZ[0]    =-hthick;  pgonZ[1]    = hthick;
     pgonRin[0]  = rinB;    pgonRin[1]  = rinB;   
     pgonRout[0] = rmax;    pgonRout[1] = rmax;   
     DDSolid solid = DDSolidFactory::polyhedra(DDName(name, nameSpace_),
                           sectors_,-alpha,CLHEP::twopi,
                           pgonZ, pgonRin, pgonRout);
     glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << solid.name() 
                       << " polyhedra of " << sectors_ 
                       << " sectors covering " 
                       << -alpha/CLHEP::deg << ":" 
                       << (-alpha+CLHEP::twopi)/CLHEP::deg
                       << " with " << pgonZ.size()
                       << " sections and filled with "
                       << matName << ":" << &matter;
     for (unsigned int k=0; k<pgonZ.size(); ++k)
       edm::LogVerbatim("HGCalGeom") << "[" << k << "] z " << pgonZ[k] 
                     << " R " << pgonRin[k] << ":" 
                     << pgonRout[k];
 #endif
       } else {
     DDSolid solid = DDSolidFactory::tubs(DDName(name, nameSpace_), 
                          hthick, rinB, routF, 0.0,
                          CLHEP::twopi);
     glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << solid.name() 
                       << " Tubs made of " << matName << ":"
                       << &matter << " of dimensions " << rinB 
                       << ", " << routF << ", " << hthick
                       << ", 0.0, " << CLHEP::twopi/CLHEP::deg
                       << " and position " << glog.name() 
                       << " number " << copy;
 #endif
     positionSensitive(glog,rinB,routF,zz,layerSense_[ly],cpv);
       }
       DDTranslation r1(0,0,zz);
       DDRotation rot;
       cpv.position(glog, module, copy, r1, rot);
       ++copyNumber_[ii];
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << glog.name() 
                     << " number " << copy << " positioned in "
                     << module.name() << " at " << r1 
                     << " with " << rot;
 #endif
       zz += hthick;
     } // End of loop over layers in a block
     zi     = zo;
     laymin = laymax;
     if (std::abs(thickTot-layerThick_[i]) < 0.00001) {
     } else if (thickTot > layerThick_[i]) {
       edm::LogError("HGCalGeom") << "Thickness of the partition " 
                  << layerThick_[i] << " is smaller than "
                  << thickTot << ": thickness of all its "
                  << "components **** ERROR ****";
     } else if (thickTot < layerThick_[i]) {
       edm::LogWarning("HGCalGeom") << "Thickness of the partition " 
                    << layerThick_[i] << " does not match with "
                    << thickTot << " of the components";
     }
   }   // End of loop over blocks
 }

void DDHGCalEEAlgo::execute ( DDCompactView & cpv )

override

Definition at line 144 of file DDHGCalEEAlgo.cc.

References constructLayers(), copies_, gen::k, and class-composition::parent.

                                               {
   
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "==>> Constructing DDHGCalEEAlgo...";
   copies_.clear();
 #endif
   constructLayers (parent(), cpv);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << copies_.size() 
                 << " different wafer copy numbers";
   int k(0);
   for (std::unordered_set<int>::const_iterator itr=copies_.begin();
        itr != copies_.end(); ++itr,++k) {
     edm::LogVerbatim("HGCalGeom") << "Copy [" << k << "] : " << (*itr);
   }
   copies_.clear();
   edm::LogVerbatim("HGCalGeom") << "<<== End of DDHGCalEEAlgo construction...";
 #endif
 }

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

override

Definition at line 27 of file DDHGCalEEAlgo.cc.

References choiceType_, copyNumber_, dbl_to_int(), firstLayer_, fracAreaMin_, mps_fire::i, cuy::ii, createfilelist::int, gen::k, layers_, layerSense_, layerThick_, layerType_, materials_, names_, nameSpace_, nCutRadPar_, DDCurrentNamespace::ns(), rad100to200_, rad200to300_, rMaxFront_, rMinFront_, sectors_, slopeB_, slopeT_, thick_, wafers_, waferSepar_, waferSize_, waferType_, zFrontB_, zFrontT_, zMinBlock_, and zMinRadPar_.

                                                           {
 
   wafers_       = vsArgs["WaferNames"];
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << wafers_.size() 
                 << " wafers";
   for (unsigned int i=0; i<wafers_.size(); ++i)
     edm::LogVerbatim("HGCalGeom") << "Wafer[" << i << "] " << wafers_[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
   edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << materials_.size()
                 << " types of volumes";
   for (unsigned int i=0; i<names_.size(); ++i)
     edm::LogVerbatim("HGCalGeom") << "Volume [" << i << "] " << names_[i] 
                   << " of thickness " << thick_[i] 
                   << " filled with " << materials_[i]
                   << " first copy number " << copyNumber_[i];
 #endif
   layers_       = dbl_to_int(vArgs["Layers"]);
   layerThick_   = vArgs["LayerThick"];
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "There are " << layers_.size() << " blocks";
   for (unsigned int i=0; i<layers_.size(); ++i)
     edm::LogVerbatim("HGCalGeom") << "Block [" << i << "] of thickness "  
                   << layerThick_[i] 
                   << " with " << layers_[i] << " layers";
 #endif
   layerType_    = dbl_to_int(vArgs["LayerType"]);
   layerSense_   = dbl_to_int(vArgs["LayerSense"]);
   firstLayer_   = (int)(nArgs["FirstLayer"]);
   if (firstLayer_ > 0) {
     for (unsigned int i=0; i<layerType_.size(); ++i) {
       if (layerSense_[i] != 0) {
     int ii = layerType_[i];
     copyNumber_[ii] = firstLayer_;
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HGCalGeom") << "First copy number for layer type "
                       << i << ":" << ii << " with "
                       << materials_[ii] << " changed to "
                       << copyNumber_[ii];
 #endif
     break;
       }
     }
   }
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "There are " << layerType_.size() 
                 << " layers" ;
   for (unsigned int i=0; i<layerType_.size(); ++i)
     edm::LogVerbatim("HGCalGeom") << "Layer [" << i << "] with material type " 
                   << layerType_[i] << " sensitive class " 
                   << layerSense_[i];
 #endif
   zMinBlock_    = nArgs["zMinBlock"];
   rad100to200_  = vArgs["rad100to200"];
   rad200to300_  = vArgs["rad200to300"];
   zMinRadPar_   = nArgs["zMinForRadPar"];
   choiceType_   = (int)(nArgs["choiceType"]);
   nCutRadPar_   = (int)(nArgs["nCornerCut"]);
   fracAreaMin_  = nArgs["fracAreaMin"];
   waferSize_    = nArgs["waferSize"];
   waferSepar_   = nArgs["SensorSeparation"];
   sectors_      = (int)(nArgs["Sectors"]);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "zStart " << zMinBlock_ 
                 << " radius for wafer type separation uses "
                 << rad100to200_.size() << " parameters; zmin "
                 << zMinRadPar_ << " cutoff " << choiceType_
                 << ":" << nCutRadPar_ << ":" << fracAreaMin_
                 << " wafer width " << waferSize_ 
                 << " separations " << waferSepar_
                 << " sectors " << sectors_;
   for (unsigned int k=0; k<rad100to200_.size(); ++k)
     edm::LogVerbatim("HGCalGeom") << "[" << k << "] 100-200 " <<rad100to200_[k]
                   << " 200-300 " << rad200to300_[k];
 #endif
   slopeB_       = vArgs["SlopeBottom"];
   zFrontB_      = vArgs["ZFrontBottom"];
   rMinFront_    = vArgs["RMinFront"];
   slopeT_       = vArgs["SlopeTop"];
   zFrontT_      = vArgs["ZFrontTop"];
   rMaxFront_    = vArgs["RMaxFront"];
 #ifdef EDM_ML_DEBUG
   for (unsigned int i=0; i<slopeB_.size(); ++i)
     edm::LogVerbatim("HGCalGeom") << "Block [" << i << "] Zmin " << zFrontB_[i]
                   << " Rmin " << rMinFront_[i] << " Slope " 
                   << slopeB_[i];
   for (unsigned int i=0; i<slopeT_.size(); ++i)
     edm::LogVerbatim("HGCalGeom") << "Block [" << i << "] Zmin " << zFrontT_[i]
                   << " Rmax " << rMaxFront_[i] << " Slope " 
                   << slopeT_[i];
 #endif
   nameSpace_    = DDCurrentNamespace::ns();
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: NameSpace " << nameSpace_;
 #endif
 
   waferType_ = std::make_unique<HGCalWaferType>(rad100to200_, rad200to300_,
                         (waferSize_+waferSepar_), 
                         zMinRadPar_, choiceType_,
                         nCutRadPar_, fracAreaMin_);
 }

void DDHGCalEEAlgo::positionSensitive	(	const DDLogicalPart &	glog,
		double	rin,
		double	rout,
		double	zpos,
		int	layertype,
		DDCompactView &	cpv
	)

protected

Definition at line 268 of file DDHGCalEEAlgo.cc.

References funct::abs(), copies_, popcon2dropbox::copy(), DDBase< N, C >::ddname(), DDSplit(), PVValHelper::dy, plotBeamSpotDB::first, createfilelist::int, gen::k, N, dataset::name, nin, DDCompactView::position(), dttmaxenums::R, alignCSCRings::r, idealTransformation::rotation, edm::second(), mathSSE::sqrt(), findQualityFiles::v, wafers_, waferSepar_, waferSize_, and waferType_.

Referenced by constructLayers().

                                           {
   static const double sqrt3 = std::sqrt(3.0);
   double r    = 0.5*(waferSize_ + waferSepar_);
   double R    = 2.0*r/sqrt3;
   double dy   = 0.75*R;
   int    N    = (int)(0.5*rout/r) + 2;
   double xc[6], yc[6];
 #ifdef EDM_ML_DEBUG
   int    ium(0), ivm(0), iumAll(0), ivmAll(0), kount(0), ntot(0), nin(0);
   std::vector<int>  ntype(6,0);
   edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: " << glog.ddname() 
                 << " rout " << rout << " N " 
                 << N << " for maximum u, v";
 #endif
   for (int u = -N; u <= N; ++u) {
     int iu = std::abs(u);
     for (int v = -N; v <= N; ++v) {
       int iv = std::abs(v);
       int nr = 2*v;
       int nc =-2*u+v;
       double xpos = nc*r;
       double ypos = nr*dy;
       xc[0] = xpos+r;  yc[0] = ypos+0.5*R;
       xc[1] = xpos;    yc[1] = ypos+R;
       xc[2] = xpos-r;  yc[2] = ypos+0.5*R;
       xc[3] = xpos-r;  yc[3] = ypos-0.5*R;
       xc[4] = xpos;    yc[4] = ypos-R;
       xc[5] = xpos+r;  yc[5] = ypos-0.5*R;
       bool cornerOne(false), 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) cornerOne = true;
     else                             cornerAll = false;
       }
 #ifdef EDM_ML_DEBUG
       ++ntot;
 #endif
       if (cornerOne) {
     int type = waferType_->getType(xpos,ypos,zpos);
     int copy = type*1000000 + iv*100 + iu;
     if (u < 0) copy += 10000;
     if (v < 0) copy += 100000;
 #ifdef EDM_ML_DEBUG
     if (iu > ium) ium = iu;
     if (iv > ivm) ivm = iv;
     kount++;
     if (copies_.count(copy) == 0) copies_.insert(copy);
 #endif
     if (cornerAll) {
 #ifdef EDM_ML_DEBUG
       if (iu > iumAll) iumAll = iu;
       if (iv > ivmAll) ivmAll = iv;
       ++nin;
 #endif
       DDTranslation tran(xpos, ypos, 0.0);
       DDRotation rotation;
       if (layertype > 1) type += 3;
       DDName name = DDName(DDSplit(wafers_[type]).first, 
                    DDSplit(wafers_[type]).second);
       cpv.position(name, glog.ddname(), copy, tran, rotation);
 #ifdef EDM_ML_DEBUG
       ++ntype[type];
       edm::LogVerbatim("HGCalGeom") << " DDHGCalEEAlgo: " << name 
                     << " number " << copy
                     << " positioned in " << glog.ddname()
                     << " at " << tran 
                     << " with " << rotation;
 #endif
     }
       }
     }
   }
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalEEAlgo: Maximum # of u " << ium 
                 << ":" << iumAll << " # of v " << ivm << ":" 
                 << ivmAll << " and " << nin << ":" << kount 
                 << ":" << ntot << " wafers (" << ntype[0] 
                 << ":" << ntype[1] << ":" << ntype[2] << ":"
                 << ntype[3] << ":" << ntype[4] << ":"
                 << ntype[5] << ") for " << glog.ddname() 
                 << " R " << rin << ":" << rout;
 #endif
 }