TEcnaRun.h

Go to the documentation of this file.

#ifndef CL_TEcnaRun_H
#define CL_TEcnaRun_H

// system include files
#include <memory>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
#include <vector>
#include <ctime>
#include <cmath>
#include <cstdio>
#include "Riostream.h"

// ROOT include files
#include "TObject.h"
#include "TSystem.h"
#include "TString.h"
#include "TVectorD.h"

// user include files
#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaObject.h"
#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaParEcal.h"
#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaHeader.h"
#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaParCout.h"
#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaParPaths.h"
#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaRead.h"
#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaWrite.h"
#include "CalibCalorimetry/EcalCorrelatedNoiseAnalysisAlgos/interface/TEcnaRootFile.h"


class TEcnaRun : public TObject {
private:
  //............ attributes

  Int_t fgMaxCar;  // Max nb of caracters for char*

  Int_t fCnaCommand, fCnaError;

  Int_t fCnew;  // flags for dynamical allocation
  Int_t fCdelete;

  TString fTTBELL;

  Int_t* fMiscDiag;  // Counters for miscellaneous diagnostics
  Int_t fNbOfMiscDiagCounters;
  Int_t fMaxMsgIndexForMiscDiag;

  TEcnaObject* fObjectManager;     // for ECNA object management
  TEcnaHeader* fFileHeader;        // header for result type file
  TEcnaParEcal* fEcal;             // for access to the Ecal current subdetector parameters
  TEcnaNumbering* fEcalNumbering;  // for access to the Ecal channel, Stin and Stex numbering
  TEcnaParCout* fCnaParCout;       // for comment/error messages
  TEcnaParPaths* fCnaParPaths;     // for file access
  TEcnaWrite* fCnaWrite;           // for access to the results files

  //  TEcnaRootFile *gCnaRootFile;

  TString fFlagSubDet;
  TString fStexName, fStinName;

  Bool_t fOpenRootFile;  // flag open ROOT file (open = kTRUE, close = kFALSE)
  Int_t fReadyToReadData;

  TString fRootFileName;
  TString fRootFileNameShort;
  TString fNewRootFileName;
  TString fNewRootFileNameShort;

  Int_t fSpecialStexStinNotIndexed;  // management of event distribution building
  Int_t fStinIndexBuilt;
  Int_t fBuildEvtNotSkipped;

  Int_t fNbSampForFic;
  Int_t fNbSampForCalc;

  Int_t fNumberOfEvents;

  Int_t fMemoReadNumberOfEventsforSamples;

  Double_t*** fT3d_AdcValues;  // 3D array[channel][sample][event] ADC values
  Double_t** fT3d2_AdcValues;
  Double_t* fT3d1_AdcValues;
  Int_t* fTagAdcEvt;

  Int_t** fT2d_NbOfEvts;  // 2D array[channel][sample] max nb of evts read for a given (channel,sample)
  Int_t* fT1d_NbOfEvts;
  Int_t* fTagNbOfEvts;

  Int_t* fT1d_StexStinFromIndex;  // 1D array[Stin] Stin Number as a function of the index Stin
  Int_t* fTagStinNumbers;

  Double_t** fT2d_ev;  // 2D array[channel][sample] for expectation values
  Double_t* fT1d_ev;
  Int_t* fTagMSp;

  Double_t** fT2d_sig;  // 2D array[channel][sample] for sigmass
  Double_t* fT1d_sig;
  Int_t* fTagSSp;

  Double_t*** fT3d_cov_ss;  // 3D array[channel][sample][sample] for (sample,sample) covariances
  Double_t** fT3d2_cov_ss;
  Double_t* fT3d1_cov_ss;
  Int_t* fTagCovCss;

  Double_t*** fT3d_cor_ss;  // 3D array[channel][sample][sample] for (sample,sample) correlations
  Double_t** fT3d2_cor_ss;
  Double_t* fT3d1_cor_ss;
  Int_t* fTagCorCss;

  //...........................................................................
  Double_t* fT1d_ev_ev;    // 1D array[channel] for expectation values of the expectation values of the samples
  Int_t* fTagPed;          // (PEDESTAL)
  Double_t* fT1d_av_mped;  // 1D array[Stin] for expectation values of the Pesdestals of the Stins
  Int_t* fTagAvPed;        // (AVERAGED PEDESTAL)

  Double_t* fT1d_evsamp_of_sigevt;  // 1D array[channel] for expectation values of the sigmas of the samples
  Int_t* fTagTno;                   // (TOTAL NOISE)
  Double_t* fT1d_av_totn;           // 1D array[Stin] for expectation values of the total noise
  Int_t* fTagAvTno;                 //(AVERAGED TOTAL NOISE)

  Double_t* fT1d_ev_cor_ss;    // 1D array[channel] for expectation values of the cor(s,s)
  Int_t* fTagMeanCorss;        // (MEAN COR(S,S))
  Double_t* fT1d_av_ev_corss;  // 1D array[Stin] for expectation values of the mean cor(s,s)
  Int_t* fTagAvMeanCorss;      // (AVERAGED MEAN COR(S,S))

  Double_t* fT1d_sigevt_of_evsamp;  // 1D array[channel] for sigmas of the expectation values of the samples
  Int_t* fTagLfn;                   // (LOW FREQUENCY NOISE)
  Double_t* fT1d_av_lofn;           // 1D array[Stin]  the expectation values of the low frequency noise
  Int_t* fTagAvLfn;                 // (AVERAGED LOW FREQUENCY NOISE)

  Double_t* fT1d_evevt_of_sigsamp;  // 1D array[channel] for sigmas of the sigmas of the samples
  Int_t* fTagHfn;                   // (HIGH FREQUENCY NOISE)
  Double_t* fT1d_av_hifn;           // 1D array[channel] for expectation values of the high frequency noise
  Int_t* fTagAvHfn;                 // (AVERAGED HIGH FREQUENCY NOISE)

  Double_t* fT1d_sig_cor_ss;    // 1D array[channel] for sigmas of the cor(s,s)
  Int_t* fTagSigCorss;          // (SIGMA OF COR(S,S))
  Double_t* fT1d_av_sig_corss;  // 1D array[channel] for expectation values of sigmas  the  of the cor(s,s)
  Int_t* fTagAvSigCorss;        // (AVERAGED SIGMA OF COR(S,S))

  //...........................................................................
  Double_t** fT2d_lf_cov;  // 2D array[channel][channel] for (channel,channel) low frequency covariances
  Double_t* fT2d1_lf_cov;
  Int_t* fTagLfCov;

  Double_t** fT2d_lf_cor;  // 2D array[channel][channel] for (channel,channel) low frequency correlations
  Double_t* fT2d1_lf_cor;
  Int_t* fTagLfCor;

  //...........................................................................
  Double_t** fT2d_hf_cov;  // 2D array[channel][channel] for (channel,channel) low frequency covariances
  Double_t* fT2d1_hf_cov;
  Int_t* fTagHfCov;

  Double_t** fT2d_hf_cor;  // 2D array[channel][channel] for (channel,channel) low frequency correlations
  Double_t* fT2d1_hf_cor;
  Int_t* fTagHfCor;

  //------------------------- 2 tableaux (ci,cj)
  Double_t** fT2d_lfcc_mostins;  // 2D array[Stin][Stin] for (Stin,Stin) mean cov(c,c)
  Double_t* fT2d1_lfcc_mostins;  // (relevant ones) averaged over samples
  Int_t* fTagLFccMoStins;

  Double_t** fT2d_hfcc_mostins;  // 2D array[Stin][Stin] for (Stin,Stin) mean cor(c,c)
  Double_t* fT2d1_hfcc_mostins;  // (relevant ones) averaged over samples
  Int_t* fTagHFccMoStins;

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

  Int_t** fT2dCrysNumbersTable;
  Int_t* fT1dCrysNumbersTable;

  std::ofstream fFcout_f;

  Int_t fFlagPrint;
  Int_t fCodePrintComments, fCodePrintWarnings, fCodePrintAllComments, fCodePrintNoComment;

public:
  //................. constructors

  TEcnaRun();                              //  constructor without argument
  TEcnaRun(TEcnaObject*, const TString&);  //  constructors with argument (FOR USER'S DECLARATION)
  TEcnaRun(TEcnaObject*, const TString&, const Int_t&);

  //TEcnaRun(const TString&, const Int_t&, const TEcnaParPaths*, const TEcnaParCout*);
  //TEcnaRun(const TString&);               //  constructors with argument (FOR USER'S DECLARATION)
  //TEcnaRun(const TString&, const Int_t&);

  TEcnaRun(const TEcnaRun&);  //  copy constructor

  //.................... C++ methods

  //TEcnaRun&  operator=(const TEcnaRun&);  //  overloading of the operator=

  //................. destructor

  ~TEcnaRun() override;

  //...................................................... methods that will (should) be private

  void Init(TEcnaObject*);

  void SetEcalSubDetector(const TString&);

  Bool_t GetPathForResults();

  Bool_t OpenRootFile(const Text_t*, const TString&);
  Bool_t CloseRootFile(const Text_t*);

  //======================================= methods for the user =========================================
  void GetReadyToReadData(const TString&, const Int_t&, const Int_t&, const Int_t&, const Int_t&, const Int_t&);
  void GetReadyToReadData(
      const TString&, const Int_t&, const Int_t&, const Int_t&, const Int_t&, const Int_t&, const Int_t&);

  Bool_t GetSampleAdcValues(const Int_t&, const Int_t&, const Int_t&, const Int_t&, const Double_t&);
  Bool_t ReadSampleAdcValues();
  Bool_t ReadSampleAdcValues(const Int_t&);

  void StartStopDate(const TString&, const TString&);
  void StartStopTime(time_t, time_t);

  //................... Calculation methods ( associated to GetReadyToReadData(...) )
  //-------------------- Standard Calculations
  void StandardCalculations();  // see list in the method itself (.cc file)

  void SampleMeans();   // Calculation of the expectation values over the events
                        // for each sample and for each channel
  void SampleSigmas();  // Calculation of the variances over the events
                        // for each sample and for each channel
  //...........................................
  void CovariancesBetweenSamples();   // Calculation of the (s,s) covariances over the events
                                      // for each channel
  void CorrelationsBetweenSamples();  // Calculation of the (s,s) correlations over the events
                                      // for each channel
  //..........................................................
  void Pedestals();
  void TotalNoise();
  void LowFrequencyNoise();
  void HighFrequencyNoise();
  void MeanCorrelationsBetweenSamples();
  void SigmaOfCorrelationsBetweenSamples();

  //..........................................................
  void AveragePedestals();
  void AverageTotalNoise();
  void AverageLowFrequencyNoise();
  void AverageHighFrequencyNoise();
  void AverageMeanCorrelationsBetweenSamples();
  void AverageSigmaOfCorrelationsBetweenSamples();

  //---------- Calculations involving cov and cor between channels
  //
  //   Recommended calling sequences: expert1, expert1 + expert2,  expert2
  //
  //   NOT recommended: expert2 + expert1  (lost of time and place)
  //
  //-------------------- Expert 1 Calculations
  void Expert1Calculations();  // see list in the method itself (.cc file)

  void LowFrequencyCovariancesBetweenChannels();
  void HighFrequencyCovariancesBetweenChannels();

  void LowFrequencyCorrelationsBetweenChannels();
  void HighFrequencyCorrelationsBetweenChannels();

  //-------------------- Expert 2 Calculations
  void Expert2Calculations();  // see list in the method itself (.cc file)

  void LowFrequencyMeanCorrelationsBetweenTowers();
  void HighFrequencyMeanCorrelationsBetweenTowers();

  void LowFrequencyMeanCorrelationsBetweenSCs();
  void HighFrequencyMeanCorrelationsBetweenSCs();

  //===================================== "technical" methods ==========================================

  void GetReadyToCompute();  // Make result root file name and check events
  void SampleValues();       // 3D histo of the sample ADC value for each triple (channel,sample,event)

  //.................................... Technical calculation methods (Stin = Tower or SC)
  void LowFrequencyMeanCorrelationsBetweenStins();
  void HighFrequencyMeanCorrelationsBetweenStins();

  //...................................... ROOT file methods
  const TString& GetRootFileName() const;
  const TString& GetRootFileNameShort() const;
  const TString& GetNewRootFileName() const;
  const TString& GetNewRootFileNameShort() const;

  Bool_t WriteRootFile();
  Bool_t WriteNewRootFile(const TString&);
  Bool_t WriteRootFile(const Text_t*, Int_t&);

  void TRootStinNumbers();
  void TRootNbOfEvts(const Int_t&);

  void TRootAdcEvt(const Int_t&, const Int_t&);

  void TRootMSp(const Int_t&);
  void TRootSSp(const Int_t&);

  void TRootCovCss(const Int_t&, const Int_t&);
  void TRootCorCss(const Int_t&, const Int_t&);

  void TRootLfCov();
  void TRootLfCor();

  void TRootHfCov();
  void TRootHfCor();

  void TRootLFccMoStins();
  void TRootHFccMoStins();

  void TRootPed();
  void TRootTno();
  void TRootMeanCorss();

  void TRootLfn();
  void TRootHfn();
  void TRootSigCorss();

  void TRootAvPed();
  void TRootAvEvCorss();
  void TRootAvSigCorss();
  void TRootAvTno();
  void TRootAvLfn();
  void TRootAvHfn();

  //................................ Flags Print Comments/Debug
  void PrintNoComment();    // (default) Set flags to forbid the printing of all the comments
                            // except ERRORS
  void PrintWarnings();     // Set flags to authorize printing of some warnings
  void PrintComments();     // Set flags to authorize printing of infos and some comments
                            // concerning initialisations
  void PrintAllComments();  // Set flags to authorize printing of all the comments

  ClassDefOverride(TEcnaRun, 1)  // Calculation of correlated noises from data
};

#endif  //  CL_TEcnaRun_H