---

NoiseAlg.h

Go to the documentation of this file.

#ifndef  NOISEALG_H
#define NOISEALG_H

//#include "HecRunHeader2001v0.h"
#include "Headers.h"
//#include "HecEvent.h"
#include "Event.h"
#include "Geometry.h"
#include "SystemAlg.h"
#include "TBID.h"
#include "CalibrationAlg.h"

#include "TH1.h"
#include "TF1.h"

#include <string>
#include <map>

using std::string;
using std::map;

/*! -Class:   NoiseAlg
  - Author:   Michel Lefebvre
  - Date:     21/7/2003
  - Description: NoiseAlg is a systemAlg that deal with digital filtering channel noise (nA)
    1- Compute an estimate of the noise (nA) of each channel given a run number and store
       the results in a file (one per detector);
    or
    2- Read noise file(s) for user access to noise (nA) values.
  */
class NoiseAlg : public SystemAlg {
public:

  /** The user should never need to use this contructor
    * @param event A pointer in the event. Information contained in the event
    *                             gets refreshed before the execute method is run
    * @param hecGeom Pointer to the singleton Geometry object
    * @param runHeader Pointer to the singleton HecRunHeader object
    */

  NoiseAlg(Event* event, Geometry* hecGeom, Headers* runHeader);

  ~NoiseAlg();

  //! Gets run once at the begining of the event Loop
  bool initialize();

  //! Gets run for every event
  bool execute();

  //! Gets run after all events have been executed
  bool finalize();

  //################################
  // hec public methods

  /** Enable the computation of noise for the hec
    * @param calibFileName Name of calibration coefficient file 
    */
  void hecEnable(string calibFileName);

  /** Set the print level for noise computation for the hec
    * 0 minimum
    * 1 print noise results (default)
    * 2 above and print the mean sigma/pedrms values
    * 3 above and print +/- 2 sigma fit results
    * 4 above and print first gaussian fit result
    * @param level Print level
    */
  void hecPrintLevel(int level){m_hecPrintLevel = level;};

  /** Set the hec noise result file name
    * @param noiseFileName the name of the noise file
    */
  void hecNoiseFileName(string noiseFileName){m_hecNoiseFileName = noiseFileName;};

  /** Get the febno keyed hec noise (nA) map
    * The map contains entries for all connected channels
    * if the noise could not be obtained for a channel, the map contains 0.
    */
  map<int, float> hecNoiseMap(){return m_hecNoiseMap;};

  /** Get the hec noise (nA)
    * If the noise could not be obtained, 0 is returned.
    * @param febno channel febno
    */
  float hecNoise(int febno);

  /** Get the febno keyed hec noise error estimate (nA) map
    * The map contains entries for all connected channels
    * if the noise could not be obtained for a channel, the map contains 0.
    */
  map<int, float> hecNoiseErrorMap(){return m_hecNoiseErrorMap;};

  /** Get the hec noise error estimate (nA)
    * If the noise could not be obtained, 0 is returned.
    * @param febno channel febno
    */
  float hecNoiseError(int febno);

  /** Get the febno keyed hec noise status word map
    * The map contains entries for all connected channels
    * status == 0  the noise was obtained directly from the channel
    * status != 0  the noise was obtained from the ped rms of the channel
    *              and the noise/pedrms of other channels
    */
  map<int, int> hecNoiseStatusMap(){return m_hecNoiseStatusMap;};

  /** Get the hec noise status word (see hecNoiseStatusMap)
    * @param febno channel febno
    */
  int hecNoiseStatus(int febno);

  /** Read a hec noise file
    * If no noise file name is given, then the file is assumed to be
    * hec_nnnnn_noise.dat
    * @param noiseFileName the name of the noise file
    */
  void hecReadNoiseFile(string noiseFileName = "");

  //! Print hec noise data
  void hecPrintNoise();


  //################################
  // emec public methods

  /** Enable the computation of noise for the emec
    * @param calibFileName Name of calibration coefficient file 
    */
  void emecEnable(string calibFileName);

  /** Set the print level for noise computation for the emec
    * 0 minimum
    * 1 print noise results (default)
    * 2 above and print the mean sigma/pedrms values
    * 3 above and print +/- 2 sigma fit results
    * 4 above and print first gaussian fit result
    * @param level Print level
    */
  void emecPrintLevel(int level){m_emecPrintLevel = level;};

  /** Set the emec noise result file name
    * @param noiseFileName the name of the noise file
    */
  void emecNoiseFileName(string noiseFileName){m_emecNoiseFileName = noiseFileName;};

  /** Get the febno keyed emec noise (nA) map
    * The map contains entries for all connected channels
    * if the noise could not be obtained for a channel, the map contains 0.
    */
  map<int, float> emecNoiseMap(){return m_emecNoiseMap;};

  /** Get the emec noise (nA)
    * If the noise could not be obtained, 0 is returned.
    * @param febno channel febno
    */
  float emecNoise(int febno);

  /** Get the febno keyed emec noise error estimate (nA) map
    * The map contains entries for all connected channels
    * if the noise could not be obtained for a channel, the map contains 0.
    */
  map<int, float> emecNoiseErrorMap(){return m_emecNoiseErrorMap;};

  /** Get the emec noise error estimate (nA)
    * If the noise could not be obtained, 0 is returned.
    * @param febno channel febno
    */
  float emecNoiseError(int febno);

  /** Get the febno keyed emec noise status word map
    * The map contains entries for all connected channels
    * status == 0  the noise was obtained directly from the channel
    * status != 0  the noise was obtained from the ped rms of the channel
    */
  map<int, int> emecNoiseStatusMap(){return m_emecNoiseStatusMap;};

  /** Get the emec noise status word (see emecNoiseStatusMap)
    * @param febno channel febno
    */
  int emecNoiseStatus(int febno);

  /** Read a emec noise file
    * If no noise file name is given, then assume the file is
    * emec?_nnnnn_noise.dat where ? is given by the input data file name
    * @param noiseFileName the name of the noise file
    */
  void emecReadNoiseFile(string noiseFileName = "");

  //! Print emec noise data
  void emecPrintNoise();


  // all the following variables will be made private eventually
  // only for experts!

  //################################
  // hec public variables

  // febno keyed maps for all connected channels
  map<int, TH1F*> m_hecHMap;          // map of histograms
  map<int, float> m_hecHistoMeanMap;  // map of histogram signal means 
  map<int, float> m_hecHistoRMSMap;   // map of histogram signal rms
  map<int, float> m_hecHistoNMap;     // map of histogram number of entries in bins
  // febno keyed mean sigma/peds maps for all connected channels
  // all entried for a given ieta are the same
  map<int, float> m_hecMeanRatioMap;
  map<int, float> m_hecMeanRatioErrorMap;
  // febno keyed maps for good channels (retained for noise fit)
  map<int, float> m_hecFitMeanMap;        // map of fitted means
  map<int, float> m_hecFitMeanErrorMap;
  map<int, float> m_hecFitSigmaMap;       // map of fitted sigmas
  map<int, float> m_hecFitSigmaErrorMap;
  map<int, float> m_hecFitProbMap;        // map of fit probabilities
  // febno keyed maps for good channels and PedRMSnA > 0
  map<int, float> m_hecFitSigmaOverPedRMSMap;      // map of sigma/ped rms
  map<int, float> m_hecFitSigmaOverPedRMSErrorMap; // map of sigma/ped rms

  //################################
  // emec public variables

  // febno keyed maps for all connected channels
  map<int, TH1F*> m_emecHMap;          // map of histograms
  map<int, float> m_emecHistoMeanMap;  // map of histogram signal means 
  map<int, float> m_emecHistoRMSMap;   // map of histogram signal rms
  map<int, float> m_emecHistoNMap;     // map of histogram number of entries in bins
  // febno keyed mean sigma/peds maps for all connected channels
  // all entried for a given ieta are the same
  map<int, float> m_emecMeanRatioMap;
  map<int, float> m_emecMeanRatioErrorMap;
  // febno keyed maps for good channels (retained for noise fit)
  map<int, float> m_emecFitMeanMap;        // map of fitted means
  map<int, float> m_emecFitMeanErrorMap;
  map<int, float> m_emecFitSigmaMap;       // map of fitted sigmas
  map<int, float> m_emecFitSigmaErrorMap;
  map<int, float> m_emecFitProbMap;        // map of fit probabilities
  // febno keyed maps for good channels and PedRMSnA > 0
  map<int, float> m_emecFitSigmaOverPedRMSMap;      // map of sigma/ped rms
  map<int, float> m_emecFitSigmaOverPedRMSErrorMap; // map of sigma/ped rms

private:

  //################################
  // hec private methods

  // make a TBID from a febno only considering ieta and iz
  TBID hecMakeTBID(int febno);
  // write noise data file
  void hecWriteNoiseFile();

  //################################
  // emec private methods

  // make a TBID from a febno only considering ieta and iz
  TBID emecMakeTBID(int febno);
  // write noise data file
  void emecWriteNoiseFile();

  //################################
  // private variables

  Geometry* m_geo;
  Event* m_event;
  Headers* m_runHeader;
  // pointer to CalibrationAlg systemAlg
  CalibrationAlg* m_calibration;
  // cell signal range (nA) and number of bins for signal histograms
  float m_sigMin;
  float m_sigMax;
  int m_nbins;
  // signal cut variables
  float m_SigmaMeanCut;  // |HistoMean-FitMean| > m_SigmaMeanCut*FitMeanError 
  float m_MeanCut;      // (nA) |HistoMean| > m_MeanCut
  // vector of TF1* needed for deletion in destructor
  vector<TF1*> m_TF1Vector;

  //################################
  // hec private variables

  // enable flags
  bool m_hecEnable;
  // print level
  int m_hecPrintLevel;
  // noise result file name
  string m_hecNoiseFileName;
  // febno keyed noise maps for all connected channels
  map<int, float> m_hecNoiseMap;
  map<int, float> m_hecNoiseErrorMap;
  map<int, int>   m_hecNoiseStatusMap;

  //################################
  // emec private variables

  // enable flags
  bool m_emecEnable;
  // print level
  int m_emecPrintLevel;
  // noise result file name
  string m_emecNoiseFileName;
  // febno keyed noise maps for all connected channels
  map<int, float> m_emecNoiseMap;
  map<int, float> m_emecNoiseErrorMap;
  map<int, int>   m_emecNoiseStatusMap;

};

#endif

---