// -----------------------------------------------------------------------------
// ----- ana_trks.C                                                        -----
// -----                                                                   -----
// ----- adapted by C. Simon on 2018-06-11                                 -----
// -----                                                                   -----
// -----------------------------------------------------------------------------

void ana_trks(Int_t iNEvents, Int_t iCorMode, Int_t iAnaCorMode, const TString& tUnpackDir, const TString& tCluDir,
              const TString& tInputFilePath, Int_t iNDigiFiles, const TString& tMCLinkFileName, Int_t iNLinkFiles,
              const TString& tTofGeoVersion, const TString& tSetupName, Bool_t bIdealCalibration,
              Bool_t bHeavyIonCollisions, Bool_t bSeparateHitFile, Bool_t bIdealClustering, Bool_t bAnalysisMCQA,
              Int_t iTrackingSetup, Double_t dRange1, Double_t dRange2, Bool_t bFinalRun,
              Int_t iDut, Int_t iMRef, Int_t iBRef, Int_t iSel2, Double_t dScaleFactor, Bool_t bSimData)
{
  // ---------------------------------------------------------------------------

  TString tLogLevel = "ERROR";
  TString tLogVerbosity = "LOW";
  gErrorIgnoreLevel = kWarning;
  gDebug = 0;

  TTree::SetMaxTreeSize(1000000000000LL); // [B] here: 1 TB

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

  TStopwatch tTimer;
  tTimer.Start();

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

  FairLogger::GetLogger()->SetLogScreenLevel(tLogLevel.Data());
  FairLogger::GetLogger()->SetLogVerbosityLevel(tLogVerbosity.Data());

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

  TString tSrcDir   = gSystem->Getenv("VMCWORKDIR");
  TString tMacroDir = tSrcDir + "/macro/beamtime";
  TString tParamDir = tSrcDir + "/parameters";
  TString tGeoDir   = tSrcDir + "/geometry";

  TString tUnpackInputFile      = tUnpackDir + "/data/unpack.out.root";
  TString tCluInputFile         = tCluDir + "/data/digi.out.root";
  TString tOutputFile           = "./hits.out.root";
  TString tHistoFile            = "./ana_track.hst.root";
  TString tInputTrackCalibFile  = "./calib_track.cor_in.root";
  TString tOutputTrackCalibFile = "./calib_track.cor_out.root";
  TString tInputAnaCalibFile    = "./calib_ana.cor_in.root";
  TString tOutputAnaCalibFile   = "./calib_ana.cor_out.root";

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

  TList* tParFileList = new TList();

  TObjString* tTofDigiParFile    = new TObjString(tParamDir + "/tof/tof_"+ tTofGeoVersion + ".digi.par");
  TObjString* tTofDigiBdfParFile = new TObjString(tParamDir + "/tof/tof_"+ tTofGeoVersion + ".digibdf.par");

  tParFileList->Add(tTofDigiParFile);
  tParFileList->Add(tTofDigiBdfParFile);

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

  if(bSimData)
  {
    if(bHeavyIonCollisions)
    {
      TFile::Open(tInputFilePath + "/001/data/mc/00001/data/" + tSetupName + "_geofile_full.root");
    }
    else
    {
      TFile::Open(tInputFilePath + "/001/data/" + tSetupName + "_geofile_full.root");
    }
  }
  else
  {
    TFile::Open(tGeoDir + "/tof/geofile_tof_" + tTofGeoVersion + ".root");
  }

  gFile->Get("FAIRGeom");
  if(!gGeoManager)
  {
    std::cout << "-E- ana_trks: FAIRGeom not found in geometry file!" << std::endl;
    return;
  }

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

  FairFileSource* tFileSource = new FairFileSource(tUnpackInputFile);
  if(bSeparateHitFile)
  {
    tFileSource->AddFriend(tCluInputFile);
  }

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

  FairRunAna* tRun= new FairRunAna();
  tRun->SetContainerStatic(kTRUE);
  tRun->SetSource(tFileSource);
  tRun->SetOutputFile(tOutputFile);

/*
  FairMonitor::GetMonitor()->EnableMonitor(kTRUE);
*/
  // ---------------------------------------------------------------------------

  Int_t iSel = 1000*iDut + iMRef;

  Int_t iDutCounter = iDut%10;
  Int_t iDutModule  = ((iDut - iDutCounter)/10)%10;
  Int_t iDutType    = (iDut - iDutCounter - 10*iDutModule)/100;

  Int_t iMRefCounter = iMRef%10;
  Int_t iMRefModule  = ((iMRef - iMRefCounter)/10)%10;
  Int_t iMRefType    = (iMRef - iMRefCounter - 10*iMRefModule)/100;

  Int_t iBRefCounter = iBRef%10;
  Int_t iBRefModule  = ((iBRef - iBRefCounter)/10)%10;
  Int_t iBRefType    = (iBRef - iBRefCounter - 10*iBRefModule)/100;

  Int_t iSel2Counter = iSel2%10;
  Int_t iSel2Module  = ((iSel2 - iSel2Counter)/10)%10;
  Int_t iSel2Type    = (iSel2 - iSel2Counter - 10*iSel2Module)/100;

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

  CbmMCDataManager* tDataManager = new CbmMCDataManager("MCManager");

  if(bSimData)
  {
    if(bHeavyIonCollisions)
    {
      for(Int_t iDigiFile = 1; iDigiFile <= iNDigiFiles; iDigiFile++)
      {
        for(Int_t iLinkFile = 1; iLinkFile <= iNLinkFiles; iLinkFile++)
        {
          tDataManager->AddFileToChain(tInputFilePath + TString::Format("/%03d/data", iDigiFile)
                                                      + TString::Format("/mc/%05d/data/", iLinkFile)
                                                      + tMCLinkFileName,
                                       iDigiFile - 1);
        }
      }
    }
    else
    {
      for(Int_t iDigiFile = 1; iDigiFile <= iNDigiFiles; iDigiFile++)
      {
        tDataManager->AddFileToChain(tInputFilePath + TString::Format("/%03d/data/", iDigiFile)
                                                    + tMCLinkFileName,
                                     iDigiFile - 1);
      }
    }
  }

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

  Double_t dTyMean = 0.11;

  CbmTofTrackFitter* tTofTrackFitter = new CbmTofTrackFitterKF(0, 211);

  CbmTofTrackFinderNN* tTofTrackFinder = new CbmTofTrackFinderNN();
  tTofTrackFinder->SetFitter(tTofTrackFitter);

  if(bSimData)
  {
    if(!bHeavyIonCollisions && bIdealCalibration)
    {
      tTofTrackFinder->SetMaxTofTimeDifference(5.);
      tTofTrackFinder->SetTxLIM(0.05);
      tTofTrackFinder->SetTyLIM(0.05);
      tTofTrackFinder->SetTyMean(dTyMean);
      tTofTrackFinder->SetSIGLIM(1.2*dRange2);
      tTofTrackFinder->SetChiMaxAccept(dRange2);
    //  tTofTrackFinder->SetPosYMaxScal(0.55);
      tTofTrackFinder->SetPosYMaxScal(100.);
    }

    if(bHeavyIonCollisions && bIdealCalibration)
    {
      tTofTrackFinder->SetMaxTofTimeDifference(0.05);
      tTofTrackFinder->SetTxLIM(0.03);
      tTofTrackFinder->SetTyLIM(0.03);
      tTofTrackFinder->SetTyMean(dTyMean);
      tTofTrackFinder->SetSIGLIM(1.4);
      tTofTrackFinder->SetChiMaxAccept(1.5);
  //    tTofTrackFinder->SetChiMaxAccept(4.);
    //  tTofTrackFinder->SetSIGLIM(dRange2*1.2);
    //  tTofTrackFinder->SetChiMaxAccept(dRange2);
  //    tTofTrackFinder->SetPosYMaxScal(0.55);
      tTofTrackFinder->SetPosYMaxScal(100.);
    }
  }
  else
  {
    tTofTrackFinder->SetMaxTofTimeDifference(5.);
    tTofTrackFinder->SetTxLIM(0.03);
    tTofTrackFinder->SetTyLIM(0.03);
    tTofTrackFinder->SetTyMean(dTyMean);
    tTofTrackFinder->SetSIGLIM(1.2*dRange2);
    tTofTrackFinder->SetChiMaxAccept(dRange2);
    tTofTrackFinder->SetPosYMaxScal(100.);
  }

  CbmTofFindTracks* tTofFindTracks = new CbmTofFindTracks("TOF Track Finder");
  tTofFindTracks->SetCalParFileName(tInputTrackCalibFile);
  tTofFindTracks->SetCalOutFileName(tOutputTrackCalibFile);
  tTofFindTracks->UseFinder(tTofTrackFinder);
  tTofFindTracks->UseFitter(tTofTrackFitter);
  tTofFindTracks->SetCorMode(iCorMode);
  tTofFindTracks->SetUseSigCalib(kTRUE);
  tTofFindTracks->SetRemoveSignalPropagationTime(!bIdealClustering);
  tTofFindTracks->SetBeamCounter(iBRefType, iBRefModule, iBRefCounter);

  if(bSimData)
  {
    if(!bHeavyIonCollisions && bIdealCalibration)
    {
      tTofFindTracks->SetStationMaxHMul(1);
      tTofFindTracks->SetTtTarg(0.035);
      tTofFindTracks->SetT0MAX(0.);
      //tTofFindTracks->SetT0MAX(dRange1);

      tTofFindTracks->SetSIGT(0.08);
      tTofFindTracks->SetSIGX(0.4);
      tTofFindTracks->SetSIGY(0.9);
      tTofFindTracks->SetSIGZ(0.05);

      tTofFindTracks->SetBeamMomentumLab(3.);
  //    tTofFindTracks->SetBeamMomentumLab(10.); FIXME: avoid hard coding?
    }

    if(bHeavyIonCollisions && bIdealCalibration)
    {
      tTofFindTracks->SetStationMaxHMul(10);
      tTofFindTracks->SetBeamMaxHMul(1);
      tTofFindTracks->SetTtTarg(0.035);
      tTofFindTracks->SetT0MAX(1.);
      //tTofFindTracks->SetT0MAX(dRange1);

      tTofFindTracks->SetSIGT(0.08);
      tTofFindTracks->SetSIGX(0.4);
      tTofFindTracks->SetSIGY(0.9);
      tTofFindTracks->SetSIGZ(0.05);

      tTofFindTracks->SetBeamMomentumLab(30.);
    }
  }
  else
  {
    tTofFindTracks->SetStationMaxHMul(10);
    tTofFindTracks->SetBeamMaxHMul(1);
    tTofFindTracks->SetTtTarg(0.035);
    tTofFindTracks->SetT0MAX(dRange1);

    tTofFindTracks->SetSIGT(0.08);
    tTofFindTracks->SetSIGX(0.4);
    tTofFindTracks->SetSIGY(0.9);
    tTofFindTracks->SetSIGZ(0.05);

    tTofFindTracks->SetBeamMomentumLab(30.);
  }

  Int_t iMinNofHits = 0;
  Int_t iNStations = 0;
  Int_t iNReqStations = 0;

  switch(iTrackingSetup)
  {
    case 0:
      iMinNofHits = 5;
      iNStations = 5;
      iNReqStations = 5;
      if(bFinalRun)
      {
        iMinNofHits--;
        iNStations--;
        iNReqStations--;
      }

      tTofFindTracks->SetStation(0, iBRefType, iBRefModule, iBRefCounter);
      switch(iDut)
      {
        case 901:
          tTofFindTracks->SetStation(1, 9, 2, 1);
          tTofFindTracks->SetStation(2, 4, 0, 0);
          tTofFindTracks->SetStation(3, 9, 2, 0);
          break;
        case 920:
          tTofFindTracks->SetStation(1, 9, 2, 1);
          tTofFindTracks->SetStation(2, 4, 0, 0);
          tTofFindTracks->SetStation(3, 9, 0, 1);
          break;
        default:
          break;
      }

      if(!bFinalRun)
      {
        tTofFindTracks->SetStation(4, iDutType, iDutModule, iDutCounter);
      }
      break;

    case 1: // FIXME
      iMinNofHits = 3;
      iNStations = 4;
      iNReqStations = 4;
      tTofFindTracks->SetStation(0, 4, 0, 0);
      tTofFindTracks->SetStation(1, 9, 2, 1);
      tTofFindTracks->SetStation(2, 9, 0, 1);
      tTofFindTracks->SetStation(3, 9, 2, 0);
      break;

    default:
      std::cout << "-E- ana_trks: tracking setup not known!" << std::endl;
      return;
  }

  tTofFindTracks->SetMinNofHits(iMinNofHits);
  tTofFindTracks->SetNStations(iNStations);
  tTofFindTracks->SetNReqStations(iNReqStations);

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

  CbmTofMatchReco* tTofMatch = new CbmTofMatchReco();
  tTofMatch->SetAlternativeBranchNames(kFALSE);
  tTofMatch->SetFileIndex(0);
  tTofMatch->SetMatchMCTracks(kTRUE);

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

  CbmTofAnaTestbeam* tTofAnaTestbeam = new CbmTofAnaTestbeam("TOF TestBeam Analysis", 1);
  tTofAnaTestbeam->SetDut(iDutType);
  tTofAnaTestbeam->SetDutSm(iDutModule);
  tTofAnaTestbeam->SetDutRpc(iDutCounter);
  tTofAnaTestbeam->SetMrpcRef(iMRefType);
  tTofAnaTestbeam->SetMrpcRefSm(iMRefModule);
  tTofAnaTestbeam->SetMrpcRefRpc(iMRefCounter);
  tTofAnaTestbeam->SetMrpcSel2(iSel2Type);
  tTofAnaTestbeam->SetMrpcSel2Sm(iSel2Module);
  tTofAnaTestbeam->SetMrpcSel2Rpc(iSel2Counter);
  tTofAnaTestbeam->SetBeamRefSmType(iBRefType);
  tTofAnaTestbeam->SetBeamRefSmId(iBRefModule);
  tTofAnaTestbeam->SetBeamRefRpc(iBRefCounter);

  tTofAnaTestbeam->SetCorMode(iAnaCorMode);
  tTofAnaTestbeam->SetCalParFileName(tInputAnaCalibFile);
  tTofAnaTestbeam->SetCalOutFileName(tOutputAnaCalibFile);
  tTofAnaTestbeam->SetMonteCarloComparison(bAnalysisMCQA);
  tTofAnaTestbeam->SetGhostTrackHitQuota(0.7);
//  tTofAnaTestbeam->SetDelayMCPoints(!bIdealClustering);
  tTofAnaTestbeam->SetAttachDutHitToTracklet(bFinalRun);

  if(bSimData)
  {
    if(!bHeavyIonCollisions && bIdealCalibration)
    {
      tTofAnaTestbeam->SetDXMean(0.);
      tTofAnaTestbeam->SetDYMean(0.);
      tTofAnaTestbeam->SetDTMean(0.);

      tTofAnaTestbeam->SetDXWidth(0.7);
      tTofAnaTestbeam->SetDYWidth(1.0);
      tTofAnaTestbeam->SetDTWidth(0.1);

      tTofAnaTestbeam->SetMulDMax(1);
      tTofAnaTestbeam->SetMul0Max(1);
      tTofAnaTestbeam->SetMul4Max(1);
    //  tTofAnaTestbeam->SetMulDMax(10);
    //  tTofAnaTestbeam->SetMul0Max(10);
    //  tTofAnaTestbeam->SetMul4Max(10);

      tTofAnaTestbeam->SetDTD4MAX(100.);

      tTofAnaTestbeam->SetCh4Sel(0.);
      tTofAnaTestbeam->SetDCh4Sel(100.);
      tTofAnaTestbeam->SetPosY4SelOff(0.);
      tTofAnaTestbeam->SetPosY4Sel(10.);
    //  tTofAnaTestbeam->SetPosY4Sel(0.5*dScaleFactor);

      tTofAnaTestbeam->SetDTDia(0.);
      tTofAnaTestbeam->SetHitDistMin(30.);

      tTofAnaTestbeam->SetChS2Sel(0.);
      tTofAnaTestbeam->SetDChS2Sel(100.);
      tTofAnaTestbeam->SetPosYS2SelOff(0.);
      tTofAnaTestbeam->SetPosYS2Sel(10.);
    //  tTofAnaTestbeam->SetPosYS2Sel(0.5);

      tTofAnaTestbeam->SetTShift(0.);
      tTofAnaTestbeam->SetSel2TOff(0.);
      tTofAnaTestbeam->SetTOffD4(0.);

      tTofAnaTestbeam->SetChi2Lim(10000.);
      tTofAnaTestbeam->SetChi2Lim2(10000.);
    //  tTofAnaTestbeam->SetChi2Lim(5.);
    //  tTofAnaTestbeam->SetChi2Lim2(2.);

      tTofAnaTestbeam->SetDutX(0.);
      tTofAnaTestbeam->SetDutY(0.);
      tTofAnaTestbeam->SetDutDX(100.);
      tTofAnaTestbeam->SetDutDY(100.);

  //    tTofAnaTestbeam->SetChi2LimFit(10.);// cf. fChiMaxAccept
      tTofAnaTestbeam->SetSIGLIM(10000.); // TODO: fdChi2Lim
      tTofAnaTestbeam->SetSIGX(0.7);   //       fdDXWidth
      tTofAnaTestbeam->SetSIGY(1.0);   //       fdDYWidth
      tTofAnaTestbeam->SetSIGT(0.1);   //       fdDTWidth
      tTofAnaTestbeam->SetBestSelTrackletOnly(kTRUE);

      tTofAnaTestbeam->SetMinMCRefTrackPoints(4);
  //    tTofAnaTestbeam->SetMaxMCRefTracks(1);
      tTofAnaTestbeam->SetMCSIGLIM(10000.);
      tTofAnaTestbeam->SetMCSIGX(0.7);
      tTofAnaTestbeam->SetMCSIGY(1.0);
      tTofAnaTestbeam->SetMCSIGT(0.1);
      if(bFinalRun)
      {
        tTofAnaTestbeam->SetUseSigCalib(kTRUE);
      }
    }

    if(bHeavyIonCollisions && bIdealCalibration)
    {
      tTofAnaTestbeam->SetDXMean(0.);
      tTofAnaTestbeam->SetDYMean(0.);
      tTofAnaTestbeam->SetDTMean(0.);

      tTofAnaTestbeam->SetDXWidth(0.3);
      tTofAnaTestbeam->SetDYWidth(1.3);
      tTofAnaTestbeam->SetDTWidth(0.1);

      tTofAnaTestbeam->SetMulDMax(1);
      tTofAnaTestbeam->SetMul0Max(0);
      tTofAnaTestbeam->SetMul4Max(10);

      tTofAnaTestbeam->SetDTD4MAX(6.);

      tTofAnaTestbeam->SetCh4Sel(0.);
      tTofAnaTestbeam->SetDCh4Sel(100.);
      tTofAnaTestbeam->SetPosY4SelOff(0.);
      tTofAnaTestbeam->SetPosY4Sel(10.);
    //  tTofAnaTestbeam->SetPosY4Sel(0.5*dScaleFactor);

      tTofAnaTestbeam->SetDTDia(0.);
      tTofAnaTestbeam->SetHitDistMin(30.);

      tTofAnaTestbeam->SetChS2Sel(0.);
      tTofAnaTestbeam->SetDChS2Sel(100.);
      tTofAnaTestbeam->SetPosYS2SelOff(0.);
      tTofAnaTestbeam->SetPosYS2Sel(10.);
    //  tTofAnaTestbeam->SetPosYS2Sel(0.5);

      tTofAnaTestbeam->SetTShift(0.);
      tTofAnaTestbeam->SetSel2TOff(0.);
      tTofAnaTestbeam->SetTOffD4(0.);

      tTofAnaTestbeam->SetChi2Lim(10.);
  //    tTofAnaTestbeam->SetChi2Lim(10000.);
      tTofAnaTestbeam->SetChi2Lim2(2.);

      tTofAnaTestbeam->SetDutX(0.);
      tTofAnaTestbeam->SetDutY(0.);
      tTofAnaTestbeam->SetDutDX(100.);
      tTofAnaTestbeam->SetDutDY(100.);

      tTofAnaTestbeam->SetChi2LimFit(10.);// cf. fChiMaxAccept
      tTofAnaTestbeam->SetSIGLIM(10.); // TODO: fdChi2Lim
  //    tTofAnaTestbeam->SetSIGLIM(10000.);
      tTofAnaTestbeam->SetSIGX(0.3);   //       fdDXWidth
      tTofAnaTestbeam->SetSIGY(1.3);   //       fdDYWidth
      tTofAnaTestbeam->SetSIGT(0.1);   //       fdDTWidth
      tTofAnaTestbeam->SetBestSelTrackletOnly(kTRUE);

      tTofAnaTestbeam->SetMinMCRefTrackPoints(4);
  //    tTofAnaTestbeam->SetMaxMCRefTracks(1);
      tTofAnaTestbeam->SetMCSIGLIM(10.);
  //    tTofAnaTestbeam->SetMCSIGLIM(2.1);
      tTofAnaTestbeam->SetMCSIGX(0.3);
      tTofAnaTestbeam->SetMCSIGY(1.3);
      tTofAnaTestbeam->SetMCSIGT(0.1);
      if(bFinalRun)
      {
        tTofAnaTestbeam->SetUseSigCalib(kTRUE);
      }
    }

    switch(iMRef)
    {
      case 921:
        switch(iDut)
        {
          case 901:
            if(bHeavyIonCollisions)
            {
              if(bIdealCalibration)
              {
                if(bIdealClustering)
                {
                }
                else
                {
                  tTofAnaTestbeam->SetDTMean(-1.667);
                  tTofAnaTestbeam->SetHitDistAv(32.92);
                }
              }
              else
              {
                if(bIdealClustering)
                {
                }
                else
                {
                }
              }
            }
            else
            {
              if(bIdealCalibration)
              {
                if(bIdealClustering)
                {
                  tTofAnaTestbeam->SetDTMean(-1.598);
                  tTofAnaTestbeam->SetHitDistAv(47.92);
                }
                else
                {
                  tTofAnaTestbeam->SetDTMean(-1.598);
                  tTofAnaTestbeam->SetHitDistAv(47.92);
                }
              }
              else
              {
                if(bIdealClustering)
                {
                }
                else
                {
                }
              }
            }
            break;

            default:
            break;
        }

        switch(iBRef)
        {
          case 510:
            if(bHeavyIonCollisions)
            {
              if(bIdealCalibration)
              {
                if(bIdealClustering)
                {
                }
                else
                {
                  tTofAnaTestbeam->SetTShift(-14.459);
                  tTofAnaTestbeam->SetTOffD4(14.290);
                }
              }
              else
              {
                if(bIdealClustering)
                {
                }
                else
                {
                }
              }
            }
            else
            {
              if(bIdealCalibration)
              {
                if(bIdealClustering)
                {
                  tTofAnaTestbeam->SetTShift(-14.383);
                  tTofAnaTestbeam->SetTOffD4(14.383);
                }
                else
                {
                  tTofAnaTestbeam->SetTShift(-15.08);
                  tTofAnaTestbeam->SetTOffD4(16.08);
                }
              }
              else
              {
                if(bIdealClustering)
                {
                }
                else
                {
                }
              }
            }
            break;

          default:
            break;
        }

        switch(iSel2)
        {
          case 400:
            if(bHeavyIonCollisions)
            {
              if(bIdealCalibration)
              {
                if(bIdealClustering)
                {
                }
                else
                {
                  tTofAnaTestbeam->SetSel2TOff(-2.252);
                }
              }
              else
              {
                if(bIdealClustering)
                {
                }
                else
                {
                }
              }
            }
            else
            {
              if(bIdealCalibration)
              {
                if(bIdealClustering)
                {
                  tTofAnaTestbeam->SetSel2TOff(-2.2399);
                }
                else
                {
                  tTofAnaTestbeam->SetSel2TOff(-2.865);
                }
              }
              else
              {
                if(bIdealClustering)
                {
                }
                else
                {
                }
              }
            }
            break;

          default:
            break;
        }
        break;

      default:
        break;
    }
  }
  else
  {
    tTofAnaTestbeam->SetDXMean(0.);
    tTofAnaTestbeam->SetDYMean(0.);
    tTofAnaTestbeam->SetDTMean(0.);

    tTofAnaTestbeam->SetDXWidth(0.3);
    tTofAnaTestbeam->SetDYWidth(1.3);
    tTofAnaTestbeam->SetDTWidth(0.1);

    tTofAnaTestbeam->SetMulDMax(1);
    tTofAnaTestbeam->SetMul0Max(0);
    tTofAnaTestbeam->SetMul4Max(10);

    tTofAnaTestbeam->SetDTD4MAX(6.);

    tTofAnaTestbeam->SetCh4Sel(0.);
    tTofAnaTestbeam->SetDCh4Sel(100.);
    tTofAnaTestbeam->SetPosY4SelOff(0.);
    tTofAnaTestbeam->SetPosY4Sel(10.);
  //  tTofAnaTestbeam->SetPosY4Sel(0.5*dScaleFactor);

    tTofAnaTestbeam->SetDTDia(0.);
    tTofAnaTestbeam->SetHitDistMin(30.);

    tTofAnaTestbeam->SetChS2Sel(0.);
    tTofAnaTestbeam->SetDChS2Sel(100.);
    tTofAnaTestbeam->SetPosYS2SelOff(0.);
    tTofAnaTestbeam->SetPosYS2Sel(10.);
  //  tTofAnaTestbeam->SetPosYS2Sel(0.5);

    tTofAnaTestbeam->SetTShift(0.);
    tTofAnaTestbeam->SetSel2TOff(0.);
    tTofAnaTestbeam->SetTOffD4(0.);

    tTofAnaTestbeam->SetChi2Lim(10.);
    tTofAnaTestbeam->SetChi2Lim2(2.);

    tTofAnaTestbeam->SetDutX(0.);
    tTofAnaTestbeam->SetDutY(0.);
    tTofAnaTestbeam->SetDutDX(100.);
    tTofAnaTestbeam->SetDutDY(100.);

    tTofAnaTestbeam->SetChi2LimFit(10.);// cf. fChiMaxAccept
    tTofAnaTestbeam->SetSIGLIM(10.); // TODO: fdChi2Lim
    tTofAnaTestbeam->SetSIGX(0.3);   //       fdDXWidth
    tTofAnaTestbeam->SetSIGY(1.3);   //       fdDYWidth
    tTofAnaTestbeam->SetSIGT(0.1);   //       fdDTWidth
    tTofAnaTestbeam->SetBestSelTrackletOnly(kTRUE);

    if(bFinalRun)
    {
      tTofAnaTestbeam->SetUseSigCalib(kTRUE);
    }

    switch(iMRef)
    {
      case 921:
        switch(iDut)
        {
          case 901:
            //TODO: tTofAnaTestbeam->SetDTMean(-1.598);
            //TODO: tTofAnaTestbeam->SetHitDistAv(32.92);
            break;

          case 920:
            //TODO: tTofAnaTestbeam->SetDTMean(-0.149);
            //TODO: tTofAnaTestbeam->SetHitDistAv(-11.);
            break;

          case 400:
            //TODO: tTofAnaTestbeam->SetDTMean(-2.917);
            //TODO: tTofAnaTestbeam->SetHitDistAv(53.92);
            break;

            default:
            break;
        }

        switch(iBRef)
        {
          case 510:
            tTofAnaTestbeam->SetTShift(1.8);
            tTofAnaTestbeam->SetTOffD4(17.);
            break;

          default:
            break;
        }

        switch(iSel2)
        {
          case 400:
            tTofAnaTestbeam->SetSel2TOff(-0.1);
            break;

          case 901:
            //TODO: tTofAnaTestbeam->SetSel2TOff(-1.671);
            break;

          default:
            break;
        }
        break;

      default:
        break;
    }
  }

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

  if(bSimData)
  {
    tRun->AddTask(tDataManager);
  }

  tRun->AddTask(tTofFindTracks);

  if(bFinalRun)
  {
    if(bAnalysisMCQA)
    {
      tRun->AddTask(tTofMatch);
    }
    tRun->AddTask(tTofAnaTestbeam);
  }

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

  FairRuntimeDb* tRuntimeDb = tRun->GetRuntimeDb();
  FairParAsciiFileIo* tParIo1 = new FairParAsciiFileIo();
  tParIo1->open(tParFileList, "in");
  tRuntimeDb->setFirstInput(tParIo1);

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

  std::cout << "-I- ana_trks: initializing run..." << std::endl;
  tRun->Init();

  std::cout << "-I- ana_trks: starting run..." << std::endl;
  tRun->Run(0, iNEvents);

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

  gROOT->LoadMacro((tMacroDir + "/save_hst.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MatD4sel.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_Mat04D4best.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_eff_XY.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_calib_trk.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_TIS.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_trk.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_XY_trk.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_pull_trk.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_Eff_DTLH.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_Eff_XY.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_Eff_TIS.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_Dut_Res.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MCEvent.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MCSel.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MCHitSel.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MCTrkSel.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MCPVReco.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MCTrkRes.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MCReco.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_MCCounter.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_over_SelTypes.C").Data());
  gROOT->LoadMacro((tMacroDir + "/pl_all_SelTypes.C").Data());

  gInterpreter->ProcessLine("save_hst(\"" + tHistoFile + "\", kTRUE)");

  if(bFinalRun)
  {
    gInterpreter->ProcessLine("pl_over_MatD4sel()");
    gInterpreter->ProcessLine("pl_over_Mat04D4best(1)");
    gInterpreter->ProcessLine("pl_eff_XY()");
    gInterpreter->ProcessLine("pl_TIS()");

    gInterpreter->ProcessLine(Form("pl_Eff_DTLH(%d%d%d, 0., 1., \"\")", iDutType, iDutModule, iDutCounter));
    gInterpreter->ProcessLine(Form("pl_Eff_XY(%d%d%d, 0., 1., \"\")", iDutType, iDutModule, iDutCounter));
    gInterpreter->ProcessLine(Form("pl_Eff_TIS(%d%d%d, 0., 1., \"\")", iDutType, iDutModule, iDutCounter));
    gInterpreter->ProcessLine(Form("pl_Dut_Res(%d%d%d, \"\")", iDutType, iDutModule, iDutCounter));

    if(bAnalysisMCQA)
    {
      gInterpreter->ProcessLine(Form("pl_over_MCEvent(%f)", dTyMean));
      gInterpreter->ProcessLine("pl_over_MCSel()");
      gInterpreter->ProcessLine("pl_over_MCHitSel()");
      gInterpreter->ProcessLine("pl_over_MCTrkSel()");
      gInterpreter->ProcessLine("pl_over_MCPVReco()");
      gInterpreter->ProcessLine("pl_over_MCTrkRes()");
      gInterpreter->ProcessLine("pl_over_MCReco()");
      gInterpreter->ProcessLine("pl_over_MCCounter(5, 1, 0)");
      gInterpreter->ProcessLine("pl_over_MCCounter(4, 0, 0)");
      gInterpreter->ProcessLine("pl_over_MCCounter(9, 0, 1)");
      gInterpreter->ProcessLine("pl_over_MCCounter(9, 2, 0)");
      gInterpreter->ProcessLine("pl_over_MCCounter(9, 2, 1)");
    }

    gInterpreter->ProcessLine("pl_over_SelTypes()");
    gInterpreter->ProcessLine("pl_all_SelTypes()");
  }

  gInterpreter->ProcessLine("pl_calib_trk()");
  gInterpreter->ProcessLine(Form("pl_over_trk(%d)", iNStations));
  gInterpreter->ProcessLine(Form("pl_XY_trk(%d, 0.5, 0.)", iNStations));
  gInterpreter->ProcessLine(Form("pl_pull_trk(%d, %d, 1)", iNStations, 0));
  gInterpreter->ProcessLine(Form("pl_pull_trk(%d, %d, 1)", iNStations, 1));
  gInterpreter->ProcessLine(Form("pl_pull_trk(%d, %d, 1)", iNStations, 3));
  gInterpreter->ProcessLine(Form("pl_pull_trk(%d, %d, 1)", iNStations, 4));

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

  tTimer.Stop();
  Double_t dRealTime = tTimer.RealTime();
  Double_t dCPUTime = tTimer.CpuTime();

  std::cout << std::endl << std::endl;
  std::cout << "Macro finished successfully." << std::endl;
  std::cout << "Real time " << dRealTime << " s, CPU time " << dCPUTime << " s" << std::endl;
  std::cout << std::endl;

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

  // Extract the maximal used memory an add is as Dart measurement
  // This line is filtered by CTest and the value send to CDash
  FairSystemInfo tSysInfo;
  Float_t fMaxMemory = tSysInfo.GetMaxMemory();
  std::cout << "<DartMeasurement name=\"MaxMemory\" type=\"numeric/double\">";
  std::cout << fMaxMemory;
  std::cout << "</DartMeasurement>" << endl;

  Float_t fCPUUsage = dCPUTime/dRealTime;
  std::cout << "<DartMeasurement name=\"CpuLoad\" type=\"numeric/double\">";
  std::cout << fCPUUsage;
  std::cout << "</DartMeasurement>" << endl;
/*
  FairMonitor::GetMonitor()->Print();
*/
  // ---------------------------------------------------------------------------

  FairRootManager::Instance()->CloseSink();

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

  RemoveGeoManager();

  // ---------------------------------------------------------------------------
}