ROOT logo
///////////////////////////////////////////////////////////////////////////
//                                                                       //
// AliFmHelix: a helper helix class                                      //
//                                                                       //
///////////////////////////////////////////////////////////////////////////

#ifndef ALIFMHELIX_H
#define ALIFMHELIX_H

#include <math.h>
#include <utility>
#include <algorithm>
#include "AliFmThreeVector.h"
#include <TMath.h>
#if !defined(ST_NO_NAMESPACES)
using std::pair;
using std::swap;
using std::max;
#endif

#ifdef WIN32
#include "gcc2vs.h"
#endif

#ifdef __SUNPRO_CC
#include <ieeefp.h>
#define __FUNCTION__ "__FILE__:__LINE__"
#endif

class AliFmHelix {
public:
    /// curvature, dip angle, phase, origin, h
    AliFmHelix(double c, double dip, double phase,
	       const AliFmThreeVector<double>& o, int h=-1);
    
    virtual ~AliFmHelix();
    // AliFmHelix(const AliFmHelix&);			// use default
    // AliFmHelix& operator=(const AliFmHelix&);	// use default

    double       DipAngle()   const;           
    double       Curvature()  const;	/// 1/R in xy-plane
    double       Phase()      const;	/// aziumth in xy-plane measured from ring center
    double       XCenter()    const;	/// x-center of circle in xy-plane
    double       YCenter()    const;	/// y-center of circle in xy-plane
    int          H()          const;	/// -sign(q*B);
    
    const AliFmThreeVector<double>& Origin() const;	/// starting point

    void SetParameters(double c, double dip, double phase, const AliFmThreeVector<double>& o, int h);
    
    double       X(double s)  const;
    double       Y(double s)  const;
    double       Z(double s)  const;

    AliFmThreeVector<double>  At(double s) const;

    /// returns period length of helix
    double       Period()       const;
    
    /// path length at given r (cylindrical r)
    pair<double, double> PathLength(double r)   const;
    
    /// path length at given r (cylindrical r, cylinder axis at x,y)
    pair<double, double> PathLength(double r, double x, double y, bool scanPeriods = true);
    
    /// path length at distance of closest approach to a given point
    double       PathLength(const AliFmThreeVector<double>& p, bool scanPeriods = true) const;
    
    /// path length at intersection with plane
    double       PathLength(const AliFmThreeVector<double>& r,
			    const AliFmThreeVector<double>& n) const;

    /// path length at distance of closest approach in the xy-plane to a given point
    double       PathLength(double x, double y) const;

    /// path lengths at dca between two helices 
    pair<double, double> PathLengths(const AliFmHelix& h, bool scanPeriods = true) const;
    
    /// minimal distance between point and helix
    double       Distance(const AliFmThreeVector<double>& p, bool scanPeriods = true) const;    
    
    /// checks for valid parametrization
    bool         Valid(double world = 1.e+5) const {return !Bad(world);}
    int            Bad(double world = 1.e+5) const;
    
    /// move the origin along the helix to s which becomes then s=0
    virtual void MoveOrigin(double s);
    
    static const double fgkNoSolution;  // coinstant indicating lack of solution
    
protected:
    AliFmHelix();
    
    void SetCurvature(double d);	/// performs also various checks   
    void SetPhase(double d);	        
    void SetDipAngle(double d);
    
    /// value of S where distance in x-y plane is minimal
    double FudgePathLength(const AliFmThreeVector<double>& v) const;
    
protected:
    bool                   fSingularity;	// true for straight line case (B=0)
    AliFmThreeVector<double>  fOrigin;          // Helix origin
    double                 fDipAngle;           // Helix dip angle
    double                 fCurvature;          // curvature
    double                 fPhase;              // phase
    int                    fH;			// -sign(q*B);

    double                 fCosDipAngle;        // cosine of the dip angle
    double                 fSinDipAngle;        // sine of the dip angle
    double                 fCosPhase;           // cosine of the phase
    double                 fSinPhase;           // sine of the phase
#ifdef __ROOT__
  ClassDef(AliFmHelix,1)
#endif
};

//
//     Non-member functions
//
int operator== (const AliFmHelix&, const AliFmHelix&);
int operator!= (const AliFmHelix&, const AliFmHelix&);
ostream& operator<<(ostream&, const AliFmHelix&);

//
//     Inline functions
//
inline int AliFmHelix::H() const {return fH;}

inline double AliFmHelix::DipAngle() const {return fDipAngle;}

inline double AliFmHelix::Curvature() const {return fCurvature;}

inline double AliFmHelix::Phase() const {return fPhase;}

inline double AliFmHelix::X(double s) const
{
    if (fSingularity)
	return fOrigin.x() - s*fCosDipAngle*fSinPhase;
    else
	return fOrigin.x() + (cos(fPhase + s*fH*fCurvature*fCosDipAngle)-fCosPhase)/fCurvature;
}
 
inline double AliFmHelix::Y(double s) const
{
    if (fSingularity)
	return fOrigin.y() + s*fCosDipAngle*fCosPhase;
    else
	return fOrigin.y() + (sin(fPhase + s*fH*fCurvature*fCosDipAngle)-fSinPhase)/fCurvature;
}

inline double AliFmHelix::Z(double s) const
{
    return fOrigin.z() + s*fSinDipAngle;
}

inline const AliFmThreeVector<double>& AliFmHelix::Origin() const {return fOrigin;}

inline AliFmThreeVector<double> AliFmHelix::At(double s) const
{
    return AliFmThreeVector<double>(X(s), Y(s), Z(s));
}

inline double AliFmHelix::PathLength(double x, double y) const
{
    return FudgePathLength(AliFmThreeVector<double>(x, y, 0));
}
inline int AliFmHelix::Bad(double WorldSize) const
{

    int ierr;
    if (!TMath::Finite(fDipAngle    )) 	return   11;
    if (!TMath::Finite(fCurvature   )) 	return   12;

    ierr = fOrigin.Bad(WorldSize);
    if (ierr)                           return    3+ierr*100;

    if (::fabs(fDipAngle)  >1.58)	return   21;
    double qwe = ::fabs(::fabs(fDipAngle)-M_PI/2);
    if (qwe < 1./WorldSize      ) 	return   31; 

    if (::fabs(fCurvature) > WorldSize)	return   22;
    if (fCurvature < 0          )	return   32;

    if (abs(fH) != 1            )       return   24; 

    return 0;
}

#endif
 AliFmHelix.h:1
 AliFmHelix.h:2
 AliFmHelix.h:3
 AliFmHelix.h:4
 AliFmHelix.h:5
 AliFmHelix.h:6
 AliFmHelix.h:7
 AliFmHelix.h:8
 AliFmHelix.h:9
 AliFmHelix.h:10
 AliFmHelix.h:11
 AliFmHelix.h:12
 AliFmHelix.h:13
 AliFmHelix.h:14
 AliFmHelix.h:15
 AliFmHelix.h:16
 AliFmHelix.h:17
 AliFmHelix.h:18
 AliFmHelix.h:19
 AliFmHelix.h:20
 AliFmHelix.h:21
 AliFmHelix.h:22
 AliFmHelix.h:23
 AliFmHelix.h:24
 AliFmHelix.h:25
 AliFmHelix.h:26
 AliFmHelix.h:27
 AliFmHelix.h:28
 AliFmHelix.h:29
 AliFmHelix.h:30
 AliFmHelix.h:31
 AliFmHelix.h:32
 AliFmHelix.h:33
 AliFmHelix.h:34
 AliFmHelix.h:35
 AliFmHelix.h:36
 AliFmHelix.h:37
 AliFmHelix.h:38
 AliFmHelix.h:39
 AliFmHelix.h:40
 AliFmHelix.h:41
 AliFmHelix.h:42
 AliFmHelix.h:43
 AliFmHelix.h:44
 AliFmHelix.h:45
 AliFmHelix.h:46
 AliFmHelix.h:47
 AliFmHelix.h:48
 AliFmHelix.h:49
 AliFmHelix.h:50
 AliFmHelix.h:51
 AliFmHelix.h:52
 AliFmHelix.h:53
 AliFmHelix.h:54
 AliFmHelix.h:55
 AliFmHelix.h:56
 AliFmHelix.h:57
 AliFmHelix.h:58
 AliFmHelix.h:59
 AliFmHelix.h:60
 AliFmHelix.h:61
 AliFmHelix.h:62
 AliFmHelix.h:63
 AliFmHelix.h:64
 AliFmHelix.h:65
 AliFmHelix.h:66
 AliFmHelix.h:67
 AliFmHelix.h:68
 AliFmHelix.h:69
 AliFmHelix.h:70
 AliFmHelix.h:71
 AliFmHelix.h:72
 AliFmHelix.h:73
 AliFmHelix.h:74
 AliFmHelix.h:75
 AliFmHelix.h:76
 AliFmHelix.h:77
 AliFmHelix.h:78
 AliFmHelix.h:79
 AliFmHelix.h:80
 AliFmHelix.h:81
 AliFmHelix.h:82
 AliFmHelix.h:83
 AliFmHelix.h:84
 AliFmHelix.h:85
 AliFmHelix.h:86
 AliFmHelix.h:87
 AliFmHelix.h:88
 AliFmHelix.h:89
 AliFmHelix.h:90
 AliFmHelix.h:91
 AliFmHelix.h:92
 AliFmHelix.h:93
 AliFmHelix.h:94
 AliFmHelix.h:95
 AliFmHelix.h:96
 AliFmHelix.h:97
 AliFmHelix.h:98
 AliFmHelix.h:99
 AliFmHelix.h:100
 AliFmHelix.h:101
 AliFmHelix.h:102
 AliFmHelix.h:103
 AliFmHelix.h:104
 AliFmHelix.h:105
 AliFmHelix.h:106
 AliFmHelix.h:107
 AliFmHelix.h:108
 AliFmHelix.h:109
 AliFmHelix.h:110
 AliFmHelix.h:111
 AliFmHelix.h:112
 AliFmHelix.h:113
 AliFmHelix.h:114
 AliFmHelix.h:115
 AliFmHelix.h:116
 AliFmHelix.h:117
 AliFmHelix.h:118
 AliFmHelix.h:119
 AliFmHelix.h:120
 AliFmHelix.h:121
 AliFmHelix.h:122
 AliFmHelix.h:123
 AliFmHelix.h:124
 AliFmHelix.h:125
 AliFmHelix.h:126
 AliFmHelix.h:127
 AliFmHelix.h:128
 AliFmHelix.h:129
 AliFmHelix.h:130
 AliFmHelix.h:131
 AliFmHelix.h:132
 AliFmHelix.h:133
 AliFmHelix.h:134
 AliFmHelix.h:135
 AliFmHelix.h:136
 AliFmHelix.h:137
 AliFmHelix.h:138
 AliFmHelix.h:139
 AliFmHelix.h:140
 AliFmHelix.h:141
 AliFmHelix.h:142
 AliFmHelix.h:143
 AliFmHelix.h:144
 AliFmHelix.h:145
 AliFmHelix.h:146
 AliFmHelix.h:147
 AliFmHelix.h:148
 AliFmHelix.h:149
 AliFmHelix.h:150
 AliFmHelix.h:151
 AliFmHelix.h:152
 AliFmHelix.h:153
 AliFmHelix.h:154
 AliFmHelix.h:155
 AliFmHelix.h:156
 AliFmHelix.h:157
 AliFmHelix.h:158
 AliFmHelix.h:159
 AliFmHelix.h:160
 AliFmHelix.h:161
 AliFmHelix.h:162
 AliFmHelix.h:163
 AliFmHelix.h:164
 AliFmHelix.h:165
 AliFmHelix.h:166
 AliFmHelix.h:167
 AliFmHelix.h:168
 AliFmHelix.h:169
 AliFmHelix.h:170
 AliFmHelix.h:171
 AliFmHelix.h:172
 AliFmHelix.h:173
 AliFmHelix.h:174
 AliFmHelix.h:175
 AliFmHelix.h:176
 AliFmHelix.h:177
 AliFmHelix.h:178
 AliFmHelix.h:179
 AliFmHelix.h:180
 AliFmHelix.h:181
 AliFmHelix.h:182
 AliFmHelix.h:183
 AliFmHelix.h:184
 AliFmHelix.h:185
 AliFmHelix.h:186
 AliFmHelix.h:187
 AliFmHelix.h:188
 AliFmHelix.h:189
 AliFmHelix.h:190