AFPSiRowColToLocalCSTool Class Reference

Translates pixels rows and columns to position in standard ATLAS coordinates system. More...

#include <AFPSiRowColToLocalCSTool.h>

Inheritance diagram for AFPSiRowColToLocalCSTool:

Collaboration diagram for AFPSiRowColToLocalCSTool:

Public Member Functions
	AFPSiRowColToLocalCSTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
	Prepare transformation matrices. More...
virtual StatusCode	finalize () override
	does nothing More...
virtual xAOD::AFPSiHitsCluster *	newXAODLocal (const int stationID, const int layerID, const AFP::SiLocAlignData &LA, const AFP::SiGlobAlignData &GA, const AFPSiClusterBasicObj &cluster, std::unique_ptr< xAOD::AFPSiHitsClusterContainer > &xAODContainer) const override
void	fillXAOD (const int stationID, const int layerID, const ROOT::Math::XYZPoint &position, const ROOT::Math::XYZPoint &positionError, xAOD::AFPSiHitsCluster *xAODCluster) const
	Sets xAOD information about station, layer, position and error based on the ROOT::Math::XYZPoint objects. More...

Private Member Functions
void	initTransformationMatricesSize (std::list< std::vector< std::vector< ROOT::Math::Transform3D > > * > &matrices, const std::vector< int > &layersInStations)
	The method initialises matrices to have the size defined in layersInStations. More...

Private Attributes
Gaudi::Property< std::vector< int > >	m_numberOfLayersInStations {this, "numberOfLayersInStations",{4,4,4,4}, "Array defining number of stations and layers in each station. The size of the array in argument defines number of stations, the value in each entry defines number of layers in the station."}
	Vector defining number of stations and number of layers in each station. More...
std::vector< std::vector< ROOT::Math::Transform3D > >	m_transformations
	Array of transformations that position in each layers. More...
Gaudi::Property< std::vector< double > >	m_transformationsInit {this, "transformations", {}, "Initialisation of the transformation matrices (4x3). It is not full transformation only part. Must be defined simultaneously with transformationsErr."}
	Vector containing initial values for m_transformations matrices. More...
std::vector< std::vector< ROOT::Math::Transform3D > >	m_transformationsErr
	Array of transformations that are applied to position uncertainties. More...
Gaudi::Property< std::vector< double > >	m_transformationsErrInit {this, "transformationsErr", {}, "Initialisation of the error transformation matrices (4x3). It is not full transformation only part. Must be defined simultaneously with transformations."}
	Vector containing initial values for m_transformationsErr matrices. More...
Gaudi::Property< double >	m_pixelHorizSize {this, "pixelHorizSize", 0.05, "Size of the pixel in horizontal direction when mounted (default = 0.05 mm)"}
	Size of the pixel in horizontal direction when mounted (default = 0.05 mm) More...
Gaudi::Property< double >	m_pixelVertSize {this, "pixelVertSize", 0.25, "Size of the pixel in vertical direction when mounted (default = 0.25 mm)"}
	Size of the pixel in vertical direction when mounted (default = 0.25 mm) More...

Detailed Description

Translates pixels rows and columns to position in standard ATLAS coordinates system.

The class rewrites AFPSiClusterBasicObj into xAOD::AFPSiHitsCluster objects and changes columns and rows into position in standard ATLAS coordinate system.

Definition at line 43 of file AFPSiRowColToLocalCSTool.h.

Constructor & Destructor Documentation

AFPSiRowColToLocalCSTool()

AFPSiRowColToLocalCSTool::AFPSiRowColToLocalCSTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 25 of file AFPSiRowColToLocalCSTool.cxx.

    : base_class(type, name, parent)
{
}

Member Function Documentation

fillXAOD()

void AFPSiRowColToLocalCSTool::fillXAOD	(	const int	stationID,
		const int	layerID,
		const ROOT::Math::XYZPoint &	position,
		const ROOT::Math::XYZPoint &	positionError,
		xAOD::AFPSiHitsCluster *	xAODCluster
	)		const

Sets xAOD information about station, layer, position and error based on the ROOT::Math::XYZPoint objects.

param[in] stationID ID number of the station where the cluster is param[in] layerID ID number of the layer where the cluster is param[in] position point object with the position of the cluster centre param[in] positionError point object with the uncertainty of the position of the cluster centre param[out] xAODCluster xAOD object to be filled with provided information

Definition at line 184 of file AFPSiRowColToLocalCSTool.cxx.

{
    xAODCluster->setStationID(stationID);
    xAODCluster->setPixelLayerID(layerID);
 
    xAODCluster->setXLocal(position.x());
    xAODCluster->setXLocalErr(positionError.x());
 
    xAODCluster->setYLocal(position.y());
    xAODCluster->setYLocalErr(positionError.y());
 
    xAODCluster->setZLocal(position.z());
    xAODCluster->setZLocalErr(positionError.z());
}

finalize()

StatusCode AFPSiRowColToLocalCSTool::finalize ( )

overridevirtual

does nothing

Definition at line 180 of file AFPSiRowColToLocalCSTool.cxx.

                                              {
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AFPSiRowColToLocalCSTool::initialize ( )

overridevirtual

Prepare transformation matrices.

Definition at line 50 of file AFPSiRowColToLocalCSTool.cxx.

{  
  using TransformVec_t = std::vector<std::vector<ROOT::Math::Transform3D>>;
 
  std::list<TransformVec_t*> matricesForLayersInit;
  matricesForLayersInit.push_back(&m_transformations);
  matricesForLayersInit.push_back(&m_transformationsErr);
 
 
  initTransformationMatricesSize(matricesForLayersInit, m_numberOfLayersInStations);
 
  // count total number of layers
  unsigned int totalLayersN = 0;
  for (const int layersN : m_numberOfLayersInStations)
    totalLayersN += layersN;
  
  // --- initialise transformations for each layer in station ---
  bool useDefualtTransformation = true;
  if (!m_transformationsInit.empty() && !m_transformationsErrInit.empty()) {
    // check if the number of arguments is correct for (4x3) matrices
    if (m_transformationsInit.size() == totalLayersN*4*3) {
      if (m_transformationsErrInit.size() == totalLayersN*4*3) {
 
        std::vector<double>::const_iterator valueIter = m_transformationsInit.begin();
        for (std::vector<ROOT::Math::Transform3D>& station : m_transformations)
          for (ROOT::Math::Transform3D& layerTransform : station) {
            layerTransform.SetComponents(valueIter, valueIter+12);
            valueIter += 12;
          }
 
        std::vector<double>::const_iterator valueErrIter = m_transformationsErrInit.begin();
        for (std::vector<ROOT::Math::Transform3D>& station : m_transformationsErr)
          for (ROOT::Math::Transform3D& layerTransform : station) {
            layerTransform.SetComponents(valueErrIter, valueErrIter+12);
            valueErrIter += 12;
          }
      
        useDefualtTransformation = false;
      }
      else
        ATH_MSG_WARNING("Incorrect number of elements in transformationErr vector in job options. Should be "<<totalLayersN<<"x4x3="<<totalLayersN*4*3<<". Is "<<m_transformationsErrInit.size()<<". Will use default transformation.");
    } // close if (m_transformationsInit.size() == totalLayersN*4*3)
    else
      ATH_MSG_WARNING("Incorrect number of elements in transformation vector in job options. Should be "<<totalLayersN<<"x4x3="<<totalLayersN*4*3<<". Is "<<m_transformationsInit.size()<<". Will use default transformation.");
  } // close if (m_transformationsInit.size() && m_transformationsErrInit.size())
  else
    ATH_MSG_INFO("In job options m_transformationsInit and m_transformationsErrInit are not defined simultaneously, so default transformations will be used.");
 
  // if there were problems with job options scaling or none was defined use default values
  if (useDefualtTransformation) {
    //---->Extra brackets are for vexing parse issues under clang14<---
    const ROOT::Math::Transform3D rotationA((ROOT::Math::RotationY(AFP_CONSTANTS::SiT_Plate_rot_xz))); // rotate by +14 degrees
    const ROOT::Math::Transform3D rotationC(ROOT::Math::RotationY(-1.*AFP_CONSTANTS::SiT_Plate_rot_xz)); // rotate by -14 degrees
    
    const ROOT::Math::Translation3D translationA0(0, 0, 0.);
    const ROOT::Math::Translation3D translationA1(0, 0, 1.*AFP_CONSTANTS::SiT_Plate_zsep);
    const ROOT::Math::Translation3D translationA2(0, 0, 2.*AFP_CONSTANTS::SiT_Plate_zsep);
    const ROOT::Math::Translation3D translationA3(0, 0, 3.*AFP_CONSTANTS::SiT_Plate_zsep);
    
    const ROOT::Math::Translation3D translationC0(0, 0, 0.);
    const ROOT::Math::Translation3D translationC1(0, 0,-1.*AFP_CONSTANTS::SiT_Plate_zsep);
    const ROOT::Math::Translation3D translationC2(0, 0,-2.*AFP_CONSTANTS::SiT_Plate_zsep);
    const ROOT::Math::Translation3D translationC3(0, 0,-3.*AFP_CONSTANTS::SiT_Plate_zsep);
    
    // station 0
    m_transformationsErr[0][0] = rotationA;
    m_transformationsErr[0][1] = rotationA;
    m_transformationsErr[0][2] = rotationA;
    m_transformationsErr[0][3] = rotationA;
 
    m_transformations[0][0] = translationA0*m_transformationsErr[0][0];
    m_transformations[0][1] = translationA1*m_transformationsErr[0][1];
    m_transformations[0][2] = translationA2*m_transformationsErr[0][2];
    m_transformations[0][3] = translationA3*m_transformationsErr[0][3];
 
    // station 1
    m_transformationsErr[1][0] = rotationA;
    m_transformationsErr[1][1] = rotationA;
    m_transformationsErr[1][2] = rotationA;
    m_transformationsErr[1][3] = rotationA;
 
    m_transformations[1][0] = translationA0*m_transformationsErr[1][0];
    m_transformations[1][1] = translationA1*m_transformationsErr[1][1];
    m_transformations[1][2] = translationA2*m_transformationsErr[1][2];
    m_transformations[1][3] = translationA3*m_transformationsErr[1][3];
 
    // station 2
    m_transformationsErr[2][0] = rotationC;
    m_transformationsErr[2][1] = rotationC;
    m_transformationsErr[2][2] = rotationC;
    m_transformationsErr[2][3] = rotationC;
 
    m_transformations[2][0] = translationC0*m_transformationsErr[2][0];
    m_transformations[2][1] = translationC1*m_transformationsErr[2][1];
    m_transformations[2][2] = translationC2*m_transformationsErr[2][2];
    m_transformations[2][3] = translationC3*m_transformationsErr[2][3];
 
    // station 3
    m_transformationsErr[3][0] = rotationC;
    m_transformationsErr[3][1] = rotationC;
    m_transformationsErr[3][2] = rotationC;
    m_transformationsErr[3][3] = rotationC;
 
    m_transformations[3][0] = translationC0*m_transformationsErr[3][0];
    m_transformations[3][1] = translationC1*m_transformationsErr[3][1];
    m_transformations[3][2] = translationC2*m_transformationsErr[3][2];
    m_transformations[3][3] = translationC3*m_transformationsErr[3][3];
  }
 
  int stationCounter(0);
  ATH_MSG_DEBUG("The following transformation matrices will be used");
  for (const std::vector<ROOT::Math::Transform3D>& station : m_transformations) {
    int layersCounter (0);
    ATH_MSG_DEBUG("Station "<<stationCounter++);
    for (const ROOT::Math::Transform3D& layerTrans : station)
      ATH_MSG_DEBUG ("Layer "<<layersCounter++<<" "<<layerTrans);
  } // close for (stations)
 
  stationCounter = 0;
  ATH_MSG_DEBUG("The following transformation matrices for errors will be used");
  for (const std::vector<ROOT::Math::Transform3D>& station : m_transformationsErr) {
    int layersCounter (0);
    ATH_MSG_DEBUG("Station "<<stationCounter++);
    for (const ROOT::Math::Transform3D& layerTrans : station)
      ATH_MSG_DEBUG ("Layer "<<layersCounter++<<" "<<layerTrans);
  } // close for (stations)
      
  return StatusCode::SUCCESS;
}

initTransformationMatricesSize()

void AFPSiRowColToLocalCSTool::initTransformationMatricesSize ( std::list< std::vector< std::vector< ROOT::Math::Transform3D > > * > &  matrices, const std::vector< int > &  layersInStations  )

private

The method initialises matrices to have the size defined in layersInStations.

Definition at line 33 of file AFPSiRowColToLocalCSTool.cxx.

{
  const int numberOfStations = layersInStations.size();
  std::list<std::vector< std::vector<ROOT::Math::Transform3D> >::iterator> iterators;
 
  // initialise number of stations in each set and prepare iterators
  for (std::vector< std::vector<ROOT::Math::Transform3D> >* theMatrix : matrices) {
    theMatrix->resize(numberOfStations);
    iterators.push_back(theMatrix->begin());
  }
 
  // initialise number of layers in each station
  for (const int layersN : layersInStations)
    for (std::vector< std::vector<ROOT::Math::Transform3D> >::iterator& matrixIter : iterators)
      (*(matrixIter++)) = std::vector<ROOT::Math::Transform3D> (layersN);
}

newXAODLocal()

xAOD::AFPSiHitsCluster * AFPSiRowColToLocalCSTool::newXAODLocal ( const int  stationID, const int  layerID, const AFP::SiLocAlignData &  LA, const AFP::SiGlobAlignData &  GA, const AFPSiClusterBasicObj &  cluster, std::unique_ptr< xAOD::AFPSiHitsClusterContainer > &  xAODContainer  ) const

overridevirtual

Definition at line 199 of file AFPSiRowColToLocalCSTool.cxx.

{
  float flipAC = (stationID<2 ? -1. : +1.);
  
  ROOT::Math::XYZPoint horizVertID ((cluster.horizID()-AFP_CONSTANTS::SiT_Pixel_amount_x)*m_pixelHorizSize, flipAC*cluster.vertID()*m_pixelVertSize, 0);
  ROOT::Math::XYZPoint horizVertIDErr (cluster.horizIDErr()*m_pixelHorizSize, cluster.vertIDErr()*m_pixelVertSize, 0);
 
  try {
    // these horrible things are needed in order to have compatibility with AFPAnalysisToolbox
    const ROOT::Math::RotationZYX locRotation(flipAC*LA.alpha(), -1.*flipAC*LA.gamma(), LA.beta()); // ATLAS coord.
    const ROOT::Math::Translation3D locTranslation(-1.*LA.yShift(), flipAC*LA.xShift(), flipAC*LA.zShift()); // ATLAS coord.
    const ROOT::Math::Translation3D globTranslation(GA.xShift(), flipAC*GA.yShift(), GA.zShift()); // ATLAS coord.
    
    ROOT::Math::XYZPoint localCS = globTranslation*locTranslation*locRotation*m_transformations.at(stationID).at(layerID)*horizVertID;
    ROOT::Math::XYZPoint localCSError = locRotation*m_transformationsErr.at(stationID).at(layerID)*horizVertIDErr;
 
    auto *xAODCluster = xAODContainer->push_back(std::make_unique<xAOD::AFPSiHitsCluster>());
 
    fillXAOD (stationID, layerID, localCS, localCSError, xAODCluster);
    xAODCluster->setDepositedCharge(cluster.charge());
    xAODCluster->setNHits(cluster.hits().size());
 
    ATH_MSG_DEBUG("Cluster info: station="<<stationID<<" layer="<<layerID<<" horizID="<<cluster.horizID()<<" vertID="<<cluster.vertID()<<"\tcoordinates: x="<<xAODCluster->xLocal()<<" y="<<xAODCluster->yLocal());
    ATH_MSG_DEBUG("hits: ");      
    for (const xAOD::AFPSiHit* theHit : cluster.hits() )
      ATH_MSG_DEBUG("("<<theHit->pixelHorizID()<<", "<<theHit->pixelVertID()<<")");
 
    return xAODCluster;
  } // close try
  catch (const std::out_of_range& outOfRange) {
    ATH_MSG_WARNING("Transformation matrix for station or pixel ID outside expected range. Aborting transformation to xAOD.");
    return nullptr;
  }
}

Member Data Documentation

m_numberOfLayersInStations

Gaudi::Property<std::vector<int> > AFPSiRowColToLocalCSTool::m_numberOfLayersInStations {this, "numberOfLayersInStations",{4,4,4,4}, "Array defining number of stations and layers in each station. The size of the array in argument defines number of stations, the value in each entry defines number of layers in the station."}

private

Vector defining number of stations and number of layers in each station.

The size of the vector sets number of stations. Each element defines number of pixel layers in the station. It is used to initialise m_transformations and m_transformationsErr. If not set in job options 4 stations, each with 4 layers are created.

Definition at line 80 of file AFPSiRowColToLocalCSTool.h.

m_pixelHorizSize

Gaudi::Property<double> AFPSiRowColToLocalCSTool::m_pixelHorizSize {this, "pixelHorizSize", 0.05, "Size of the pixel in horizontal direction when mounted (default = 0.05 mm)"}

private

Size of the pixel in horizontal direction when mounted (default = 0.05 mm)

This value is used to multiply pixel horizontal ID in order to obtain position.

Definition at line 118 of file AFPSiRowColToLocalCSTool.h.

m_pixelVertSize

Gaudi::Property<double> AFPSiRowColToLocalCSTool::m_pixelVertSize {this, "pixelVertSize", 0.25, "Size of the pixel in vertical direction when mounted (default = 0.25 mm)"}

private

Size of the pixel in vertical direction when mounted (default = 0.25 mm)

This value is used to multiply pixel vertical ID in order to obtain position.

Definition at line 124 of file AFPSiRowColToLocalCSTool.h.

m_transformations

std::vector< std::vector<ROOT::Math::Transform3D> > AFPSiRowColToLocalCSTool::m_transformations

private

Array of transformations that position in each layers.

These transformations combined with m_transformationsErr are applied to the pixels and provide full local alignment. They are not applied to the uncertainties and should contain mainly translation. These are 4x4 matrices.

Definition at line 88 of file AFPSiRowColToLocalCSTool.h.

m_transformationsErr

std::vector< std::vector<ROOT::Math::Transform3D> > AFPSiRowColToLocalCSTool::m_transformationsErr

private

Array of transformations that are applied to position uncertainties.

These transformations are applied both to the pixel positions and uncertainties. They should not contain translations, because it will add an offset to the error. These are 4x4 matrices.

Definition at line 103 of file AFPSiRowColToLocalCSTool.h.

m_transformationsErrInit

Gaudi::Property<std::vector<double> > AFPSiRowColToLocalCSTool::m_transformationsErrInit {this, "transformationsErr", {}, "Initialisation of the error transformation matrices (4x3). It is not full transformation only part. Must be defined simultaneously with transformations."}

private

Vector containing initial values for m_transformationsErr matrices.

The first four numbers are the first row in the first transformation matrix, the second four numbers are the second row. Numbers on positions from 16 to 32 represent second matrix, etc.

Definition at line 111 of file AFPSiRowColToLocalCSTool.h.

m_transformationsInit

Gaudi::Property<std::vector<double> > AFPSiRowColToLocalCSTool::m_transformationsInit {this, "transformations", {}, "Initialisation of the transformation matrices (4x3). It is not full transformation only part. Must be defined simultaneously with transformationsErr."}

private

Vector containing initial values for m_transformations matrices.

The first four numbers are the first row in the first transformation matrix, the second four numbers are the second row. Numbers on positions from 16 to 32 represent second matrix, etc.

Definition at line 96 of file AFPSiRowColToLocalCSTool.h.

---

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

• AFPSiRowColToLocalCSTool.h
• AFPSiRowColToLocalCSTool.cxx