TransformData Class Reference

Transformation data. More...

#include <TransformData.h>

Inheritance diagram for TransformData:

Public Types
enum	Displacement {   c_None ,   c_Displacement ,   c_Alignment }
	Source of displacement (alignment) data. More...

Public Member Functions
	TransformData (bool global, Displacement displacementType)
	Constructor.
	TransformData (const TransformData &)=delete
	Copy constructor (disabled).
TransformData &	operator= (const TransformData &)=delete
	Operator = (disabled).
	~TransformData ()
	Destructor.
const HepGeom::Transform3D *	getSectionTransform (int section) const
	Get section transformation.
const HepGeom::Transform3D *	getLayerTransform (int section, int layer) const
	Get layer transformation.
const HepGeom::Transform3D *	getSectorTransform (int section, int layer, int sector) const
	Get sector transformation.
const HepGeom::Transform3D *	getPlaneTransform (int section, int layer, int sector, int plane) const
	Get plane transformation.
const HepGeom::Transform3D *	getPlaneDisplacement (int section, int layer, int sector, int plane) const
	Get additional displacement for plane internal volumes.
const HepGeom::Transform3D *	getSegmentTransform (int section, int layer, int sector, int plane, int segment) const
	Get segment transformation.
const HepGeom::Transform3D *	getStripLocalToGlobal (KLMDigit *hit) const
	Get strip local to global transformation by hit.
const HepGeom::Transform3D *	getStripGlobalToLocal (KLMDigit *hit) const
	Get strip global to local transformation by hit.
const HepGeom::Transform3D *	getStripTransform (int section, int layer, int sector, int plane, int strip) const
	Get strip transformation.
const HepGeom::Transform3D *	getStripGlobalToLocal (int section, int layer, int sector, int plane, int strip) const
	Get strip global to local transformation by hit.
bool	intersection (KLMDigit *hit1, KLMDigit *hit2, HepGeom::Point3D< double > *cross, double *d1, double *d2, double *sd, bool segments=true) const
	Check if strips intersect, and find intersection point if yes.
int	getSectorByPosition (int section, const HepGeom::Point3D< double > &position) const
	Get sector by position.
int	getStripsByIntersection (const HepGeom::Point3D< double > &intersection, int *strip1, int *strip2) const
	Find strips by intersection.

Private Member Functions
void	transformsToGlobal ()
	Make transformations global from local.

Private Attributes
const EKLMElementNumbers *	m_ElementNumbers
	Element numbers.
const GeometryData *	m_GeoDat
	Geometry data.
HepGeom::Transform3D *	m_Section
	Section transformations.
HepGeom::Transform3D **	m_Layer
	Layer transformations.
HepGeom::Transform3D ***	m_Sector
	Sector transformations.
HepGeom::Transform3D ****	m_Plane
	Plane transformations.
HepGeom::Transform3D ****	m_PlaneDisplacement
	Plane internal volumes displacements.
HepGeom::Transform3D *****	m_Segment
	Segment transformations.
HepGeom::Transform3D *****	m_Strip
	Strip transformations.
HepGeom::Transform3D *****	m_StripInverse
	Inverse strip transformations.

Detailed Description

Transformation data.

All data and function results are in CLHEP units unless noted otherwise.

Definition at line 35 of file TransformData.h.

Member Enumeration Documentation

Displacement

enum Displacement

Source of displacement (alignment) data.

Enumerator
c_None	Displacement is not used.
c_Displacement	Use displacement data (for geometry).
c_Alignment	Use alignment data (for everything else).

Definition at line 42 of file TransformData.h.

                        {
        c_None,         
        c_Displacement, 
        c_Alignment,    
      };

Constructor & Destructor Documentation

TransformData()

TransformData	(	bool	global,
		Displacement	displacementType
	)

Constructor.

Parameters

[in]	global	If true, load global transformations (false - local).
[in]	displacementType	Displacement type.

Definition at line 25 of file TransformData.cc.

{
  /* cppcheck-suppress variableScope */
  int iSection, iLayer, iSector, iPlane, iSegment, iStrip, sector, segment;
  int nSections, nLayers, nSectors, nPlanes, nStrips, nSegments, nStripsSegment;
  int nDetectorLayers;
  AlignmentChecker alignmentChecker(true);
  m_ElementNumbers = &(EKLMElementNumbers::Instance());
  m_GeoDat = &(GeometryData::Instance());
  nSections = m_GeoDat->getNSections();
  nSectors = m_GeoDat->getNSectors();
  nLayers = m_GeoDat->getNLayers();
  nPlanes = m_GeoDat->getNPlanes();
  nStrips = m_GeoDat->getNStrips();
  nSegments = m_GeoDat->getNSegments();
  nStripsSegment = m_ElementNumbers->getNStripsSegment();
  m_Section = new HepGeom::Transform3D[nSections];
  m_Layer = new HepGeom::Transform3D*[nSections];
  m_Sector = new HepGeom::Transform3D** [nSections];
  m_Plane = new HepGeom::Transform3D** *[nSections];
  m_PlaneDisplacement = new HepGeom::Transform3D** *[nSections];
  m_Segment = new HepGeom::Transform3D**** [nSections];
  m_Strip = new HepGeom::Transform3D**** [nSections];
  m_StripInverse = new HepGeom::Transform3D**** [nSections];
  for (iSection = 0; iSection < nSections; iSection++) {
    m_GeoDat->getSectionTransform(&m_Section[iSection], iSection);
    nDetectorLayers = m_GeoDat->getNDetectorLayers(iSection + 1);
    m_Layer[iSection] = new HepGeom::Transform3D[nLayers];
    m_Sector[iSection] = new HepGeom::Transform3D*[nLayers];
    m_Plane[iSection] = new HepGeom::Transform3D** [nLayers];
    m_PlaneDisplacement[iSection] = new HepGeom::Transform3D** [nLayers];
    m_Segment[iSection] = new HepGeom::Transform3D** *[nLayers];
    m_Strip[iSection] = new HepGeom::Transform3D** *[nLayers];
    m_StripInverse[iSection] = new HepGeom::Transform3D** *[nLayers];
    for (iLayer = 0; iLayer < nLayers; iLayer++) {
      m_GeoDat->getLayerTransform(&m_Layer[iSection][iLayer], iLayer);
      m_Sector[iSection][iLayer] = new HepGeom::Transform3D[nSectors];
      if (iLayer < nDetectorLayers) {
        m_Plane[iSection][iLayer] = new HepGeom::Transform3D*[nSectors];
        m_PlaneDisplacement[iSection][iLayer] =
          new HepGeom::Transform3D*[nSectors];
        m_Segment[iSection][iLayer] = new HepGeom::Transform3D** [nSectors];
        m_Strip[iSection][iLayer] = new HepGeom::Transform3D** [nSectors];
        m_StripInverse[iSection][iLayer] = new HepGeom::Transform3D** [nSectors];
      }
      for (iSector = 0; iSector < nSectors; iSector++) {
        m_GeoDat->getSectorTransform(&m_Sector[iSection][iLayer][iSector],
                                     iSector);
        if (iLayer >= nDetectorLayers)
          continue;
        m_Plane[iSection][iLayer][iSector] = new HepGeom::Transform3D[nPlanes];
        m_PlaneDisplacement[iSection][iLayer][iSector] =
          new HepGeom::Transform3D[nPlanes];
        m_Segment[iSection][iLayer][iSector] =
          new HepGeom::Transform3D*[nPlanes];
        m_Strip[iSection][iLayer][iSector] = new HepGeom::Transform3D*[nPlanes];
        m_StripInverse[iSection][iLayer][iSector] =
          new HepGeom::Transform3D*[nPlanes];
        for (iPlane = 0; iPlane < nPlanes; iPlane++) {
          m_GeoDat->getPlaneTransform(
            &m_Plane[iSection][iLayer][iSector][iPlane], iPlane);
          m_PlaneDisplacement[iSection][iLayer][iSector][iPlane] =
            HepGeom::Translate3D(0, 0, 0);
          m_Segment[iSection][iLayer][iSector][iPlane] =
            new HepGeom::Transform3D[nSegments];
          for (iSegment = 0; iSegment < nSegments; iSegment++) {
            m_Segment[iSection][iLayer][iSector][iPlane][iSegment] =
              HepGeom::Translate3D(0, 0, 0);
          }
          m_Strip[iSection][iLayer][iSector][iPlane] =
            new HepGeom::Transform3D[nStrips];
          m_StripInverse[iSection][iLayer][iSector][iPlane] =
            new HepGeom::Transform3D[nStrips];
          for (iStrip = 0; iStrip < nStrips; iStrip++) {
            m_GeoDat->getStripTransform(
              &m_Strip[iSection][iLayer][iSector][iPlane][iStrip], iStrip);
          }
        }
      }
    }
  }
  /* Read alignment data from the database and modify transformations. */
  if (displacementType != c_None) {
    std::string payload, segmentPayload;
    if (displacementType == c_Displacement) {
      payload = "EKLMDisplacement";
      segmentPayload = "EKLMSegmentDisplacement";
    } else {
      payload = "EKLMAlignment";
      segmentPayload = "EKLMSegmentAlignment";
    }
    DBObjPtr<EKLMAlignment> alignment(payload);
    DBObjPtr<EKLMSegmentAlignment> segmentAlignment(segmentPayload);
    if (!alignment.isValid())
      B2FATAL("No EKLM displacement (alignment) data.");
    if (displacementType == c_Displacement) {
      if (!alignmentChecker.checkAlignment(&(*alignment), &(*segmentAlignment)))
        B2FATAL("EKLM displacement data are incorrect, overlaps exist.");
    }
    for (iSection = 1; iSection <= nSections; iSection++) {
      nDetectorLayers = m_GeoDat->getNDetectorLayers(iSection);
      for (iLayer = 1; iLayer <= nDetectorLayers; iLayer++) {
        for (iSector = 1; iSector <= nSectors; iSector++) {
          sector = m_ElementNumbers->sectorNumber(iSection, iLayer, iSector);
          const KLMAlignmentData* sectorAlignment =
            alignment->getModuleAlignment(sector);
          if (sectorAlignment == nullptr)
            B2FATAL("Incomplete EKLM displacement (alignment) data.");
          for (iPlane = 1; iPlane <= nPlanes; iPlane++) {
            /* First plane is rotated. */
            if (iPlane == 1) {
              m_PlaneDisplacement[iSection - 1][iLayer - 1][iSector - 1][iPlane - 1] =
                HepGeom::Translate3D(
                  sectorAlignment->getDeltaV() * CLHEP::cm / Unit::cm,
                  sectorAlignment->getDeltaU() * CLHEP::cm / Unit::cm, 0) *
                HepGeom::RotateZ3D(-sectorAlignment->getDeltaGamma() *
                                   CLHEP::rad / Unit::rad);
            } else {
              m_PlaneDisplacement[iSection - 1][iLayer - 1][iSector - 1][iPlane - 1] =
                HepGeom::Translate3D(
                  sectorAlignment->getDeltaU() * CLHEP::cm / Unit::cm,
                  sectorAlignment->getDeltaV() * CLHEP::cm / Unit::cm, 0) *
                HepGeom::RotateZ3D(sectorAlignment->getDeltaGamma() *
                                   CLHEP::rad / Unit::rad);
            }
            for (iSegment = 1; iSegment <= nSegments; iSegment++) {
              segment = m_ElementNumbers->segmentNumber(
                          iSection, iLayer, iSector, iPlane, iSegment);
              const KLMAlignmentData* segmentAlignmentData =
                segmentAlignment->getSegmentAlignment(segment);
              if (segmentAlignmentData == nullptr)
                B2FATAL("Incomplete EKLM displacement (alignment) data.");
              m_Segment[iSection - 1][iLayer - 1][iSector - 1][iPlane - 1]
              [iSegment - 1] =
                HepGeom::Translate3D(
                  segmentAlignmentData->getDeltaU() * CLHEP::cm / Unit::cm,
                  segmentAlignmentData->getDeltaV() * CLHEP::cm / Unit::cm, 0) *
                m_Segment[iSection - 1][iLayer - 1][iSector - 1][iPlane - 1]
                [iSegment - 1] *
                HepGeom::RotateZ3D(segmentAlignmentData->getDeltaGamma() *
                                   CLHEP::rad / Unit::rad);
              for (iStrip = 1; iStrip <= nStripsSegment; iStrip++) {
                m_Strip[iSection - 1][iLayer - 1][iSector - 1][iPlane - 1]
                [nStripsSegment * (iSegment - 1) + iStrip - 1] =
                  HepGeom::Translate3D(
                    segmentAlignmentData->getDeltaU() * CLHEP::cm / Unit::cm,
                    segmentAlignmentData->getDeltaV() * CLHEP::cm / Unit::cm,
                    0) *
                  m_Strip[iSection - 1][iLayer - 1][iSector - 1][iPlane - 1]
                  [nStripsSegment * (iSegment - 1) + iStrip - 1] *
                  HepGeom::RotateZ3D(segmentAlignmentData->getDeltaGamma() *
                                     CLHEP::rad / Unit::rad);
              }
            }
          }
        }
      }
    }
  }
  if (global)
    transformsToGlobal();
}

~TransformData()

~TransformData

(

)

Destructor.

Definition at line 188 of file TransformData.cc.

{
  int iSection, iLayer, iSector, iPlane;
  /* cppcheck-suppress variableScope */
  int nSections, nLayers, nDetectorLayers, nSectors, nPlanes;
  nSections = m_GeoDat->getNSections();
  nLayers = m_GeoDat->getNLayers();
  nSectors = m_GeoDat->getNSectors();
  nPlanes = m_GeoDat->getNPlanes();
  for (iSection = 0; iSection < nSections; iSection++) {
    nDetectorLayers = m_GeoDat->getNDetectorLayers(iSection + 1);
    for (iLayer = 0; iLayer < nLayers; iLayer++) {
      delete[] m_Sector[iSection][iLayer];
      if (iLayer >= nDetectorLayers)
        continue;
      for (iSector = 0; iSector < nSectors; iSector++) {
        for (iPlane = 0; iPlane < nPlanes; iPlane++) {
          delete[] m_Segment[iSection][iLayer][iSector][iPlane];
          delete[] m_Strip[iSection][iLayer][iSector][iPlane];
          delete[] m_StripInverse[iSection][iLayer][iSector][iPlane];
        }
        delete[] m_Plane[iSection][iLayer][iSector];
        delete[] m_PlaneDisplacement[iSection][iLayer][iSector];
        delete[] m_Segment[iSection][iLayer][iSector];
        delete[] m_Strip[iSection][iLayer][iSector];
        delete[] m_StripInverse[iSection][iLayer][iSector];
      }
      delete[] m_Plane[iSection][iLayer];
      delete[] m_PlaneDisplacement[iSection][iLayer];
      delete[] m_Segment[iSection][iLayer];
      delete[] m_Strip[iSection][iLayer];
      delete[] m_StripInverse[iSection][iLayer];
    }
    delete[] m_Layer[iSection];
    delete[] m_Sector[iSection];
    delete[] m_PlaneDisplacement[iSection];
    delete[] m_Plane[iSection];
    delete[] m_Segment[iSection];
    delete[] m_Strip[iSection];
    delete[] m_StripInverse[iSection];
  }
  delete[] m_Section;
  delete[] m_Layer;
  delete[] m_Sector;
  delete[] m_PlaneDisplacement;
  delete[] m_Plane;
  delete[] m_Segment;
  delete[] m_Strip;
  delete[] m_StripInverse;
}

Member Function Documentation

getLayerTransform()

const HepGeom::Transform3D * getLayerTransform	(	int	section,
		int	layer
	)		const

Get layer transformation.

Parameters

[in]	section	Section number.
[in]	layer	Layer number.

Definition at line 290 of file TransformData.cc.

{
  return &m_Layer[section - 1][layer - 1];
}

getPlaneDisplacement()

const HepGeom::Transform3D * getPlaneDisplacement	(	int	section,
		int	layer,
		int	sector,
		int	plane
	)		const

Get additional displacement for plane internal volumes.

Parameters

[in]	section	Section number.
[in]	layer	Layer number.
[in]	sector	Sector number.
[in]	plane	Plane number.

Definition at line 307 of file TransformData.cc.

{
  return &m_PlaneDisplacement[section - 1][layer - 1][sector - 1][plane - 1];
}

getPlaneTransform()

const HepGeom::Transform3D * getPlaneTransform	(	int	section,
		int	layer,
		int	sector,
		int	plane
	)		const

Get plane transformation.

Parameters

[in]	section	Section number.
[in]	layer	Layer number.
[in]	sector	Sector number.
[in]	plane	Plane number.

Definition at line 301 of file TransformData.cc.

{
  return &m_Plane[section - 1][layer - 1][sector - 1][plane - 1];
}

getSectionTransform()

const HepGeom::Transform3D * getSectionTransform

(

int

section

)

const

Get section transformation.

Parameters

[in]

section

Section number.

Definition at line 284 of file TransformData.cc.

{
  return &m_Section[section - 1];
}

getSectorByPosition()

int getSectorByPosition	(	int	section,
		const HepGeom::Point3D< double > &	position
	)		const

Get sector by position.

Parameters

[in]	section	Section number.
[in]	position	Position.

Definition at line 416 of file TransformData.cc.

{
  int sector;
  double x;
  if (section == 1) {
    x = position.x();
  } else {
    x = -position.x();
  }
  if (position.y() > 0) {
    if (x > 0)
      sector = 1;
    else
      sector = 2;
  } else {
    if (x > 0)
      sector = 4;
    else
      sector = 3;
  }
  return sector;
}

getSectorTransform()

const HepGeom::Transform3D * getSectorTransform	(	int	section,
		int	layer,
		int	sector
	)		const

Get sector transformation.

Parameters

[in]	section	Section number.
[in]	layer	Layer number.
[in]	sector	Sector number.

Definition at line 295 of file TransformData.cc.

{
  return &m_Sector[section - 1][layer - 1][sector - 1];
}

getSegmentTransform()

const HepGeom::Transform3D * getSegmentTransform	(	int	section,
		int	layer,
		int	sector,
		int	plane,
		int	segment
	)		const

Get segment transformation.

Parameters

[in]	section	Section number.
[in]	layer	Layer number.
[in]	sector	Sector number.
[in]	plane	Plane number.
[in]	segment	Segment number.

Definition at line 313 of file TransformData.cc.

{
  return &m_Segment[section - 1][layer - 1][sector - 1][plane - 1][segment - 1];
}

getStripGlobalToLocal() [1/2]

const HepGeom::Transform3D * getStripGlobalToLocal	(	int	section,
		int	layer,
		int	sector,
		int	plane,
		int	strip
	)		const

Get strip global to local transformation by hit.

Parameters

[in]	section	Section number.
[in]	layer	Layer number.
[in]	sector	Sector number.
[in]	plane	Plane number.
[in]	strip	Strip number.

Returns

Transformation.

Definition at line 341 of file TransformData.cc.

{
  return &(m_StripInverse[section - 1][layer - 1][sector - 1][plane - 1]
           [strip - 1]);
}

getStripGlobalToLocal() [2/2]

const HepGeom::Transform3D * getStripGlobalToLocal

(

KLMDigit *

hit

)

const

Get strip global to local transformation by hit.

Parameters

[in]

hit

Hit.

Returns

Transformation.

Definition at line 334 of file TransformData.cc.

{
  return &(m_StripInverse[hit->getSection() - 1][hit->getLayer() - 1]
           [hit->getSector() - 1][hit->getPlane() - 1][hit->getStrip() - 1]);
}

getStripLocalToGlobal()

const HepGeom::Transform3D * getStripLocalToGlobal

(

KLMDigit *

hit

)

const

Get strip local to global transformation by hit.

Parameters

[in]

hit

Hit.

Returns

Transformation.

Definition at line 327 of file TransformData.cc.

{
  return &(m_Strip[hit->getSection() - 1][hit->getLayer() - 1]
           [hit->getSector() - 1][hit->getPlane() - 1][hit->getStrip() - 1]);
}

getStripsByIntersection()

int getStripsByIntersection	(	const HepGeom::Point3D< double > &	intersection,
		int *	strip1,
		int *	strip2
	)		const

Find strips by intersection.

Parameters

[in]	intersection	Intersection point.
[out]	strip1	Strip 1 global number.
[out]	strip2	Strip 2 global number.

Returns

0 on success, -1 on error.

Definition at line 440 of file TransformData.cc.

{
  /* cppcheck-suppress variableScope */
  int section, layer, sector, plane, segment, strip, stripSegment, stripGlobal;
  /* cppcheck-suppress variableScope */
  int nLayers, nPlanes, nSegments, nStripsSegment, minDistanceSegment;
  double solenoidCenter, firstLayerCenter, layerShift;
  /* cppcheck-suppress variableScope */
  double x, y, z, l, minY, maxY;
  double minDistance = 0, minDistanceNew, stripWidth;
  HepGeom::Point3D<double> intersectionClhep, intersectionLocal;
  intersectionClhep = intersection * CLHEP::cm / Unit::cm;
  solenoidCenter = m_GeoDat->getSolenoidZ() / CLHEP::cm * Unit::cm;
  if (intersection.z() < solenoidCenter)
    section = 1;
  else
    section = 2;
  firstLayerCenter =
    (m_GeoDat->getSectionPosition()->getZ()
     - 0.5 * m_GeoDat->getSectionPosition()->getLength()
     + m_GeoDat->getLayerShiftZ()
     - 0.5 * m_GeoDat->getLayerPosition()->getLength()) /
    CLHEP::cm * Unit::cm;
  layerShift = m_GeoDat->getLayerShiftZ() / CLHEP::cm * Unit::cm;
  z = fabs(intersection.z() - solenoidCenter);
  layer = round((z - firstLayerCenter) / layerShift) + 1;
  if (layer <= 0)
    layer = 1;
  nLayers = m_GeoDat->getNDetectorLayers(section);
  if (layer > nLayers)
    layer = nLayers;
  sector = getSectorByPosition(section, intersection);
  nPlanes = m_GeoDat->getNPlanes();
  nSegments = m_GeoDat->getNSegments();
  nStripsSegment = m_ElementNumbers->getNStripsSegment();
  stripWidth = m_GeoDat->getStripGeometry()->getWidth() / CLHEP::cm * Unit::cm;
  minY = -stripWidth / 2;
  maxY = (double(nStripsSegment) - 0.5) * stripWidth;
  for (plane = 1; plane <= nPlanes; plane++) {
    minDistanceSegment = 1;
    for (segment = 1; segment <= nSegments; segment++) {
      strip = (segment - 1) * nStripsSegment;
      intersectionLocal = m_StripInverse[section - 1][layer - 1]
                          [sector - 1][plane - 1][strip] * intersectionClhep;
      y = intersectionLocal.y() / CLHEP::cm * Unit::cm;
      if (y < minY) {
        minDistanceNew = minY - y;
      } else if (y > maxY) {
        minDistanceNew = y - maxY;
      } else {
        minDistance = 0;
        minDistanceSegment = segment;
        break;
      }
      if (segment == 1) {
        minDistance = minDistanceNew;
      } else if (minDistanceNew < minDistance) {
        minDistance = minDistanceNew;
        minDistanceSegment = segment;
      }
    }
    /*
     * The intersection is required to be strictly within a segment,
     * this condition might be adjusted later.
     */
    if (minDistance > 0)
      return -1;
    strip = (minDistanceSegment - 1) * nStripsSegment;
    intersectionLocal = m_StripInverse[section - 1][layer - 1]
                        [sector - 1][plane - 1][strip] * intersectionClhep;
    y = intersectionLocal.y() / CLHEP::cm * Unit::cm;
    stripSegment = ceil((y - 0.5 * stripWidth) / stripWidth);
    if (stripSegment <= 0)
      stripSegment = 1;
    else if (stripSegment > nStripsSegment)
      stripSegment = nStripsSegment;
    strip = stripSegment + (minDistanceSegment - 1) * nStripsSegment;
    intersectionLocal = m_StripInverse[section - 1][layer - 1]
                        [sector - 1][plane - 1][strip - 1] * intersectionClhep;
    x = intersectionLocal.x();
    l = m_GeoDat->getStripLength(strip);
    /*
     * The intersection is required to be strictly within the strip length,
     * this condition might be adjusted later.
     */
    if (fabs(x) > 0.5 * l)
      return -1;
    stripGlobal = m_ElementNumbers->stripNumber(
                    section, layer, sector, plane, strip);
    if (plane == 1)
      *strip1 = stripGlobal;
    else
      *strip2 = stripGlobal;
  }
  return 0;
}

getStripTransform()

const HepGeom::Transform3D * getStripTransform	(	int	section,
		int	layer,
		int	sector,
		int	plane,
		int	strip
	)		const

Get strip transformation.

Parameters

[in]	section	Section number.
[in]	layer	Layer number.
[in]	sector	Sector number.
[in]	plane	Plane number.
[in]	strip	Strip number.

Definition at line 320 of file TransformData.cc.

{
  return &m_Strip[section - 1][layer - 1][sector - 1][plane - 1][strip - 1];
}

intersection()

bool intersection	(	KLMDigit *	hit1,
		KLMDigit *	hit2,
		HepGeom::Point3D< double > *	cross,
		double *	d1,
		double *	d2,
		double *	sd,
		bool	segments = true
	)		const

Check if strips intersect, and find intersection point if yes.

Parameters

[in]	hit1	First hit.
[in]	hit2	Second hit.
[out]	cross	Crossing point (coordinate unit is cm).
[out]	d1	Distance from hit to SiPM of strip 1, cm.
[out]	d2	Distance from hit to SiPM of strip 2, cm.
[out]	sd	Shortest distance between strips, cm. Or if second strip is closer to interaction point, then (- shortest distance).
[in]	segments	Check if segments intersect (may need to turn this check off for debugging).

Returns

True if strips intersect.

Line parametric equations: (s1_1g) + (s1_2g - s1_1g) * t1 = a1 + v1 * t1, (s2_1g) + (s2_2g - s2_1g) * t2 = a2 + v2 * t2. Points of closest approach: t1 = ((v1,v2)*(d,v2) - v2^2*(d,v1)) / (v1^2*v2^2 - (v1,v2)^2) t2 = - ((v1,v2)*(d,v1) - v1^2*(d,v2)) / (v1^2*v2^2 - (v1,v2)^2) where d = a1 - a2.

Definition at line 348 of file TransformData.cc.

{
  /* Hits must be from the same sector, */
  if (hit1->getSection() != hit2->getSection())
    return false;
  if (hit1->getLayer() != hit2->getLayer())
    return false;
  if (hit1->getSector() != hit2->getSector())
    return false;
  /* but different planes. */
  if (hit1->getPlane() == hit2->getPlane())
    return false;
  /* Coordinates of strip 1 ends. */
  double l1 = m_GeoDat->getStripLength(hit1->getStrip());
  HepGeom::Point3D<double> s1_1(-0.5 * l1, 0.0, 0.0);
  HepGeom::Point3D<double> s1_2(0.5 * l1, 0.0, 0.0);
  const HepGeom::Transform3D* tr1 = getStripLocalToGlobal(hit1);
  HepGeom::Point3D<double> s1_1g = (*tr1) * s1_1;
  HepGeom::Point3D<double> s1_2g = (*tr1) * s1_2;
  /* Coordinates of strip 2 ends. */
  double l2 = m_GeoDat->getStripLength(hit2->getStrip());
  HepGeom::Point3D<double> s2_1(-0.5 * l2, 0.0, 0.0);
  HepGeom::Point3D<double> s2_2(0.5 * l2, 0.0, 0.0);
  const HepGeom::Transform3D* tr2 = getStripLocalToGlobal(hit2);
  HepGeom::Point3D<double> s2_1g = (*tr2) * s2_1;
  HepGeom::Point3D<double> s2_2g = (*tr2) * s2_2;
  HepGeom::Vector3D<double> v1 = s1_2g - s1_1g;
  HepGeom::Vector3D<double> v2 = s2_2g - s2_1g;
  HepGeom::Vector3D<double> d = s1_1g - s2_1g;
  double v1sq = v1.mag2();
  double v2sq = v2.mag2();
  double v1dv2 = v1.dot(v2);
  double ddv1 = d.dot(v1);
  double ddv2 = d.dot(v2);
  double den = v1sq * v2sq - v1dv2 * v1dv2;
  double t1 = (v1dv2 * ddv2 - v2sq * ddv1) / den;
  double t2 = (- v1dv2 * ddv1 + v1sq * ddv2) / den;
  /* Segments do not intersect. */
  if (segments) {
    if (t1 < 0.0 || t1 > 1.0)
      return false;
    if (t2 < 0.0 || t2 > 1.0)
      return false;
  }
  /* Segments intersect, set return values. */
  HepGeom::Point3D<double> s1_cg = s1_1g + v1 * t1;
  HepGeom::Point3D<double> s2_cg = s2_1g + v2 * t2;
  *d1 = s1_2g.distance(s1_cg) / CLHEP::mm * Unit::mm;
  *d2 = s2_2g.distance(s2_cg) / CLHEP::mm * Unit::mm;
  *cross = 0.5 * (s1_cg + s2_cg) / CLHEP::mm * Unit::mm;
  *sd = s1_cg.distance(s2_cg) / CLHEP::mm * Unit::mm;
  if (s2_cg.mag2() < s1_cg.mag2())
    *sd = - *sd;
  return true;
}

transformsToGlobal()

void transformsToGlobal ( )

private

Make transformations global from local.

Definition at line 239 of file TransformData.cc.

{
  int iSection, iLayer, iSector, iPlane, iSegment, iStrip;
  /* cppcheck-suppress variableScope */
  int nSections, nLayers, nDetectorLayers, nSectors, nPlanes, nSegments, nStrips;
  nSections = m_GeoDat->getNSections();
  nLayers = m_GeoDat->getNLayers();
  nSectors = m_GeoDat->getNSectors();
  nPlanes = m_GeoDat->getNPlanes();
  nSegments = m_GeoDat->getNSegments();
  nStrips = m_GeoDat->getNStrips();
  for (iSection = 0; iSection < nSections; iSection++) {
    nDetectorLayers = m_GeoDat->getNDetectorLayers(iSection + 1);
    for (iLayer = 0; iLayer < nLayers; iLayer++) {
      m_Layer[iSection][iLayer] = m_Section[iSection] * m_Layer[iSection][iLayer];
      for (iSector = 0; iSector < nSectors; iSector++) {
        m_Sector[iSection][iLayer][iSector] =
          m_Layer[iSection][iLayer] * m_Sector[iSection][iLayer][iSector];
        if (iLayer >= nDetectorLayers)
          continue;
        for (iPlane = 0; iPlane < nPlanes; iPlane++) {
          m_Plane[iSection][iLayer][iSector][iPlane] =
            m_Sector[iSection][iLayer][iSector] *
            m_Plane[iSection][iLayer][iSector][iPlane];
          for (iSegment = 0; iSegment < nSegments; iSegment++) {
            m_Segment[iSection][iLayer][iSector][iPlane][iSegment] =
              m_Plane[iSection][iLayer][iSector][iPlane] *
              m_PlaneDisplacement[iSection][iLayer][iSector][iPlane] *
              m_Segment[iSection][iLayer][iSector][iPlane][iSegment];
          }
          for (iStrip = 0; iStrip < nStrips; iStrip++) {
            m_Strip[iSection][iLayer][iSector][iPlane][iStrip] =
              m_Plane[iSection][iLayer][iSector][iPlane] *
              m_PlaneDisplacement[iSection][iLayer][iSector][iPlane] *
              m_Strip[iSection][iLayer][iSector][iPlane][iStrip];
            m_StripInverse[iSection][iLayer][iSector][iPlane][iStrip] =
              m_Strip[iSection][iLayer][iSector][iPlane][iStrip].inverse();
          }
        }
      }
    }
  }
}

Member Data Documentation

m_ElementNumbers

const EKLMElementNumbers* m_ElementNumbers

private

Element numbers.

Definition at line 211 of file TransformData.h.

m_GeoDat

const GeometryData* m_GeoDat

private

Geometry data.

Definition at line 214 of file TransformData.h.

m_Layer

HepGeom::Transform3D** m_Layer

private

Layer transformations.

Definition at line 220 of file TransformData.h.

m_Plane

HepGeom::Transform3D**** m_Plane

private

Plane transformations.

Definition at line 226 of file TransformData.h.

m_PlaneDisplacement

HepGeom::Transform3D**** m_PlaneDisplacement

private

Plane internal volumes displacements.

Definition at line 229 of file TransformData.h.

m_Section

HepGeom::Transform3D* m_Section

private

Section transformations.

Definition at line 217 of file TransformData.h.

m_Sector

HepGeom::Transform3D*** m_Sector

private

Sector transformations.

Definition at line 223 of file TransformData.h.

m_Segment

HepGeom::Transform3D***** m_Segment

private

Segment transformations.

Definition at line 232 of file TransformData.h.

m_Strip

HepGeom::Transform3D***** m_Strip

private

Strip transformations.

Definition at line 235 of file TransformData.h.

m_StripInverse

HepGeom::Transform3D***** m_StripInverse

private

Inverse strip transformations.

Definition at line 238 of file TransformData.h.

---

The documentation for this class was generated from the following files:

• klm/eklm/geometry/include/TransformData.h
• klm/eklm/geometry/src/TransformData.cc