AFP_ProtonRecoAnalytical Class Reference

Tool for proton reconstruction by directly using transport parameterisation. More...

#include <AFP_ProtonRecoAnalytical.h>

Inheritance diagram for AFP_ProtonRecoAnalytical:

Collaboration diagram for AFP_ProtonRecoAnalytical:

Public Member Functions
	AFP_ProtonRecoAnalytical (const std::string &type, const std::string &name, const IInterface *parent)
	Default constructor.
	~AFP_ProtonRecoAnalytical ()=default
StatusCode	initialize () override
	Loads parameterization.
const std::string &	outputContainerName () const override
StatusCode	doProtonReco (std::unique_ptr< xAOD::AFPProtonContainer > &outputContainer, const EventContext &ctx) const override

Protected Types
using	Momentum = std::array<double, 3>
	3-momentum of reconstructed proton

Protected Member Functions
xAOD::AFPProton *	createProton (const Momentum &momentum, const Measurement &my_measAFP, const int algID, std::unique_ptr< xAOD::AFPProtonContainer > &outputContainer) const
	Creates and sets up a proton.
void	linkTracksToProton (const xAOD::AFPTrack *track, SG::ReadHandle< xAOD::AFPTrackContainer > &trackContainer, xAOD::AFPProton *proton) const
	Links track pair to reconstructed proton.

Protected Attributes
Gaudi::Property< std::vector< double > >	m_detectorPositions {this, "detectorPositions", {}, "absolute values of detector positions for each station on one side"}
Gaudi::Property< int >	m_side {this, "side", 0, "side id, A=0, C=1"}
Gaudi::Property< double >	m_trackDistance {this, "trackDistance", 2.0, "Maximum distance between tracks in the near and the far station on xy-plane"}
Gaudi::Property< bool >	m_allowSingleStationReco {this, "allowSingleStationReco", false, "Switch for allowing proton reconstruction using only far station"}
SG::ReadHandleKey< xAOD::AFPTrackContainer >	m_trackContainerKey {this, "AFPTrackContainerKey", "AFPTrackContainer", "Name of the container with tracks of hits from which protons are to be reconstructed"}
Gaudi::Property< std::string >	m_protonsContainerName {this, "protonsContainerName", "AFPProtonContainer", "Name of the container in which protons are saved"}
double	m_detectorPositionNear = 0.0
	Default position of AFP near station.
double	m_detectorPositionFar = 0.0
	Default position of AFP far station.
const std::vector< double >	m_vertexIP = {0, 0, 0}
	Vertex position.

Static Protected Attributes
static constexpr double	m_xSigma = 10e-6
	x-Sigma value
static constexpr double	m_ySigma = 30e-6
	y-Sigma value

Private Member Functions
StatusCode	configInfo () const
virtual xAOD::AFPProton *	reco (const xAOD::AFPTrack *trkNear, const xAOD::AFPTrack *trkFar, std::unique_ptr< xAOD::AFPProtonContainer > &outputContainer) const override
	Reconstructs single proton from pair of tracks.
virtual xAOD::AFPProton *	reco (const xAOD::AFPTrack *trkFar, std::unique_ptr< xAOD::AFPProtonContainer > &outputContainer) const override
	Reconstructs single proton using only one track from far station.
virtual double	chi2 (double energy, double sx, double sy, const Measurement &my_measAFP) const override
	Calculates chi2 for reconstructed proton.
double	bisection (double(AFP_ProtonRecoAnalytical::*fun)(double, const Measurement &, std::vector< double > &, std::vector< double > &) const, const Measurement &my_measAFP, std::vector< double > &my_slopeCalculated, std::vector< double > &my_positionCalculated) const
	Calculates root of given function.
double	bothStations (double energy, const Measurement &my_measAFP, std::vector< double > &my_slopeCalculated, std::vector< double > &my_positionCalculated) const
	Function obtained from parameterization equation.
double	singleStation (double energy, const Measurement &my_measAFP, std::vector< double > &my_slopeCalculated, std::vector< double > &my_positionCalculated) const
	Function obtained from parameterization equation.
double	calculateSlope (double energy, int XorY, std::vector< double > &my_slopeCalculated) const
	Calculates ininial slope based on measurements and reconstructed energy.
double	calculateXslope (double energy, std::vector< double > &my_slopeCalculated) const
	Calculates initial horizontal slope Calls calculateSlope(energy, 0)
double	calculateYslope (double energy, std::vector< double > &my_slopeCalculated) const
	Calculates initial vertical slope Calls calculateSlope(energy, 1)

Private Attributes
std::unique_ptr< AFP::Parameterization >	m_parametrization
	Pointer to parameterization.
double	m_distanceBetweenStations = 0.0
	Distance between near and far station.
Gaudi::Property< std::string >	m_parametrizationFileName {this, "parametrizationFileName", {}, "Name of the file containing parameterization"}
	Name of the file containing parameterization.
double	m_parametrizationPosition = 0.0
	Position for which parameterization was performed.
double	m_parametrizationEnergy = 0.0
	Parameterization energy.

Detailed Description

Tool for proton reconstruction by directly using transport parameterisation.

Definition at line 31 of file AFP_ProtonRecoAnalytical.h.

Member Typedef Documentation

Momentum

using AFP_ProtonRecoBase::Momentum = std::array<double, 3>

protectedinherited

3-momentum of reconstructed proton

Definition at line 83 of file AFP_ProtonRecoBase.h.

Constructor & Destructor Documentation

AFP_ProtonRecoAnalytical()

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

Default constructor.

Definition at line 8 of file AFP_ProtonRecoAnalytical.cxx.

 : AFP_ProtonRecoBase(type, name, parent)
{
  ATH_MSG_DEBUG("in AFP_ProtonRecoAnalytical constructor");
}

~AFP_ProtonRecoAnalytical()

AFP_ProtonRecoAnalytical::~AFP_ProtonRecoAnalytical ( )

default

Member Function Documentation

bisection()

double AFP_ProtonRecoAnalytical::bisection ( double(AFP_ProtonRecoAnalytical::* fun )(double, const Measurement &, std::vector< double > &, std::vector< double > &) const, const Measurement & my_measAFP, std::vector< double > & my_slopeCalculated, std::vector< double > & my_positionCalculated ) const

private

Calculates root of given function.

Definition at line 97 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                                                                                                                                                                                                 {
 
  // Alias to minimized function
  auto fn = [this, fun, my_slopeCalculated, my_positionCalculated](double x, const Measurement& m, std::vector<double>& s, std::vector<double>& p) { return (this->*fun)(x,m,s,p); };
 
  constexpr double tol = 1e-3; // 1 MeV
  double eMin = m_parametrizationEnergy - 2000.; // ~30% xi
  double eMax = m_parametrizationEnergy;
 
  if (fn(eMax, my_measAFP, my_slopeCalculated, my_positionCalculated) * fn(eMin, my_measAFP, my_slopeCalculated, my_positionCalculated) >= 0) { // Cannot use bisection method
 
    ATH_MSG_DEBUG("Cannot use bisection method");
 
    // Return value closest to zero
    return (fn(eMin, my_measAFP, my_slopeCalculated, my_positionCalculated) < 0) ? std::max(fn(eMin, my_measAFP, my_slopeCalculated, my_positionCalculated), fn(eMax, my_measAFP, my_slopeCalculated, my_positionCalculated)) : std::min(fn(eMin, my_measAFP, my_slopeCalculated, my_positionCalculated), fn(eMax, my_measAFP, my_slopeCalculated, my_positionCalculated));
  }
 
  ATH_MSG_VERBOSE("==== eMin\teMax\te\tfun(eMin)\tfun(eMax)\tfun(E) ====");
 
  double e = eMin;
 
  // Bisection method
  while (eMax - eMin > tol) {
    e = (eMin + eMax)/2.0;
    ATH_MSG_VERBOSE("* " << eMin << "\t" << eMax << "\t" << e << "\t" << fn(e, my_measAFP, my_slopeCalculated, my_positionCalculated) << "\t" << fn(eMin, my_measAFP, my_slopeCalculated, my_positionCalculated) << "\t" << fn(eMax, my_measAFP, my_slopeCalculated, my_positionCalculated));
    if (fn(eMax, my_measAFP, my_slopeCalculated, my_positionCalculated) * fn(e, my_measAFP, my_slopeCalculated, my_positionCalculated) < 0)
      eMin = e;
    else if (fn(eMin, my_measAFP, my_slopeCalculated, my_positionCalculated) * fn(e, my_measAFP, my_slopeCalculated, my_positionCalculated) < 0)
      eMax = e;
    else {
      eMin = e;
      eMax = e;
    }
  }
 
  ATH_MSG_DEBUG("Bisection energy: " << e);
 
  return e;
}

bothStations()

double AFP_ProtonRecoAnalytical::bothStations ( double energy, const Measurement & my_measAFP, std::vector< double > & my_slopeCalculated, std::vector< double > & my_positionCalculated ) const

private

Function obtained from parameterization equation.

Used in bisection method.

Definition at line 183 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                                                                                         {
 
  const double xi = 1.0 - energy / m_parametrizationEnergy;
 
  return
    (my_positionCalculated.at(0)
     - m_parametrization->getEquation(0)->getPolynomial(0)->Eval(xi)
     - m_vertexIP.at(0)*m_parametrization->getEquation(0)->getPolynomial(1)->Eval(xi)
     - m_vertexIP.at(2)*m_parametrization->getEquation(0)->getPolynomial(3)->Eval(xi)
     )
    *(
      m_parametrization->getEquation(2)->getPolynomial(4)->Eval(xi)
      + m_vertexIP.at(2)*m_parametrization->getEquation(2)->getPolynomial(6)->Eval(xi)
      )
    -  (
        my_slopeCalculated.at(0)
        - m_parametrization->getEquation(2)->getPolynomial(0)->Eval(xi)
        - m_vertexIP.at(0)*m_parametrization->getEquation(2)->getPolynomial(1)->Eval(xi)
        - m_vertexIP.at(2)*m_parametrization->getEquation(2)->getPolynomial(3)->Eval(xi)
        )
    *(
      m_parametrization->getEquation(0)->getPolynomial(4)->Eval(xi)
      + m_vertexIP.at(2)*m_parametrization->getEquation(0)->getPolynomial(6)->Eval(xi)
      );
}

calculateSlope()

double AFP_ProtonRecoAnalytical::calculateSlope ( double energy, int XorY, std::vector< double > & my_slopeCalculated ) const

private

Calculates ininial slope based on measurements and reconstructed energy.

Definition at line 223 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                                     { // 0 - X, 1 - Y
 
  const double xi = 1.0 - energy / m_parametrizationEnergy;
 
  const double Ax = m_parametrization->getEquation(2 + XorY)->getPolynomial(0)->Eval(xi);
  const double Bx = m_parametrization->getEquation(2 + XorY)->getPolynomial(4 + XorY)->Eval(xi);
  const double Cx = m_parametrization->getEquation(2 + XorY)->getPolynomial(1 + XorY)->Eval(xi);
  const double Dx = m_parametrization->getEquation(2 + XorY)->getPolynomial(6 + XorY)->Eval(xi);
  const double Ex = m_parametrization->getEquation(2 + XorY)->getPolynomial(3)->Eval(xi);
 
  const double Fx = my_slopeCalculated.at(0 + XorY) - Ax - Cx*m_vertexIP.at(0 + XorY) - Ex*m_vertexIP.at(2);
  const double Gx = Bx + m_vertexIP.at(2)*Dx;
  const double slp = (Gx == 0) ? 0. : Fx/Gx;
 
  return slp;
}

calculateXslope()

double AFP_ProtonRecoAnalytical::calculateXslope ( double energy, std::vector< double > & my_slopeCalculated ) const

private

Calculates initial horizontal slope Calls calculateSlope(energy, 0)

Definition at line 241 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                            {
 
  return calculateSlope(energy, 0, my_slopeCalculated);
}

calculateYslope()

double AFP_ProtonRecoAnalytical::calculateYslope ( double energy, std::vector< double > & my_slopeCalculated ) const

private

Calculates initial vertical slope Calls calculateSlope(energy, 1)

Definition at line 247 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                            {
 
  return calculateSlope(energy, 1, my_slopeCalculated);
}

chi2()

double AFP_ProtonRecoAnalytical::chi2 ( double energy, double sx, double sy, const Measurement & my_measAFP ) const

overrideprivatevirtual

Calculates chi2 for reconstructed proton.

Reimplemented from AFP_ProtonRecoBase.

Definition at line 253 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                           {
 
  const double energy = sqrt(px*px + py*py + pz*pz);
  const double sx = px/energy;
  const double sy = py/energy;
 
  const double xNear = m_parametrization->x(m_vertexIP.at(0), m_vertexIP.at(1), m_vertexIP.at(2), sx, sy, energy);
  const double yNear = m_parametrization->y(m_vertexIP.at(0), m_vertexIP.at(1), m_vertexIP.at(2), sx, sy, energy);
  const double xFar = xNear + m_distanceBetweenStations * m_parametrization->sx(m_vertexIP.at(0), m_vertexIP.at(1), m_vertexIP.at(2), sx, sy, energy);
  const double yFar = yNear + m_distanceBetweenStations * m_parametrization->sy(m_vertexIP.at(0), m_vertexIP.at(1), m_vertexIP.at(2), sx, sy, energy);
 
  if (m_allowSingleStationReco and my_measAFP.xN == 0 and my_measAFP.yN == 0) {
    const double dx2 = my_measAFP.xF - xFar;
    const double dy2 = my_measAFP.yF - yFar;
 
    const double chi2x2 = dx2 * dx2 / (m_xSigma * m_xSigma);
    const double chi2y2 = (m_parametrization->yIsUsed()) ? dy2 * dy2 / (m_ySigma * m_ySigma) : 0.;
 
    return chi2x2 + chi2y2;
  }
 
  const double dx1 = my_measAFP.xN - xNear;
  const double dx2 = my_measAFP.xF - xFar;
  const double dy1 = my_measAFP.yN - yNear;
  const double dy2 = my_measAFP.yF - yFar;
 
  const double chi2x1 = dx1 * dx1 / (m_xSigma * m_xSigma);
  const double chi2x2 = dx2 * dx2 / (m_xSigma * m_xSigma);
  const double chi2y1 = (m_parametrization->yIsUsed()) ? dy1 * dy1 / (m_ySigma * m_ySigma) : 0.;
  const double chi2y2 = (m_parametrization->yIsUsed()) ? dy2 * dy2 / (m_ySigma * m_ySigma) : 0.;
 
  return chi2x1 + chi2y1 + chi2x2 + chi2y2;
}

configInfo()

StatusCode AFP_ProtonRecoAnalytical::configInfo ( ) const

private

Definition at line 15 of file AFP_ProtonRecoAnalytical.cxx.

{
  ATH_MSG_INFO("----- AFP_ProtonRecoAnalytical -----");
 
  ATH_MSG_INFO("\tNear AFP position [m]: " << m_detectorPositionNear );
  ATH_MSG_INFO("\tFar AFP position  [m]: " << m_detectorPositionFar );
  ATH_MSG_INFO("\tSingle station reconstruction: " << m_allowSingleStationReco );
  ATH_MSG_INFO("\tCuts:\n");
  ATH_MSG_INFO("\t\ttrackDistance [mm]: " << m_trackDistance );
  
  ATH_MSG_INFO("\tparametrizationFileName = " << m_parametrizationFileName);
  ATH_MSG_INFO("\tparametrizationPosition = " << m_parametrizationPosition);
  ATH_MSG_INFO("\tparametrizationEnergy   = " << m_parametrizationEnergy);
 
  return StatusCode::SUCCESS;
}

createProton()

xAOD::AFPProton * AFP_ProtonRecoBase::createProton ( const Momentum & momentum, const Measurement & my_measAFP, const int algID, std::unique_ptr< xAOD::AFPProtonContainer > & outputContainer ) const

protectedinherited

Creates and sets up a proton.

Definition at line 94 of file AFP_ProtonRecoBase.cxx.

{
 
  // Return nullptr if any of momentum components is not a number
  if ( std::any_of(begin(momentum), end(momentum), [](auto& el) { return !std::isfinite(el); }) )
    return nullptr;
 
  const auto [px, py, pz] = momentum;
 
  auto * proton = outputContainer->push_back(std::make_unique<xAOD::AFPProton>());
  
  // Set proton properties
  constexpr double protonMass = 0.938; // in GeV
  
  proton->setPxPyPzE(px, py, pz, sqrt(px*px + py*py + pz*pz + protonMass*protonMass));
  proton->setChi2(chi2(px, py, pz, my_measAFP));
  proton->setSide(m_side);
  proton->setMethodID(algID);
  
  ATH_MSG_DEBUG("Reconstructed proton (px, py, pz): " << proton->px() << ", " << proton->py() << ", " << proton->pz()<<", chi2 "<<proton->chi2()<<", side "<<proton->side());
 
  return proton;
}

doProtonReco()

StatusCode AFP_ProtonRecoBase::doProtonReco ( std::unique_ptr< xAOD::AFPProtonContainer > & outputContainer, const EventContext & ctx ) const

overrideinherited

Definition at line 16 of file AFP_ProtonRecoBase.cxx.

{
  
  SG::ReadHandle<xAOD::AFPTrackContainer> trackContainer( m_trackContainerKey, ctx );
  if(!trackContainer.isValid())
  {
    // this is allowed, there might be no AFP data in the input
    return StatusCode::SUCCESS;
  }
  
  const double trackDistanceRadiusSq = m_trackDistance*m_trackDistance;
 
  // Select tracks in near station
  std::vector<const xAOD::AFPTrack*> trackNearContainer;
  const int nearId = m_side + 1;
  std::copy_if(trackContainer->begin(), trackContainer->end(), std::back_inserter(trackNearContainer),
      [&nearId](auto track) { return track->stationID() == nearId; });
 
  // Select tracks in far station
  std::vector<const xAOD::AFPTrack*> trackFarContainer;
  const int farId = 3 * m_side;
  std::copy_if(trackContainer->begin(), trackContainer->end(), std::back_inserter(trackFarContainer),
      [&farId](auto track) { return track->stationID() == farId; });
 
  ATH_MSG_DEBUG("trackNearContainer size: " << trackNearContainer.size()<<", side "<<m_side);
  ATH_MSG_DEBUG("trackFarContainer  size: " << trackFarContainer.size()<<", side "<<m_side);
 
  // Loop over both containers
  for (const xAOD::AFPTrack* trackFar : trackFarContainer) {
    bool foundMatchingTrack = false;
 
    for (const xAOD::AFPTrack* trackNear : trackNearContainer) {
      // Apply cuts
      const double dx = trackFar->xLocal() - trackNear->xLocal();
      const double dy = trackFar->yLocal() - trackNear->yLocal();
      const double r2 = dx*dx + dy*dy;
 
      if (r2 > trackDistanceRadiusSq) {
        ATH_MSG_DEBUG(
            "Tracks too far away from each other (xNear, yNear; xFar, yFar; distance) [mm]: "
            << trackNear->xLocal() << ", " << trackNear->yLocal() << "; "
            << trackFar->xLocal()  << ", " << trackFar->yLocal()  << "; " << r2);
 
        continue;
      }
 
      // Reconstruct proton and add it to the container
      xAOD::AFPProton * proton = reco(trackNear, trackFar, outputContainer);
 
      if (!proton)
        continue;
 
      foundMatchingTrack = true;
 
      // Create link to tracks
      linkTracksToProton(trackNear, trackContainer, proton);
      linkTracksToProton(trackFar, trackContainer, proton);
    }
 
    // Reconstuct proton using only FAR station if
    // no matching track on NEAR station was found
    if (m_allowSingleStationReco and !foundMatchingTrack) {
      // Apply cuts
      // none
 
      xAOD::AFPProton * proton = reco(trackFar, outputContainer);
 
      if (!proton)
        continue;
 
      linkTracksToProton(trackFar, trackContainer, proton);
    }
  }
  
  return StatusCode::SUCCESS;
}

initialize()

StatusCode AFP_ProtonRecoAnalytical::initialize ( )

override

Loads parameterization.

Definition at line 33 of file AFP_ProtonRecoAnalytical.cxx.

{
 
  CHECK( m_trackContainerKey.initialize() );
  
  if(m_detectorPositions.empty())
  {
    if(m_side==0)
    {
      m_detectorPositionNear=205.217;
      m_detectorPositionFar=217.302;
    }
    else if(m_side==1)
    {
      m_detectorPositionNear=205.824;
      m_detectorPositionFar=217.909;
    }
    else
    {
      ATH_MSG_ERROR("unknown side id "<<m_side<<", allowed values are 0 (for A) and 1 (for C)");
      return StatusCode::FAILURE;
    }
  }
  else if(m_detectorPositions.size()==2)
  {
    if(m_detectorPositions[0]<m_detectorPositions[1])
    {
      m_detectorPositionNear=m_detectorPositions[0];
      m_detectorPositionFar =m_detectorPositions[1];
    }
    else
    {
      m_detectorPositionNear=m_detectorPositions[1];
      m_detectorPositionFar =m_detectorPositions[0];
    }
  }
  else
  {
    ATH_MSG_ERROR("there are "<<m_detectorPositions.size()<<" entries for m_detectorPositions, we have only 2 detectors on each side");
    return StatusCode::FAILURE;
  }
 
  if(m_parametrizationFileName.empty())
  {
    ATH_MSG_ERROR("parametrizationFileName is not set");
    return StatusCode::FAILURE;
  }
  
  const std::string parametrization = PathResolverFindDataFile(m_parametrizationFileName);
  if(parametrization.empty())
  {
    ATH_MSG_ERROR("Cannot find " << m_parametrizationFileName);
    return StatusCode::FAILURE;
  }
 
  m_parametrization = std::make_unique<AFP::Parameterization>(parametrization);
  m_parametrizationPosition = m_parametrization->parametrizationPosition();
  m_parametrizationEnergy = m_parametrization->energy();
  m_distanceBetweenStations = m_detectorPositionFar - m_detectorPositionNear;
 
  return StatusCode::SUCCESS;
}

linkTracksToProton()

void AFP_ProtonRecoBase::linkTracksToProton ( const xAOD::AFPTrack * track, SG::ReadHandle< xAOD::AFPTrackContainer > & trackContainer, xAOD::AFPProton * proton ) const

protectedinherited

Links track pair to reconstructed proton.

Definition at line 119 of file AFP_ProtonRecoBase.cxx.

                                                                                                                 {
 
  ElementLink<xAOD::AFPTrackContainer> trackLink;
 
  trackLink.toContainedElement(*trackContainer, track);
  proton->addAFPTrackLink(trackLink);
}

outputContainerName()

const std::string & AFP_ProtonRecoBase::outputContainerName ( ) const

inlineoverrideinherited

Definition at line 41 of file AFP_ProtonRecoBase.h.

{return m_protonsContainerName;}

reco() [1/2]

xAOD::AFPProton * AFP_ProtonRecoAnalytical::reco ( const xAOD::AFPTrack * trkFar, std::unique_ptr< xAOD::AFPProtonContainer > & outputContainer ) const

overrideprivatevirtual

Reconstructs single proton using only one track from far station.

Reimplemented from AFP_ProtonRecoBase.

Definition at line 167 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                                                          {
 
  const Measurement my_measAFP = Measurement(0., 0., trackFar->xLocal(), trackFar->yLocal());
 
  ATH_MSG_DEBUG("Reconstructing proton with bisection method (single station)...");
  ATH_MSG_DEBUG("Tracks (xFar, yFar): " << my_measAFP.xF << ", " << my_measAFP.yF);
 
  std::vector<double> my_slopeCalculated = {0, 0};
  std::vector<double> my_positionCalculated = {0, 0};
 
  const double energy = bisection(&AFP_ProtonRecoAnalytical::singleStation, my_measAFP, my_slopeCalculated, my_positionCalculated);
 
  return createProton({0., 0., energy}, my_measAFP, xAOD::AFPProtonRecoAlgID::analytical, outputContainer);
}

reco() [2/2]

xAOD::AFPProton * AFP_ProtonRecoAnalytical::reco ( const xAOD::AFPTrack * trkNear, const xAOD::AFPTrack * trkFar, std::unique_ptr< xAOD::AFPProtonContainer > & outputContainer ) const

overrideprivatevirtual

Reconstructs single proton from pair of tracks.

• Sets up measurement and calculates slopes and postitions
• Reconstructs energy of proton with bisection method
• Calculates initial proton slopes
• Adds proton to outputContainer and sets its properties

Returns

Pointer to reconstructed AFPProton

AFP measurement

Reimplemented from AFP_ProtonRecoBase.

Definition at line 138 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                                                                                         {
  
  const Measurement my_measAFP = Measurement(trackNear->xLocal(), trackNear->yLocal(), trackFar->xLocal(), trackFar->yLocal());
  
  std::vector<double> my_slopeCalculated = {0, 0};
  std::vector<double> my_positionCalculated = {0, 0};
  
  my_slopeCalculated.at(0) = (my_measAFP.xF - my_measAFP.xN)/m_distanceBetweenStations;
  my_slopeCalculated.at(1) = (my_measAFP.yF - my_measAFP.yN)/m_distanceBetweenStations;
  my_positionCalculated.at(0) = my_measAFP.xN + my_slopeCalculated.at(0)*(m_parametrizationPosition - m_detectorPositionNear);
  my_positionCalculated.at(1) = my_measAFP.yN + my_slopeCalculated.at(1)*(m_parametrizationPosition - m_detectorPositionNear);
 
  ATH_MSG_DEBUG("Reconstructing proton with bisection method...");
  ATH_MSG_DEBUG("Tracks (xNear, yNear; xFar, yFar): " << my_measAFP.xN << ", " << my_measAFP.yN << "; "
                                                      << my_measAFP.xF << ", " << my_measAFP.yF);
 
  const double energy = bisection(&AFP_ProtonRecoAnalytical::bothStations, my_measAFP, my_slopeCalculated, my_positionCalculated);
  const double slopeX = calculateXslope(energy,my_slopeCalculated);
  const double slopeY = calculateYslope(energy,my_slopeCalculated);
 
  const double px = energy * slopeX;
  const double py = energy * slopeY;
  const double pz = energy * sqrt(1. - slopeX*slopeX - slopeY*slopeY);
 
  return createProton({px, py, pz}, my_measAFP, xAOD::AFPProtonRecoAlgID::analytical, outputContainer);
}

singleStation()

double AFP_ProtonRecoAnalytical::singleStation ( double energy, const Measurement & my_measAFP, std::vector< double > & my_slopeCalculated, std::vector< double > & my_positionCalculated ) const

private

Function obtained from parameterization equation.

Used in bisection method for single station reconstruction.

Definition at line 210 of file AFP_ProtonRecoAnalytical.cxx.

                                                                                                                                              {
 
  const double xi    = 1.0 - energy / m_parametrizationEnergy;
  const double xNear = my_measAFP.xF - m_distanceBetweenStations * m_parametrization->sx(m_vertexIP.at(0), m_vertexIP.at(1), m_vertexIP.at(2), 0, 0, energy);
 
  const double Ax = m_parametrization->getEquation(0)->getPolynomial(0)->Eval(xi);
  const double Bx = m_parametrization->getEquation(0)->getPolynomial(1)->Eval(xi);
  const double Dx = m_parametrization->getEquation(0)->getPolynomial(3)->Eval(xi);
 
  return xNear - Ax - m_vertexIP.at(0)*Bx - m_vertexIP.at(2)*Dx;
}

Member Data Documentation

m_allowSingleStationReco

Gaudi::Property<bool> AFP_ProtonRecoBase::m_allowSingleStationReco {this, "allowSingleStationReco", false, "Switch for allowing proton reconstruction using only far station"}

protectedinherited

Definition at line 76 of file AFP_ProtonRecoBase.h.

{this, "allowSingleStationReco", false, "Switch for allowing proton reconstruction using only far station"};

m_detectorPositionFar

double AFP_ProtonRecoBase::m_detectorPositionFar = 0.0

protectedinherited

Default position of AFP far station.

Definition at line 95 of file AFP_ProtonRecoBase.h.

m_detectorPositionNear

double AFP_ProtonRecoBase::m_detectorPositionNear = 0.0

protectedinherited

Default position of AFP near station.

Definition at line 92 of file AFP_ProtonRecoBase.h.

m_detectorPositions

Gaudi::Property<std::vector<double> > AFP_ProtonRecoBase::m_detectorPositions {this, "detectorPositions", {}, "absolute values of detector positions for each station on one side"}

protectedinherited

Definition at line 70 of file AFP_ProtonRecoBase.h.

{this, "detectorPositions", {}, "absolute values of detector positions for each station on one side"};

m_distanceBetweenStations

double AFP_ProtonRecoAnalytical::m_distanceBetweenStations = 0.0

private

Distance between near and far station.

Definition at line 92 of file AFP_ProtonRecoAnalytical.h.

m_parametrization

std::unique_ptr<AFP::Parameterization> AFP_ProtonRecoAnalytical::m_parametrization

private

Pointer to parameterization.

Definition at line 89 of file AFP_ProtonRecoAnalytical.h.

m_parametrizationEnergy

double AFP_ProtonRecoAnalytical::m_parametrizationEnergy = 0.0

private

Parameterization energy.

Definition at line 101 of file AFP_ProtonRecoAnalytical.h.

m_parametrizationFileName

Gaudi::Property<std::string> AFP_ProtonRecoAnalytical::m_parametrizationFileName {this, "parametrizationFileName", {}, "Name of the file containing parameterization"}

private

Name of the file containing parameterization.

Definition at line 95 of file AFP_ProtonRecoAnalytical.h.

{this, "parametrizationFileName", {}, "Name of the file containing parameterization"};

m_parametrizationPosition

double AFP_ProtonRecoAnalytical::m_parametrizationPosition = 0.0

private

Position for which parameterization was performed.

Definition at line 98 of file AFP_ProtonRecoAnalytical.h.

m_protonsContainerName

Gaudi::Property<std::string> AFP_ProtonRecoBase::m_protonsContainerName {this, "protonsContainerName", "AFPProtonContainer", "Name of the container in which protons are saved"}

protectedinherited

Definition at line 80 of file AFP_ProtonRecoBase.h.

{this, "protonsContainerName", "AFPProtonContainer", "Name of the container in which protons are saved"};

m_side

Gaudi::Property<int> AFP_ProtonRecoBase::m_side {this, "side", 0, "side id, A=0, C=1"}

protectedinherited

Definition at line 72 of file AFP_ProtonRecoBase.h.

{this, "side", 0, "side id, A=0, C=1"};

m_trackContainerKey

SG::ReadHandleKey<xAOD::AFPTrackContainer> AFP_ProtonRecoBase::m_trackContainerKey {this, "AFPTrackContainerKey", "AFPTrackContainer", "Name of the container with tracks of hits from which protons are to be reconstructed"}

protectedinherited

Definition at line 78 of file AFP_ProtonRecoBase.h.

{this, "AFPTrackContainerKey", "AFPTrackContainer", "Name of the container with tracks of hits from which protons are to be reconstructed"};

m_trackDistance

Gaudi::Property<double> AFP_ProtonRecoBase::m_trackDistance {this, "trackDistance", 2.0, "Maximum distance between tracks in the near and the far station on xy-plane"}

protectedinherited

Definition at line 74 of file AFP_ProtonRecoBase.h.

{this, "trackDistance", 2.0, "Maximum distance between tracks in the near and the far station on xy-plane"};

m_vertexIP

const std::vector<double> AFP_ProtonRecoBase::m_vertexIP = {0, 0, 0}

protectedinherited

Vertex position.

Definition at line 105 of file AFP_ProtonRecoBase.h.

{0, 0, 0};

m_xSigma

double AFP_ProtonRecoBase::m_xSigma = 10e-6

staticconstexprprotectedinherited

x-Sigma value

Definition at line 98 of file AFP_ProtonRecoBase.h.

m_ySigma

double AFP_ProtonRecoBase::m_ySigma = 30e-6

staticconstexprprotectedinherited

y-Sigma value

Definition at line 101 of file AFP_ProtonRecoBase.h.

---

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

• AFP_ProtonRecoAnalytical.h
• AFP_ProtonRecoAnalytical.cxx