TEcnaRead.cc

Go to the documentation of this file.

//----------Author's Name: B.Fabbro, FX Gentit DSM/IRFU/SPP CEA-Saclay
//----------Copyright: Those valid for CEA sofware
//----------Modified: 04/07/2011

#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaRead.h"

//--------------------------------------
//  TEcnaRead.cc
//  Class creation: 03 Dec 2002
//  Documentation: see TEcnaRead.h
//--------------------------------------

R__EXTERN TEcnaRootFile *gCnaRootFile;

ClassImp(TEcnaRead);
//___________________________________________________________________________
//

TEcnaRead::TEcnaRead()
{
  Init();
  // std::cout << "[Info Management] CLASS: TEcnaRead.          CREATE OBJECT: this = " << this << std::endl;
}
//Constructor without argument

TEcnaRead::TEcnaRead(TEcnaObject* pObjectManager, const TString& SubDet)
{
  fObjectManager = (TEcnaObject*)pObjectManager;
  Long_t i_this = (Long_t)this;
  pObjectManager->RegisterPointer("TEcnaRead", i_this);

 //----------------------- Object management
  //............................ fCnaParCout
  fCnaParCout = nullptr;
  Long_t iCnaParCout = pObjectManager->GetPointerValue("TEcnaParCout");
  if( iCnaParCout == 0 )
    {fCnaParCout = new TEcnaParCout(pObjectManager); /*fCnew++*/}
  else
    {fCnaParCout = (TEcnaParCout*)iCnaParCout;}

  //............................ fCnaParPaths
  fCnaParPaths = nullptr;
  Long_t iCnaParPaths = pObjectManager->GetPointerValue("TEcnaParPaths");
  if( iCnaParPaths == 0 )
    {fCnaParPaths = new TEcnaParPaths(pObjectManager); /*fCnew++*/}
  else
    {fCnaParPaths = (TEcnaParPaths*)iCnaParPaths;}

  //............................ fEcalNumbering
  fEcalNumbering = nullptr;
  Long_t iEcalNumbering = pObjectManager->GetPointerValue("TEcnaNumbering");
  if( iEcalNumbering == 0 )
    {fEcalNumbering = new TEcnaNumbering(pObjectManager, SubDet.Data()); /*fCnew++*/}
  else
    {fEcalNumbering = (TEcnaNumbering*)iEcalNumbering;}

  //............................ fCnaParHistos
  fCnaParHistos = nullptr;
  Long_t iCnaParHistos = pObjectManager->GetPointerValue("TEcnaParHistos");
  if( iCnaParHistos == 0 )
    {fCnaParHistos = new TEcnaParHistos(pObjectManager, SubDet.Data()); /*fCnew++*/}
  else
    {fCnaParHistos = (TEcnaParHistos*)iCnaParHistos;}

  //............................ fCnaWrite
  fCnaWrite = nullptr;
  Long_t iCnaWrite = pObjectManager->GetPointerValue("TEcnaWrite");
  if( iCnaWrite == 0 )
    {fCnaWrite = new TEcnaWrite(pObjectManager, SubDet.Data()); /*fCnew++*/}
  else
    {fCnaWrite = (TEcnaWrite*)iCnaWrite;}

  // fEcal = 0; fEcal = new TEcnaParEcal(SubDet.Data());            // Anew("fEcal");
  //............................ fEcal  => to be changed in fParEcal
  fEcal = nullptr;
  Long_t iParEcal = pObjectManager->GetPointerValue("TEcnaParEcal");
  if( iParEcal == 0 )
    {fEcal = new TEcnaParEcal(pObjectManager, SubDet.Data()); /*fCnew++*/}
  else
    {fEcal = (TEcnaParEcal*)iParEcal;}

  //fFileHeader  = 0; 
  //const Text_t *h_name  = "CnaHeader";  //==> voir cette question avec FXG
  //const Text_t *h_title = "CnaHeader";  //==> voir cette question avec FXG
  //fFileHeader = new TEcnaHeader(h_name, h_title);  // Anew("fFileHeader");

  //............................ fFileHeader
  const Text_t *h_name  = "CnaHeader";  //==> voir cette question avec FXG
  const Text_t *h_title = "CnaHeader";  //==> voir cette question avec FXG

  // "CnaHeader" est le nom du fichier utilisé dans ReadRootFileHeader(...) sous la forme:
  //
  // TEcnaHeader *h;
  // h =(TEcnaHeader*)gCnaRootFile->fRootFile->Get("CnaHeader");
  //

  fFileHeader = nullptr;
  Long_t iFileHeader = pObjectManager->GetPointerValue("TEcnaHeader");
  if( iFileHeader == 0 )
    {fFileHeader = new TEcnaHeader(pObjectManager, h_name, h_title); /*fCnew++*/}
  else
    {fFileHeader = (TEcnaHeader*)iFileHeader;}

  Init();
  SetEcalSubDetector(SubDet.Data());

 // std::cout << "[Info Management] CLASS: TEcnaRead.          CREATE OBJECT: this = " << this << std::endl;
}

void TEcnaRead::Init()
{
//Initialisation concerning the ROOT file

  fCnew    = 0;
  fCdelete = 0;

  fTTBELL = '\007';

  fgMaxCar = (Int_t)512;

  fCodePrintNoComment   = fCnaParCout->GetCodePrint("NoComment");
  fCodePrintWarnings    = fCnaParCout->GetCodePrint("Warnings ");
  fCodePrintComments    = fCnaParCout->GetCodePrint("Comments");
  fCodePrintAllComments = fCnaParCout->GetCodePrint("AllComments");

  //.................................. Set flag print to "Warnings"   (Init)
  fFlagPrint = fCodePrintWarnings;

  //................................ tags and array Stin numbers
  fTagStinNumbers  = nullptr;
  fMemoStinNumbers = 0;
  fT1d_StexStinFromIndex = nullptr;

  //................................ 
  //  fMemoReadNumberOfEventsforSamples = 0;

  //.......................... flag data exist (utile ici?)
  fDataExist = kFALSE;

  //......................... transfert Sample ADC Values 3D array   (Init)
  fT3d_AdcValues  = nullptr;
  fT3d2_AdcValues = nullptr;
  fT3d1_AdcValues = nullptr;

  //................................. path for .root files
  Int_t MaxCar = fgMaxCar;
  MaxCar = fgMaxCar;
  fPathRoot.Resize(MaxCar);
  fPathRoot  = "fPathRoot not defined";

  //.................................. Pointer and Flags for Root File   (Init)
  gCnaRootFile = nullptr;

  fOpenRootFile = kFALSE;
  fReadyToReadRootFile = 0;
  fLookAtRootFile      = 0;

  //................................. currently open file
  MaxCar = fgMaxCar;
  fFlagNoFileOpen.Resize(MaxCar);
  fFlagNoFileOpen = "No file is open";

  MaxCar = fgMaxCar;
  fCurrentlyOpenFileName.Resize(MaxCar);
  fCurrentlyOpenFileName = fFlagNoFileOpen;

}// end of Init()

//============================================================================================================

void  TEcnaRead::SetEcalSubDetector(const TString& SubDet)
{
 // Set Subdetector (EB or EE)

  Int_t MaxCar = fgMaxCar;
  fFlagSubDet.Resize(MaxCar);
  fFlagSubDet = fEcal->GetEcalSubDetector();

  if( fFlagSubDet == "EB" ){fStexName = "SM";  fStinName = "tower";}
  if( fFlagSubDet == "EE" ){fStexName = "Dee"; fStinName = "SC";}
}

//============================================================================================================
void TEcnaRead::Anew(const TString& VarName)
{
  // allocation survey for new
  
  fCnew++;
  // std::cout << "TEcnaRead::Anew---> new " << std::setw(4) << fCnew << " --------------> " << std::setw(25)
  //      << VarName.Data() << " / object(this): " << this << std::endl;
}

void TEcnaRead::Adelete(const TString& VarName)
{
  // allocation survey for delete
  
  fCdelete++;
  // std::cout << "TEcnaRead::Adelete> ========== delete" << std::setw(4) << fCdelete << " -> " << std::setw(25)
  //      << VarName.Data() << " / object(this): " << this << std::endl;
}

//=========================================== private copy ==========

void  TEcnaRead::fCopy(const TEcnaRead& rund)
{
//Private copy

  fFileHeader   = rund.fFileHeader;
  fOpenRootFile = rund.fOpenRootFile;

  //........................................ Codes 

  fCodePrintComments    = rund.fCodePrintComments;
  fCodePrintWarnings    = rund.fCodePrintWarnings;
  fCodePrintAllComments = rund.fCodePrintAllComments;
  fCodePrintNoComment   = rund.fCodePrintNoComment;

  //.................................................. Tags
  fTagStinNumbers  = rund.fTagStinNumbers;

  fFlagPrint = rund.fFlagPrint;
  fPathRoot  = rund.fPathRoot;

  fCnew    = rund.fCnew;
  fCdelete = rund.fCdelete;
}

//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//
//                    copy constructor
//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

TEcnaRead::TEcnaRead(const TEcnaRead& dcop)
{
  std::cout << "*TEcnaRead::TEcnaRead(const TEcnaRead& dcop)> "
       << " It is time to write a copy constructor"
       << std::endl;
  
  // { Int_t cintoto;  cin >> cintoto; }
  
}

//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//
//                    overloading of the operator=
//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

TEcnaRead& TEcnaRead::operator=(const TEcnaRead& dcop)
{
//Overloading of the operator=

  fCopy(dcop);
  return *this;
}

//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//
//                            destructor
//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

TEcnaRead::~TEcnaRead()
{
//Destructor
  
  // std::cout << "[Info Management] CLASS: TEcnaRead.          DESTROY OBJECT: this = " << this << std::endl;

  if(fFlagPrint == fCodePrintAllComments || fFlagPrint == fCodePrintComments){
    std::cout << "*TEcnaRead::~TEcnaRead()> Entering destructor" << std::endl;}
  
  //if (fFileHeader    != 0){delete fFileHeader;    Adelete("fFileHeader");}
  //if (fEcal          != 0){delete fEcal;          Adelete("fEcal");}
  //if (fCnaParCout    != 0){delete fCnaParCout;    Adelete("fCnaParCout");}
  //if (fCnaParPaths   != 0){delete fCnaParPaths;   Adelete("fCnaParPaths");}
  //if (fCnaWrite      != 0){delete fCnaWrite;      Adelete("fCnaWrite");}
  //if (fEcalNumbering != 0){delete fEcalNumbering; Adelete("fEcalNumbering");}

  if (fT1d_StexStinFromIndex != nullptr){delete [] fT1d_StexStinFromIndex; Adelete("fT1d_StexStinFromIndex");}
  if (fTagStinNumbers        != nullptr){delete [] fTagStinNumbers;        Adelete("fTagStinNumbers");}

  if (fT3d_AdcValues  != nullptr){delete [] fT3d_AdcValues;  Adelete("fT3d_AdcValues");}
  if (fT3d2_AdcValues != nullptr){delete [] fT3d2_AdcValues; Adelete("fT3d2_AdcValues");}
  if (fT3d1_AdcValues != nullptr){delete [] fT3d1_AdcValues; Adelete("fT3d1_AdcValues");}

  if ( fCnew != fCdelete )
    {
      std::cout << "!TEcnaRead/destructor> WRONG MANAGEMENT OF ALLOCATIONS: fCnew = "
       << fCnew << ", fCdelete = " << fCdelete << fTTBELL << std::endl;
    }
  else
    {
      // std::cout << "*TEcnaRead/destructor> BRAVO! GOOD MANAGEMENT OF ALLOCATIONS: fCnew = "
      //      << fCnew << ", fCdelete = " << fCdelete << std::endl;
    }
  
  if(fFlagPrint == fCodePrintAllComments || fFlagPrint == fCodePrintComments){
    std::cout << "*TEcnaRead::~TEcnaRead()> End of destructor " << std::endl;}
}

//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
//
//                             M  E  T  H  O  D  S
//
//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

//============================================================================
//
//                       1 D   H I S T O S 
//
//============================================================================
TVectorD TEcnaRead::Read1DHisto(const Int_t& VecDim,     const TString& UserQuantity,
                const Int_t& n1StexStin, const Int_t& i0StinEcha, const Int_t& n1Sample)
{
  Int_t VecDimTest = fFileHeader->fReqNbOfEvts;

  if( VecDim == VecDimTest )
    {
      TVectorD vec(VecDim);

      TString CallingMethod = "1D";
      TString StandardQuantity = fCnaParHistos->BuildStandard1DHistoCodeY(CallingMethod, UserQuantity);

      if( StandardQuantity == "Adc" )
    {
      Int_t i0Sample = n1Sample-1;
      vec = ReadSampleAdcValues(n1StexStin, i0StinEcha, i0Sample, VecDim);
    }
      else
    {
      for(Int_t i=0; i<VecDim; i++){vec(i) = (double_t)0.;}
      std::cout <<"!TEcnaRead::Read1DHisto(...)>  UserQuantity = " << UserQuantity
           << "(StandardQuantity = " << StandardQuantity
           << "). Wrong code, no file reading." << fTTBELL << std::endl;
    }
      return vec;
    }
  else
    {
      TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i) = (double_t)0.;}
      std::cout <<"!TEcnaRead::Read1DHisto(...)> UserQuantity = " << UserQuantity
       << ", VecDim = " << VecDim << "(VecDimTest = " << VecDimTest << ")"
       << ". Wrong code or array dimension. No file reading." << fTTBELL << std::endl;
      return vec;
    }
}  // end of Read1DHisto / ReadSampleAdcValues

TVectorD TEcnaRead::Read1DHisto(const Int_t& VecDim, const TString& UserQuantity, const Int_t& n1StexStin)
{
  Int_t  VecDimTest = fEcal->MaxCrysInStin()*fEcal->MaxSampADC();
  if( VecDim == VecDimTest )
    {
      TVectorD vec(VecDim);
      
      TString CallingMethod = "1D";
      TString StandardQuantity = fCnaParHistos->BuildStandard1DHistoCodeY(CallingMethod, UserQuantity);
      
      if( StandardQuantity == "MSp" || StandardQuantity == "SSp" )
    {
      if( StandardQuantity == "MSp" ){vec = ReadSampleMeans(n1StexStin, VecDim);}
      if( StandardQuantity == "SSp" ){vec = ReadSampleSigmas(n1StexStin, VecDim);}
    }
      else
    {
      for(Int_t i=0; i<VecDim; i++){vec(i) = (double_t)0.;}
      std::cout <<"!TEcnaRead::Read1DHisto(...)>  UserQuantity = " << UserQuantity
           << ", StandardQuantity = " << StandardQuantity
           << ". Wrong code, no file reading." << fTTBELL << std::endl;
    }
      return vec;
    }
  else
    {
      TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i) = (double_t)0.;}
      std::cout <<"!TEcnaRead::Read1DHisto(...)> UserQuantity = " << UserQuantity
       << ", VecDim = " << VecDim << "(VecDimTest = " << VecDimTest << ")"
       << ". Wrong code or array dimension. No file reading." << fTTBELL << std::endl; 
      return vec;
    }
}  // end of Read1DHisto / ReadSampleMeans , ReadSampleSigmas

TVectorD TEcnaRead::Read1DHisto(const Int_t& VecDim, const TString& UserQuantity, const TString& UserDetector)
{
  // VecDim = fEcal->MaxCrysEcnaInStex if StandardDetector = "SM" or "Dee"
  // VecDim = fEcal->MaxStinEcnaInStas if StandardDetector = "EB" or "EE"

  Int_t VecDimTest = 1;
  TString StandardDetector = fCnaParHistos->BuildStandardDetectorCode(UserDetector);
  if( StandardDetector == "SM" || StandardDetector == "Dee"){VecDimTest = fEcal->MaxCrysEcnaInStex();}
  if( StandardDetector == "EB" || StandardDetector == "EE" ){VecDimTest = fEcal->MaxStinEcnaInStas();}

  if( VecDim == VecDimTest )
    {
      TVectorD vec(VecDim);

      TString CallingMethod = "1D";
      TString StandardQuantity = "?";
      StandardQuantity = fCnaParHistos->BuildStandard1DHistoCodeY(CallingMethod, UserQuantity);
      TString rTechReadCode = GetTechReadCode(StandardQuantity, StandardDetector);

      if( rTechReadCode != "?" )
    {
      if( StandardDetector == "SM" || StandardDetector == "Dee")
        {
          if( rTechReadCode == "NOEStex" ){vec = ReadNumberOfEvents(fEcal->MaxCrysEcnaInStex());}
          if( rTechReadCode == "PedStex" ){vec = ReadPedestals(fEcal->MaxCrysEcnaInStex());}
          if( rTechReadCode == "TNoStex" ){vec = ReadTotalNoise(fEcal->MaxCrysEcnaInStex());}
          if( rTechReadCode == "LFNStex" ){vec = ReadLowFrequencyNoise(fEcal->MaxCrysEcnaInStex());}
          if( rTechReadCode == "HFNStex" ){vec = ReadHighFrequencyNoise(fEcal->MaxCrysEcnaInStex());}
          if( rTechReadCode == "MCsStex" ){vec = ReadMeanCorrelationsBetweenSamples(fEcal->MaxCrysEcnaInStex());}
          if( rTechReadCode == "SCsStex" ){vec = ReadSigmaOfCorrelationsBetweenSamples(fEcal->MaxCrysEcnaInStex());}
        }

      if( StandardDetector == "EB" || StandardDetector == "EE" )
        {
          TVectorD vecStex(fEcal->MaxStinEcnaInStex());
          for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vecStex(i)=(Double_t)0.;}

          time_t xStartTime = GetStartTime();
          time_t xStopTime =  GetStopTime();
          TString xStartDate = "sStartDate";
          TString xStopDate  = "sStopDate";

          for(Int_t i0Stex=0; i0Stex<fEcal->MaxStexInStas(); i0Stex++)
        {
          Int_t n1Stex = i0Stex+1;
          FileParameters(fFileHeader->fTypAna,           fFileHeader->fNbOfSamples,
                 fFileHeader->fRunNumber,        fFileHeader->fFirstReqEvtNumber,
                 fFileHeader->fLastReqEvtNumber, fFileHeader->fReqNbOfEvts,
                 n1Stex, fPathRoot);

          if( LookAtRootFile() == kTRUE )
            {
              if( rTechReadCode == "NOEStas" ){vecStex = ReadAverageNumberOfEvents(fEcal->MaxStinEcnaInStex());}
              if( rTechReadCode == "PedStas" ){vecStex = ReadAveragePedestals(fEcal->MaxStinEcnaInStex());}
              if( rTechReadCode == "TNoStas" ){vecStex = ReadAverageTotalNoise(fEcal->MaxStinEcnaInStex());}
              if( rTechReadCode == "LFNStas" ){vecStex = ReadAverageLowFrequencyNoise(fEcal->MaxStinEcnaInStex());}
              if( rTechReadCode == "HFNStas" ){vecStex = ReadAverageHighFrequencyNoise(fEcal->MaxStinEcnaInStex());}
              if( rTechReadCode == "MCsStas" )
            {vecStex = ReadAverageMeanCorrelationsBetweenSamples(fEcal->MaxStinEcnaInStex());}
              if( rTechReadCode == "SCsStas" )
            {vecStex = ReadAverageSigmaOfCorrelationsBetweenSamples(fEcal->MaxStinEcnaInStex());}
          
              for(Int_t i0Stin=0; i0Stin<fEcal->MaxStinEcnaInStex(); i0Stin++)
            {
              vec(fEcal->MaxStinEcnaInStex()*i0Stex+i0Stin) = vecStex(i0Stin);
            }

              //............ Get start and stop date for the Stas (Stas = EB or EE)
              if( i0Stex == 0 )
            {
              xStartTime = GetStartTime();
              xStopTime =  GetStopTime();
              xStartDate = GetStartDate();
              xStopDate  = GetStopDate();
            }
              time_t  cStartTime = GetStartTime();
              time_t  cStopTime  = GetStopTime();
              TString cStartDate = GetStartDate();
              TString cStopDate  = GetStopDate();

              if( cStartTime < xStartTime ){xStartTime = cStartTime; xStartDate = cStartDate;}
              if( cStopTime  > xStopTime  ){xStopTime  = cStopTime;  xStopDate  = cStopDate;}

              fFileHeader->fStartDate = xStartDate;
              fFileHeader->fStopDate  = xStopDate;
            }
          else
            {
              std::cout  << "!TEcnaRead::Read1DHisto(const TString&, const TString&)> *ERROR* =====> "
                << " ROOT file not found" << fTTBELL << std::endl;
            }
        }
        }
    }
      else
    {
      for(Int_t i=0; i<VecDim; i++){vec(i) = (double_t)0.;}
      std::cout <<"!TEcnaRead::Read1DHisto(...)> UserQuantity = " << UserQuantity
           << ", UserDetector = " << UserDetector
           << ". Wrong code(s). No file reading." << fTTBELL << std::endl;
    }
      return vec;
    }
  else
    {
      TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i) = (double_t)0.;}
      std::cout <<"!TEcnaRead::Read1DHisto(...)> UserQuantity = " << UserQuantity
       << ", UserDetector = " << UserDetector << ", VecDim = " << VecDim
       << ". Wrong code(s) or array dimension. No file reading." << fTTBELL << std::endl; 
      return vec;
    }
}  // end of Read1DHisto / Stex and Stas histos

//============================================================================
//
//                       2 D   H I S T O S 
//
//============================================================================
TMatrixD TEcnaRead::ReadMatrix(const Int_t& MatDim,   const TString& UserCorOrCov, const TString& UserBetweenWhat,
                   const Int_t& nb_arg_1, const Int_t&  nb_arg_2)
{
  TMatrixD mat(MatDim, MatDim);
  TString CallingMethod = "2D";
  TString StandardMatrixType  = "?";
  TString StandardBetweenWhat = "?";

  StandardMatrixType  = fCnaParHistos->BuildStandardCovOrCorCode(CallingMethod, UserCorOrCov);
  StandardBetweenWhat = fCnaParHistos->BuildStandardBetweenWhatCode(CallingMethod, UserBetweenWhat);

  if( StandardMatrixType != "?" && StandardBetweenWhat != "?" )
    {
      if( StandardBetweenWhat == "Mss" )
    {
      Int_t n1StexStin = nb_arg_1; 
      Int_t i0StinEcha = nb_arg_2;
      
      if( StandardMatrixType == "Cov" )
        {mat = ReadCovariancesBetweenSamples(n1StexStin, i0StinEcha, MatDim);}
      
      if( StandardMatrixType == "Cor" )
        {mat = ReadCorrelationsBetweenSamples(n1StexStin, i0StinEcha, MatDim);}
    }

      if( StandardBetweenWhat != "Mss" )
    {
      Int_t n1StexStin_a = nb_arg_1; 
      Int_t n1StexStin_b = nb_arg_2;

      if( StandardMatrixType == "Cov" && StandardBetweenWhat == "MccLF" )
        {mat = ReadLowFrequencyCovariancesBetweenChannels(n1StexStin_a, n1StexStin_b, MatDim);}

      if( StandardMatrixType == "Cor" && StandardBetweenWhat == "MccLF" )
        {mat = ReadLowFrequencyCorrelationsBetweenChannels(n1StexStin_a, n1StexStin_b, MatDim);}

      if( StandardMatrixType == "Cov" && StandardBetweenWhat == "MccHF" )
        {mat = ReadHighFrequencyCovariancesBetweenChannels(n1StexStin_a, n1StexStin_b, MatDim);}

      if( StandardMatrixType == "Cor" && StandardBetweenWhat == "MccHF" )
        {mat = ReadHighFrequencyCorrelationsBetweenChannels(n1StexStin_a, n1StexStin_b, MatDim);}
    }
    }
  else
    {
      for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++)
        {mat(i,j) = (double_t)0.;}}
      std::cout <<"!TEcnaRead::ReadMatrix(...)> UserCorOrCov = " << UserCorOrCov
       << ", UserBetweenWhat = " << UserBetweenWhat
       << ". Wrong code(s), no file reading." << fTTBELL << std::endl;
    }
  return mat;
}

TMatrixD TEcnaRead::ReadMatrix(const Int_t& MatDim, const TString& UserCorOrCov, const TString& UserBetweenWhat)
{
  //------------------- (BIG MATRIX 1700x1700 for barrel, 5000x5000 for endcap) ------------------
  TMatrixD mat(MatDim, MatDim);
  TString CallingMethod = "2D";
  TString StandardMatrixType  = "?";
  TString StandardBetweenWhat = "?";

  StandardMatrixType  = fCnaParHistos->BuildStandardCovOrCorCode(CallingMethod, UserCorOrCov);
  StandardBetweenWhat = fCnaParHistos->BuildStandardBetweenWhatCode(CallingMethod, UserBetweenWhat);

  if( StandardMatrixType != "?" && StandardBetweenWhat != "?" )
    {
      //......................... between channels (covariances, correlations)
      if( StandardMatrixType == "Cov" && StandardBetweenWhat == "MccLF" )
    {mat = ReadLowFrequencyCovariancesBetweenChannels(MatDim);}

      if( StandardMatrixType == "Cor" && StandardBetweenWhat == "MccLF" )
    {mat = ReadLowFrequencyCorrelationsBetweenChannels(MatDim);}

      if( StandardMatrixType == "Cov" && StandardBetweenWhat == "MccHF" )
    {mat = ReadHighFrequencyCovariancesBetweenChannels(MatDim);}

      if( StandardMatrixType == "Cor" && StandardBetweenWhat == "MccHF" )
    {mat = ReadHighFrequencyCorrelationsBetweenChannels(MatDim);}

      //......................... between Stins (mean correlations)
      if( StandardMatrixType == "Cor" && StandardBetweenWhat == "MttLF" )
    {mat = ReadLowFrequencyMeanCorrelationsBetweenStins(MatDim);}

      if( StandardMatrixType == "Cor" && StandardBetweenWhat == "MttHF" )
    {mat = ReadHighFrequencyMeanCorrelationsBetweenStins(MatDim);}
  }
  else
    {
      for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++)
        {mat(i,j) = (double_t)0.;}}
      std::cout <<"!TEcnaRead::ReadMatrix(...)> UserCorOrCov = " << UserCorOrCov
       << ", UserBetweenWhat = " << UserBetweenWhat
       << ". Wrong code(s), no file reading." << fTTBELL << std::endl;
    }
  return mat;
}

//============================================================================
TString TEcnaRead::GetTechReadCode(const TString& StandardQuantity, const TString& StandardDetector)
{
  TString rTechReadCode = "?";
  TString dTechDetector = "?";

  if( StandardDetector == "SM" || StandardDetector == "Dee"){dTechDetector = "Stex";}
  if( StandardDetector == "EB" || StandardDetector == "EE" ){dTechDetector = "Stas";}

  if( dTechDetector == "?")
    {
      std::cout << "!TEcnaRead::GetTechReadCode(...)> *** ERROR: wrong standard code *** dTechDetector = "
       << dTechDetector << ", StandardDetector = " << StandardDetector
       << fTTBELL << std::endl;
    }
  else
    {
      if( StandardQuantity == "NOE" && dTechDetector == "Stex" ){rTechReadCode = "NOEStex";}
      if( StandardQuantity == "NOE" && dTechDetector == "Stas" ){rTechReadCode = "NOEStas";}
      if( StandardQuantity == "Ped" && dTechDetector == "Stex" ){rTechReadCode = "PedStex";}
      if( StandardQuantity == "Ped" && dTechDetector == "Stas" ){rTechReadCode = "PedStas";}
      if( StandardQuantity == "TNo" && dTechDetector == "Stex" ){rTechReadCode = "TNoStex";}
      if( StandardQuantity == "TNo" && dTechDetector == "Stas" ){rTechReadCode = "TNoStas";}
      if( StandardQuantity == "LFN" && dTechDetector == "Stex" ){rTechReadCode = "LFNStex";}
      if( StandardQuantity == "LFN" && dTechDetector == "Stas" ){rTechReadCode = "LFNStas";}
      if( StandardQuantity == "HFN" && dTechDetector == "Stex" ){rTechReadCode = "HFNStex";}
      if( StandardQuantity == "HFN" && dTechDetector == "Stas" ){rTechReadCode = "HFNStas";}
      if( StandardQuantity == "MCs" && dTechDetector == "Stex" ){rTechReadCode = "MCsStex";}
      if( StandardQuantity == "MCs" && dTechDetector == "Stas" ){rTechReadCode = "MCsStas";}
      if( StandardQuantity == "SCs" && dTechDetector == "Stex" ){rTechReadCode = "SCsStex";}
      if( StandardQuantity == "SCs" && dTechDetector == "Stas" ){rTechReadCode = "SCsStas";}
    }

  if( rTechReadCode == "?")
    {
      std::cout << "!TEcnaRead::GetTechReadCode(...)> *** ERROR: wrong standard code *** rTechReadCode = " << rTechReadCode
       << ", StandardQuantity = " << StandardQuantity
       << fTTBELL << std::endl;
    }

  return rTechReadCode;
}

//==========================================================================================
//
//                             FileParameters(...)
//                  
//==========================================================================================
void TEcnaRead::FileParameters(const TString&      typ_ana,    const Int_t& nb_of_samples,
                   const Int_t& run_number, const Int_t& nfirst,
                   const Int_t& nlast,      const Int_t& nreqevts,
                   const Int_t& Stex,       const TString&      path_root)
{
  // Preparation for reading the ROOT file
  // Preliminary save of the arguments values because they can be of the form: fFileHeader->...
  // and because fFileHeader can be deleted and re-created in this method

  const TString& sTypAna      = typ_ana;
  Int_t   nNbOfSamples = nb_of_samples;
  Int_t   nRunNumber   = run_number;
  Int_t   nFirstEvt    = nfirst;
  Int_t   nLastEvt     = nlast;
  Int_t   nReqNbOfEvts = nreqevts;
  Int_t   nStexNumber  = Stex;

  //................................................................................................
  const Text_t *h_name  = "CnaHeader";   //==> voir cette question avec FXG
  const Text_t *h_title = "CnaHeader";   //==> voir cette question avec FXG

  // "CnaHeader" est le nom du fichier utilisé dans ReadRootFileHeader(...) sous la forme:
  //
  // TEcnaHeader *h;
  // h =(TEcnaHeader*)gCnaRootFile->fRootFile->Get("CnaHeader");
  //

  //----------- old version, with arguments h_name, h_title, (FXG) ----------
  //
  // fFileHeader->HeaderParameters(h_name,    h_title,
  //                       sTypAna,   nNbOfSamples, nRunNumber,
  //                       nFirstEvt, nLastEvt, nReqNbOfEvts, nStexNumber);
  //
  //-------------------------------------------------------------------------

  //---------- new version
  if( fFileHeader == nullptr ){fFileHeader = new TEcnaHeader(fObjectManager, h_name, h_title);  /* Anew("fFileHeader") */ ;}
  fFileHeader->HeaderParameters(sTypAna,   nNbOfSamples, nRunNumber,
                nFirstEvt, nLastEvt,     nReqNbOfEvts, nStexNumber);

  // After this call to TEcnaHeader, we have:
  //     fFileHeader->fTypAna            = sTypAna
  //     fFileHeader->fNbOfSamples       = nNbOfSamples
  //     fFileHeader->fRunNumber         = nRunNumber
  //     fFileHeader->fFirstReqEvtNumber = nFirstEvt
  //     fFileHeader->fLastReqEvtNumber  = nLastEvt
  //     fFileHeader->fReqNbOfEvts       = nReqNbOfEvts
  //     fFileHeader->fStex              = nStexNumber                       ( FileParameters(...) )
  //.......................... path_root
  fPathRoot = path_root;

  //-------- gets the arguments for the file names (long and short) and makes these names
  fCnaWrite->RegisterFileParameters(typ_ana, nb_of_samples, run_number, nfirst, nlast, nreqevts, Stex);
  fCnaWrite->fMakeResultsFileName();
  //         names can be now recovered by call to TEcnaWrite methods: GetRootFileName() and GetRootFileNameShort()

  //------------------------- init Stin numbers memo flags
  fMemoStinNumbers = 0;

  if( fFlagPrint == fCodePrintAllComments || fFlagPrint == fCodePrintComments )
    {
      std::cout << std::endl;
      std::cout << "*TEcnaRead::FileParameters(...)>" << std::endl
       << "          The method has been called with the following argument values:" << std::endl
       << "          Analysis name                = "
       << fFileHeader->fTypAna << std::endl
       << "          Nb of required samples       = "
       << fFileHeader->fNbOfSamples << std::endl
       << "          Run number                   = "
       << fFileHeader->fRunNumber << std::endl
       << "          First requested event number = "
       << fFileHeader->fFirstReqEvtNumber << std::endl
       << "          Last requested event number  = "
       << fFileHeader->fLastReqEvtNumber << std::endl
       << "          Requested number of events   = "
       << fFileHeader->fReqNbOfEvts << std::endl
       << "          Stex number                  = "
       << fFileHeader->fStex << std::endl
       << "          Path for the ROOT file       = "
       << fPathRoot << std::endl
       << std::endl;
    }
  
  fReadyToReadRootFile = 1;           // set flag

} //----------------- end of FileParameters(...)

//=========================================================================
//
//   GetAnalysisName, GetNbOfSamples, GetRunNumber, GetFirstReqEvtNumber
//   GetLastReqEvtNumber, GetReqNbOfEvts, GetStexNumber
//
//=========================================================================
TString TEcnaRead::GetAnalysisName()     {return fFileHeader->fTypAna;}
Int_t   TEcnaRead::GetNbOfSamples()      {return fFileHeader->fNbOfSamples;}
Int_t   TEcnaRead::GetRunNumber()        {return fFileHeader->fRunNumber;}
Int_t   TEcnaRead::GetFirstReqEvtNumber(){return fFileHeader->fFirstReqEvtNumber;}
Int_t   TEcnaRead::GetLastReqEvtNumber() {return fFileHeader->fLastReqEvtNumber;}
Int_t   TEcnaRead::GetReqNbOfEvts()      {return fFileHeader->fReqNbOfEvts;}
Int_t   TEcnaRead::GetStexNumber()       {return fFileHeader->fStex;}
//=========================================================================
//
//     GetStartDate, GetStopDate, GetRunType
//
//=========================================================================
time_t  TEcnaRead::GetStartTime(){return fFileHeader->fStartTime;}
time_t  TEcnaRead::GetStopTime() {return fFileHeader->fStopTime;}
TString TEcnaRead::GetStartDate(){return fFileHeader->fStartDate;}
TString TEcnaRead::GetStopDate() {return fFileHeader->fStopDate;}
TString TEcnaRead::GetRunType()
{
  TString cType = "run type not defined";
  Int_t numtype = fFileHeader->fRunType;
  //----------------------------------------- run types

  if( numtype ==  0 ){cType = "COSMICS";}
  if( numtype ==  1 ){cType = "BEAMH4";}
  if( numtype ==  2 ){cType = "BEAMH2";}
  if( numtype ==  3 ){cType = "MTCC";}
  if( numtype ==  4 ){cType = "LASER_STD";}
  if( numtype ==  5 ){cType = "LASER_POWER_SCAN";}
  if( numtype ==  6 ){cType = "LASER_DELAY_SCAN";}
  if( numtype ==  7 ){cType = "TESTPULSE_SCAN_MEM";}
  if( numtype ==  8 ){cType = "TESTPULSE_MGPA";}
  if( numtype ==  9 ){cType = "PEDESTAL_STD";}
  if( numtype == 10 ){cType = "PEDESTAL_OFFSET_SCAN";}
  if( numtype == 11 ){cType = "PEDESTAL_25NS_SCAN";}
  if( numtype == 12 ){cType = "LED_STD";}

  if( numtype == 13 ){cType = "PHYSICS_GLOBAL";}
  if( numtype == 14 ){cType = "COSMICS_GLOBAL";}
  if( numtype == 15 ){cType = "HALO_GLOBAL";}

  if( numtype == 16 ){cType = "LASER_GAP";}
  if( numtype == 17 ){cType = "TESTPULSE_GAP";}
  if( numtype == 18 ){cType = "PEDESTAL_GAP";}
  if( numtype == 19 ){cType = "LED_GAP";}

  if( numtype == 20 ){cType = "PHYSICS_LOCAL";}
  if( numtype == 21 ){cType = "COSMICS_LOCAL";}
  if( numtype == 22 ){cType = "HALO_LOCAL";}
  if( numtype == 23 ){cType = "CALIB_LOCAL";}

  if( numtype == 24 ){cType = "PEDSIM";}

  return cType;
}
//==========================================================================
//
//                       R E A D    M E T H O D S  
//                      (   R O O T    F I L E  )
//
//==========================================================================
//-------------------------------------------------------------
//
//                      OpenRootFile
//
//-------------------------------------------------------------
Bool_t TEcnaRead::OpenRootFile(const Text_t *name, const TString& status) {
//Open the Root file

  Bool_t ok_open = kFALSE;

  TString s_name;
  s_name = fPathRoot;
  s_name.Append('/');
  s_name.Append(name);

  // if( gCnaRootFile != 0 )
  //  {
  //    Int_t iPointer = (Int_t)gCnaRootFile;
  //   std::cout << "*TEcnaRead::OpenRootFile(...)> RootFile pointer not (re)initialized to 0. gCnaRootFile = "
  //       << gCnaRootFile << ", pointer =  " << iPointer << fTTBELL << std::endl;
  //
  //   delete gCnaRootFile; gCnaRootFile = 0;  Adelete("gCnaRootFile");
  //  }

  //if( gCnaRootFile != 0 ){gCnaRootFile->ReStart(s_name.Data(), status);}
  //if( gCnaRootFile == 0 )
  //  {
      // gCnaRootFile = new TEcnaRootFile(fObjectManager, s_name.Data(), status);  Anew("gCnaRootFile");

      Long_t iCnaRootFile = fObjectManager->GetPointerValue("TEcnaRootFile");
      if( iCnaRootFile == 0 )
    {
      gCnaRootFile = new TEcnaRootFile(fObjectManager, s_name.Data(), status); /* Anew("gCnaRootFile");*/
    }
      else
    { 
      gCnaRootFile = (TEcnaRootFile*)iCnaRootFile;
      gCnaRootFile->ReStart(s_name.Data(), status);
    }
  //  }
  
  if ( gCnaRootFile->fRootFileStatus == "RECREATE" ){ok_open = gCnaRootFile->OpenW();}
  if ( gCnaRootFile->fRootFileStatus == "READ"     ){ok_open = gCnaRootFile->OpenR();}

  if ( ok_open == kFALSE )
    {
      std::cout << "!TEcnaRead::OpenRootFile> " << s_name.Data() << ": file not found." << std::endl;
      //if( gCnaRootFile != 0 )
      //  {delete gCnaRootFile; gCnaRootFile = 0;  Adelete("gCnaRootFile");}
    }
  else
    {
      if(fFlagPrint == fCodePrintAllComments)
    {
      std::cout << "*TEcnaRead::OpenRootFile> Open ROOT file " << s_name.Data() << " OK "
           << ", gCnaRootFile = " << gCnaRootFile << std::endl;
    }      
      fOpenRootFile = kTRUE;
      fCurrentlyOpenFileName = s_name;
      if(fFlagPrint == fCodePrintAllComments)
    {
      std::cout << "*TEcnaRead::OpenRootFile> Open ROOT file: " << fCurrentlyOpenFileName.Data() << " => OK "
           << ", gCnaRootFile = " << gCnaRootFile << std::endl << std::endl;
    }
    }
  return ok_open;
}                     // end of OpenRootFile()

//-------------------------------------------------------------
//
//                      CloseRootFile
//
//-------------------------------------------------------------
Bool_t TEcnaRead::CloseRootFile(const Text_t *name) {
//Close the Root file
 
  Bool_t ok_close = kFALSE;

  if (fOpenRootFile == kTRUE ) 
    {
      if( gCnaRootFile != nullptr )
    {
      gCnaRootFile->CloseFile();
      
      if(fFlagPrint == fCodePrintAllComments){
        TString e_path;  e_path.Append(name);
        std::cout << "*TEcnaRead::CloseRootFile> Close ROOT file " << e_path.Data() << " OK " << std::endl;}
      if(fFlagPrint == fCodePrintAllComments){
        Long_t pointer_value = (Long_t)gCnaRootFile;
        std::cout << "*TEcnaRead::CloseRootFile(...)> going to delete gCnaRootFile, gCnaRootFile = " << gCnaRootFile
         << ", pointer = " << pointer_value << std::endl;}

      //delete gCnaRootFile;   gCnaRootFile = 0;  Adelete("gCnaRootFile");
      
      ok_close      = kTRUE;
      fOpenRootFile = kFALSE;
      fCurrentlyOpenFileName = fFlagNoFileOpen;
      fReadyToReadRootFile = 0;
    }
      else
    {
      std::cout << "*TEcnaRead::CloseRootFile(...)> RootFile pointer equal to zero. Close not possible. gCnaRootFile = "
           << gCnaRootFile
           << fTTBELL << std::endl;
    }
    }
  else
    {
      std::cout << "*TEcnaRead::CloseRootFile(...)> no close since no file is open. fOpenRootFile = " << fOpenRootFile
       << std::endl;
    }
  return ok_close;
}

//============================================================================
//
//                      LookAtRootFile()
//                   Called by TEcnaHistos
//                  
//============================================================================
Bool_t TEcnaRead::LookAtRootFile()
{
//---------- Reads the ROOT file header and makes allocations and some other things

  fLookAtRootFile = 0;          // set flag to zero before looking for the file

  if(fReadyToReadRootFile == 1)
    {
      //------------ Call to ReadRootFileHeader
      Int_t iprint = 0;
      if( ReadRootFileHeader(iprint) == kTRUE )   //    (1) = print, (0) = no print
    {
      //........................................ allocation tags      
      if( fTagStinNumbers == nullptr ){fTagStinNumbers = new Int_t[1]; Anew("fTagStinNumbers");}

      //...................... allocation for fT1d_StexStinFromIndex[]
      if(fT1d_StexStinFromIndex == nullptr)
        {fT1d_StexStinFromIndex = new Int_t[fEcal->MaxStinEcnaInStex()]; Anew("fT1d_StexStinFromIndex");}
      
      //.. recover of the Stin numbers from the ROOT file (= init fT1d_StexStinFromIndex+init TagStin)
      TVectorD vec(fEcal->MaxStinEcnaInStex());
      for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
      vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());
      
      for (Int_t i = 0; i < fEcal->MaxStinEcnaInStex(); i++ ){
        fT1d_StexStinFromIndex[i] = (Int_t)vec(i);}

      fTagStinNumbers[0] = 1;                fFileHeader->fStinNumbersCalc++;
      
      fLookAtRootFile = 1;           // set flag
      return kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::LookAtRootFile()> *** ERROR ***>"
           << " ROOT file not found " << fTTBELL << std::endl;
      return kFALSE; 
    }
    }
  else
    {
      std::cout << "!TEcnaRead::LookAtRootFile()> *** ERROR ***>"
       << " FileParameters not called " << fTTBELL << std::endl;
      return kFALSE;      
    }
  return kFALSE;
} //----------------- end of LookAtRootFile()
//-------------------------------------------------------------------------
//
//                     DataExist()
//
//     DON'T SUPPRESS: CALLED BY ANOTHER CLASSES
//
//-------------------------------------------------------------------------
Bool_t TEcnaRead::DataExist()
{
  // return kTRUE if the data are present in the ROOT file, kFALSE if not.
  // fDataExist is set in the read methods

  return fDataExist;
}
//-------------------------------------------------------------------------
//
//                     ReadRootFileHeader
//
//-------------------------------------------------------------------------
Bool_t TEcnaRead::ReadRootFileHeader(const Int_t& i_print)
{
//Read the header of the Root file => test the file existence

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  if( i_print == 1 ){std::cout << "*TEcnaRead::ReadRootFileHeader> file_name = "
             << fCnaWrite->fRootFileNameShort.Data() << std::endl;}

  Bool_t ok_open = kFALSE;
 
  TString FileNameLong = fCnaWrite->GetRootFileName(); 
  Bool_t allowed_to_read = kFALSE;

  //  if( fOpenRootFile )
  //    {
  //      std::cout << "!TEcnaRead::ReadRootFileHeader(...)*** ERROR ***> "
  //       << "Reading header on file already open." << std::endl;
  //    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");
      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadRootFileHeader(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      TEcnaHeader *headerFile;
      headerFile =(TEcnaHeader*)gCnaRootFile->fRootFile->Get("CnaHeader");

      //..... get the attributes which are not already set by the call to TEcnaHeader
      //      in FileParameters(...) and are only available in the ROOT file

      fFileHeader->fStartTime = headerFile->fStartTime;
      fFileHeader->fStopTime  = headerFile->fStopTime;
      fFileHeader->fStartDate = headerFile->fStartDate;
      fFileHeader->fStopDate  = headerFile->fStopDate;

      fFileHeader->fRunType   = headerFile->fRunType;

      //....... Les f..Calc dans le header: pour acces direct a la taille des differentes data du fichier
      fFileHeader->fStinNumbersCalc = headerFile->fStinNumbersCalc;
      fFileHeader->fAdcEvtCalc      = headerFile->fAdcEvtCalc;
      fFileHeader->fMSpCalc         = headerFile->fMSpCalc;
      fFileHeader->fSSpCalc         = headerFile->fSSpCalc;
      fFileHeader->fAvTnoCalc       = headerFile->fAvTnoCalc;
      fFileHeader->fAvLfnCalc       = headerFile->fAvLfnCalc;
      fFileHeader->fAvHfnCalc       = headerFile->fAvHfnCalc;

      fFileHeader->fCovCssCalc      = headerFile->fCovCssCalc;
      fFileHeader->fCorCssCalc      = headerFile->fCorCssCalc;
      fFileHeader->fHfCovCalc       = headerFile->fHfCovCalc;
      fFileHeader->fHfCorCalc       = headerFile->fHfCorCalc;
      fFileHeader->fLfCovCalc       = headerFile->fLfCovCalc;
      fFileHeader->fLfCorCalc       = headerFile->fLfCorCalc;
      fFileHeader->fLFccMoStinsCalc = headerFile->fLFccMoStinsCalc;
      fFileHeader->fHFccMoStinsCalc = headerFile->fHFccMoStinsCalc;
      fFileHeader->fMeanCorssCalc   = headerFile->fMeanCorssCalc;
      fFileHeader->fSigCorssCalc    = headerFile->fSigCorssCalc;

      fFileHeader->fAvPedCalc       = headerFile->fAvPedCalc;
      fFileHeader->fAvMeanCorssCalc = headerFile->fAvMeanCorssCalc;
      fFileHeader->fAvSigCorssCalc  = headerFile->fAvSigCorssCalc;
      
      if(i_print == 1){fFileHeader->Print();}

      CloseRootFile(file_name);
      return kTRUE;
    }
  return kFALSE;
}
//-------------------------------------------------------------------------
void  TEcnaRead::TestArrayDimH1(const TString& CallingMethod, const TString& MaxName,
                const Int_t& MaxValue, const Int_t& VecDim)
{
// array dim test

  if( MaxValue != VecDim)
    {
      std::cout << "!TEcnaRead::TestArrayDimH1(...)> No matching for array dimension: CallingMethod: " << CallingMethod.Data()
       << ", MaxName: " << MaxName.Data()
       << ", Maxvalue = " << MaxValue
       << ", VecDim = " << VecDim << fTTBELL << std::endl;
    }
#define NOPM
#ifndef NOPM
  else
    {
      std::cout << "!TEcnaRead::TestArrayDimH1(...)> matching array dimension: OK. CallingMethod: " << CallingMethod.Data()
       << ", MaxName: " << MaxName.Data()
       << ", Maxvalue = " << MaxValue
       << ", VecDim = " << VecDim << std::endl;
    }
#endif // NOPM
}
//-------------------------------------------------------------------------
void  TEcnaRead::TestArrayDimH2(const TString& CallingMethod, const TString& MaxName,
                const Int_t& MaxValue, const Int_t& MatDim)
{
// array dim test

  if( MaxValue != MatDim)
    {
      std::cout << "!TEcnaRead::TestArrayDimH2(...)> No matching for array dimension: CallingMethod: " << CallingMethod.Data()
       << ", MaxName: " << MaxName.Data()
       << ", Maxvalue = " << MaxValue
       << ", MatDim = " << MatDim << fTTBELL << std::endl;
    }
#define NOPN
#ifndef NOPN
  else
    {
      std::cout << "!TEcnaRead::TestArrayDimH2(...)> matching array dimension: OK. CallingMethod: " << CallingMethod.Data()
       << ", MaxName: " << MaxName.Data()
       << ", Maxvalue = " << MaxValue
       << ", MatDim = " << MatDim << std::endl;
    }
#endif // NOPN
}

//-------------------------------------------------------------------------
//
//                     ReadStinNumbers(...)
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadStinNumbers(const Int_t& VecDim)
{
//Get the Stin numbers and put them in a TVectorD
//Read the ROOT file at first call and load in a TVectorD attribute
//Get directly the TVectorD attribute at other times
//
// Possible values for VecDim:
//          (1) VecDim = fEcal->MaxStinEcnaInStex()

  TVectorD vec(VecDim);

  TestArrayDimH1("ReadStinNumbers", "fEcal->MaxStinEcnaInStex()", fEcal->MaxStinEcnaInStex(), VecDim);

  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  if (fMemoStinNumbers == 0)
    {
      CnaResultTyp typ = cTypNumbers;
      const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
      const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

      //.............. reading of the ROOT file data type TResultTyp = cTypStinsNumbers
      //               to get the conversion: Stin index -> Stin number (n1StexStin)

      Bool_t ok_open = kFALSE;
      Bool_t ok_read = kFALSE;

      TString FileNameLong = fCnaWrite->GetRootFileName();
      Bool_t allowed_to_read = kFALSE;

//      if ( fOpenRootFile )
//  {
//    std::cout << "!TEcnaRead::ReadStinNumbers(...) *** ERROR ***> Reading on file already open."
//         << fTTBELL << std::endl;
//  }

      if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");
      
      if(ok_open)
        {
          allowed_to_read = kTRUE;
        }
      else
        {
          std::cout << "!TEcnaRead::ReadStinNumbers(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
          allowed_to_read = kFALSE;
          ok_read = kFALSE;
        }
    }

      if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if( ok_read == kTRUE )
        {
          fDataExist = kTRUE;
          //......... Get the Stin numbers and put them in TVectorD vec()
          for ( Int_t i_Stin = 0; i_Stin < VecDim; i_Stin++)
        {
          vec(i_Stin) = gCnaRootFile->fCnaIndivResult->fMatHis(0,i_Stin);
          fT1d_StexStinFromIndex[i_Stin] = (Int_t)vec(i_Stin);
        }
          fMemoStinNumbers++;
        }
      else
        {
          fDataExist = kFALSE;
          std::cout << "!TEcnaRead::ReadStinNumbers(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
        }
      CloseRootFile(file_name);
    }
      
      if( ok_read == kTRUE )
    {
      //........................... Print the Stin numbers 
      if(fFlagPrint == fCodePrintAllComments)
        {
          for(Int_t i=0; i < VecDim; i++)
        {
          std::cout << "*TEcnaRead::ReadStinNumbers(...)> StinNumber[" << i << "] = "
               << vec[i] << std::endl;
        }
        }
    }
    }
  else
    {
      fDataExist = kTRUE;
      for ( Int_t i_Stin = 0; i_Stin < VecDim; i_Stin++)
    {vec(i_Stin) = fT1d_StexStinFromIndex[i_Stin];}
    }
  return vec;
} // ----------------- ( end of ReadStinNumbers(...) ) -----------------

//============================================================================
//
//                       1 D   H I S T O S   (TECHNICAL METHODS)
//
//============================================================================

//--------------------------------------------------------------------------------------
//
//                 ReadSampleAdcValues(i0StexEcha,sample,fFileHeader->fReqNbOfEvts)  
//
//--------------------------------------------------------------------------------------
TVectorD TEcnaRead::ReadSampleAdcValues(const Int_t& n1StexStin, const Int_t& i0StinEcha,
                    const Int_t& sample,     const Int_t& VecDim)
{
//Read the sample ADC values for each event for a given i0StexEcha and a given sample
//in the results ROOT file and return it in a TVectorD(requested nb of events)
//
//Possible values for VecDim: (1) VecDim = fFileHeader->fReqNbOfEvts

  TestArrayDimH1("ReadSampleAdcValues", "fFileHeader->fReqNbOfEvts", fFileHeader->fReqNbOfEvts, VecDim);

  Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);

  TVectorD vec(VecDim);
  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypAdcEvt;   //  sample as a function of time type

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
  //  if ( fOpenRootFile )
  //   {
  //     std::cout << "!TEcnaRead::ReadSampleAdcValues(...) *** ERROR ***> "
  //       << "Reading on file already open." << fTTBELL << std::endl;
  //   }
  
  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadSampleAdcValues(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }
  
  if( allowed_to_read == kTRUE )
    {
      ok_read = gCnaRootFile->ReadElement(typ, i0StexEcha);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_bin=0; i_bin<VecDim; i_bin++)
        {
          vec(i_bin) = gCnaRootFile->fCnaIndivResult->fMatHis(sample, i_bin);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadSampleAdcValues(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                 -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}
//--- (end of ReadSampleAdcValues) ----------


//-------------------------------------------------------------------------
//
//                  ReadSampleMeans  
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadSampleMeans(const Int_t & n1StexStin, const Int_t & i0StinEcha,
                    const Int_t & VecDim)
{
//Read the expectation values of the samples
//for a given Stin and a given channel
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim : (1) VecDim = fFileHeader->fNbOfSamples

  TestArrayDimH1("ReadSampleMeans", "fFileHeader->fNbOfSamples", fFileHeader->fNbOfSamples, VecDim);

  Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);
  
  TVectorD vec(VecDim);
  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypMSp;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
    
  // if ( fOpenRootFile )
  //  {
  //    std::cout << "!TEcnaRead::ReadSampleMeans(...) *** ERROR ***> "
  //       << " Reading on file already open." << fTTBELL << std::endl;
  //  }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");
      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadSampleMeans(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }
  
  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_samp = 0; i_samp < VecDim; i_samp++)
        {
          vec(i_samp) = gCnaRootFile->fCnaIndivResult->fMatHis(i0StexEcha, i_samp);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadSampleMeans(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}
//------------------------------------------------------------------------------------------------
TVectorD TEcnaRead::ReadSampleMeans(const Int_t & n1StexStin, const Int_t & VecDim)
{
//Read the expectation values of the samples
//for all the channel of a given Stin 
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim : (1) VecDim = fFileHeader->fNbOfSamples*fEcal->MaxCrysInStin()

  TestArrayDimH1("ReadSampleMeans", "fFileHeader->fNbOfSamples*fEcal->MaxCrysInStin()",
         fFileHeader->fNbOfSamples*fEcal->MaxCrysInStin() , VecDim);
  
  TVectorD vec(VecDim);
  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypMSp;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
      
  //if ( fOpenRootFile )
  //  {
  //    std::cout << "!TEcnaRead::ReadSampleMeans(...) *** ERROR ***> "
  //       << " Reading on file already open." << fTTBELL << std::endl;
  //  }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    } 
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadSampleMeans(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }
  
  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;

      for( Int_t i0StinEcha=0; i0StinEcha<fEcal->MaxCrysInStin(); i0StinEcha++ )
        {
          Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);
          for ( Int_t i_samp=0; i_samp<fFileHeader->fNbOfSamples; i_samp++ )
        {
          vec(i0StinEcha*fFileHeader->fNbOfSamples+i_samp) =
            gCnaRootFile->fCnaIndivResult->fMatHis(i0StexEcha, i_samp);
        }
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadSampleMeans(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}

//-------------------------------------------------------------------------
//
//                  ReadSampleSigmas  
//                   
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadSampleSigmas(const Int_t & n1StexStin, const Int_t & i0StinEcha,
                     const Int_t & VecDim)
{
//Read the expectation values of the samples
//for a given Stin and a given channel
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim : (1) VecDim = fFileHeader->fNbOfSamples

  TestArrayDimH1("ReadSampleSigmas", "fFileHeader->fNbOfSamples", fFileHeader->fNbOfSamples, VecDim);

  Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);
  
  TVectorD vec(VecDim);
  vec.Zero();

  CnaResultTyp typ = cTypSSp;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  TString FileNameLong = fCnaWrite->GetRootFileName();
     
  //if ( fOpenRootFile )
  //  {
  //    std::cout << "!TEcnaRead::ReadSampleSigmas(...) *** ERROR ***> "
  //       << "Reading on file already open." << fTTBELL << std::endl;
  //  }

  if (FileNameLong != fCurrentlyOpenFileName)
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen )
        CloseRootFile(current_file_name);

      if(!(OpenRootFile(file_name, "READ")))
    {
      std::cout << "!TEcnaRead::ReadSampleSigmas(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
          return vec;
    }
    }
  
  Int_t i_zero = 0;
  
  if ( gCnaRootFile->ReadElement(typ, i_zero) )
    {
      fDataExist = kTRUE;
      for ( Int_t i_samp = 0; i_samp < VecDim; i_samp++)
        {
          vec(i_samp) = gCnaRootFile->fCnaIndivResult->fMatHis(i0StexEcha,i_samp);
        }   
    }
  else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadSampleSigmas(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                 -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
  CloseRootFile(file_name);
  return vec;
}
//------------------------------------------------------------------------------------------------
TVectorD TEcnaRead::ReadSampleSigmas(const Int_t & n1StexStin, const Int_t & VecDim)
{
//Read the expectation values of the samples
//for all the channel of a given Stin
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim : (1) VecDim = fFileHeader->fNbOfSamples*fEcal->MaxCrysInStin()

  TestArrayDimH1("ReadSampleSigmas", "fFileHeader->fNbOfSamples*fEcal->MaxCrysInStin()", 
         fFileHeader->fNbOfSamples*fEcal->MaxCrysInStin(), VecDim);
  
  TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypSSp;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
       
  //if ( fOpenRootFile )
  //  {
  //    std::cout << "!TEcnaRead::ReadSampleSigmas(...) *** ERROR ***> "
  //       << "Reading on file already open." << fTTBELL << std::endl;
  // }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadSampleSigmas(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }
  
  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;

      for( Int_t i0StinEcha=0; i0StinEcha<fEcal->MaxCrysInStin(); i0StinEcha++ )
        {
          Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);
          for ( Int_t i_samp = 0; i_samp < fFileHeader->fNbOfSamples; i_samp++)
        {
          vec(i0StinEcha*fFileHeader->fNbOfSamples+i_samp) =
            gCnaRootFile->fCnaIndivResult->fMatHis(i0StexEcha,i_samp);
        }
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadSampleSigmas(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                 -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}

//-----------------------------------------------------------------------------
//
//                  ReadNumberOfEvents(...)
//
//-----------------------------------------------------------------------------
TVectorD TEcnaRead::ReadNumberOfEvents(const Int_t& VecDim)
{
//Read the numbers of found events in the data
//for the crystals and for the samples for all the Stin's in the Stex
//in the ROOT file, compute the average on the samples
//and return them in a TVectorD(MaxCrysEcnaInStex)
//
//Possible values for VecDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH1("ReadNumberOfEvents", "fEcal->MaxCrysEcnaInStex()", fEcal->MaxCrysEcnaInStex(), VecDim);

  TVectorD vec(VecDim);
  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  TMatrixD mat(fEcal->MaxCrysInStin(), fFileHeader->fNbOfSamples);

  for(Int_t iStexStin=0; iStexStin<fEcal->MaxStinEcnaInStex(); iStexStin++)
    {
      //............. set mat(,) to zero before reading it
      for(Int_t i=0; i<fEcal->MaxCrysInStin(); i++)
    {for(Int_t j=0; j<fFileHeader->fNbOfSamples; j++){mat(i,j)=(Double_t)0.;}}
      //............. read mat(,)
      Int_t n1StexStin = iStexStin+1;
      mat = ReadNumberOfEventsForSamples(n1StexStin, fEcal->MaxCrysInStin(), fFileHeader->fNbOfSamples);

      for(Int_t i0StinEcha=0; i0StinEcha<fEcal->MaxCrysInStin(); i0StinEcha++)
    {
      Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);
      vec(i0StexEcha) = 0; 
      //.... average value over the samples
      for(Int_t i_samp=0; i_samp<fFileHeader->fNbOfSamples; i_samp++)
        {vec(i0StexEcha) += mat(i0StinEcha, i_samp);}
      vec(i0StexEcha) = vec(i0StexEcha)/fFileHeader->fNbOfSamples;
    } 
    }
  return vec;
}

//-----------------------------------------------------------------------------
//
//                  ReadNumberOfEventsForSamples 
//
//-----------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadNumberOfEventsForSamples(const Int_t& n1StexStin,
                         const Int_t& MatDimX, const Int_t& MatDimY)
{
//Read the numbers of found events in the data
//for the crystals and for the samples, for a given Stin in the Stex
//in the ROOT file and return them in a TMatrixD(MaxCrysInStin,NbOfSamples)
//
//Possible values for MatDimX and MatDimY:
//  (1) MatDimX = fEcal->MaxCrysInStin(), MatDimY = fFileHeader->fNbOfSamples



  TMatrixD mat(MatDimX, MatDimY);
  for(Int_t i=0; i-MatDimX<0; i++)
    {for(Int_t j=0; j-MatDimY<0; j++){mat(i,j)=(Double_t)0.;}}

  Int_t Stin_index = GetStinIndex(n1StexStin);
  if( Stin_index >= 0 )
    {
      if(fLookAtRootFile == 1)
    {
      CnaResultTyp typ = cTypNbOfEvts;
      const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
      const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();
      
      Bool_t ok_open = kFALSE;
      Bool_t ok_read = kFALSE;
      
      TString FileNameLong = fCnaWrite->GetRootFileName();
      Bool_t allowed_to_read = kFALSE;
      
      //      if ( fOpenRootFile )
      //        {
      //          std::cout << "!TEcnaRead::ReadNumberOfEventsForSamples(...) *** ERROR ***> "
      //           << " Reading on file already open." << fTTBELL << std::endl;
      //        }

      if( FileNameLong == fCurrentlyOpenFileName  )
        {
          allowed_to_read = kTRUE;
        }
      else
        {
          if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
          ok_open = OpenRootFile(file_name, "READ");  // set fOpenRootFile to kTRUE
          if(ok_open)
        {
          allowed_to_read = kTRUE;
        }
          else
        {
          std::cout << "!TEcnaRead::ReadNumberOfEventsForSamples(...) *** ERROR ***> Open .root file failed for file: "
               << file_name << fTTBELL << std::endl;
          allowed_to_read = kFALSE;
          ok_read = kFALSE;
        }
        }
      
      if( allowed_to_read == kTRUE )
        {
          Int_t i_zero = 0;
          ok_read = gCnaRootFile->ReadElement(typ, i_zero);
          
          if ( ok_read == kTRUE )
        {
          fDataExist = kTRUE;
          for (Int_t i_crys=0; i_crys-MatDimX<0; i_crys++)
            {             
              Int_t j_cna_chan = Stin_index*MatDimX + i_crys;
              for ( Int_t i_samp=0; i_samp-MatDimY<0; i_samp++)
            {
              mat(i_crys, i_samp) = gCnaRootFile->fCnaIndivResult->fMatHis(j_cna_chan, i_samp);
            }
            }
        }
          else
        {
          fDataExist = kFALSE;
          std::cout << "!TEcnaRead::ReadNumberOfEventsForSamples(...) *** ERROR ***> "
               << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
               << "                                                                 -> quantity: <"
               << GetTypeOfQuantity(typ) << "> not available in file."
               << fTTBELL << std::endl;
        }
        }
      CloseRootFile(file_name);
    }  // end of if (fLookAtRootFile == 1)
      else
    {
      std::cout << "!TEcnaRead::ReadNumberOfEventsForSamples(...) *** ERROR ***> "
           << "It is not possible to access the number of found events: the ROOT file has not been read."
           << fTTBELL << std::endl;
    }
    }  // end of if (Stin_index >= 0)
  return mat;
}// ----------------- end of ReadNumberOfEventsForSamples(...)

//-------------------------------------------------------------------------
//
//        ReadPedestals(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadPedestals(const Int_t& VecDim)
{
//Read the expectation values of the expectation values of the samples
//for all the channels of a given Stin
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH1("ReadPedestals", "fEcal->MaxCrysEcnaInStex()", fEcal->MaxCrysEcnaInStex(), VecDim);

  TVectorD vec(VecDim);
  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypPed;    // pedestals type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
  
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//    if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadPedestals(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");
      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadPedestals(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_StexCrys = 0; i_StexCrys < VecDim; i_StexCrys++)
        {
          vec(i_StexCrys) = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero, i_StexCrys);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadPedestals(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                              -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}

//-------------------------------------------------------------------------
//
//              ReadTotalNoise(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadTotalNoise(const Int_t& VecDim)
{
//Read the expectation values of the sigmas of the samples
//for all the channels of a given Stin
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH1("ReadTotalNoise", "fEcal->MaxCrysEcnaInStex()", fEcal->MaxCrysEcnaInStex(), VecDim);

  TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}
  CnaResultTyp typ = cTypTno;   // Total noise type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
  //  if ( fOpenRootFile )
  //  {
  //    std::cout << "!TEcnaRead::ReadTotalNoise(...) *** ERROR ***> "
  //       << "Reading on file already open." << fTTBELL << std::endl;
  //  }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");
      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadTotalNoise(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_StexCrys = 0; i_StexCrys < VecDim; i_StexCrys++)
        {
          vec(i_StexCrys)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero,i_StexCrys);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadTotalNoise(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                               -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}
//-------------------------------------------------------------------------
//
//          ReadMeanCorrelationsBetweenSamples(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadMeanCorrelationsBetweenSamples(const Int_t& VecDim)
{
//Read the Expectation values of the (sample,sample) correlations
//for all the channels of a given Stin
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) VecDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH1("ReadMeanCorrelationsBetweenSamples", "fEcal->MaxCrysEcnaInStex()",
         fEcal->MaxCrysEcnaInStex(), VecDim);

  TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}
  CnaResultTyp typ = cTypMeanCorss;     // mean corss type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
   
  //if ( fOpenRootFile )
  //  {
  //    std::cout << "!TEcnaRead::ReadMeanCorrelationsBetweenSamples(...) *** ERROR ***> "
  //       << "Reading on file already open." << fTTBELL << std::endl;
  //  }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");
      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadMeanCorrelationsBetweenSamples(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_StexCrys = 0; i_StexCrys < VecDim; i_StexCrys++)
        {
          vec(i_StexCrys)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero,i_StexCrys);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadMeanCorrelationsBetweenSamples(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                   ->  quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}

//-------------------------------------------------------------------------
//
//              ReadLowFrequencyNoise(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadLowFrequencyNoise(const Int_t& VecDim)
{
//Read the sigmas of the expectation values of the samples
//for all the channels of a given Stin
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH1("ReadLowFrequencyNoise", "fEcal->MaxCrysEcnaInStex()", fEcal->MaxCrysEcnaInStex(), VecDim);

  TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}
  CnaResultTyp typ = cTypLfn;        // low frequency noise type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
    
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadLowFrequencyNoise(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadLowFrequencyNoise(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_StexCrys = 0; i_StexCrys < VecDim; i_StexCrys++)
        {
          vec(i_StexCrys)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero,i_StexCrys);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadLowFrequencyNoise(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                      -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}

//-------------------------------------------------------------------------
//
//              ReadHighFrequencyNoise(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadHighFrequencyNoise(const Int_t& VecDim)
{
//Read the sigmas of the sigmas of the samples
//for all the channels of a given Stin
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH1("ReadHighFrequencyNoise", "fEcal->MaxCrysEcnaInStex()", fEcal->MaxCrysEcnaInStex(), VecDim);
  
  TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}
  CnaResultTyp typ = cTypHfn;        // high frequency noise type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
  
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;

//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadHighFrequencyNoise(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadHighFrequencyNoise(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_StexCrys = 0; i_StexCrys < VecDim; i_StexCrys++)
        {
          vec(i_StexCrys)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero,i_StexCrys);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadHighFrequencyNoise(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                       -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}

//-------------------------------------------------------------------------
//
//              ReadSigmaOfCorrelationsBetweenSamples(...)       
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadSigmaOfCorrelationsBetweenSamples(const Int_t& VecDim)
{
//Read the Expectation values of the (sample,sample) correlations
//for all the channels of a given Stin
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH1("ReadSigmaOfCorrelationsBetweenSamples", "fEcal->MaxCrysEcnaInStex()",
         fEcal->MaxCrysEcnaInStex(), VecDim);

  TVectorD vec(VecDim); for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}
  CnaResultTyp typ = cTypSigCorss;  // sigma of corss type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
  
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadSigmaOfCorrelationsBetweenSamples(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadSigmaOfCorrelationsBetweenSamples(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_StexCrys = 0; i_StexCrys < VecDim; i_StexCrys++)
        {
          vec(i_StexCrys)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero,i_StexCrys);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadSigmaOfCorrelationsBetweenSamples(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                      -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}
//==================================================================================================
//-----------------------------------------------------------------------------
//
//                  ReadAverageNumberOfEvents(...)
//
//       NB: read "direct" numbers of evts and compute the average HERE
//           (different from ReadAveragePedestals, Noises, etc...)
//
//-----------------------------------------------------------------------------
TVectorD TEcnaRead::ReadAverageNumberOfEvents(const Int_t& VecDim)
{
//Read the numbers of found events in the data
//for the crystals and for the samples for all the Stin's in the Stex
//in the ROOT file, compute the average on the samples and on the crystals
//and return them in a TVectorD(MaxStinEcnaInStex)
//
//Possible values for VecDim: (1) VecDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH1("ReadAverageNumberOfEvents", "fEcal->MaxStinEcnaInStex()", fEcal->MaxStinEcnaInStex(), VecDim);

  TVectorD vecAverage(VecDim);
  for(Int_t i=0; i<VecDim; i++){vecAverage(i)=(Double_t)0.;}

  TVectorD vecMean(fEcal->MaxCrysEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxCrysEcnaInStex(); i++){vecMean(i)=(Double_t)0.;}

  vecMean = ReadNumberOfEvents(fEcal->MaxCrysEcnaInStex());

  for(Int_t i0StexStin=0; i0StexStin<VecDim; i0StexStin++)
    {
      vecAverage(i0StexStin) = 0;
      //.... average value over the crystals
      for(Int_t i0StinEcha=0; i0StinEcha<fEcal->MaxCrysInStin(); i0StinEcha++)
    {
      Int_t n1StexStin = i0StexStin+1;
      Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);
      
      if( fStexName == "SM" )
        {vecAverage(i0StexStin) += vecMean(i0StexEcha);}

      if( fStexName == "Dee" )
        {
          //--------- EE --> Special translation for mixed SCEcna (29 and 32)
          //                 Xtal 11 of SCEcna 29 -> Xtal 11 of SCEcna 10
          //                 Xtal 11 of SCEcna 32 -> Xtal 11 of SCEcna 11
          Int_t n1StinEcha = i0StinEcha+1;
          if( n1StexStin == 10 && n1StinEcha == 11 )
        {i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(29, i0StinEcha);}
          if( n1StexStin == 11 && n1StinEcha == 11 )
        {i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(32, i0StinEcha);}
          if( !( (n1StexStin == 29 || n1StexStin == 32) && n1StinEcha == 11 )  )
        {vecAverage(i0StexStin) += vecMean(i0StexEcha);}
        }
    }

      Double_t xdivis = (Double_t)0.;
      if( fStexName == "SM"  )
    {xdivis = (Double_t)fEcal->MaxCrysInStin();}
      if( fStexName == "Dee" )
    {
      Int_t n1StexStin = i0StexStin+1;
      xdivis = (Double_t)fEcalNumbering->MaxCrysInStinEcna(fFileHeader->fStex, n1StexStin, "TEcnaRead");
    }

      vecAverage(i0StexStin) = vecAverage(i0StexStin)/xdivis;   
    }
  return vecAverage;
}

//-------------------------------------------------------------------------
//
//        ReadAveragePedestals(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadAveragePedestals(const Int_t& VecDim)
{
//Read the expectation values of the Pedestals
//for all the Stins of a given Stex
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) VecDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH1("ReadAveragePedestals", "fEcal->MaxStinEcnaInStex()", fEcal->MaxStinEcnaInStex(), VecDim);

  TVectorD vec(VecDim);
  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypAvPed;    // averaged pedestals type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadAveragePedestals(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadAveragePedestals(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for(Int_t i0StexStin=0; i0StexStin<VecDim; i0StexStin++)
        {
          vec(i0StexStin) = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero, i0StexStin);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadAveragePedestals(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                     -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
} // end of ReadAveragePedestals

//-------------------------------------------------------------------------
//
//        ReadAverageTotalNoise(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadAverageTotalNoise(const Int_t& VecDim)
{
//Read the expectation values of the Total Noise
//for all the Stins of a given Stex
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) VecDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH1("ReadAverageTotalNoise", "fEcal->MaxStinEcnaInStex()", fEcal->MaxStinEcnaInStex(), VecDim);

  TVectorD vec(VecDim);
  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypAvTno;    // averaged Total Noise type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
  
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadAverageTotalNoise(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadAverageTotalNoise(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i0StexStin = 0; i0StexStin < VecDim; i0StexStin++)
        {
          vec(i0StexStin)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero, i0StexStin);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadAverageTotalNoise(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                      -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
}

//-------------------------------------------------------------------------
//
//        ReadAverageLowFrequencyNoise(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadAverageLowFrequencyNoise(const Int_t& VecDim)
{
//Read the expectation values of the Pedestals
//for all the Stins of a given Stex
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) VecDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH1("ReadAverageLowFrequencyNoise", "fEcal->MaxStinEcnaInStex()", fEcal->MaxStinEcnaInStex(), VecDim);

  TVectorD vec(VecDim);
  for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypAvLfn;    // averaged Low FrequencyNoise type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
  
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;

//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadAverageLowFrequencyNoise(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadAverageLowFrequencyNoise(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i0StexStin = 0; i0StexStin < VecDim; i0StexStin++)
        {
          vec(i0StexStin)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero, i0StexStin);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadAverageLowFrequencyNoise(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                             -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
} // end of ReadAverageLowFrequencyNoise

//-------------------------------------------------------------------------
//
//        ReadAverageHighFrequencyNoise(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadAverageHighFrequencyNoise(const Int_t& VecDim)
{
//Read the expectation values of the Pedestals
//for all the Stins of a given Stex
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) VecDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH1("ReadAverageHighFrequencyNoise", "fEcal->MaxStinEcnaInStex()", fEcal->MaxStinEcnaInStex(), VecDim);

  TVectorD vec(VecDim);
 for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypAvHfn;    // averaged High FrequencyNoise type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
  
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadAverageHighFrequencyNoise(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadAverageHighFrequencyNoise(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i0StexStin = 0; i0StexStin < VecDim; i0StexStin++)
        {
          vec(i0StexStin)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero, i0StexStin);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadAverageHighFrequencyNoise(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                              -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
} // end of ReadAverageHighFrequencyNoise

//-------------------------------------------------------------------------
//
//        ReadAverageMeanCorrelationsBetweenSamples(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadAverageMeanCorrelationsBetweenSamples(const Int_t& VecDim)
{
//Read the expectation values of the Pedestals
//for all the Stins of a given Stex
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) VecDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH1("ReadAverageMeanCorrelationsBetweenSamples", "fEcal->MaxStinEcnaInStex()",
         fEcal->MaxStinEcnaInStex(), VecDim);

  TVectorD vec(VecDim);
 for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypAvMeanCorss;    // averaged MeanCorrelationsBetweenSamples type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
    
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadAverageMeanCorrelationsBetweenSamples(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadAverageMeanCorrelationsBetweenSamples(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i0StexStin = 0; i0StexStin < VecDim; i0StexStin++)
        {
          vec(i0StexStin)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero, i0StexStin);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadAverageMeanCorrelationsBetweenSamples(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                          -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
} // end of ReadAverageMeanCorrelationsBetweenSamples

//-------------------------------------------------------------------------
//
//        ReadAverageSigmaOfCorrelationsBetweenSamples(...)      
//
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadAverageSigmaOfCorrelationsBetweenSamples(const Int_t& VecDim)
{
//Read the expectation values of the Pedestals
//for all the Stins of a given Stex
//in the ROOT file and return them in a TVectorD
//
//Possible values for VecDim: (1) VecDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH1("ReadAverageSigmaOfCorrelationsBetweenSamples", "fEcal->MaxStinEcnaInStex()",
         fEcal->MaxStinEcnaInStex(), VecDim);

  TVectorD vec(VecDim);
 for(Int_t i=0; i<VecDim; i++){vec(i)=(Double_t)0.;}

  CnaResultTyp typ = cTypAvSigCorss;    // averaged SigmaOfCorrelationsBetweenSamples type
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
      
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadAverageSigmaOfCorrelationsBetweenSamples(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadAverageSigmaOfCorrelationsBetweenSamples(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i0StexStin = 0; i0StexStin < VecDim; i0StexStin++)
        {
          vec(i0StexStin)  = gCnaRootFile->fCnaIndivResult->fMatHis(i_zero, i0StexStin);
        }   
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadAverageSigmaOfCorrelationsBetweenSamples(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                             -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec;
} // end of ReadAverageSigmaOfCorrelationsBetweenSamples


//============================================================================
//
//                       2 D   H I S T O S   (TECHNICAL METHODS)
//
//============================================================================
//-------------------------------------------------------------------------
//
//  ReadCovariancesBetweenSamples(n1StexStin,StinEcha,fFileHeader->fNbOfSamples)
//
//-------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadCovariancesBetweenSamples(const Int_t & n1StexStin, const Int_t & i0StinEcha,
                          const Int_t& MatDim)
{
//Read the (sample,sample) covariances for a given channel
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fFileHeader->fNbOfSamples

  TestArrayDimH2("ReadCovariancesBetweenSamples", "fFileHeader->fNbOfSamples", fFileHeader->fNbOfSamples, MatDim);

  Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);

  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}
  
  CnaResultTyp typ = cTypCovCss;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
  
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
      
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadCovariancesBetweenSamples(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadCovariancesBetweenSamples(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      ok_read = gCnaRootFile->ReadElement(typ, i0StexEcha);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for( Int_t i_samp = 0; i_samp - MatDim < 0; i_samp++ )
        {
          for ( Int_t j_samp = 0; j_samp - MatDim < 0; j_samp++)
        {
         mat(i_samp, j_samp) = gCnaRootFile->fCnaIndivResult->fMatMat(i_samp,j_samp);
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadCovariancesBetweenSamples() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                           -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}

//-------------------------------------------------------------------------
//
//  ReadCorrelationsBetweenSamples(n1StexStin,StinEcha,fFileHeader->fNbOfSamples)
//
//-------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadCorrelationsBetweenSamples(const Int_t & n1StexStin, const Int_t & i0StinEcha,
                           const Int_t& MatDim)
{
//Read the (sample,sample) correlations for a given channel
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fFileHeader->fNbOfSamples

  TestArrayDimH2("ReadCorrelationsBetweenSamples", "fFileHeader->fNbOfSamples", fFileHeader->fNbOfSamples, MatDim);

  Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);
  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i- MatDim <0; i++)
    {for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}

  CnaResultTyp typ = cTypCorCss;
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
      
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadCorrelationsBetweenSamples(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadCorrelationsBetweenSamples(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      ok_read = gCnaRootFile->ReadElement(typ, i0StexEcha);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_samp = 0; i_samp - MatDim < 0; i_samp++){
        for ( Int_t j_samp = 0; j_samp - MatDim < 0; j_samp++){
          mat(i_samp, j_samp) = gCnaRootFile->fCnaIndivResult->fMatMat(i_samp,j_samp);}}
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadCorrelationsBetweenSamples() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                            -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//-------------------------------------------------------------------------
//
//  ReadRelevantCorrelationsBetweenSamples(n1StexStin,i0StinEcha)
//                 (NOT USED)
//-------------------------------------------------------------------------
TVectorD TEcnaRead::ReadRelevantCorrelationsBetweenSamples(const Int_t & n1StexStin, const Int_t & i0StinEcha,
                               const Int_t & InPutMatDim )
{
//Read the (sample,sample) correlations for a given channel
//in ROOT file and return the relevant correlations in a TVectorD
//
//Possible values for InPutMatDim: (1) InPutMatDim = fFileHeader->fNbOfSamples
//
//  *===>  OutPut TVectorD dimension value = InPutMatDim*(InPutMatDim-1)/2

  TestArrayDimH2("ReadRelevantCorrelationsBetweenSamples", "fFileHeader->fNbOfSamples",
         fFileHeader->fNbOfSamples, InPutMatDim);

  Int_t i0StexEcha = fEcalNumbering->Get0StexEchaFrom1StexStinAnd0StinEcha(n1StexStin, i0StinEcha);
  Int_t nb_of_relevant = InPutMatDim*(InPutMatDim-1)/2;
  TVectorD vec_rel(nb_of_relevant); for(Int_t i=0; i<nb_of_relevant; i++){vec_rel(i)=(Double_t)0.;}
  CnaResultTyp typ = cTypCorCss;
  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;

//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadRelevantCorrelationsBetweenSamples(...) *** ERROR ***> "
//     << "Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadRelevantCorrelationsBetweenSamples(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      ok_read = gCnaRootFile->ReadElement(typ, i0StexEcha);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      Int_t k_cor = 0;
      for ( Int_t i_samp = 0; i_samp < InPutMatDim; i_samp++){
        for ( Int_t j_samp = 0; j_samp < i_samp; j_samp++){
          vec_rel(k_cor) = gCnaRootFile->fCnaIndivResult->fMatMat(i_samp,j_samp);
          k_cor++;}}
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadRelevantCorrelationsBetweenSamples() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                    -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return vec_rel;
}
//----- end of (ReadRelevantCorrelationsBetweenSamples ) -------

//-----------------------------------------------------------------------------------------
//
//        ReadLowFrequencyCovariancesBetweenChannels(Stin_a, Stin_b)
//
//-----------------------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadLowFrequencyCovariancesBetweenChannels(const Int_t& n1StexStin_a,
                                   const Int_t& n1StexStin_b,
                                   const Int_t& MatDim)
{
//Read the Low Frequency cov(i0StinEcha of Stin_a, i0StinEcha of Stin b)
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxCrysInStin()

  TestArrayDimH2("ReadLowFrequencyCovariancesBetweenChannels", "fEcal->MaxCrysInStin()",
         fEcal->MaxCrysInStin(), MatDim);

  Int_t   index_Stin_a = GetStinIndex(n1StexStin_a);
  Int_t   index_Stin_b = GetStinIndex(n1StexStin_b);

  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}
  
  CnaResultTyp typ = cTypLfCov;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadLowFrequencyCovariancesBetweenChannels(...) *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadLowFrequencyCovariancesBetweenChannels(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ,i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_crys = 0; i_crys - MatDim < 0; i_crys++)
        {
          Int_t i_cna_chan = index_Stin_a*MatDim + i_crys;
          for ( Int_t j_crys = 0; j_crys - MatDim<0; j_crys++)
        {
          Int_t j_cna_chan = index_Stin_b*MatDim + j_crys;
          mat(i_crys, j_crys) = gCnaRootFile->fCnaIndivResult->fMatMat(i_cna_chan,j_cna_chan);
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadLowFrequencyCovariancesBetweenChannels(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                           -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//----- end of ( ReadLowFrequencyCovariancesBetweenChannels(...) ) -------

//-------------------------------------------------------------------------------------------
//
//         ReadLowFrequencyCorrelationsBetweenChannels(Stin_a, Stin_b)
//
//-------------------------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadLowFrequencyCorrelationsBetweenChannels(const Int_t & n1StexStin_a,
                                const Int_t & n1StexStin_b,
                                const Int_t& MatDim)
{
//Read the Low Frequency cor(i0StinEcha of Stin_a, i0StinEcha of Stin b)
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxCrysInStin()

  TestArrayDimH2("ReadLowFrequencyCorrelationsBetweenChannels", "fEcal->MaxCrysInStin()", fEcal->MaxCrysInStin(), MatDim);

  Int_t   index_Stin_a = GetStinIndex(n1StexStin_a);
  Int_t   index_Stin_b = GetStinIndex(n1StexStin_b);

  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}
  
  CnaResultTyp typ = cTypLfCor;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadLowFrequencyCorrelationsBetweenChannels(...) *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadLowFrequencyCorrelationsBetweenChannels(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;

      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_crys = 0; i_crys - MatDim<0; i_crys++)
        {
          Int_t i_cna_chan = index_Stin_a*MatDim + i_crys;
          for ( Int_t j_crys = 0; j_crys - MatDim<0; j_crys++)
        {
          Int_t j_cna_chan = index_Stin_b*MatDim + j_crys;
          mat(i_crys, j_crys) = gCnaRootFile->fCnaIndivResult->fMatMat(i_cna_chan,j_cna_chan);
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadLowFrequencyCorrelationsBetweenChannels(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                            -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//----- end of ( ReadLowFrequencyCorrelationsBetweenChannels(...) ) -------

//-----------------------------------------------------------------------------------------
//
//        ReadHighFrequencyCovariancesBetweenChannels(Stin_a, Stin_b)
//
//-----------------------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadHighFrequencyCovariancesBetweenChannels(const Int_t & n1StexStin_a,
                                const Int_t & n1StexStin_b,
                                const Int_t& MatDim)
{
//Read the High Frequency cov(i0StinEcha of Stin_a, i0StinEcha of Stin b)
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxCrysInStin()

  TestArrayDimH2("ReadHighFrequencyCovariancesBetweenChannels", "fEcal->MaxCrysInStin()",
         fEcal->MaxCrysInStin(), MatDim);

  Int_t   index_Stin_a = GetStinIndex(n1StexStin_a);
  Int_t   index_Stin_b = GetStinIndex(n1StexStin_b);

  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}
  
  CnaResultTyp typ = cTypHfCov;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadHighFrequencyCovariancesBetweenChannels(...) *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadHighFrequencyCovariancesBetweenChannels(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ,i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_crys = 0; i_crys - MatDim<0; i_crys++)
        {
          Int_t i_cna_chan = index_Stin_a*MatDim + i_crys;
          for ( Int_t j_crys = 0; j_crys - MatDim<0; j_crys++)
        {
          Int_t j_cna_chan = index_Stin_b*MatDim + j_crys;
          mat(i_crys, j_crys) = gCnaRootFile->fCnaIndivResult->fMatMat(i_cna_chan,j_cna_chan);
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadHighFrequencyCovariancesBetweenChannels(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                            -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//----- end of ( ReadHighFrequencyCovariancesBetweenChannels(...) ) -------

//-------------------------------------------------------------------------------------------
//
//         ReadHighFrequencyCorrelationsBetweenChannels(Stin_a, Stin_b)
//
//-------------------------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadHighFrequencyCorrelationsBetweenChannels(const Int_t & n1StexStin_a,
                                 const Int_t & n1StexStin_b,
                                 const Int_t& MatDim)
{
//Read the High Frequency Cor(i0StinEcha of Stin_a, i0StinEcha of Stin b)
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxCrysInStin()

  TestArrayDimH2("ReadHighFrequencyCorrelationsBetweenChannels", "fEcal->MaxCrysInStin()",
         fEcal->MaxCrysInStin(), MatDim);

  Int_t   index_Stin_a = GetStinIndex(n1StexStin_a);
  Int_t   index_Stin_b = GetStinIndex(n1StexStin_b);

  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}
  
  CnaResultTyp typ = cTypHfCor;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
    
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadHighFrequencyCorrelationsBetweenChannels(...) *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadHighFrequencyCorrelationsBetweenChannels(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;

      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for ( Int_t i_crys = 0; i_crys - MatDim<0; i_crys++)
        {
          Int_t i_cna_chan = index_Stin_a*MatDim + i_crys;
          for ( Int_t j_crys = 0; j_crys - MatDim<0; j_crys++)
        {
          Int_t j_cna_chan = index_Stin_b*MatDim + j_crys;
          mat(i_crys, j_crys) = gCnaRootFile->fCnaIndivResult->fMatMat(i_cna_chan,j_cna_chan);
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadHighFrequencyCorrelationsBetweenChannels(...) *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                             -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//----- end of ( ReadHighFrequencyCorrelationsBetweenChannels(...) ) -------

//-------------------------------------------------------------------------
//
//         ReadLowFrequencyCovariancesBetweenChannels(...)
//                  (NOT USED)
//-------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadLowFrequencyCovariancesBetweenChannels(const Int_t& MatDim)
{
//Read all the Low Frequency covariances
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH2("ReadLowFrequencyCovariancesBetweenChannels", "fEcal->MaxCrysEcnaInStex()",
         fEcal->MaxCrysEcnaInStex(), MatDim);

  //=====> WARNING: BIG MATRIX (1700x1700)
  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++){for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}

  TVectorD vec(fEcal->MaxStinEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
  vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());
  
  CnaResultTyp typ = cTypLfCov;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadLowFrequencyCovariancesBetweenChannels() *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadLowFrequencyCovariancesBetweenChannels(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for (Int_t index_Stin_a = 0; index_Stin_a < fEcal->MaxStinEcnaInStex(); index_Stin_a++)
        {
          if ( vec(index_Stin_a) > 0 && vec(index_Stin_a) <= fEcal->MaxStinEcnaInStex())
        {
          for (Int_t index_Stin_b = 0; index_Stin_b < fEcal->MaxStinEcnaInStex(); index_Stin_b++)
            {
              if ( vec(index_Stin_b) > 0 && vec(index_Stin_b) <= fEcal->MaxStinEcnaInStex())
            {
              for ( Int_t i_crys = 0; i_crys < fEcal->MaxCrysInStin(); i_crys++)
                {
                  Int_t i_cna_chan = index_Stin_a*fEcal->MaxCrysInStin() + i_crys;
                  Int_t i_chan_sm = (Int_t)(vec(index_Stin_a)-1)*fEcal->MaxCrysInStin() +i_crys;
                  for ( Int_t j_crys = 0; j_crys < fEcal->MaxCrysInStin(); j_crys++)
                {
                  Int_t j_cna_chan = index_Stin_b*fEcal->MaxCrysInStin() + j_crys;
                  Int_t j_chan_sm = (Int_t)(vec(index_Stin_b)-1)*fEcal->MaxCrysInStin() +j_crys;
                  mat(i_chan_sm, j_chan_sm) =
                    gCnaRootFile->fCnaIndivResult->fMatMat(i_cna_chan,j_cna_chan);
                }
                }
            }
            }
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadLowFrequencyCovariancesBetweenChannels() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                        -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//----- end of ( ReadLowFrequencyCovariancesBetweenChannels(...) ) -------

//-------------------------------------------------------------------------
//
//         ReadLowFrequencyCorrelationsBetweenChannels(...)
//
//-------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadLowFrequencyCorrelationsBetweenChannels(const Int_t& MatDim)
{
//Read all the Low Frequency correlations
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH2("ReadLowFrequencyCorrelationsBetweenChannels", "fEcal->MaxCrysEcnaInStex()",
         fEcal->MaxCrysEcnaInStex(), MatDim);

  //=====> WARNING: BIG MATRIX (1700x1700)
  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++){for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}

  TVectorD vec(fEcal->MaxStinEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
  vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());
  
  CnaResultTyp typ = cTypLfCor;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
    
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadLowFrequencyCorrelationsBetweenChannels() *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadLowFrequencyCorrelationsBetweenChannels(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for (Int_t index_Stin_a = 0; index_Stin_a < fEcal->MaxStinEcnaInStex(); index_Stin_a++)
        {
          if ( vec(index_Stin_a) > 0 && vec(index_Stin_a) <= fEcal->MaxStinEcnaInStex())
        {
          for (Int_t index_Stin_b = 0; index_Stin_b < fEcal->MaxStinEcnaInStex(); index_Stin_b++)
            {
              if ( vec(index_Stin_b) > 0 && vec(index_Stin_b) <= fEcal->MaxStinEcnaInStex())
            {
              for ( Int_t i_crys = 0; i_crys < fEcal->MaxCrysInStin(); i_crys++)
                {
                  Int_t i_cna_chan = index_Stin_a*fEcal->MaxCrysInStin() + i_crys;
                  Int_t i_chan_sm = (Int_t)(vec(index_Stin_a)-1)*fEcal->MaxCrysInStin() + i_crys;
                  for ( Int_t j_crys = 0; j_crys < fEcal->MaxCrysInStin(); j_crys++)
                {
                  Int_t j_cna_chan = index_Stin_b*fEcal->MaxCrysInStin() + j_crys;
                  Int_t j_chan_sm = (Int_t)(vec(index_Stin_b)-1)*fEcal->MaxCrysInStin() + j_crys;
                  mat(i_chan_sm, j_chan_sm) =
                    gCnaRootFile->fCnaIndivResult->fMatMat(i_cna_chan,j_cna_chan);
                }
                }
            }
            }
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadLowFrequencyCorrelationsBetweenChannels() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                         ->  quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//----- end of (ReadLowFrequencyCorrelationsBetweenChannels(...) ) -------

//-------------------------------------------------------------------------
//
//         ReadHighFrequencyCovariancesBetweenChannels(...)
//                  (NOT USED)
//-------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadHighFrequencyCovariancesBetweenChannels(const Int_t& MatDim)
{
//Read all the High Frequency covariances
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH2("ReadHighFrequencyCovariancesBetweenChannels", "fEcal->MaxCrysEcnaInStex()",
         fEcal->MaxCrysEcnaInStex(), MatDim);

  //=====> WARNING: BIG MATRIX (1700x1700)
  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++){for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}

  TVectorD vec(fEcal->MaxStinEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
  vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());
  
  CnaResultTyp typ = cTypHfCov;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;

//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadHighFrequencyCovariancesBetweenChannels() *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadHighFrequencyCovariancesBetweenChannels(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for (Int_t index_Stin_a = 0; index_Stin_a < fEcal->MaxStinEcnaInStex(); index_Stin_a++)
        {
          if ( vec(index_Stin_a) > 0 && vec(index_Stin_a) <= fEcal->MaxStinEcnaInStex())
        {
          for (Int_t index_Stin_b = 0; index_Stin_b < fEcal->MaxStinEcnaInStex(); index_Stin_b++)
            {
              if ( vec(index_Stin_b) > 0 && vec(index_Stin_b) <= fEcal->MaxStinEcnaInStex())
            {
              for ( Int_t i_crys = 0; i_crys < fEcal->MaxCrysInStin(); i_crys++)
                {
                  Int_t i_cna_chan = index_Stin_a*fEcal->MaxCrysInStin() + i_crys;
                  Int_t i_chan_sm = (Int_t)(vec(index_Stin_a)-1)*fEcal->MaxCrysInStin() +i_crys;
                  for ( Int_t j_crys = 0; j_crys < fEcal->MaxCrysInStin(); j_crys++)
                {
                  Int_t j_cna_chan = index_Stin_b*fEcal->MaxCrysInStin() + j_crys;
                  Int_t j_chan_sm = (Int_t)(vec(index_Stin_b)-1)*fEcal->MaxCrysInStin() +j_crys;
                  mat(i_chan_sm, j_chan_sm) =
                    gCnaRootFile->fCnaIndivResult->fMatMat(i_cna_chan,j_cna_chan);
                }
                }
            }
            }
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadHighFrequencyCovariancesBetweenChannels() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                         -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//----- end of ( ReadHighFrequencyCovariancesBetweenChannels(...) ) -------

//-------------------------------------------------------------------------
//
//         ReadHighFrequencyCorrelationsBetweenChannels(...)
//
//-------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadHighFrequencyCorrelationsBetweenChannels(const Int_t& MatDim)
{
//Read all the High Frequency correlations
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxCrysEcnaInStex()

  TestArrayDimH2("ReadHighFrequencyCorrelationsBetweenChannels", "fEcal->MaxCrysEcnaInStex()",
         fEcal->MaxCrysEcnaInStex(), MatDim);

  //=====> WARNING: BIG MATRIX (1700x1700)
  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++){for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}

  TVectorD vec(fEcal->MaxStinEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
  vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());
  
  CnaResultTyp typ = cTypHfCor;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadHighFrequencyCorrelationsBetweenChannels() *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadHighFrequencyCorrelationsBetweenChannels(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if ( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for (Int_t index_Stin_a = 0; index_Stin_a < fEcal->MaxStinEcnaInStex(); index_Stin_a++)
        {
          if ( vec(index_Stin_a) > 0 && vec(index_Stin_a) <= fEcal->MaxStinEcnaInStex())
        {
          for (Int_t index_Stin_b = 0; index_Stin_b < fEcal->MaxStinEcnaInStex(); index_Stin_b++)
            {
              if ( vec(index_Stin_b) > 0 && vec(index_Stin_b) <= fEcal->MaxStinEcnaInStex())
            {
              for ( Int_t i_crys = 0; i_crys < fEcal->MaxCrysInStin(); i_crys++)
                {
                  Int_t i_cna_chan = index_Stin_a*fEcal->MaxCrysInStin() + i_crys;
                  Int_t i_chan_sm = (Int_t)(vec(index_Stin_a)-1)*fEcal->MaxCrysInStin() + i_crys;
                  for ( Int_t j_crys = 0; j_crys < fEcal->MaxCrysInStin(); j_crys++)
                {
                  Int_t j_cna_chan = index_Stin_b*fEcal->MaxCrysInStin() + j_crys;
                  Int_t j_chan_sm = (Int_t)(vec(index_Stin_b)-1)*fEcal->MaxCrysInStin() + j_crys;
                  mat(i_chan_sm, j_chan_sm) =
                    gCnaRootFile->fCnaIndivResult->fMatMat(i_cna_chan,j_cna_chan);
                }
                }
            }
            }
        }
        }
    }
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadHighFrequencyCorrelationsBetweenChannels() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                          -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//-------------- ( end of ReadHighFrequencyCorrelationsBetweenChannels(...) ) ---------


//-------------------------------------------------------------------------
//
//         ReadLowFrequencyMeanCorrelationsBetweenStins(...)
//
//-------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadLowFrequencyMeanCorrelationsBetweenStins(const Int_t& MatDim)
{
//Read all the Low Frequency Mean Correlations Between Stins the for all (Stin_X, Stin_Y)
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH2("ReadLowFrequencyMeanCorrelationsBetweenStins", "fEcal->MaxStinEcnaInStex()",
         fEcal->MaxStinEcnaInStex(), MatDim);

  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}

  TVectorD vec(fEcal->MaxStinEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
  vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());

  CnaResultTyp typ = cTypLFccMoStins;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
    
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadLowFrequencyMeanCorrelationsBetweenStins() *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadLowFrequencyMeanCorrelationsBetweenStins(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for(Int_t index_Stin_a = 0; index_Stin_a - MatDim < 0; index_Stin_a++)
        {
          for(Int_t index_Stin_b = 0; index_Stin_b - MatDim < 0; index_Stin_b++)   
        {
          if( vec(index_Stin_a) > 0 && vec(index_Stin_a) <= MatDim)
            {
              if( vec(index_Stin_b) > 0 && vec(index_Stin_b) <= MatDim)
            {
              Int_t vec_ia_m = (Int_t)vec(index_Stin_a)-1;
              Int_t vec_ib_m = (Int_t)vec(index_Stin_b)-1;
              mat((Int_t)vec_ia_m, vec_ib_m) =
                gCnaRootFile->fCnaIndivResult->fMatMat(index_Stin_a,index_Stin_b);
            }
            }
        }
        }
    } 
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadLowFrequencyMeanCorrelationsBetweenStins() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                          -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//-------- ( end of ReadLowFrequencyMeanCorrelationsBetweenStins) --------

//-------------------------------------------------------------------------
//
//         ReadHighFrequencyMeanCorrelationsBetweenStins(...)
//
//-------------------------------------------------------------------------
TMatrixD TEcnaRead::ReadHighFrequencyMeanCorrelationsBetweenStins(const Int_t& MatDim)
{
//Read all the High Frequency Mean Correlations Between Stins the for all (Stin_X, Stin_Y)
//in ROOT file and return them in a TMatrixD
//
//Possible values for MatDim: (1) MatDim = fEcal->MaxStinEcnaInStex()

  TestArrayDimH2("ReadHighFrequencyMeanCorrelationsBetweenStins", "fEcal->MaxStinEcnaInStex()",
         fEcal->MaxStinEcnaInStex(), MatDim);

  TMatrixD mat(MatDim, MatDim);
  for(Int_t i=0; i-MatDim<0; i++)
    {for(Int_t j=0; j-MatDim<0; j++){mat(i,j)=(Double_t)0.;}}

  TVectorD vec(fEcal->MaxStinEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
  vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());

  CnaResultTyp typ = cTypHFccMoStins;

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();
  const Text_t *current_file_name = (const Text_t *)fCurrentlyOpenFileName.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;
    
  TString FileNameLong = fCnaWrite->GetRootFileName();
  Bool_t allowed_to_read = kFALSE;
  
//  if ( fOpenRootFile )
//    {
//      std::cout << "!TEcnaRead::ReadHighFrequencyMeanCorrelationsBetweenStins() *** ERROR ***>"
//     << " Reading on file already open." << fTTBELL << std::endl;
//    }

  if( FileNameLong == fCurrentlyOpenFileName )
    {
      allowed_to_read = kTRUE;
    }
  else
    {
      if( fCurrentlyOpenFileName != fFlagNoFileOpen ){CloseRootFile(current_file_name);}
      ok_open = OpenRootFile(file_name, "READ");

      if(ok_open)
    {
      allowed_to_read = kTRUE;
    }
      else
    {
      std::cout << "!TEcnaRead::ReadHighFrequencyMeanCorrelationsBetweenStins(...) *** ERROR ***> Open .root file failed for file: "
           << file_name << fTTBELL << std::endl;
      allowed_to_read = kFALSE;
      ok_read = kFALSE;
    }
    }

  if( allowed_to_read == kTRUE )
    {
      Int_t i_zero = 0;
      ok_read = gCnaRootFile->ReadElement(typ, i_zero);
      
      if( ok_read == kTRUE )
    {
      fDataExist = kTRUE;
      for(Int_t index_Stin_a = 0; index_Stin_a - MatDim<0; index_Stin_a++)
        {
          for(Int_t index_Stin_b = 0; index_Stin_b - MatDim<0; index_Stin_b++)   
        {
          if( vec(index_Stin_a) > 0 && vec(index_Stin_a) <= MatDim)
            {
              if( vec(index_Stin_b) > 0 && vec(index_Stin_b) <= MatDim)
            {
              Int_t vec_ia_m = (Int_t)vec(index_Stin_a)-1;
              Int_t vec_ib_m = (Int_t)vec(index_Stin_b)-1;
              mat((Int_t)vec_ia_m, (Int_t)vec_ib_m) =
                gCnaRootFile->fCnaIndivResult->fMatMat(index_Stin_a,index_Stin_b);
            }
            }
        }
        }
    } 
      else
    {
      fDataExist = kFALSE;
      std::cout << "!TEcnaRead::ReadHighFrequencyMeanCorrelationsBetweenStins() *** ERROR ***> "
           << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
           << "                                                                           -> quantity: <"
           << GetTypeOfQuantity(typ) << "> not available in file."
           << fTTBELL << std::endl;
    }
      CloseRootFile(file_name);
    }
  return mat;
}
//-------- ( end of ReadHighFrequencyMeanCorrelationsBetweenStins) --------

//=============================================================================
//
//             M I S C E L L A N E O U S     R E A D      M E T H O D S
//
//=============================================================================

//--------------------------------------------------------------------------------------
//
//       ReadSampleAdcValuesSameFile(fEcal->MaxCrysEcnaInStex(),
//                                   fFileHeader->fNbOfSamples, fFileHeader->fReqNbOfEvts)  
//
//--------------------------------------------------------------------------------------
Double_t*** TEcnaRead::ReadSampleAdcValuesSameFile(const Int_t& DimX, const Int_t& DimY, const Int_t& DimZ)
{

//Possible values for DimX, DimY, DimZ : (1) DimX = fEcal->MaxCrysEcnaInStex()
//                                           DimY = fFileHeader->fNbOfSamples
//                                           DimZ = fFileHeader->fReqNbOfEvts

  if(fT3d_AdcValues == nullptr)
    {
      //............ Allocation for the 3d array 
      fT3d_AdcValues   = new Double_t**[DimX];                         fCnew++;  
      fT3d2_AdcValues  = new  Double_t*[DimX*DimY];                    fCnew++;  
      fT3d1_AdcValues  = new   Double_t[DimX*DimY*DimZ];               fCnew++;
      
      for(Int_t i0StexEcha = 0 ; i0StexEcha < DimX ; i0StexEcha++){
    fT3d_AdcValues[i0StexEcha] = &fT3d2_AdcValues[0] + i0StexEcha*DimY;
    for(Int_t j_samp = 0 ; j_samp < DimY ; j_samp++){
      fT3d2_AdcValues[DimY*i0StexEcha + j_samp] = &fT3d1_AdcValues[0]+
        DimZ*(DimY*i0StexEcha+j_samp);}}
    }
  
  //................................. Init to zero                 (ReadSampleAdcValuesSameFile)
  for (Int_t iza=0; iza<DimX; iza++)
    {
      for (Int_t izb=0; izb<DimY; izb++)
    {
      for (Int_t izc=0; izc<DimZ; izc++)
        {
          if( fT3d_AdcValues[iza][izb][izc] != (Double_t)0 )
        {
          fT3d_AdcValues[iza][izb][izc] = (Double_t)0;
        }
        }
    }
    }     
  
  //-------------------------------------------------------------------------- (ReadSampleAdcValuesSameFile)
  CnaResultTyp typ = cTypAdcEvt;   //  sample as a function of time type

  const Text_t *file_name = (const Text_t *)fCnaWrite->fRootFileNameShort.Data();

  Bool_t ok_open = kFALSE;
  Bool_t ok_read = kFALSE;

  Int_t  i_entry      = 0;  
  Int_t  i_entry_fail = 0;  

  ok_open = OpenRootFile(file_name, "READ");
  
  if( ok_open == kTRUE )
    {
      for(Int_t i0StexEcha=0; i0StexEcha<DimX; i0StexEcha++)
    {
      if( i0StexEcha == 0 )
        {
          i_entry = gCnaRootFile->ReadElementNextEntryNumber(typ, i0StexEcha);
          if( i_entry >= 0 ){ok_read = kTRUE;}
        }
      if( i_entry >= 0 )                                                //  (ReadSampleAdcValuesSameFile)
        {
          if( i0StexEcha > 0 ){ok_read = gCnaRootFile->ReadElement(i_entry); i_entry++;}
          
          if ( ok_read == kTRUE )
        {
          fDataExist = kTRUE;     
          for(Int_t sample=0; sample<DimY; sample++)
            {
              for ( Int_t i_bin=0; i_bin<DimZ; i_bin++)
            {
              fT3d_AdcValues[i0StexEcha][sample][i_bin]
                = gCnaRootFile->fCnaIndivResult->fMatHis(sample, i_bin);
            }  
            }
        } 
          else                                                        //  (ReadSampleAdcValuesSameFile)
        {
          fDataExist = kFALSE;
          std::cout << "!TEcnaRead::ReadSampleAdcValuesSameFile(...) *** ERROR ***> "
               << fCnaWrite->fRootFileNameShort.Data() << ": .root file failed" << std::endl
               << "                                                         -> quantity: <"
               << GetTypeOfQuantity(typ) << "> not available in file."
               << fTTBELL << std::endl;
        }
        }
      else
        {
          i_entry_fail++;
        }
    }
      CloseRootFile(file_name);
    }
  else
    {
      std::cout  << "*TEcnaRead::ReadSampleAdcValuesSameFile(...)> *ERROR* =====> "
        << " ROOT file not found" << fTTBELL << std::endl;
    }

  if(i_entry_fail > 0 )
    {
      std::cout  << "*TEcnaRead::ReadSampleAdcValuesSameFile(...)> *ERROR* =====> "
        << " Entry reading failure(s). i_entry_fail = "
        << i_entry_fail << fTTBELL << std::endl;
    }
  return fT3d_AdcValues;
}
//--- (end of ReadSampleAdcValuesSameFile) ----------


//=========================================================================
//
//          M I S C E L L A N E O U S    G E T    M E T H O D S   
//
//=========================================================================
Int_t TEcnaRead::GetNumberOfEvents(const Int_t& xFapNbOfReqEvts, const Int_t& xStexNumber)
{
  //...... Calculate the number of found events  (file existence already tested in calling method)
  Int_t xFapNbOfEvts = 0; 

  TVectorD NOFE_histp(fEcal->MaxCrysEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxCrysEcnaInStex(); i++){NOFE_histp(i)=(Double_t)0.;}
  NOFE_histp = ReadNumberOfEvents(fEcal->MaxCrysEcnaInStex());

  //... Call to fCnaWrite->NumberOfEventsAnalysis(...) 1rst argument must be Int_t, not TVectorD,
  //    duplicate NOFE_histp to NOFE_int to obtain fFapNbOfEvts from fCnaWrite->NumberOfEventsAnalysis(...)
  Int_t* NOFE_int = new Int_t[fEcal->MaxCrysEcnaInStex()];   fCnew++;
  for(Int_t i=0; i<fEcal->MaxCrysEcnaInStex(); i++){NOFE_int[i]=(Int_t)NOFE_histp(i);}

  xFapNbOfEvts =
    fCnaWrite->NumberOfEventsAnalysis(NOFE_int, fEcal->MaxCrysEcnaInStex(), xFapNbOfReqEvts, xStexNumber);

  delete [] NOFE_int; NOFE_int = nullptr;                          fCdelete++;

  return xFapNbOfEvts;
}

//-------------------------------------------------------------------------
//
//    Get the name of the quantity from its "CnaResultTyp" type
//
//-------------------------------------------------------------------------
TString TEcnaRead::GetTypeOfQuantity(const CnaResultTyp arg_typ)
{
  TString quantity_name = "?";

  if( arg_typ == cTypNumbers)
    {
      if( fFlagSubDet == "EB" ){quantity_name = "SM numbers";}
      if( fFlagSubDet == "EE" ){quantity_name = "Dee numbers";}
    }
  if( arg_typ == cTypMSp    ){quantity_name = "Mean samples";}
  if( arg_typ == cTypSSp    ){quantity_name = "Sigma of samples";}

  if( arg_typ == cTypNbOfEvts ){quantity_name = "Number of events";}
  if( arg_typ == cTypPed      ){quantity_name = "Pedestals";}
  if( arg_typ == cTypTno      ){quantity_name = "Total noise";}
  if( arg_typ == cTypLfn      ){quantity_name = "LF noise";}
  if( arg_typ == cTypHfn      ){quantity_name = "HF noise";}
  if( arg_typ == cTypMeanCorss){quantity_name = "Mean cor(s,s')";}
  if( arg_typ == cTypSigCorss ){quantity_name = "Sigma of cor(s,s')";}

  if( arg_typ == cTypAvPed      ){quantity_name = "Average pedestals";}
  if( arg_typ == cTypAvTno      ){quantity_name = "Average total noise";}
  if( arg_typ == cTypAvLfn      ){quantity_name = "Average LF noise";}
  if( arg_typ == cTypAvHfn      ){quantity_name = "Average HF noise";}
  if( arg_typ == cTypAvMeanCorss){quantity_name = "Average mean cor(s,s')";}
  if( arg_typ == cTypAvSigCorss ){quantity_name = "Average sigma of cor(s,s')";}

  if( arg_typ == cTypAdcEvt ){quantity_name = "Sample ADC a.f.o event number";}

  if( arg_typ == cTypCovCss ){quantity_name = "Cov(s,s')";}
  if( arg_typ == cTypCorCss ){quantity_name = "Cor(s,s')";}
  if( arg_typ == cTypLfCov  ){quantity_name = "LF Cov(c,c')";}
  if( arg_typ == cTypLfCor  ){quantity_name = "LF Cor(c,c')";}
  if( arg_typ == cTypHfCov  ){quantity_name = "HF Cov(c,c')";}
  if( arg_typ == cTypHfCor  ){quantity_name = "HF Cor(c,c')";}

  if( fFlagSubDet == "EB" )
    {
      if( arg_typ == cTypLFccMoStins){quantity_name = "Mean LF |Cor(c,c')| in (tow,tow')";}
      if( arg_typ == cTypHFccMoStins){quantity_name = "Mean HF |Cor(c,c')| in (tow,tow')";}
    }
  if( fFlagSubDet == "EE" )
    {
      if( arg_typ == cTypLFccMoStins){quantity_name = "Mean LF |Cor(c,c')| in (SC,SC')";}
      if( arg_typ == cTypHFccMoStins){quantity_name = "Mean HF |Cor(c,c')| in (SC,SC')";}
    }
  return quantity_name;
}

//-------------------------------------------------------------------------
//
//    Get the ROOT file name (long and short)
//
//-------------------------------------------------------------------------
TString TEcnaRead::GetRootFileName(){return fCnaWrite->GetRootFileName();}
TString TEcnaRead::GetRootFileNameShort(){return fCnaWrite->GetRootFileNameShort();}
//-------------------------------------------------------------------------
//
//                     GetStexStinFromIndex
//
//  *==> DON'T SUPPRESS: this method is called by TEcnaRun and TEcnaHistos
//
//-------------------------------------------------------------------------
Int_t TEcnaRead::GetStexStinFromIndex(const Int_t& i0StexStinEcna)
{
// Get the Stin number in Stex from the Stin index

  Int_t number = -1;
  TVectorD vec(fEcal->MaxStinEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
  vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());
  number = (Int_t)vec(i0StexStinEcna);
  return number;
}

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

Int_t  TEcnaRead::GetNumberOfBinsSampleAsFunctionOfTime(){return GetReqNbOfEvts();}
//-------------------------------------------------------------------------
//
//                     GetStinIndex(n1StexStin)
//
//-------------------------------------------------------------------------
Int_t  TEcnaRead::GetStinIndex(const Int_t & n1StexStin)
{
//Get the index of the Stin from its number in Stex

  if(fFlagPrint == fCodePrintAllComments){
    std::cout << "*TEcnaRead::GetStinIndex(...)> fEcal->MaxStinEcnaInStex() = "
     << fEcal->MaxStinEcnaInStex() << std::endl
     << "                              n1StexStin = " << n1StexStin
     << std::endl << std::endl;}

  Int_t Stin_index = n1StexStin-1;    // suppose les 68 tours 

#define NOGT
#ifndef NOGT
  Int_t Stin_index = -1;
  TVectorD vec(fEcal->MaxStinEcnaInStex());
  for(Int_t i=0; i<fEcal->MaxStinEcnaInStex(); i++){vec(i)=(Double_t)0.;}
  vec = ReadStinNumbers(fEcal->MaxStinEcnaInStex());

  //........................... Get the Stin index

  for(Int_t i=0; i < fEcal->MaxStinEcnaInStex(); i++)
    {
      if(fFlagPrint == fCodePrintAllComments){
        std::cout << "*TEcnaRead::GetStinIndex(...)> StinNumber[" << i << "] = "
             << vec[i] << std::endl;}
      if ( vec[i] == n1StexStin ){Stin_index = i;}
    }

  if(fFlagPrint == fCodePrintAllComments){
    std::cout << "~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-" << std::endl;
    std::cout << "*TEcnaRead::GetStinIndex> Stin number: " << n1StexStin  << std::endl
         << "                          Stin index : " << Stin_index << std::endl;
    std::cout << "~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-" << std::endl;}

  if ( Stin_index < 0 )
    {
      if(fFlagPrint == fCodePrintAllComments){
    std::cout << "!TEcnaRead::GetStinIndex *** WARNING ***> n1StexStin" << n1StexStin << " : "
         << "index Stin not found"
         << fTTBELL << std::endl;}
    }
#endif // NOGT

  return Stin_index;
}

//=========================================================================
//
//         METHODS TO SET FLAGS TO PRINT (OR NOT) COMMENTS (DEBUG)
//
//=========================================================================

void  TEcnaRead::PrintComments()
{
// Set flags to authorize printing of some comments concerning initialisations (default)

  fFlagPrint = fCodePrintComments;
  std::cout << "*TEcnaRead::PrintComments()> Warnings and some comments on init will be printed" << std::endl;
}

void  TEcnaRead::PrintWarnings()
{
// Set flags to authorize printing of warnings

  fFlagPrint = fCodePrintWarnings;
  std::cout << "*TEcnaRead::PrintWarnings()> Warnings will be printed" << std::endl;
}

void  TEcnaRead::PrintAllComments()
{
// Set flags to authorize printing of the comments of all the methods

  fFlagPrint = fCodePrintAllComments;
  std::cout << "*TEcnaRead::PrintAllComments()> All the comments will be printed" << std::endl;
}

void  TEcnaRead::PrintNoComment()
{
// Set flags to forbid the printing of all the comments

  fFlagPrint = fCodePrintNoComment;
}