#include <CaloCellCrossing.h>

Public Types
typedef std::vector< DetId >	DetIds

typedef std::vector< double >	Lengths

typedef std::vector< GlobalPoint >	Points

Public Member Functions
	CaloCellCrossing (const GlobalPoint &gp, const GlobalVector &gv, const DetIds di, const CaloSubdetectorGeometry sg, DetId::Detector det, int subdet, double small=1.e-10, bool onewayonly=false)

	CaloCellCrossing (const CaloCellCrossing &)=delete

const Points &	centers () const

const DetIds &	detIds () const

const Points &	entrances () const

const Points &	exits () const

const GlobalPoint &	gp () const

const GlobalVector &	gv () const

const Lengths &	lengths () const

CaloCellCrossing	operator= (const CaloCellCrossing &)=delete

virtual	~CaloCellCrossing ()

Private Attributes
Points	m_ctr

DetIds	m_detId

Points	m_entr

Points	m_exit

GlobalPoint	m_gp

GlobalVector	m_gv

Lengths	m_len

Detailed Description

Definition at line 12 of file CaloCellCrossing.h.

Member Typedef Documentation

◆ DetIds

typedef std::vector<DetId> CaloCellCrossing::DetIds

Definition at line 14 of file CaloCellCrossing.h.

◆ Lengths

typedef std::vector<double> CaloCellCrossing::Lengths

Definition at line 16 of file CaloCellCrossing.h.

◆ Points

typedef std::vector<GlobalPoint> CaloCellCrossing::Points

Definition at line 15 of file CaloCellCrossing.h.

Constructor & Destructor Documentation

◆ CaloCellCrossing() [1/2]

CaloCellCrossing::CaloCellCrossing	(	const GlobalPoint &	gp,
		const GlobalVector &	gv,
		const DetIds *	di,
		const CaloSubdetectorGeometry *	sg,
		DetId::Detector	det,
		int	subdet,
		double	small = `1.e-10`,
		bool	onewayonly = `false`
	)

Definition at line 5 of file CaloCellCrossing.cc.

References cms::cuda::assert(), dqmiodatasetharvest::ctr, cuy::cv, dot(), MillePedeFileConverter_cfg::e, HLT_2023v11_cff::eps, newFWLiteAna::found, CaloSubdetectorGeometry::getGeometry(), CaloSubdetectorGeometry::getValidDetIds(), gp(), gv(), mps_fire::i, mps_splice::line, LogDebug, m_ctr, m_detId, m_entr, m_exit, m_len, mag(), mag2(), HepLine3D::point(), DiDispStaMuonMonitor_cfi::pt, mathSSE::sqrt(), x, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

     : m_gp(gp), m_gv(gv) {
   const double eps(fabs(small) > 1.e-15 ? fabs(small) : 1.e-10);
   static unsigned int k_rlen(30);
   m_detId.reserve(k_rlen);
   m_ctr.reserve(k_rlen);
   m_entr.reserve(k_rlen);
   m_exit.reserve(k_rlen);
   //------------------------------------------------------------
   const HepLine3D line(
       HepGeom::Point3D<double>(gp.x(), gp.y(), gp.z()), HepGeom::Vector3D<double>(gv.x(), gv.y(), gv.z()), eps);
 
   LogDebug("CaloCellCrossing") << "*** Line: pt=" << line.pt() << ", unitvec=" << line.uv();
 
   const DetIds& ids(nullptr == di ? sg->getValidDetIds(det, subdet) : *di);
   //------------------------------------------------------------
   for (auto dId : ids) {
     unsigned int found(0);
     auto cg = sg->getGeometry(dId);
     const CaloCellGeometry::CornersVec& gc(cg->getCorners());
     const HepGeom::Point3D<double> fr(cg->getPosition().x(), cg->getPosition().y(), cg->getPosition().z());
     const double bCut2((gc[0] - gc[6]).mag2());
 
     if ((!onewayonly || eps < HepGeom::Vector3D<double>(fr - line.pt()).dot(line.uv())) &&
         bCut2 > line.dist2(fr))  // first loose cut
     {
       LogDebug("CaloCellCrossing") << "*** fr=" << fr << ", bCut =" << sqrt(bCut2) << ", dis=" << line.dist(fr);
       const HepGeom::Point3D<double> cv[8] = {HepGeom::Point3D<double>(gc[0].x(), gc[0].y(), gc[0].z()),
                                               HepGeom::Point3D<double>(gc[1].x(), gc[1].y(), gc[1].z()),
                                               HepGeom::Point3D<double>(gc[2].x(), gc[2].y(), gc[2].z()),
                                               HepGeom::Point3D<double>(gc[3].x(), gc[3].y(), gc[3].z()),
                                               HepGeom::Point3D<double>(gc[4].x(), gc[4].y(), gc[4].z()),
                                               HepGeom::Point3D<double>(gc[5].x(), gc[5].y(), gc[5].z()),
                                               HepGeom::Point3D<double>(gc[6].x(), gc[6].y(), gc[6].z()),
                                               HepGeom::Point3D<double>(gc[7].x(), gc[7].y(), gc[7].z())};
       const HepGeom::Point3D<double> ctr(0.125 * (cv[0] + cv[1] + cv[2] + cv[3] + cv[4] + cv[5] + cv[6] + cv[7]));
       const double dCut2(bCut2 / 4.);
       if (dCut2 > line.dist2(ctr))  // tighter cut
       {
         LogDebug("CaloCellCrossing") << "** 2nd cut: ctr=" << ctr << ", dist=" << line.dist(ctr);
         static const unsigned int nc[6][4] = {
             {0, 1, 2, 3}, {0, 4, 5, 1}, {0, 4, 7, 3}, {6, 7, 4, 5}, {6, 2, 3, 7}, {6, 2, 1, 5}};
         for (unsigned int face(0); face != 6; ++face) {
           const unsigned int* ic(&nc[face][0]);
           const HepGeom::Plane3D<double> pl(cv[ic[0]], cv[ic[1]], cv[ic[2]]);
           bool parallel;
           const HepGeom::Point3D<double> pt(line.point(pl, parallel));
           LogDebug("CaloCellCrossing") << "***Face: " << face << ", pt=" << pt;
           if (!parallel) {
             LogDebug("CaloCellCrossing") << "Not parallel";
             const HepLine3D la(cv[ic[0]], cv[ic[1]], eps);
             const HepLine3D lb(cv[ic[2]], cv[ic[3]], eps);
             LogDebug("CaloCellCrossing") << "la.point=" << la.point(pt);
 
             //        const double dot (  ( la.point( pt ) - pt ).dot( ( lb.point( pt ) - pt ) ) ) ;
             //        LogDebug("CaloCellCrossing")<<"***Dot1="<<dot;
             if (eps > (la.point(pt) - pt).dot((lb.point(pt) - pt))) {
               const HepLine3D lc(cv[ic[0]], cv[ic[3]], eps);
               const HepLine3D ld(cv[ic[1]], cv[ic[2]], eps);
               //             const double dot (  ( lc.point( pt ) - pt ).dot( ( ld.point( pt ) - pt ) ) ) ;
               //             LogDebug("CaloCellCrossing")<<"***Dot2="<<dot;
               if (eps > (lc.point(pt) - pt).dot((ld.point(pt) - pt))) {
                 if (0 == found) {
                   ++found;
                   m_detId.emplace_back(dId);
                   m_ctr.emplace_back(GlobalPoint(ctr.x(), ctr.y(), ctr.z()));
                   m_entr.emplace_back(GlobalPoint(pt.x(), pt.y(), pt.z()));
                 } else {
                   if (1 == found) {
                     ++found;
                     m_exit.emplace_back(GlobalPoint(pt.x(), pt.y(), pt.z()));
                   } else {
                     const double dist1(
                         (pt - HepGeom::Point3D<double>(m_entr.back().x(), m_entr.back().y(), m_entr.back().z())).mag());
                     const double dist2(
                         (pt - HepGeom::Point3D<double>(m_exit.back().x(), m_exit.back().y(), m_exit.back().z())).mag());
                     if (eps < dist1 && eps < dist2) {
                       edm::LogWarning("CaloCellCrossing")
                           << "********For DetId = " << dId << " distances too big: " << dist1 << ", " << dist2;
                     }
                   }
                 }
               }
             }
           }
         }
       }
     }
     assert(2 >= found);
     if (1 == found)
       m_exit.emplace_back(m_entr.back());
   }
   //------------------------------------------------------------
   assert(m_detId.size() == m_entr.size() && m_detId.size() == m_ctr.size() && m_detId.size() == m_exit.size());
 
   m_len.reserve(m_entr.size());
   for (unsigned int i(0); i != m_entr.size(); ++i) {
     m_len.emplace_back((m_exit[i] - m_entr[i]).mag());
   }
 }