#ifndef HiTofCalPar_H
#define HiTofCalPar_H



#include "hparset.h"

#include "TObject.h"
#include "TObjArray.h"


#define NCHAN 15

class HiTofCalParCell : public TObject {
    Float_t fOffset [NCHAN];  // offset parameter for calibration of the cell
    Float_t fSlope  [NCHAN];  // channel -> time conversion constant
    Float_t fadcPar0[NCHAN];   // ADC par 0 (par2 * x^0)
    Float_t fadcPar1[NCHAN];   // ADC par 1 (par1 * x^1)
    Float_t fadcPar2[NCHAN];   // ADC par 2 (par0 * x^2)
    Float_t ftwcPar0[NCHAN];   // TWC par 0
    Float_t ftwcPar1[NCHAN];   // TWC par 1
    Float_t ftwcPar2[NCHAN];   // TWC par 2
public:
    HiTofCalParCell();
    ~HiTofCalParCell() {}

    void    reset();
    Float_t getOffset (Int_t i)                { return (i >= 0 && i < NCHAN)? fOffset[i] : -1; }
    Float_t getSlope  (Int_t i)                { return (i >= 0 && i < NCHAN)? fSlope [i] : -1; }
    Float_t getAdcPar0(Int_t i)                { return (i >= 0 && i < NCHAN)? fadcPar0 [i] : -1; }
    Float_t getAdcPar1(Int_t i)                { return (i >= 0 && i < NCHAN)? fadcPar1 [i] : -1; }
    Float_t getAdcPar2(Int_t i)                { return (i >= 0 && i < NCHAN)? fadcPar2 [i] : -1; }
    Float_t getTwcPar0(Int_t i)                { return (i >= 0 && i < NCHAN)? ftwcPar0 [i] : -1; }
    Float_t getTwcPar1(Int_t i)                { return (i >= 0 && i < NCHAN)? ftwcPar1 [i] : -1; }
    Float_t getTwcPar2(Int_t i)                { return (i >= 0 && i < NCHAN)? ftwcPar2 [i] : -1; }

    void    setOffset (Int_t i, Float_t offset){ if(i >= 0 && i < NCHAN) fOffset[i] = offset;}
    void    setSlope  (Int_t i, Float_t c)     { if(i >= 0 && i < NCHAN) fSlope [i] = c; }
    void    setAdcPar0(Int_t i, Float_t c)     { if(i >= 0 && i < NCHAN) fadcPar0 [i] = c; }
    void    setAdcPar1(Int_t i, Float_t c)     { if(i >= 0 && i < NCHAN) fadcPar1 [i] = c; }
    void    setAdcPar2(Int_t i, Float_t c)     { if(i >= 0 && i < NCHAN) fadcPar2 [i] = c; }
    void    setTwcPar0(Int_t i, Float_t c)     { if(i >= 0 && i < NCHAN) ftwcPar0 [i] = c; }
    void    setTwcPar1(Int_t i, Float_t c)     { if(i >= 0 && i < NCHAN) ftwcPar1 [i] = c; }
    void    setTwcPar2(Int_t i, Float_t c)     { if(i >= 0 && i < NCHAN) ftwcPar1 [i] = c; }

    Float_t calibrateTime  (Int_t i,Float_t time);
    Float_t calibrateTime_walkcorr  (Int_t i,Float_t time,Float_t width);
    Float_t calibrateCharge(Int_t i,Float_t width);
    Float_t correctSignalPropagation_walkcorr(Int_t i,Float_t time,Float_t theta);
    void    fill(HiTofCalParCell&);

    ClassDef(HiTofCalParCell,1) //iTof calibration parameters per cell

};

class HiTofCalParMod: public TObject {
private:
    TObjArray* array;  // pointer array containing HStartCalParChan objects
public:
    HiTofCalParMod(Int_t n=3);
    ~HiTofCalParMod();
    HiTofCalParCell& operator[](Int_t i) {
	return *static_cast<HiTofCalParCell*>((*array)[i]);
    }
    Int_t getSize() { return array->GetEntries(); }
    ClassDef(HiTofCalParMod,1) // Module level of the iTof Calibration parameters
};

class HiTofCalParSec: public TObject {
private:
    TObjArray* array;  // pointer array containing HStartCalParMod objects
public:
    HiTofCalParSec(Int_t n=1);
    ~HiTofCalParSec();
    HiTofCalParMod& operator[](Int_t i) {
	return *static_cast<HiTofCalParMod*>((*array)[i]);
    }
    Int_t getSize() { return array->GetEntries(); }
    ClassDef(HiTofCalParSec,1) // Sector level of the iTof Calibration parameters
};


class HiTofCalPar : public HParSet {
  TObjArray* array;     // array of pointers of type HiTofCalParMod

public:
    HiTofCalPar(const Char_t* name    = "iTofCalPar",
		const Char_t* title   = "Calibration parameters for iTof",
		const Char_t* context = "iTofStandardCalibration",
	       Int_t ns = 6);
    ~HiTofCalPar();
    HiTofCalParSec& operator[](Int_t i) {
	return *static_cast<HiTofCalParSec*>((*array)[i]);
    }
    Int_t  getSize() { return array->GetEntries(); }
    Bool_t init(HParIo*,Int_t*);
    Int_t  write(HParIo*);
    void   clear();
    void   printParam();
    void   readline(const Char_t*, Int_t*);
    void   putAsciiHeader(TString&);
    Bool_t writeline(Char_t*, Int_t, Int_t, Int_t,Int_t);

    Int_t   getNumberOfChannels()  { return NCHAN;}
    Float_t calibrateTime  (Int_t s,Int_t m,Int_t c,Int_t i,Float_t rawTime);
    Float_t calibrateTime_walkcorr  (Int_t s,Int_t m,Int_t c,Int_t i,Float_t rawTime,Float_t width);
    Float_t correctSignalPropagation_walkcorr(Int_t s,Int_t m,Int_t c,Int_t i,Float_t calTime,Float_t theta);
    Float_t calibrateCharge(Int_t s,Int_t m,Int_t c,Int_t i,Float_t width);
    void    printDummy();
    ClassDef(HiTofCalPar,1) //iTof calibration parameter container

    private:
};

#endif