---

OccupancyAlg.h

Go to the documentation of this file.

#ifndef  OCCUPANCYALG_H
#define OCCUPANCYALG_H

#include "Headers.h"
#include "Event.h"
#include "Geometry.h"
#include "SystemAlg.h"

#include "NoiseAlg.h"
#include "CalibrationAlg.h"

#include <string>
#include <map>

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

/*! -Class:   OccupancyAlg
  - Author:   Michel Lefebvre
  - Date:     29/7/2003
  - Description: OccupancyAlg is a systemAlg that computes the occupancy of each channel.
    The cut is |signal| > NoiseCut*noise.  The occupancy results are stored to files.
    Occupancy files can also be read back and the occupancy values accessed.
  */
class OccupancyAlg : 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
    */

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

  //! 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 channel occupancy for the hec
    * If no noise file name is given, then the file is assumed to be
    * hec_nnnnn_noise.dat
    * @param noiseFileName Name of noise file 
    */
  void hecEnable(string noiseFileName = "");

  /** Set the noise cut level
    * |signal| > m_hecNoiseCut*Noise
    * @param noiseCut the noise cut level in noise sigma units
    */
  void hecNoiseCut(float noiseCut){m_hecNoiseCut = noiseCut;};

  /** Read the noise cut level
    * Useful when reading occupancy files (where it is stored)
    */
  float hecNoiseCut(){return m_hecNoiseCut;};

  /** Set the print level for noise computation for the hec
    * 0 minimum
    * 1 print occupancy results (default)
    * @param level Print level
    */
  void hecPrintLevel(int level){m_hecPrintLevel = level;};

  /** Set the hec occupancy file name
    * @param occupancyFileName the name of the occupancy file
    */
  void hecOccupancyFileName(string occupancyFileName){m_hecOccupancyFileName = occupancyFileName;};

  /** Get the febno keyed occupancy map
    * The map contains entries for all connected channels
    */
  map<int, float> hecOccupancyMap(){return m_hecOccupancyMap;};

  /** Get the hec occupancy
    * @param febno channel febno
    */
  float hecOccupancy(int febno);

  /** Get the febno keyed hec occupancy error estimate map
    * The map contains entries for all connected channels
    */
  map<int, float> hecOccupancyErrorMap(){return m_hecOccupancyErrorMap;};

  /** Get the hec occupancy error estimate
    * @param febno channel febno
    */
  float hecOccupancyError(int febno);

  /** Read a hec occupancy file
    * If no noise file name is given, then the file is assumed to be
    * hec_nnnnn_occupancy.dat
    * Returns the run number in the occupancy file
    * @param occupancyFileName the name of the occupancy file
    */
  int hecReadOccupancyFile(string occupancyFileName = "");

  //! Print hec occupancy data
  void hecPrintOccupancy();

  /** Set the hec calibration file name
    * Needed if the ntuple data is in ADC 
    * Must be called before hecEnable 
    * @param calibrationFileName the name of the calibration file
    */
  void hecCalibrationFileName(string calibrationFileName){m_hecCalibrationFileName = calibrationFileName;};

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

  /** Enable the computation of channel occupancy for the emec
    * If no noise file name is given, then the file is assumed to be
    * emec?_nnnnn_noise.dat where ? is given by the input data file name
    * @param noiseFileName Name of noise file 
    */
  void emecEnable(string noiseFileName = "");

  /** Set the noise cut level
    * |signal| > m_emecNoiseCut*Noise
    * @param noiseCut the noise cut level in noise sigma units
    */
  void emecNoiseCut(float noiseCut){m_emecNoiseCut = noiseCut;};

  /** Read the noise cut level
    * Useful when reading occupancy files (where it is stored)
    */
  float emecNoiseCut(){return m_emecNoiseCut;};

  /** Set the print level for noise computation for the emec
    * 0 minimum
    * 1 print occupancy results (default)
    * @param level Print level
    */
  void emecPrintLevel(int level){m_emecPrintLevel = level;};

  /** Set the emec occupancy file name
    * @param occupancyFileName the name of the occupancy file
    */
  void emecOccupancyFileName(string occupancyFileName){m_emecOccupancyFileName = occupancyFileName;};

  /** Get the febno keyed occupancy map
    * The map contains entries for all connected channels
    */
  map<int, float> emecOccupancyMap(){return m_emecOccupancyMap;};

  /** Get the emec occupancy
    * @param febno channel febno
    */
  float emecOccupancy(int febno);

  /** Get the febno keyed emec occupancy error estimate map
    * The map contains entries for all connected channels
    */
  map<int, float> emecOccupancyErrorMap(){return m_emecOccupancyErrorMap;};

  /** Get the emec occupancy error estimate
    * @param febno channel febno
    */
  float emecOccupancyError(int febno);

  /** Read a emec occupancy file
    * If no occupancy file name is given, then assume the file is
    * emec?_nnnnn_occupancy.dat where ? is given by the input data file name
    * Returns the run number in the occupancy file
    * @param occupancyFileName the name of the occupancy file
    */
  int emecReadOccupancyFile(string occupancyFileName = "");

  //! Print emec occupancy data
  void emecPrintOccupancy();

  /** Set the emec calibration file name
    * Needed if the ntuple data is in ADC
    * Must be called before emecEnable 
    * @param calibrationFileName the name of the calibration file
    */
  void emecCalibrationFileName(string calibrationFileName){m_emecCalibrationFileName = calibrationFileName;};

private:

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

  // write occupancy data to file
  void hecWriteOccupancyFile();

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

  // write occupancy data to file
  void emecWriteOccupancyFile();

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

  Geometry* m_geo;
  Event* m_event;
  Headers* m_runHeader;
  // pointer to NoiseAlg systemAlg
  NoiseAlg* m_noise;
  // pointer to CalibrationAlg systemAlg
  CalibrationAlg* m_calibration;

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

  // enable flags
  bool m_hecEnable;
  // signal cut variable
  float m_hecNoiseCut;   // |signal| > m_hecNoiseCut*Noise
  // print level
  int m_hecPrintLevel;
  // occupancy result file name
  string m_hecOccupancyFileName;
  // febno keyed occupancy maps for all connected channels
  map<int, float> m_hecOccupancyMap;
  map<int, float> m_hecOccupancyErrorMap;
  // calibration file name
  string m_hecCalibrationFileName;
  // event counter
  int m_hecEvents;

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

  // enable flags
  bool m_emecEnable;
  // signal cut variable
  float m_emecNoiseCut;   // |signal| > m_emecNoiseCut*Noise
   // print level
  int m_emecPrintLevel;
  // occupancy result file name
  string m_emecOccupancyFileName;
  // febno keyed occupancy maps for all connected channels
  map<int, float> m_emecOccupancyMap;
  map<int, float> m_emecOccupancyErrorMap;
  // calibration file name
  string m_emecCalibrationFileName;
  // event counter
  int m_emecEvents;

};

#endif

---