Alignment of a TOP module. More...

#include <ModuleAlignment.h>

Public Member Functions
	ModuleAlignment (PDFConstructor::EPDFOption opt=PDFConstructor::c_Rough)
	Constructor.

void	setModuleID (int moduleID)
	Sets module ID.

void	setSteps (double position, double angle, double time)
	Sets steps for numerical calculation of derivatives.

void	setParameters (const std::vector< double > &parInit)
	Sets initial values of parameters (overwrites current parameters!) Order is: translations in x, y, z, rotation angles around x, y, z, module T0.

void	fixParameter (const std::string &name)
	Fixes parameter with its name given as argument.

void	releaseParameter (const std::string &name)
	Release fixed parameter.

void	releaseAllParameters ()
	Release all fixed parameters.

int	iterate (TOPTrack &track, const Const::ChargedStable &hypothesis)
	Run a single alignment iteration, on success update alignment parameters.

void	reset ()
	Reset the object.

int	getModuleID () const
	Returns module ID.

const std::vector< std::string > &	getParameterNames () const
	Returns alignment parameter names.

const std::vector< double > &	getParams () const
	Returns alignment parameters.

std::vector< float >	getParameters () const
	Returns alignment parameters.

std::vector< float >	getErrors () const
	Returns errors on alignment parameters.

const TMatrixDSym &	getErrorMatrix () const
	Returns error matrix of alignment parameters Order is: translations in x, y, z, rotation angles around x, y, z, module T0.

int	getNumTracks () const
	Returns track counter.

int	getNumUsedTracks () const
	Returns number of tracks used in current result.

bool	isValid () const
	Checks if the results are valid.

int	getNumOfPhotons () const
	Returns number of photons used for log likelihood calculation.

Private Member Functions
double	getLogL (const std::vector< double > &par, bool &ok)
	Returns log likelihood for given parameters Note: it changes helix parameters of TOPTrack object (m_track)

bool	derivatives (std::vector< double > &first, TMatrixDSym &second)
	Calculates numerically first and second derivatives of log likelihood against the parameters.

int	invertMatrixU ()
	Inverts matrix m_U using Cholesky decomposition.

Private Attributes
int	m_moduleID = 0
	module ID

PDFConstructor::EPDFOption	m_opt = PDFConstructor::c_Rough
	PDF option.

std::vector< std::string >	m_parNames
	parameter names

std::vector< double >	m_parInit
	initial parameter values

std::vector< double >	m_par
	current parameter values

std::vector< double >	m_steps
	step sizes

std::vector< double >	m_maxDpar
	maximal parameter changes in one iteration

std::vector< bool >	m_fixed
	true if parameter is fixed

TMatrixDSym	m_COV
	covariance matrix

int	m_numTracks = 0
	track counter

int	m_numUsedTracks = 0
	number of tracks used

int	m_numPhotons = 0
	number of photons used for log likelihood calculation

bool	m_valid = false
	validity of results

TMatrixDSym	m_U
	matrix (neg.

TOPTrack *	m_track = 0
	track parameters at TOP

Const::ChargedStable	m_hypothesis = Const::muon
	particle hypothesis

Detailed Description

Alignment of a TOP module.

Definition at line 30 of file ModuleAlignment.h.

Constructor & Destructor Documentation

◆ ModuleAlignment()

ModuleAlignment ( PDFConstructor::EPDFOption opt = PDFConstructor::c_Rough )

Constructor.

Parameters

opt	PDF construction option

Definition at line 25 of file ModuleAlignment.cc.

                                                                : m_opt(opt)
    {
      m_parNames.push_back("x");
      m_parNames.push_back("y");
      m_parNames.push_back("z");
      m_parNames.push_back("alpha");
      m_parNames.push_back("beta");
      m_parNames.push_back("gamma");
      m_parNames.push_back("t0");
      unsigned numPar = m_parNames.size();
      m_parInit.resize(numPar, 0);
      m_par = m_parInit;
      m_steps.resize(numPar, 0);
      m_fixed.resize(numPar, false);
      m_COV.ResizeTo(numPar, numPar);
      m_U.ResizeTo(numPar, numPar);
      setSteps(1.0, 0.01, 0.05);
    }

Member Function Documentation

◆ derivatives()

bool derivatives	(	std::vector< double > &	first,
		TMatrixDSym &	second
	)

private

Calculates numerically first and second derivatives of log likelihood against the parameters.

Parameters

first	a vector of first derivatives [out]
second	a matrix of second derivatives [out]

Returns: status (true on success)

Definition at line 141 of file ModuleAlignment.cc.

    {
      bool ok = false;
      double f0 = getLogL(m_par, ok);
      if (not ok) return false;
 
      auto par = m_par;
      for (size_t k = 0; k < par.size(); k++) {
        if (m_fixed[k]) continue;
 
        par[k] = m_par[k] + m_steps[k];
        double fp = getLogL(par, ok);
        if (not ok) return false;
 
        par[k] = m_par[k] - m_steps[k];
        double fm = getLogL(par, ok);
        if (not ok) return false;
 
        first[k] = (fp - fm) / 2 / m_steps[k];
        second[k][k] = (fp - 2 * f0 + fm) / pow(m_steps[k], 2);
 
        par[k] = m_par[k];
      }
 
      for (size_t k = 0; k < par.size(); k++) {
        if (m_fixed[k]) continue;
        for (size_t j = k + 1; j < par.size(); j++) {
          if (m_fixed[j]) continue;
 
          par[k] = m_par[k] + m_steps[k];
          par[j] = m_par[j] + m_steps[j];
          double fpp = getLogL(par, ok);
          if (not ok) return false;
 
          par[j] = m_par[j] - m_steps[j];
          double fpm = getLogL(par, ok);
          if (not ok) return false;
 
          par[k] = m_par[k] - m_steps[k];
          par[j] = m_par[j] + m_steps[j];
          double fmp = getLogL(par, ok);
          if (not ok) return false;
 
          par[j] = m_par[j] - m_steps[j];
          double fmm = getLogL(par, ok);
          if (not ok) return false;
 
          second[j][k] = second[k][j] = (fpp - fmp - fpm + fmm) / 4 / m_steps[k] / m_steps[j];
 
          par[j] = m_par[j];
        }
        par[k] = m_par[k];
      }
 
      return true;
    }

◆ fixParameter()

void fixParameter ( const std::string & name )

inline

Fixes parameter with its name given as argument.

Parameters

name	parameter name

Definition at line 70 of file ModuleAlignment.h.

      {
        for (unsigned i = 0; i < m_parNames.size(); i++) {
          if (name == m_parNames[i]) {
            m_fixed[i] = true;
            return;
          }
        }
        B2ERROR("TOP::ModuleAlignment::fixParameter: invalid parameter name '" << name << "'");
      }

◆ getErrorMatrix()

const TMatrixDSym & getErrorMatrix ( ) const

inline

Returns error matrix of alignment parameters Order is: translations in x, y, z, rotation angles around x, y, z, module T0.

Returns: error matrix

Definition at line 155 of file ModuleAlignment.h.

155{return m_COV;}

◆ getErrors()

std::vector< float > getErrors ( ) const

Returns errors on alignment parameters.

Order is: translations in x, y, z, rotation angles around x, y, z, module T0

Returns: errors in single precision

Definition at line 109 of file ModuleAlignment.cc.

    {
      std::vector<float> errors;
      int numPar = m_par.size();
      for (int i = 0; i < numPar; i++) {
        errors.push_back(sqrt(m_COV[i][i]));
      }
      return errors;
    }

◆ getLogL()

double getLogL	(	const std::vector< double > &	par,
		bool &	ok
	)

private

Returns log likelihood for given parameters Note: it changes helix parameters of TOPTrack object (m_track)

Parameters

par	parameters
ok	status [out]

Returns: log likelihood

Definition at line 119 of file ModuleAlignment.cc.

    {
      ROOT::Math::Translation3D t(par[0], par[1], par[2]);
      ROOT::Math::RotationX Rx(par[3]);
      ROOT::Math::RotationY Ry(par[4]);
      ROOT::Math::RotationZ Rz(par[5]);
      ROOT::Math::Transform3D T(Rz * Ry * Rx, t);
      ok = m_track->overrideTransformation(T);
      if (not ok) return 0;
 
      PDFConstructor pdfConstructor(*m_track, m_hypothesis, m_opt);
      if (not pdfConstructor.isValid()) {
        ok = false;
        return 0;
      }
 
      auto LL = pdfConstructor.getLogL(par[6]);
      m_numPhotons = LL.numPhotons;
 
      return LL.logL;
    }

◆ getModuleID()

int getModuleID ( ) const

inline

Returns module ID.

Returns: module ID

Definition at line 121 of file ModuleAlignment.h.

121{return m_moduleID;}

Belle2::TOP::ModuleAlignment::m_moduleID

int m_moduleID

module ID

Definition: ModuleAlignment.h:206

◆ getNumOfPhotons()

int getNumOfPhotons ( ) const

inline

Returns number of photons used for log likelihood calculation.

Returns: number of photons

Definition at line 179 of file ModuleAlignment.h.

179{return m_numPhotons;}

◆ getNumTracks()

int getNumTracks ( ) const

inline

Returns track counter.

Returns: number of tracks

Definition at line 161 of file ModuleAlignment.h.

161{return m_numTracks;}

Belle2::TOP::ModuleAlignment::m_numTracks

int m_numTracks

track counter

Definition: ModuleAlignment.h:216

◆ getNumUsedTracks()

int getNumUsedTracks ( ) const

inline

Returns number of tracks used in current result.

Returns: number of tracks

Definition at line 167 of file ModuleAlignment.h.

167{return m_numUsedTracks;}

Belle2::TOP::ModuleAlignment::m_numUsedTracks

int m_numUsedTracks

number of tracks used

Definition: ModuleAlignment.h:217

◆ getParameterNames()

const std::vector< std::string > & getParameterNames ( ) const

inline

Returns alignment parameter names.

Returns: parameter names

Definition at line 127 of file ModuleAlignment.h.

127{return m_parNames;}

◆ getParameters()

std::vector< float > getParameters ( ) const

Returns alignment parameters.

Order is: translations in x, y, z, rotation angles around x, y, z, module T0

Returns: parameters in single precision

Definition at line 102 of file ModuleAlignment.cc.

    {
      std::vector<float> pars;
      for (auto par : m_par) pars.push_back(par);
      return pars;
    }

◆ getParams()

const std::vector< double > & getParams ( ) const

inline

Returns alignment parameters.

Order is: translations in x, y, z, rotation angles around x, y, z, module T0

Returns: parameters in double precision

Definition at line 134 of file ModuleAlignment.h.

134{return m_par;}

◆ invertMatrixU()

int invertMatrixU ( )

private

Inverts matrix m_U using Cholesky decomposition.

Returns: error status (0 = OK, > 0 matrix not pos. definite)

Definition at line 198 of file ModuleAlignment.cc.

    {
      int n = 0;
      for (auto fixed : m_fixed) {
        if (not fixed) n++;
      }
 
      TMatrixDSym A(n);
      int ii = 0;
      for (int i = 0; i < m_U.GetNrows(); i++) {
        if (m_fixed[i]) continue;
        int kk = 0;
        for (int k = 0; k < m_U.GetNrows(); k++) {
          if (m_fixed[k]) continue;
          A[ii][kk] = m_U[i][k];
          kk++;
        }
        ii++;
      }
 
      TDecompChol chol(A);
      if (not chol.Decompose()) return 1;
      chol.Invert(A);
 
      ii = 0;
      for (int i = 0; i < m_U.GetNrows(); i++) {
        if (m_fixed[i]) continue;
        int kk = 0;
        for (int k = 0; k < m_U.GetNrows(); k++) {
          if (m_fixed[k]) continue;
          m_COV[i][k] = A[ii][kk];
          kk++;
        }
        ii++;
      }
 
      return 0;
    }

◆ isValid()

bool isValid ( ) const

inline

Checks if the results are valid.

Returns: true if results valid

Definition at line 173 of file ModuleAlignment.h.

173{return m_valid;}

Belle2::TOP::ModuleAlignment::m_valid

bool m_valid

validity of results

Definition: ModuleAlignment.h:219

◆ iterate()

int iterate	(	TOPTrack &	track,
		const Const::ChargedStable &	hypothesis
	)

Run a single alignment iteration, on success update alignment parameters.

Parameters

track	track parameters
hypothesis	particle hypothesis

Returns: error status (0 = OK, < 0 no track hit, > 0 matrix not positive definite)

Definition at line 56 of file ModuleAlignment.cc.

    {
      m_numPhotons = 0;
      if (track.getModuleID() != m_moduleID) return -2;
 
      m_track = &track;
      m_hypothesis = hypothesis;
 
      std::vector<double> first(m_par.size(), 0);
      TMatrixDSym second(m_par.size());
      if (not derivatives(first, second)) return -1;
 
      m_U -= second;
      m_numTracks++;
 
      int ier = invertMatrixU();
      if (ier != 0) return ier;
 
      std::vector<double> dpar(m_par.size(), 0);
      for (size_t i = 0; i < dpar.size(); i++) {
        for (size_t k = 0; k < dpar.size(); k++) {
          dpar[i] += m_COV[i][k] * first[k];
        }
        if (fabs(dpar[i]) > m_maxDpar[i]) return ier;
      }
 
      for (size_t i = 0; i < dpar.size(); i++) {
        m_par[i] += dpar[i];
      }
      m_numUsedTracks = m_numTracks;
      m_valid = true;
 
      return 0;
    }

◆ releaseAllParameters()

void releaseAllParameters ( )

inline

Release all fixed parameters.

Definition at line 99 of file ModuleAlignment.h.

      {
        for (unsigned i = 0; i < m_fixed.size(); i++) m_fixed[i] = false;
      }

◆ releaseParameter()

void releaseParameter ( const std::string & name )

inline

Release fixed parameter.

Parameters

name	parameter name

Definition at line 85 of file ModuleAlignment.h.

      {
        for (unsigned i = 0; i < m_parNames.size(); i++) {
          if (name == m_parNames[i]) {
            m_fixed[i] = false;
            return;
          }
        }
        B2ERROR("TOP::ModuleAlignment::releaseParameter: invalid parameter name '" << name << "'");
      }

◆ reset()

void reset ( )

Reset the object.

Definition at line 91 of file ModuleAlignment.cc.

    {
      m_par = m_parInit;
      m_COV.Zero();
      m_U.Zero();
      m_numTracks = 0;
      m_numUsedTracks = 0;
      m_valid = false;
      m_numPhotons = 0;
    }

◆ setModuleID()

void setModuleID ( int moduleID )

inline

Sets module ID.

Parameters

moduleID module ID

Definition at line 43 of file ModuleAlignment.h.

43{m_moduleID = moduleID;}

◆ setParameters()

void setParameters ( const std::vector< double > & parInit )

inline

Sets initial values of parameters (overwrites current parameters!) Order is: translations in x, y, z, rotation angles around x, y, z, module T0.

Parameters

parInit initial values

Definition at line 58 of file ModuleAlignment.h.

      {
        for (size_t i = 0; i < std::min(parInit.size(), m_parInit.size()); i++) {
          m_parInit[i] = parInit[i];
        }
        m_par = m_parInit;
      }

◆ setSteps()

void setSteps	(	double	position,
		double	angle,
		double	time
	)

Sets steps for numerical calculation of derivatives.

Parameters

position	step size for translations [cm]
angle	step size for rotations [radians]
time	step size for module T0 [ns]

Definition at line 44 of file ModuleAlignment.cc.

    {
      m_steps[0] = position;
      m_steps[1] = position;
      m_steps[2] = position;
      m_steps[3] = angle;
      m_steps[4] = angle;
      m_steps[5] = angle;
      m_steps[6] = time;
      m_maxDpar = m_steps;
    }

Member Data Documentation

◆ m_COV

TMatrixDSym m_COV

private

covariance matrix

Definition at line 215 of file ModuleAlignment.h.

◆ m_fixed

std::vector<bool> m_fixed

private

true if parameter is fixed

Definition at line 214 of file ModuleAlignment.h.

◆ m_hypothesis

Const::ChargedStable m_hypothesis = Const::muon

private

particle hypothesis

Definition at line 223 of file ModuleAlignment.h.

◆ m_maxDpar

std::vector<double> m_maxDpar

private

maximal parameter changes in one iteration

Definition at line 213 of file ModuleAlignment.h.

◆ m_moduleID

int m_moduleID = 0

private

module ID

Definition at line 206 of file ModuleAlignment.h.

◆ m_numPhotons

int m_numPhotons = 0

private

number of photons used for log likelihood calculation

Definition at line 218 of file ModuleAlignment.h.

◆ m_numTracks

int m_numTracks = 0

private

track counter

Definition at line 216 of file ModuleAlignment.h.

◆ m_numUsedTracks

int m_numUsedTracks = 0

private

number of tracks used

Definition at line 217 of file ModuleAlignment.h.

◆ m_opt

PDFConstructor::EPDFOption m_opt = PDFConstructor::c_Rough

private

PDF option.

Definition at line 207 of file ModuleAlignment.h.

◆ m_par

std::vector<double> m_par

private

current parameter values

Definition at line 211 of file ModuleAlignment.h.

◆ m_parInit

std::vector<double> m_parInit

private

initial parameter values

Definition at line 210 of file ModuleAlignment.h.

◆ m_parNames

std::vector<std::string> m_parNames

private

parameter names

Definition at line 209 of file ModuleAlignment.h.

◆ m_steps

std::vector<double> m_steps

private

step sizes

Definition at line 212 of file ModuleAlignment.h.

◆ m_track

TOPTrack* m_track = 0

private

track parameters at TOP

Definition at line 222 of file ModuleAlignment.h.

◆ m_U

TMatrixDSym m_U

private

matrix (neg.

sum of second derivatives)

Definition at line 221 of file ModuleAlignment.h.

◆ m_valid

bool m_valid = false

private

validity of results

Definition at line 219 of file ModuleAlignment.h.

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

top/reconstruction_cpp/include/ModuleAlignment.h
top/reconstruction_cpp/src/ModuleAlignment.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ModuleAlignment()

Member Function Documentation

◆ derivatives()

◆ fixParameter()

◆ getErrorMatrix()

◆ getErrors()

◆ getLogL()

◆ getModuleID()

◆ getNumOfPhotons()

◆ getNumTracks()

◆ getNumUsedTracks()

◆ getParameterNames()

◆ getParameters()

◆ getParams()

◆ invertMatrixU()

◆ isValid()

◆ iterate()

◆ releaseAllParameters()

◆ releaseParameter()

◆ reset()

◆ setModuleID()

◆ setParameters()

◆ setSteps()

Member Data Documentation

◆ m_COV

◆ m_fixed

◆ m_hypothesis

◆ m_maxDpar

◆ m_moduleID

◆ m_numPhotons

◆ m_numTracks

◆ m_numUsedTracks

◆ m_opt

◆ m_par

◆ m_parInit

◆ m_parNames

◆ m_steps

◆ m_track

◆ m_U

◆ m_valid