#ifndef BRAT_BrZdcCalibration
#include "BrZdcCalibration.h"
#endif

#ifndef BRAT_BrCalibration
#include "BrCalibration.h"
#endif

ClassImp (BrZdcCalibration);

 BrZdcCalibration::BrZdcCalibration ()
{

}



 BrZdcCalibration::BrZdcCalibration (Char_t *name, Char_t *title):BrCalibration (name, title)
{
    AddParameterData ("TdcGain", &fTdcGain);
    AddParameterData ("Slewpar1", &fSlewpar1);
    AddParameterData ("Slewpar2", &fSlewpar2);
    AddParameterData ("Slewpar3", &fSlewpar3);
    AddParameterData ("Slewpar4", &fSlewpar4);
    AddParameterData ("Slewpar5", &fSlewpar5);

    AddParameterData ("PedHi", &fPedHi);
    AddParameterData ("PedWidthHi", &fPedWidthHi);
    AddParameterData ("AdcGainHi", &fAdcGainHi);
    AddParameterData ("PedLo", &fPedLo);
    AddParameterData ("PedWidthLo", &fPedWidthLo);
    AddParameterData ("AdcGainLo", &fAdcGainLo);
}



 BrZdcCalibration::~BrZdcCalibration ()
{

}



 Int_t BrZdcCalibration::GetAccessMode (const Char_t* par) const
{
    TString s (par);
    Int_t mode= 0;

    if (s== "TdcGain") mode= fTdcGain.fAccessMode;
    if (s== "Slewpar1") mode= fSlewpar1.fAccessMode;
    if (s== "Slewpar2") mode= fSlewpar2.fAccessMode;
    if (s== "Slewpar3") mode= fSlewpar3.fAccessMode;
    if (s== "Slewpar4") mode= fSlewpar4.fAccessMode;
    if (s== "Slewpar5") mode= fSlewpar5.fAccessMode;

    if (s== "PedHi") mode= fPedHi.fAccessMode;
    if (s== "PedWidthHi") mode= fPedWidthHi.fAccessMode;
    if (s== "AdcGainHi") mode= fAdcGainHi.fAccessMode;
    if (s== "PedLo") mode= fPedLo.fAccessMode;
    if (s== "PedWidthLo") mode= fPedWidthLo.fAccessMode;
    if (s== "AdcGainLo") mode= fAdcGainLo.fAccessMode;

    return mode;
}



//----- set calibration parameters

 void BrZdcCalibration::SetTdcGain (Int_t module, Float_t value)
{
    if (fTdcGain.fAccessMode)
    {
        Float_t *array= (Float_t*) fTdcGain.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



 void BrZdcCalibration::SetSlewpar1 (Int_t module, Float_t value)
{
    if (fSlewpar1.fAccessMode)
    {
        Float_t *array= (Float_t*) fSlewpar1.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



 void BrZdcCalibration::SetSlewpar2 (Int_t module, Float_t value)
{
    if (fSlewpar2.fAccessMode)
    {
        Float_t *array= (Float_t*) fSlewpar2.fRevision->GetArray ();
        array [module- 1]= value;
  }
}



 void BrZdcCalibration::SetSlewpar3 (Int_t module, Float_t value)
{
    if (fSlewpar3.fAccessMode)
    {
        Float_t *array= (Float_t*) fSlewpar3.fRevision->GetArray ();
        array[module- 1]= value;
    }
}



 void BrZdcCalibration::SetSlewpar4 (Int_t module, Float_t value)
{
    if (fSlewpar4.fAccessMode)
    {
        Float_t *array= (Float_t*) fSlewpar4.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



 void BrZdcCalibration::SetSlewpar5 (Int_t module, Float_t value)
{
    if (fSlewpar5.fAccessMode)
    {
        Float_t *array= (Float_t*) fSlewpar5.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



 void BrZdcCalibration::SetPedHi (Int_t module, Float_t value)
{
    if (fPedHi.fAccessMode)
    {
        Float_t *array= (Float_t*) fPedHi.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



 void BrZdcCalibration::SetPedWidthHi (Int_t module, Float_t value)
{
    if (fPedWidthHi.fAccessMode)
    {
        Float_t *array= (Float_t*) fPedWidthHi.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



 void BrZdcCalibration::SetAdcGainHi (Int_t module, Float_t value)
{
    if(fAdcGainHi.fAccessMode)
    {
        Float_t *array= (Float_t*) fAdcGainHi.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



 void BrZdcCalibration::SetPedLo (Int_t module, Float_t value)
{
    if(fPedLo.fAccessMode)
    {
        Float_t *array= (Float_t*) fPedLo.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



 void BrZdcCalibration::SetPedWidthLo (Int_t module, Float_t value)
{
    if (fPedWidthLo.fAccessMode)
    {
        Float_t* array= (Float_t*) fPedWidthLo.fRevision->GetArray ();
        array [module- 1]= value;
  }
}



 void BrZdcCalibration::SetAdcGainLo (Int_t module, Float_t value)
{
    if (fAdcGainLo.fAccessMode)
    {
        Float_t* array= (Float_t*) fAdcGainLo.fRevision->GetArray ();
        array [module- 1]= value;
    }
}



//----- get calibration parameters

 Float_t BrZdcCalibration::GetTdcGain (Int_t module) const
{
    if (fTdcGain.fAccessMode) return ((Float_t*) fTdcGain.fRevision->GetArray ()) [module- 1];
    else return 0;
}



 Float_t BrZdcCalibration::GetSlewpar1 (Int_t module) const
{
    if (fSlewpar1.fAccessMode) return ((Float_t*) fSlewpar1.fRevision->GetArray ()) [module- 1];
    else return 0;
}



 Float_t BrZdcCalibration::GetSlewpar2 (Int_t module) const
{
    if (fSlewpar2.fAccessMode) return ((Float_t*) fSlewpar2.fRevision->GetArray ()) [module- 1];
    else return 0;
}



 Float_t BrZdcCalibration::GetSlewpar3 (Int_t module) const
{
    if (fSlewpar3.fAccessMode) return ((Float_t*) fSlewpar3.fRevision->GetArray ()) [module- 1];
    else return 0;
}



 Float_t BrZdcCalibration::GetSlewpar4 (Int_t module) const
{
    if (fSlewpar4.fAccessMode) return ((Float_t*) fSlewpar4.fRevision->GetArray ()) [module- 1];
    else return 0;
}



 Float_t BrZdcCalibration::GetSlewpar5 (Int_t module) const
{
    if (fSlewpar5.fAccessMode) return ((Float_t*) fSlewpar5.fRevision->GetArray ()) [module- 1];
    else return 0;
}



 Float_t BrZdcCalibration::GetPedHi (Int_t module) const
{
    if (fPedHi.fAccessMode) return ((Float_t*) fPedHi.fRevision->GetArray ()) [module- 1] ;
    else return 0;
}



 Float_t BrZdcCalibration::GetPedWidthHi (Int_t module) const
{
    if (fPedWidthHi.fAccessMode) return ((Float_t*) fPedWidthHi.fRevision->GetArray ()) [module- 1] ;
    else return 0;
}



 Float_t BrZdcCalibration::GetAdcGainHi (Int_t module) const
{
    if (fAdcGainHi.fAccessMode) return ((Float_t*) fAdcGainHi.fRevision->GetArray ()) [module-1] ;
    else return 0;
}



 Float_t BrZdcCalibration::GetPedLo (Int_t module) const
{
    if (fPedLo.fAccessMode) return ((Float_t*) fPedLo.fRevision->GetArray ()) [module- 1] ;
    else return 0;
}



 Float_t BrZdcCalibration::GetPedWidthLo (Int_t module) const
{
    if (fPedWidthLo.fAccessMode) return ((Float_t*) fPedWidthLo.fRevision->GetArray ()) [module- 1] ;
    else return 0;
}



 Float_t BrZdcCalibration::GetAdcGainLo (Int_t module) const
{
    if (fAdcGainLo.fAccessMode) return ((Float_t*) fAdcGainLo.fRevision->GetArray ()) [module- 1] ;
    else return 0;
}

Copyright ; 2002 BRAHMS Collaboration <brahmlib@rcf.rhic.bnl.gov>
Last Update on by

Validate HTML
Validate CSS