Inheritance diagram for DDAHcalModuleAlgo:

Public Member Functions
	DDAHcalModuleAlgo ()

void	execute (DDCompactView &cpv) override

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

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

void	positionSensitive (DDLogicalPart &glog, DDCompactView &cpv)

Private Attributes
std::vector< int >	copyNumber_

std::vector< double >	heights_

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_

std::vector< double >	thick_

std::string	tile_

std::vector< int >	tileN_

std::vector< double >	tileStep_

std::vector< double >	widths_

double	zMinBlock_

Static Private Attributes
static constexpr double	tol_ = 0.00001

Detailed Description

Definition at line 26 of file DDAHcalModuleAlgo.cc.

Constructor & Destructor Documentation

◆ DDAHcalModuleAlgo()

DDAHcalModuleAlgo::DDAHcalModuleAlgo ( )

Definition at line 62 of file DDAHcalModuleAlgo.cc.

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

Member Function Documentation

◆ constructLayers()

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

protected

Definition at line 139 of file DDAHcalModuleAlgo.cc.

                                                                                        {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo test: \t\tInside Layers";
 #endif
   double zi(zMinBlock_);
   int laymin(0);
   for (unsigned int i = 0; i < layers_.size(); i++) {
     double zo = zi + layerThick_[i];
     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];
       zz += (0.5 * thick_[ii]);
       thickTot += thick_[ii];
  
       std::string name = "HGCal" + names_[ii] + std::to_string(copy);
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo test: Layer " << ly << ":" << ii << " Front " << zi
                                     << " Back " << zo << " superlayer thickness " << layerThick_[i];
 #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_), 0.5 * widths_[0], 0.5 * heights_[0], 0.5 * thick_[ii]);
         glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
         edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << solid.name() << " Box made of " << matName
                                       << " of dimensions " << 0.5 * widths_[0] << ", " << 0.5 * heights_[0] << ", "
                                       << 0.5 * thick_[ii];
 #endif
       } else {
         DDSolid solid =
             DDSolidFactory::box(DDName(name, idNameSpace_), 0.5 * widths_[1], 0.5 * heights_[1], 0.5 * thick_[ii]);
         glog = DDLogicalPart(solid.ddname(), matter, solid);
 #ifdef EDM_ML_DEBUG
         edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << solid.name() << " Box made of " << matName
                                       << " of dimensions " << 0.5 * widths_[1] << ", " << 0.5 * heights_[1] << ", "
                                       << 0.5 * thick_[ii];
 #endif
         positionSensitive(glog, cpv);
       }
       DDTranslation r1(0, 0, zz);
       DDRotation rot;
       cpv.position(glog, module, copy, r1, rot);
       ++copyNumber_[ii];
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << glog.name() << " number " << copy << " positioned in "
                                     << module.name() << " at " << r1 << " with " << rot;
 #endif
       zz += (0.5 * thick_[ii]);
     }  // End of loop over layers in a block
     zi = zo;
     laymin = laymax;
     if (fabs(thickTot - layerThick_[i]) > tol_) {
       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 {
         edm::LogWarning("HGCalGeom") << "Thickness of the partition " << layerThick_[i] << " does not match with "
                                      << thickTot << " of the components\n";
       }
     }
   }  // End of loop over blocks
 }

References DDSolidFactory::box(), filterCSVwithJSON::copy, copyNumber_, DDBase< N, C >::ddname(), DDSplit(), dqmdumpme::first, heights_, mps_fire::i, idNameSpace_, cuy::ii, layers_, layerSense_, layerThick_, layerType_, materials_, Skims_PA_cff::name, DDBase< N, C >::name(), names_, DDCompactView::position(), positionSensitive(), diffTwoXMLs::r1, makeMuonMisalignmentScenario::rot, edm::second(), AlCaHLTBitMon_QueryRunRegistry::string, thick_, tol_, widths_, zMinBlock_, and geometryCSVtoXML::zz.

Referenced by execute().

◆ execute()

void DDAHcalModuleAlgo::execute ( DDCompactView & cpv )

override

Definition at line 129 of file DDAHcalModuleAlgo.cc.

                                                   {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "==>> Constructing DDAHcalModuleAlgo...";
 #endif
   constructLayers(parent(), cpv);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "<<== End of DDAHcalModuleAlgo construction";
 #endif
 }

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

◆ initialize()

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

override

Definition at line 68 of file DDAHcalModuleAlgo.cc.

                                                                           {
   tile_ = sArgs["TileName"];
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: Tile " << tile_;
 #endif
   materials_ = vsArgs["MaterialNames"];
   names_ = vsArgs["VolumeNames"];
   thick_ = vArgs["Thickness"];
   copyNumber_.resize(materials_.size(), 1);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << 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") << "DDAHcalModuleAlgo: " << 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"]);
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << 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
   widths_ = vArgs["Widths"];
   heights_ = vArgs["Heights"];
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << widths_.size() << " sizes for width "
                                 << "and height:";
   for (unsigned int i = 0; i < widths_.size(); ++i)
     edm::LogVerbatim("HGCalGeom") << " [" << i << "] " << widths_[i] << ":" << heights_[i];
 #endif
   tileN_ = dbl_to_int(vArgs["TileN"]);
   tileStep_ = vArgs["TileStep"];
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << tileN_.size() << " tile positioning parameters";
   for (unsigned int i = 0; i < tileN_.size(); ++i)
     edm::LogVerbatim("HGCalGeom") << " [" << i << "] " << tileN_[i] << ":" << tileStep_[i];
 #endif
   zMinBlock_ = nArgs["zMinBlock"];
   idNameSpace_ = DDCurrentNamespace::ns();
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDHGCalModule: zStart " << zMinBlock_ << "  NameSpace " << idNameSpace_;
 #endif
 }

References copyNumber_, dbl_to_int(), heights_, mps_fire::i, idNameSpace_, layers_, layerSense_, layerThick_, layerType_, materials_, names_, DDCurrentNamespace::ns(), thick_, tile_, tileN_, tileStep_, widths_, and zMinBlock_.

◆ positionSensitive()

void DDAHcalModuleAlgo::positionSensitive	(	DDLogicalPart &	glog,
		DDCompactView &	cpv
	)

protected

Definition at line 208 of file DDAHcalModuleAlgo.cc.

                                                                                  {
   int ncol = tileN_[0] / 2;
   int nrow = tileN_[1] / 2;
 #ifdef EDM_ML_DEBUG
   int kount(0);
   edm::LogVerbatim("HGCalGeom") << glog.ddname() << " Row " << nrow << " Column " << ncol;
 #endif
   for (int nr = -nrow; nr <= nrow; ++nr) {
     int inr = (nr >= 0) ? nr : -nr;
     double ypos = (nr >= 0) ? (inr - 0.5) * tileStep_[1] : -(inr - 0.5) * tileStep_[1];
     for (int nc = -ncol; nc <= ncol; ++nc) {
       int inc = (nc >= 0) ? nc : -nc;
       double xpos = (nc >= 0) ? (inc - 0.5) * tileStep_[0] : -(inc - 0.5) * tileStep_[0];
       if (nr != 0 && nc != 0) {
         DDTranslation tran(xpos, ypos, 0.0);
         DDRotation rotation;
         int copy = inr * AHCalParameters::kColumn_ + inc;
         if (nc < 0)
           copy += AHCalParameters::kRowColumn_;
         if (nr < 0)
           copy += AHCalParameters::kSignRowColumn_;
         DDName name = DDName(DDSplit(tile_).first, DDSplit(tile_).second);
         cpv.position(name, glog.ddname(), copy, tran, rotation);
 #ifdef EDM_ML_DEBUG
         kount++;
         edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << name << " number " << copy << " positioned in "
                                       << glog.ddname() << " at " << tran << " with " << rotation;
 #endif
       }
     }
   }
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom") << "DDAHcalModuleAlgo: " << kount << " tiles for " << glog.ddname();
 #endif
 }