#include <HGCalWaferType.h>

Public Member Functions
int	getType (double xpos, double ypos, double zpos)

	HGCalWaferType (const std::vector< double > &rad100, const std::vector< double > &rad200, double waferSize, double zMin, int choice, unsigned int cutValue, double cutFracArea)

std::pair< double, double >	rLimits (double zpos)

	~HGCalWaferType ()

Private Member Functions
double	areaPolygon (std::vector< double > const &, std::vector< double > const &)

std::pair< double, double >	intersection (int, int, std::vector< double > const &, std::vector< double > const &, double xp, double yp, double rr)

Private Attributes
const int	choice_

const double	cutFracArea_

const unsigned int	cutValue_

double	r_

double	R_

const std::vector< double >	rad100_

const std::vector< double >	rad200_

const double	sqrt3_ = 1.0 / std::sqrt(3.0)

const double	waferSize_

const double	zMin_

Detailed Description

this class determines the wafer type depending on its position (taken from Philippe Bloch's parametrisation) rad100, rad200 parameters assume r,z to be in cm xpos, ypos, zpos, zmin, waferSize are all in mm

Date: 2018/03/22 00:06:50

Author: Sunanda Banerjee, Fermilab sunan.nosp@m.da.b.nosp@m.anerj.nosp@m.ee@c.nosp@m.ern.c.nosp@m.h

Definition at line 19 of file HGCalWaferType.h.

Constructor & Destructor Documentation

HGCalWaferType::HGCalWaferType	(	const std::vector< double > &	rad100,
		const std::vector< double > &	rad200,
		double	waferSize,
		double	zMin,
		int	choice,
		unsigned int	cutValue,
		double	cutFracArea
	)

Definition at line 7 of file HGCalWaferType.cc.

References choice_, cutFracArea_, cutValue_, gen::k, r_, R_, rad100_, rad200_, sqrt3_, waferSize_, and zMin_.

     : rad100_(rad100),
       rad200_(rad200),
       waferSize_(waferSize),
       zMin_(zMin),
       choice_(choice),
       cutValue_(cornerCut),
       cutFracArea_(cutArea) {
   r_ = 0.5 * waferSize_;
   R_ = sqrt3_ * waferSize_;
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom")
       << "HGCalWaferType: initialized with waferR's " << waferSize_ << ":" 
       << r_ << ":" << R_ << " Choice " << choice_ << " Cuts " << cutValue_ 
       << ":" << cutFracArea_ << " zMin " << zMin_ << " with " << rad100_.size()
       << ":" << rad200_.size() << " parameters for R:";
   for (unsigned k = 0; k < rad100_.size(); ++k)
     edm::LogVerbatim("HGCalGeom")
         << "[" << k << "] 100:200 " << rad100_[k] << " 200:300 " << rad200_[k];
 #endif
 }

HGCalWaferType::~HGCalWaferType ( )

Definition at line 32 of file HGCalWaferType.cc.

32 {}

Member Function Documentation

double HGCalWaferType::areaPolygon	(	std::vector< double > const &	x,
		std::vector< double > const &	y
	)

private

Definition at line 126 of file HGCalWaferType.cc.

References custom_jme_cff::area, mps_fire::i, and gen::n.

Referenced by getType().

                                                                {
   double area = 0.0;
   int n = x.size();
   int j = n - 1;
   for (int i = 0; i < n; ++i) {
     area += ((x[j] + x[i]) * (y[i] - y[j]));
     j = i;
   }
   return (0.5 * area);
 }

int HGCalWaferType::getType	(	double	xpos,
		double	ypos,
		double	zpos
	)

Definition at line 34 of file HGCalWaferType.cc.

References areaPolygon(), choice_, cutFracArea_, cutValue_, spr::find(), intersection(), gen::k, HGCalParameters::k_CornerSize, convertSQLiteXML::ok, r_, R_, rLimits(), findQualityFiles::rr, mathSSE::sqrt(), and geometryCSVtoXML::xy.

                                                                  {
   std::vector<double> xc(HGCalParameters::k_CornerSize, 0);
   std::vector<double> yc(HGCalParameters::k_CornerSize, 0);
   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_;
   std::pair<double, double> rv = rLimits(zpos);
   std::vector<int> fine, coarse;
   for (unsigned int k = 0; k < HGCalParameters::k_CornerSize; ++k) {
     double rpos = std::sqrt(xc[k] * xc[k] + yc[k] * yc[k]);
     if (rpos <= rv.first)
       fine.emplace_back(k);
     else if (rpos <= rv.second)
       coarse.emplace_back(k);
   }
   int type(-2);
   double fracArea(0);
   if (choice_ == 1) {
     if (fine.size() >= cutValue_)
       type = 0;
     else if (coarse.size() >= cutValue_)
       type = 1;
     else
       type = 2;
   } else {
     if (fine.size() >= 4)
       type = 0;
     else if (coarse.size() >= 4 && fine.size() <= 1)
       type = 1;
     else if (coarse.size() < 2 && fine.empty())
       type = 2;
     else if (!fine.empty())
       type = -1;
     if (type < 0) {
       unsigned int kmax = (type == -1) ? fine.size() : coarse.size();
       std::vector<double> xcn, ycn;
       for (unsigned int k = 0; k < kmax; ++k) {
         unsigned int k1 = (type == -1) ? fine[k] : coarse[k];
         unsigned int k2 = (k1 == xc.size() - 1) ? 0 : k1 + 1;
         bool ok = ((type == -1)
                        ? (std::find(fine.begin(), fine.end(), k2) != fine.end())
                        : (std::find(coarse.begin(), coarse.end(), k2) !=
                           coarse.end()));
         xcn.emplace_back(xc[k1]);
         ycn.emplace_back(yc[k1]);
         if (!ok) {
           double rr = (type == -1) ? rv.first : rv.second;
           std::pair<double, double> xy =
               intersection(k1, k2, xc, yc, xpos, ypos, rr);
           xcn.emplace_back(xy.first);
           ycn.emplace_back(xy.second);
         }
       }
       fracArea = areaPolygon(xcn, ycn) / areaPolygon(xc, yc);
       type = (fracArea > cutFracArea_) ? -(1 + type) : -type;
     }
   }
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HGCalGeom")
       << "HGCalWaferType: position " << xpos << ":" << ypos << ":" << zpos
       << " R "
       << ":" << rv.first << ":" << rv.second << " corners|type " << fine.size()
       << ":" << coarse.size() << ":" << fracArea << ":" << type;
 #endif
   return type;
 }

std::pair< double, double > HGCalWaferType::intersection	(	int	k1,
		int	k2,
		std::vector< double > const &	x,
		std::vector< double > const &	y,
		double	xp,
		double	yp,
		double	rr
	)

private

Definition at line 138 of file HGCalWaferType.cc.

References mps_fire::i, slope, mathSSE::sqrt(), geometryCSVtoXML::xx, and geometryCSVtoXML::yy.

Referenced by getType().

                                          {
   double slope = (x[k1] - x[k2]) / (y[k1] - y[k2]);
   double interc = x[k1] - slope * y[k1];
   double xx[2], yy[2], dist[2];
   double v1 = std::sqrt((slope * slope + 1) * rr * rr - (interc * interc));
   yy[0] = (-slope * interc + v1) / (1 + slope * slope);
   yy[1] = (-slope * interc - v1) / (1 + slope * slope);
   for (int i = 0; i < 2; ++i) {
     xx[i] = (slope * yy[i] + interc);
     dist[i] =
         ((xx[i] - xpos) * (xx[i] - xpos)) + ((yy[i] - ypos) * (yy[i] - ypos));
   }
   if (dist[0] > dist[1])
     return std::pair<double, double>(xx[1], yy[1]);
   else
     return std::pair<double, double>(xx[0], yy[0]);
 }

std::pair< double, double > HGCalWaferType::rLimits ( double zpos )

Definition at line 110 of file HGCalWaferType.cc.

References funct::abs(), mps_fire::i, HGCalParameters::k_ScaleFromDDD, HGCalParameters::k_ScaleToDDD, rad100_, rad200_, zMin_, and geometryCSVtoXML::zz.

Referenced by getType().

                                                            {
   double zz = std::abs(zpos);
   if (zz < zMin_) zz = zMin_;
   zz *= HGCalParameters::k_ScaleFromDDD;
   double rfine = rad100_[0];
   double rcoarse = rad200_[0];
   for (int i = 1; i < 5; ++i) {
     rfine *= zz;
     rfine += rad100_[i];
     rcoarse *= zz;
     rcoarse += rad200_[i];
   }
   return std::pair<double, double>(rfine * HGCalParameters::k_ScaleToDDD,
                                    rcoarse * HGCalParameters::k_ScaleToDDD);
 }