MuonR4::CombinatorialSeedSolver Namespace Reference

Functions
template<typename spacePointContainer >
requires acceptedContainer< spacePointContainer > &&hasPointerValues< spacePointContainer >	AmgSymMatrix (2) betaMatrix(const spacePointContainer &spacePoints)
	defines the betaMatrix calculated from the combinatoric hits More...
template<typename spacePointContainer >
requires acceptedContainer< spacePointContainer > &&hasPointerValues< spacePointContainer > std::array< double, 4 >	defineParameters (AmgSymMatrix(2) betaMatrix, const spacePointContainer &spacePoints)
	calculates the parameters lamda,alpha,gamma,kappa of the system More...
template<typename spacePointContainer >
requires acceptedContainer< spacePointContainer > &&hasPointerValues< spacePointContainer > std::pair< Amg::Vector3D, Amg::Vector3D >	seedSolution (const spacePointContainer &spacePoints, const std::array< double, 4 > &parameters)
	solves the equation system to calculate the seed More...

Variables
template<typename Container >
concept	hasPositionAndDirection
template<typename Container >
concept	hasPointerValues
template<typename Container >
concept	acceptedContainer

Function Documentation

AmgSymMatrix()

template<typename spacePointContainer >

requires acceptedContainer<spacePointContainer>&& hasPointerValues<spacePointContainer> MuonR4::CombinatorialSeedSolver::AmgSymMatrix

(

2

)

const &

defines the betaMatrix calculated from the combinatoric hits

Template Parameters

spacePointContainer

the space point container

Parameters

spacePoints

the space points of the combinatorics

Returns

the 2x2 beta matrix

Definition at line 66 of file CombinatorialSeedSolver.h.

                                                                        {
 
        AmgSymMatrix(2) bMatrix{AmgSymMatrix(2)::Identity()};
        Amg::Vector3D b1Aterm = (spacePoints[3]->directionInChamber().dot(spacePoints[1]->directionInChamber()))*spacePoints[1]->directionInChamber()-spacePoints[3]->directionInChamber();
        Amg::Vector3D b1Gterm = (spacePoints[3]->directionInChamber().dot(spacePoints[0]->directionInChamber()))*spacePoints[0]->directionInChamber() - (spacePoints[3]->directionInChamber().dot(spacePoints[1]->directionInChamber()))*spacePoints[1]->directionInChamber(); 
 
        Amg::Vector3D b2Aterm = spacePoints[2]->directionInChamber()- (spacePoints[2]->directionInChamber().dot(spacePoints[1]->directionInChamber()))*spacePoints[1]->directionInChamber();
        Amg::Vector3D b2Kterm = (spacePoints[2]->directionInChamber().dot(spacePoints[1]->directionInChamber()))*spacePoints[1]->directionInChamber() - (spacePoints[2]->directionInChamber().dot(spacePoints[0]->directionInChamber()))*spacePoints[0]->directionInChamber();
    
        //get the distances of the layers along z direction
        double A = (spacePoints[0]->positionInChamber().z() - spacePoints[1]->positionInChamber().z());
        double G = (spacePoints[0]->positionInChamber().z() - spacePoints[2]->positionInChamber().z());
        double K = (spacePoints[0]->positionInChamber().z() - spacePoints[3]->positionInChamber().z());
 
        //define B matrix
        Amg::Vector3D b1 = A*b1Aterm + G*b1Gterm;
        Amg::Vector3D b2 = K*b2Kterm + A*b2Aterm;
 
        bMatrix.col(0) = Amg::Vector2D(b1.x(), b1.y());
        bMatrix.col(1) = Amg::Vector2D(b2.x(), b2.y());
 
        return bMatrix;
      };

defineParameters()

template<typename spacePointContainer >

requires acceptedContainer<spacePointContainer>&& hasPointerValues<spacePointContainer> std::array<double,4> MuonR4::CombinatorialSeedSolver::defineParameters	(	AmgSymMatrix(2)	betaMatrix,
		const spacePointContainer &	spacePoints
	)

calculates the parameters lamda,alpha,gamma,kappa of the system

Template Parameters

spacePointContainer

the space point container

Parameters

betaMatrix	the betaMatrix for the system
spacePoints	the space points of the combinatorics

Returns

an array of the calculated parameters

Definition at line 97 of file CombinatorialSeedSolver.h.

                                                                                                             {
 
        double A = (spacePoints[0]->positionInChamber().z() - spacePoints[1]->positionInChamber().z());
        double G = (spacePoints[0]->positionInChamber().z() - spacePoints[2]->positionInChamber().z());
        double K = (spacePoints[0]->positionInChamber().z() - spacePoints[3]->positionInChamber().z());
 
        //Define y2 for the linear system
        Amg::Vector3D y0 = K*(spacePoints[2]->positionInChamber()- spacePoints[0]->positionInChamber()) + G*(spacePoints[0]->positionInChamber()- spacePoints[3]->positionInChamber());
        Amg::Vector3D y1 = A*(spacePoints[3]->positionInChamber() - spacePoints[2]->positionInChamber()) + G*(spacePoints[1]->positionInChamber() - spacePoints[3]->positionInChamber()) + K*(spacePoints[2]->positionInChamber()-spacePoints[1]->positionInChamber());
        Amg::Vector3D y2 = (K-G)*(spacePoints[0]->positionInChamber()- spacePoints[1]->positionInChamber()) - (y1.dot(spacePoints[1]->directionInChamber()))*spacePoints[1]->directionInChamber() + (y0.dot(spacePoints[0]->directionInChamber()))*spacePoints[0]->directionInChamber() +A*(spacePoints[3]->positionInChamber()- spacePoints[2]->positionInChamber());
 
        Amg::Vector2D solution = betaMatrix.inverse()*y2.block<2,1>(0,0);
        double kappa = solution.x();
        double gamma = solution.y();
 
        double lamda = (y0.dot(spacePoints[0]->directionInChamber()) + K*gamma*(spacePoints[0]->directionInChamber().dot(spacePoints[2]->directionInChamber())) -G*kappa*(spacePoints[0]->directionInChamber().dot(spacePoints[3]->directionInChamber())))/(K-G);
        double alpha = (y1.dot(spacePoints[1]->directionInChamber())+(A-G)*kappa*spacePoints[3]->directionInChamber().dot(spacePoints[1]->directionInChamber()) + (K-A)*gamma*spacePoints[2]->directionInChamber().dot(spacePoints[1]->directionInChamber()))/(K-G);
        
        return std::array<double,4>({lamda,alpha,gamma,kappa});
 
      };

seedSolution()

template<typename spacePointContainer >

requires acceptedContainer<spacePointContainer>&& hasPointerValues<spacePointContainer> std::pair<Amg::Vector3D, Amg::Vector3D> MuonR4::CombinatorialSeedSolver::seedSolution	(	const spacePointContainer &	spacePoints,
		const std::array< double, 4 > &	parameters
	)

solves the equation system to calculate the seed

Template Parameters

spacePointContainr

the space point container

Parameters

spacePoints	the space points of the combinatorics
parameters	the lamda,alpha,gamma,kappa paramaters of the four layers

Returns

the pair of the seed position and direction

Definition at line 127 of file CombinatorialSeedSolver.h.

                                                                                                                                  {
        
        //estimate the seed positionInChamber from the 1st equation of the system of the layer equations
        Amg::Vector3D seedPosition = spacePoints[0]->positionInChamber() + parameters[0]*spacePoints[0]->directionInChamber();
 
        //estimate the seed direction from the 2nd equation of the system of the layer equations
        Amg::Vector3D seedDirection = ((spacePoints[1]->positionInChamber() + parameters[1]*spacePoints[1]->directionInChamber() - seedPosition)).unit();
 
        Amg::Vector3D seedPositionZ0 = seedPosition + Amg::intersect<3>(seedPosition, seedDirection, Amg::Vector3D::UnitZ(), 0.).value_or(0.)*seedDirection;
 
    
 
        return std::make_pair(seedPositionZ0, seedDirection.z() > 0 ? seedDirection : -seedDirection);
 
      };

Variable Documentation

acceptedContainer

template<typename Container >

concept MuonR4::CombinatorialSeedSolver::acceptedContainer

Initial value:

= requires(const Container& c){
        {c.size()} ->std::same_as<std::size_t>;
        requires hasPositionAndDirection<Container>;
 
      }

Definition at line 52 of file CombinatorialSeedSolver.h.

hasPointerValues

template<typename Container >

concept MuonR4::CombinatorialSeedSolver::hasPointerValues

Initial value:

= requires {
      typename Container::value_type; 
      requires std::is_pointer_v<typename Container::value_type>; 
      }

Definition at line 44 of file CombinatorialSeedSolver.h.

hasPositionAndDirection

template<typename Container >

concept MuonR4::CombinatorialSeedSolver::hasPositionAndDirection

Initial value:

= requires(typename Container::value_type& v){
 
          {v->directionInChamber()}->std::same_as<const Amg::Vector3D&>;
          {v->positionInChamber()}->std::same_as<const Amg::Vector3D&>;
 
      }

Definition at line 35 of file CombinatorialSeedSolver.h.