ROOT logo
#ifndef HPARTICLEBTPAR_H
#define HPARTICLEBTPAR_H
#include "TArrayF.h"
#include "hparcond.h"

#include <iostream>

using namespace std;


class HParamList;

class HParticleBtPar : public HParCond {

protected:


    Float_t fNSigma;          // nSigma
    Int_t   fSizeMatrix;      // matrix size
    Float_t fPhiOffsetPar;    // phiOffsetPar
    Float_t fMinimumSigmaVal; // Minimum Sigma value for parametrization
    Int_t   fMaximumType;     //MaximumType:7,8,4

    TArrayI fRingFitPar;      // nRingSegments, nVertex, nParMean, nParSigma
    TArrayF fChargeThres;     // sector-wise charge thresholds
    TArrayF fGeomConst;       // padWidthX, padWidthY thetaAngleMin , thetaAngleMax
    TArrayI fRingSeg;         // ringSegStep, ringSegOffset;
    TArrayF fSharedCharge;    // 3 x diagonal pads;3 x vertical pads;3 x hporizontal pads
    TArrayF fSigmaGaus;       // 2 x SigmaGauss;2 x SigmaGaussRange
    TArrayF fParThetaAngle;   // min and max theta angles
    TArrayF fPhiOffset;       // 6 x 2 Phi offsets

    TArrayF fSigmaRange;      // Sigma, Sigma Small, Sigma Max, PadError
    TArrayI fClusterLimits;   // MaximaLimit, PadLimit
    TArrayF fVertexPos;       // pos Min, pos Max, step width
    TArrayI fRichSeg;         // nRichSeg, x-border, y-border
    TArrayI fNeighbourPad;    // up ,upRight, right, downRight, down, downLeft, left, upLeft
    TArrayF fTF2ParMean;      // Radius Parametrization functions (nRingSeg,nVertex,8)
    TArrayF fTF2ParSigma;     // Sigma Parametrization functions (nRingSeg,nVertex,8)
    TArrayF fLeptonSelection; // Cuts: beta RPC, beta TOF, MDC dEdx


public:
    HParticleBtPar(const Char_t* name ="ParticleBtPar",
		   const Char_t* title  ="Parameters for particle back tracking to RICH",
		   const Char_t* context="ParticleBtParProduction");
    ~HParticleBtPar();

    //--------------Get functions----------------

    Int_t          getNRingSegments()                    { return fRingFitPar[0]; }
    Int_t          getNVertex()                          { return fRingFitPar[1]; }
    Int_t          getNParMean()                         { return fRingFitPar[2]; }
    Int_t          getNParSigma()                        { return fRingFitPar[3]; }

    Float_t*       getChargeThres()                      { return &fChargeThres[0];}
    Float_t*       getChargeThresMax()                   { return &fChargeThres[6];}

    Float_t        getNSigma()                           { return fNSigma;}
    Int_t          getMaximumType()                      { return fMaximumType;}
    Int_t          getSizeMatrix()                       { return fSizeMatrix;}
    Int_t          getRingSegStep()                      { return fRingSeg[0];}
    Int_t          getRingSegOffset()                    { return fRingSeg[1];}

    Float_t*       getSharedChargeDiagonal()             { return &fSharedCharge[0];}
    Float_t*       getSharedChargeVertical()             { return &fSharedCharge[3];}
    Float_t*       getSharedChargeHorizontal()           { return &fSharedCharge[6];}

    Float_t*       getSigmaGaus()                        { return &fSigmaGaus[0];}
    Float_t*       getSigmaGausRange()                   { return &fSigmaGaus[2];}
    Float_t        getParThetaAngleMin()                 { return fParThetaAngle[0];}
    Float_t        getParThetaAngleMax()                 { return fParThetaAngle[1];}

    Float_t        getSigmaRange()                       { return fSigmaRange[0];}
    Float_t        getSigmaRangeSmall()                  { return fSigmaRange[1];}
    Float_t        getSigmaRangeMax()                    { return fSigmaRange[2];}
    Float_t        getSigmaRangePadError()               { return fSigmaRange[3];}

    Float_t*       getPhiOffset()                        { return &fPhiOffset[0];}
    Float_t*       getPhiOffset2()                       { return &fPhiOffset[6];}
    Float_t        getOffsetPar()                        { return fPhiOffsetPar;}

    Float_t        getPadWidthX()                        { return fGeomConst[0];}
    Float_t        getPadWidthY()                        { return fGeomConst[1];}
    Float_t        getThetaAngleMin()                    { return fGeomConst[2];}
    Float_t        getThetaAngleMax()                    { return fGeomConst[3];}

   
    Int_t          getClusMaximaLimit()                  { return fClusterLimits[0];}
    Int_t          getClusSizeLimit()                    { return fClusterLimits[1];}

    Float_t        getVertexPosMin()                     { return fVertexPos[0];}
    Float_t        getVertexPosMax()                     { return fVertexPos[1];}
    Float_t        getVertexStep()                       { return fVertexPos[2];}

    Int_t          getNRichSeg()                         { return fRichSeg[0];}
    Int_t          getRichSegBorderX()                   { return fRichSeg[1];}
    Int_t          getRichSegBorderY()                   { return fRichSeg[2];}

    Int_t          getNeighbourPad(Int_t par)            { return fNeighbourPad[0+par];}

    Float_t        getMinimumSigmaValue()                { return fMinimumSigmaVal;}
    Double_t       getTF2ParMean(Int_t ringSeg, Int_t vertex, Int_t par) { return fTF2ParMean[ringSeg*(15*8)+vertex*8+par];}
    Double_t       getTF2ParSigma(Int_t ringSeg, Int_t vertex, Int_t par) { return fTF2ParSigma[ringSeg*(15*13)+vertex*13+par];}

    Float_t        getBetaRPCLimit()                     { return fLeptonSelection[0];}
    Float_t        getBetaTOFLimit()                     { return fLeptonSelection[1];}
    Float_t        getMDCdEdxLimit()                     { return fLeptonSelection[2];}




    //---------------Set functions---------------

    void    setNRingSegments(Int_t val)                         {  fRingFitPar[0] = val; }
    void    setNVertex(Int_t val)                               {  fRingFitPar[1] = val; }
    void    setNParMean(Int_t val)                              {  fRingFitPar[2] = val; }
    void    setNParSigma(Int_t val)                             {  fRingFitPar[3] = val; }

    void    setChargeThres(Float_t* pars)                       {  for(Int_t i=0;i<6;i++) fChargeThres[i]   = pars[i];}
    void    setChargeThresMax(Float_t* pars)                    {  for(Int_t i=0;i<6;i++) fChargeThres[i+6] = pars[i];}

    void    setNSigma(Float_t val)                              {  fNSigma = val;}
    void    setMaximumType(Int_t val)                           {  fMaximumType = val;}
    void    setSizeMatrix(Int_t val)                            {  fSizeMatrix = val;}
    void    setRingSegStep(Int_t val)                           {  fRingSeg[0] = val;}
    void    setRingSegOffset(Int_t val)                         {  fRingSeg[1] = val;}

    void    setSharedChargeDiagonal(Float_t* pars)              {  for(Int_t i=0;i<3;i++) fSharedCharge[0+i] = pars[i];}
    void    setSharedChargeVertical(Float_t* pars)              {  for(Int_t i=0;i<3;i++) fSharedCharge[3+i] = pars[i];}
    void    setSharedChargeHorizontal(Float_t* pars)            {  for(Int_t i=0;i<3;i++) fSharedCharge[6+i] = pars[i];}

    void    setSigmaGaus(Float_t val1,Float_t val2)             {  fSigmaGaus[0] = val1; fSigmaGaus[1] = val2;}
    void    setSigmaGausRange(Float_t val1,Float_t val2)        {  fSigmaGaus[2] = val1; fSigmaGaus[3] = val2;}
    void    setParThetaAngleMin(Float_t val)                    {  fParThetaAngle[0] = val;}
    void    setParThetaAngleMax(Float_t val)                    {  fParThetaAngle[1] = val;}

    void    setSigmaRange(Float_t val)                          {  fSigmaRange[0] = val;}
    void    setSigmaRangeSmall(Float_t val)                     {  fSigmaRange[1] = val;}
    void    setSigmaRangeMax(Float_t val)                       {  fSigmaRange[2] = val;}
    void    setSigmaRangePadError(Float_t val)                  {  fSigmaRange[3] = val;}

    void    setPhiOffset(Float_t* pars)                         {  for(Int_t i=0;i<6;i++) fPhiOffset[0+i] = pars[i];}
    void    setPhiOffset2(Float_t* pars)                        {  for(Int_t i=0;i<6;i++) fPhiOffset[6+i] = pars[i];}
    void    setOffsetPar(Float_t val)                           {  fPhiOffsetPar = val;}

    void    setPadWidthX(Float_t val)                           {  fGeomConst[0] = val;}
    void    setPadWidthY(Float_t val)                           {  fGeomConst[1] = val;}
    void    setThetaAngleMin(Float_t val)                       {  fGeomConst[2] = val;}
    void    setThetaAngleMax(Float_t val)                       {  fGeomConst[3] = val;}

    void    setClusMaximaLimit(Int_t val)                       {  fClusterLimits[0] = val;}
    void    setClusSizeLimit(Int_t val)                         {  fClusterLimits[1] = val;}

    void    setVertexPosMin(Float_t val)                        {  fVertexPos[0] = val;}
    void    setVertexPosMax(Float_t val)                        {  fVertexPos[1] = val;}
    void    setVertexStep(Float_t val)                          {  fVertexPos[2] = val;}

    void    setNRichSeg(Int_t val)                              {  fRichSeg[0] = val;}
    void    setRichSegBorderX(Int_t val)                        {  fRichSeg[1] = val;}
    void    setRichSegBorderY(Int_t val)                        {  fRichSeg[2] = val;}

    void    setNeighbourPad(Int_t val,Int_t par)                {  fNeighbourPad[0+par] = val;}

    void    setMinimumSigmaValue(Float_t val)                   { fMinimumSigmaVal = val;}
    void    setTF2ParMean(Int_t ringSeg, Int_t vertex, Int_t par, Double_t val)  { fTF2ParMean[(ringSeg*15*8)+(vertex*8)+par]  = val;}
    void    setTF2ParSigma(Int_t ringSeg, Int_t vertex, Int_t par, Double_t val) { fTF2ParSigma[ringSeg*(15*13)+vertex*13+par] = val;}

    void    setBetaRPCLimit(Float_t val )                       { fLeptonSelection[0] = val;}
    void    setBetaTOFLimit(Float_t val )                       { fLeptonSelection[1] = val;}
    void    setMDCdEdxLimit(Float_t val )                       { fLeptonSelection[2] = val;}



    //--------------------------



    void    putParams(HParamList*);
    Bool_t  getParams(HParamList*);
    void    clear();

    ClassDef(HParticleBtPar,1) // Container for the particleBT parameters

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