/**
 * @file
 * @author Christian Simon <csimon@physi.uni-heidelberg.de>
 * @since 2017-06-07
 */

#include "CbmTofDigiTbPar.h"

#include "CbmDefs.h"
#include "CbmSetup.h"

#include "FairLogger.h"
#include "FairParamList.h"

#include "TFile.h"
#include "TSystem.h"
#include "TGeoManager.h"
#include "TObjArray.h"
#include "TArrayD.h"


// -----   parameterized constructor   ---------------------------------------
CbmTofDigiTbPar::CbmTofDigiTbPar(const char* name, const char* title, const char* context) :
  FairParGenericSet(name, title, context),
  fiNumberReadoutElectrodes(),
  fdCellAcrossWidth(),
  fdCellAlongWidth(),
  fdGapAcrossWidth(),
  fdGapAlongWidth(),
  fbCellsAlongX(),
  fbCellIndexingAlongAxis(),
  fiNWalkBinsX(),
  fdMinimumToT(),
  fdMaximumToT(),
  fdSignalTimeOffset(),
  fdPropagationVelocity(),
  fdDigitizationJitterSigma(),
  fdMaximumRuntimeOffset(),
  fdToTTargetExpectationValue(),
  fdToTTargetStandardDeviation(),
  fdSignalEdgeRuntimeOffsetsSigma(),
  fiMaximumClusterSize(),
  fdDegradedEfficiencyReference(),
  fdChargeModus(),
  fdChargeScaling(),
  fdChargeDistance(),
  fdDiscriminationJitterSigma(),
  fdSignalTimeConstant(),
  fdSignalThreshold(),
  fdStripToTOffset(),
  fdAvalancheJitterSigma(),
  fdReferenceMeanClusterSizeCentralCell(),
  fdReferenceRMSClusterSizeCentralCell(),
  fdReferenceMeanToTCentralChannel(),
  fdReferenceRMSToTCentralChannel(),
  fdReferenceEfficiency(),
  fdReferenceTimeResolution(),
  fdReferenceAlongPositionResidualSigmaRatio(),
  fdReferenceSigmoidalEfficiencyDrop(),
  fdReferenceDegradedTimeResolution(),
  fdActualMeanClusterSizeCentralCell(),
  fdActualRMSClusterSizeCentralCell(),
  fdActualMeanToTCentralChannel(),
  fdActualRMSToTCentralChannel(),
  fdActualEfficiency(),
  fdActualTimeResolution(),
  fdActualAlongPositionResidualSigmaRatio(),
  fdActualSigmoidalEfficiencyDrop(),
  fdActualDegradedTimeResolution(),
  fdToTDistributionScaling(),
  fdToTDistributionOffset(),
  fdRuntimeCorrections(),
  fdSlewingCorrections(),
  fdRuntimeOffsets(),
  fdSignalEdgeRuntimeOffsets(),
  fdAcrossPositionResidualSigma(),
  fdAlongPositionResidualSigma(),
  fdTimeResidualSigma(),
  fdSigmoidalEfficiencyFlex(),
  fdSigmoidalEfficiencyScale(),
  fdKneeCoefficient(),
  fdCalibrationCoefficient(),
  fdHitDistanceScale(),
  fdRelaxationTimeConstant(),
  fdChannelDeadTime(),
  fdCounterDarkRate(),
  fbTwoSidedReadout(),
  fdWorkingCoefficient(),
  ftGeoTag(""),
  fbParametersAvailable()
{
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::putParams(FairParamList* tOutputParamList)
{
  LOG(ERROR)<<"Parameter container CbmTofDigiTbPar cannot be saved to an ASCII file."<<FairLogger::endl;
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
Bool_t CbmTofDigiTbPar::getParams(FairParamList* tInputParamList)
{
  CbmSetup::Instance()->GetGeoTag(kTof, ftGeoTag);

  if(ftGeoTag.IsNull())
  {
    LOG(ERROR)<<"ToF geometry tag read from CbmSetup is an empty string."<<FairLogger::endl;
    return kFALSE;
  }

  if(gGeoManager)
  {
    Bool_t bFoundTofNode(kFALSE);
    TObjArray* tDetectorNodes = gGeoManager->GetTopNode()->GetNodes();

    for(Int_t iNode = 0; iNode < tDetectorNodes->GetEntriesFast(); iNode++)
    {
      TGeoNode* tNode = dynamic_cast<TGeoNode*>(tDetectorNodes->At(iNode));
      if(TString(tNode->GetName()).BeginsWith("tof_"))
      {
        bFoundTofNode = kTRUE;
/*
        // The actually loaded ToF geometry file CANNOT be assessed by inspecting
        // the name of the top ToF node because the same version tag can be
        // used for different geometries that follow the same underlying building
        // scheme (e.g. the geometry file tagged "v15c" is built according
        // to the "v14a" scheme; its top volume is thus named "tof_v14a" instead
        // of "tof_v15c").

        TString tTofVersion = tNode->GetVolume()->GetName();
        // After removing the leading substring "tof_" the remaining substring should hold the ToF geometry version
        tTofVersion.Remove(0,4);
        SetGeoTag(tTofVersion.Data());
*/
      }
    }

    if(!bFoundTofNode)
    {
      LOG(ERROR)<<"Could not retrieve 'tof' node from TGeoManager."<<FairLogger::endl;
      return kFALSE;
    }
  }
  else
  {
    LOG(ERROR)<<"TGeoManager not available."<<FairLogger::endl;
    return kFALSE;
  }

  TFile* tCalibFile = new TFile(Form("%s/parameters/tof/tof_%s.digitb.root",gSystem->Getenv("VMCWORKDIR"),ftGeoTag.Data()),"READ");
  if( tCalibFile->IsZombie() )
  {
    tCalibFile->Close();
    delete tCalibFile;

    LOG(ERROR)<<"Could not open calibration file to extract CbmTofDigiTbPar."<<FairLogger::endl;
    return kFALSE;
  }

  CbmTofDigiTbPar* tCalibObject = dynamic_cast<CbmTofDigiTbPar*>(tCalibFile->FindObjectAny("CbmTofDigiTbPar"));
  if( !tCalibObject )
  {
    tCalibFile->Close();
    delete tCalibFile;

    LOG(ERROR)<<"Could not retrieve object 'CbmTofDigiTbPar' from calibration file."<<FairLogger::endl;
    return kFALSE;
  }

  *this = *tCalibObject;

  tCalibFile->Close();
  delete tCalibFile;

  if(!tInputParamList)
  {
    return kFALSE;
  }

  TArrayD tMemPropArray;

  if(!tInputParamList->fill("MemoryProperties",&tMemPropArray))
  {
    LOG(ERROR)<<"Could not retrieve parameter object 'MemoryProperties' from ASCII input file."<<FairLogger::endl;
    return kFALSE;
  }

  if(tMemPropArray.GetSize()%7)
  {
    LOG(ERROR)<<"Number of elements listed in parameter object 'MemoryProperties' in ASCII input file MUST be a multiple of 7."<<FairLogger::endl;
    return kFALSE;
  }

  Int_t iModuleType(0);
  Int_t iModuleIndex(0);
  Int_t iCounterIndex(0);
  Int_t iKey(0);
  Double_t dHitDistanceScale(1.);
  Double_t dRelaxationTimeConstant(1.);
  Double_t dChannelDeadTime(0.);
  Double_t dCounterDarkRate(0.);
  Bool_t bTwoSidedReadout(kTRUE);
  Double_t dWorkingCoefficient(1.);

  for(Int_t iEntry = 0; iEntry < tMemPropArray.GetSize(); iEntry += 7)
  {
    iKey = static_cast<Int_t>(tMemPropArray.GetAt(iEntry));
    dHitDistanceScale = tMemPropArray.GetAt(iEntry + 1);
    dRelaxationTimeConstant = tMemPropArray.GetAt(iEntry + 2);
    dWorkingCoefficient = tMemPropArray.GetAt(iEntry + 3);
    dChannelDeadTime = tMemPropArray.GetAt(iEntry + 4);
    dCounterDarkRate = tMemPropArray.GetAt(iEntry + 5);
    bTwoSidedReadout = static_cast<Bool_t>(tMemPropArray.GetAt(iEntry + 6));

    iCounterIndex = iKey%1000;
    iModuleIndex = ((iKey - iCounterIndex)%1000000)/1000;
    iModuleType = (iKey - 1000*iModuleIndex - iCounterIndex)/1000000;

    SetHitDistanceScale(iModuleType, iModuleIndex, iCounterIndex, dHitDistanceScale);
    SetRelaxationTimeConstant(iModuleType, iModuleIndex, iCounterIndex, dRelaxationTimeConstant);
    SetChannelDeadTime(iModuleType, iModuleIndex, iCounterIndex, dChannelDeadTime);
    SetCounterDarkRate(iModuleType, iModuleIndex, iCounterIndex, dCounterDarkRate);
    SetTwoSidedReadout(iModuleType, iModuleIndex, iCounterIndex, bTwoSidedReadout);
    SetWorkingCoefficient(iModuleType, iModuleIndex, iCounterIndex, dWorkingCoefficient);

    if(GetParametersAvailable(iModuleType, iModuleIndex, iCounterIndex))
    {
      SetParametersAvailable(iModuleType, iModuleIndex, iCounterIndex, kTRUE);
    }
    else
    {
      LOG(WARNING)<<Form("Counter %d-%d-%d available in ASCII but not in ROOT parameter file.", iModuleType, iModuleIndex, iCounterIndex)<<FairLogger::endl;
    }

  }

  return kTRUE;
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::printParams()
{
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Int_t* CbmTofDigiTbPar::GetNumberReadoutElectrodes(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fiNumberReadoutElectrodes);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetCellAcrossWidth(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdCellAcrossWidth);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetCellAlongWidth(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdCellAlongWidth);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetGapAcrossWidth(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdGapAcrossWidth);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetGapAlongWidth(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdGapAlongWidth);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Bool_t* CbmTofDigiTbPar::GetCellsAlongX(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fbCellsAlongX);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Bool_t* CbmTofDigiTbPar::GetCellIndexingAlongAxis(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fbCellIndexingAlongAxis);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Int_t* CbmTofDigiTbPar::GetNWalkBinsX(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fiNWalkBinsX);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetMinimumToT(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdMinimumToT);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetMaximumToT(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdMaximumToT);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetSignalTimeOffset(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdSignalTimeOffset);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetPropagationVelocity(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdPropagationVelocity);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetDigitizationJitterSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdDigitizationJitterSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetMaximumRuntimeOffset(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdMaximumRuntimeOffset);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetToTTargetExpectationValue(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdToTTargetExpectationValue);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetToTTargetStandardDeviation(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdToTTargetStandardDeviation);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetSignalEdgeRuntimeOffsetsSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdSignalEdgeRuntimeOffsetsSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Int_t* CbmTofDigiTbPar::GetMaximumClusterSize(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fiMaximumClusterSize);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetDegradedEfficiencyReference(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdDegradedEfficiencyReference);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetChargeModus(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdChargeModus);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetChargeScaling(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdChargeScaling);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetChargeDistance(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdChargeDistance);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetDiscriminationJitterSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdDiscriminationJitterSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetSignalTimeConstant(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdSignalTimeConstant);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetSignalThreshold(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdSignalThreshold);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetStripToTOffset(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdStripToTOffset);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetAvalancheJitterSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdAvalancheJitterSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceMeanClusterSizeCentralCell(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceMeanClusterSizeCentralCell);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceRMSClusterSizeCentralCell(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceRMSClusterSizeCentralCell);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceMeanToTCentralChannel(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceMeanToTCentralChannel);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceRMSToTCentralChannel(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceRMSToTCentralChannel);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceEfficiency(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceEfficiency);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceTimeResolution(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceTimeResolution);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceAlongPositionResidualSigmaRatio(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceAlongPositionResidualSigmaRatio);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceSigmoidalEfficiencyDrop(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceSigmoidalEfficiencyDrop);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetReferenceDegradedTimeResolution(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdReferenceDegradedTimeResolution);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualMeanClusterSizeCentralCell(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualMeanClusterSizeCentralCell);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualRMSClusterSizeCentralCell(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualRMSClusterSizeCentralCell);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualMeanToTCentralChannel(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualMeanToTCentralChannel);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualRMSToTCentralChannel(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualRMSToTCentralChannel);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualEfficiency(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualEfficiency);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualTimeResolution(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualTimeResolution);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualAlongPositionResidualSigmaRatio(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualAlongPositionResidualSigmaRatio);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualSigmoidalEfficiencyDrop(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualSigmoidalEfficiencyDrop);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetActualDegradedTimeResolution(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdActualDegradedTimeResolution);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const std::vector<Double_t>* CbmTofDigiTbPar::GetToTDistributionScaling(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdToTDistributionScaling);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const std::vector<Double_t>* CbmTofDigiTbPar::GetToTDistributionOffset(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdToTDistributionOffset);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const std::vector<Double_t>* CbmTofDigiTbPar::GetRuntimeCorrections(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdRuntimeCorrections);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const std::vector<std::vector<Double_t>>* CbmTofDigiTbPar::GetSlewingCorrections(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdSlewingCorrections);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const std::vector<Double_t>* CbmTofDigiTbPar::GetRuntimeOffsets(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdRuntimeOffsets);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const std::vector<Double_t>* CbmTofDigiTbPar::GetSignalEdgeRuntimeOffsets(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdSignalEdgeRuntimeOffsets);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetAcrossPositionResidualSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdAcrossPositionResidualSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetAlongPositionResidualSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdAlongPositionResidualSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetTimeResidualSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdTimeResidualSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetSigmoidalEfficiencyFlex(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdSigmoidalEfficiencyFlex);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetSigmoidalEfficiencyScale(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdSigmoidalEfficiencyScale);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetKneeCoefficient(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdKneeCoefficient);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetCalibrationCoefficient(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdCalibrationCoefficient);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetHitDistanceScale(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdHitDistanceScale);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetRelaxationTimeConstant(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdRelaxationTimeConstant);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetChannelDeadTime(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdChannelDeadTime);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetCounterDarkRate(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdCounterDarkRate);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Bool_t* CbmTofDigiTbPar::GetTwoSidedReadout(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fbTwoSidedReadout);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Double_t* CbmTofDigiTbPar::GetWorkingCoefficient(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fdWorkingCoefficient);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
const Bool_t* CbmTofDigiTbPar::GetParametersAvailable(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex) const
{
  return GetMappedValue(iMType, iMIndex, iCIndex, fbParametersAvailable);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetNumberReadoutElectrodes(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Int_t& iNumberReadoutElectrodes)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fiNumberReadoutElectrodes, iNumberReadoutElectrodes);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetCellAcrossWidth(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dCellAcrossWidth)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdCellAcrossWidth, dCellAcrossWidth);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetCellAlongWidth(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dCellAlongWidth)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdCellAlongWidth, dCellAlongWidth);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetGapAcrossWidth(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dGapAcrossWidth)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdGapAcrossWidth, dGapAcrossWidth);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetGapAlongWidth(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dGapAlongWidth)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdGapAlongWidth, dGapAlongWidth);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetCellsAlongX(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Bool_t& bCellsAlongX)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fbCellsAlongX, bCellsAlongX);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetCellIndexingAlongAxis(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Bool_t& bCellIndexingAlongAxis)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fbCellIndexingAlongAxis, bCellIndexingAlongAxis);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetNWalkBinsX(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Int_t& iNWalkBinsX)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fiNWalkBinsX, iNWalkBinsX);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetMinimumToT(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dMinimumToT)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdMinimumToT, dMinimumToT);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetMaximumToT(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dMaximumToT)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdMaximumToT, dMaximumToT);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetSignalTimeOffset(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dSignalTimeOffset)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdSignalTimeOffset, dSignalTimeOffset);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetPropagationVelocity(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dPropagationVelocity)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdPropagationVelocity, dPropagationVelocity);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetDigitizationJitterSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dDigitizationJitterSigma)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdDigitizationJitterSigma, dDigitizationJitterSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetMaximumRuntimeOffset(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dMaximumRuntimeOffset)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdMaximumRuntimeOffset, dMaximumRuntimeOffset);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetToTTargetExpectationValue(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dToTTargetExpectationValue)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdToTTargetExpectationValue, dToTTargetExpectationValue);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetToTTargetStandardDeviation(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dToTTargetStandardDeviation)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdToTTargetStandardDeviation, dToTTargetStandardDeviation);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetSignalEdgeRuntimeOffsetsSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dSignalEdgeRuntimeOffsetsSigma)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdSignalEdgeRuntimeOffsetsSigma, dSignalEdgeRuntimeOffsetsSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetMaximumClusterSize(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Int_t& iMaximumClusterSize)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fiMaximumClusterSize, iMaximumClusterSize);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetDegradedEfficiencyReference(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dDegradedEfficiencyReference)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdDegradedEfficiencyReference, dDegradedEfficiencyReference);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetChargeModus(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dChargeModus)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdChargeModus, dChargeModus);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetChargeScaling(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dChargeScaling)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdChargeScaling, dChargeScaling);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetChargeDistance(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dChargeDistance)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdChargeDistance, dChargeDistance);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetDiscriminationJitterSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dDiscriminationJitterSigma)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdDiscriminationJitterSigma, dDiscriminationJitterSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetSignalTimeConstant(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dSignalTimeConstant)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdSignalTimeConstant, dSignalTimeConstant);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetSignalThreshold(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dSignalThreshold)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdSignalThreshold, dSignalThreshold);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetStripToTOffset(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dStripToTOffset)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdStripToTOffset, dStripToTOffset);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetAvalancheJitterSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dAvalancheJitterSigma)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdAvalancheJitterSigma, dAvalancheJitterSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceMeanClusterSizeCentralCell(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceMeanClusterSizeCentralCell)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceMeanClusterSizeCentralCell, dReferenceMeanClusterSizeCentralCell);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceRMSClusterSizeCentralCell(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceRMSClusterSizeCentralCell)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceRMSClusterSizeCentralCell, dReferenceRMSClusterSizeCentralCell);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceMeanToTCentralChannel(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceMeanToTCentralChannel)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceMeanToTCentralChannel, dReferenceMeanToTCentralChannel);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceRMSToTCentralChannel(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceRMSToTCentralChannel)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceRMSToTCentralChannel, dReferenceRMSToTCentralChannel);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceEfficiency(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceEfficiency)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceEfficiency, dReferenceEfficiency);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceTimeResolution(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceTimeResolution)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceTimeResolution, dReferenceTimeResolution);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceAlongPositionResidualSigmaRatio(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceAlongPositionResidualSigmaRatio)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceAlongPositionResidualSigmaRatio, dReferenceAlongPositionResidualSigmaRatio);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceSigmoidalEfficiencyDrop(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceSigmoidalEfficiencyDrop)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceSigmoidalEfficiencyDrop, dReferenceSigmoidalEfficiencyDrop);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetReferenceDegradedTimeResolution(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dReferenceDegradedTimeResolution)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdReferenceDegradedTimeResolution, dReferenceDegradedTimeResolution);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualMeanClusterSizeCentralCell(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualMeanClusterSizeCentralCell)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualMeanClusterSizeCentralCell, dActualMeanClusterSizeCentralCell);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualRMSClusterSizeCentralCell(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualRMSClusterSizeCentralCell)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualRMSClusterSizeCentralCell, dActualRMSClusterSizeCentralCell);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualMeanToTCentralChannel(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualMeanToTCentralChannel)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualMeanToTCentralChannel, dActualMeanToTCentralChannel);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualRMSToTCentralChannel(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualRMSToTCentralChannel)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualRMSToTCentralChannel, dActualRMSToTCentralChannel);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualEfficiency(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualEfficiency)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualEfficiency, dActualEfficiency);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualTimeResolution(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualTimeResolution)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualTimeResolution, dActualTimeResolution);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualAlongPositionResidualSigmaRatio(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualAlongPositionResidualSigmaRatio)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualAlongPositionResidualSigmaRatio, dActualAlongPositionResidualSigmaRatio);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualSigmoidalEfficiencyDrop(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualSigmoidalEfficiencyDrop)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualSigmoidalEfficiencyDrop, dActualSigmoidalEfficiencyDrop);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetActualDegradedTimeResolution(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dActualDegradedTimeResolution)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdActualDegradedTimeResolution, dActualDegradedTimeResolution);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetToTDistributionScaling(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const std::vector<Double_t>& dToTDistributionScaling)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdToTDistributionScaling, dToTDistributionScaling);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetToTDistributionOffset(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const std::vector<Double_t>& dToTDistributionOffset)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdToTDistributionOffset, dToTDistributionOffset);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetRuntimeCorrections(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const std::vector<Double_t>& dRuntimeCorrections)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdRuntimeCorrections, dRuntimeCorrections);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetSlewingCorrections(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const std::vector<std::vector<Double_t>>& dSlewingCorrections)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdSlewingCorrections, dSlewingCorrections);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetRuntimeOffsets(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const std::vector<Double_t>& dRuntimeOffsets)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdRuntimeOffsets, dRuntimeOffsets);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetSignalEdgeRuntimeOffsets(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const std::vector<Double_t>& dSignalEdgeRuntimeOffsets)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdSignalEdgeRuntimeOffsets, dSignalEdgeRuntimeOffsets);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetAcrossPositionResidualSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dAcrossPositionResidualSigma)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdAcrossPositionResidualSigma, dAcrossPositionResidualSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetAlongPositionResidualSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dAlongPositionResidualSigma)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdAlongPositionResidualSigma, dAlongPositionResidualSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetTimeResidualSigma(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dTimeResidualSigma)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdTimeResidualSigma, dTimeResidualSigma);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetSigmoidalEfficiencyFlex(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dSigmoidalEfficiencyFlex)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdSigmoidalEfficiencyFlex, dSigmoidalEfficiencyFlex);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetSigmoidalEfficiencyScale(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dSigmoidalEfficiencyScale)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdSigmoidalEfficiencyScale, dSigmoidalEfficiencyScale);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetKneeCoefficient(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dKneeCoefficient)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdKneeCoefficient, dKneeCoefficient);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetCalibrationCoefficient(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dCalibrationCoefficient)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdCalibrationCoefficient, dCalibrationCoefficient);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetHitDistanceScale(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dHitDistanceScale)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdHitDistanceScale, dHitDistanceScale);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetRelaxationTimeConstant(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dRelaxationTimeConstant)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdRelaxationTimeConstant, dRelaxationTimeConstant);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetChannelDeadTime(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dChannelDeadTime)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdChannelDeadTime, dChannelDeadTime);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetCounterDarkRate(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dCounterDarkRate)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdCounterDarkRate, dCounterDarkRate);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetTwoSidedReadout(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Bool_t& bTwoSidedReadout)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fbTwoSidedReadout, bTwoSidedReadout);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetWorkingCoefficient(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Double_t& dWorkingCoefficient)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fdWorkingCoefficient, dWorkingCoefficient);
}
// ---------------------------------------------------------------------------



// ---------------------------------------------------------------------------
void CbmTofDigiTbPar::SetParametersAvailable(const Int_t& iMType, const Int_t& iMIndex, const Int_t& iCIndex, const Bool_t& bParametersAvailable)
{
  SetMappedValue(iMType, iMIndex, iCIndex, fbParametersAvailable, bParametersAvailable);
}
// ---------------------------------------------------------------------------



ClassImp(CbmTofDigiTbPar)