emcCalFEM.h

Go to the documentation of this file.

#ifndef __EMCCALFEM_H__
#define __EMCCALFEM_H__

#ifndef __EMCMANAGEABLE_H__
#include "emcManageable.h"
#endif
#ifndef __PHTIMESTAMP_H__
#include "PHTimeStamp.h"
#endif
#include <string>
#include <iostream>
#include <ctime>

class emcCalFEM : public emcManageable
{
public:

  virtual ~emcCalFEM();

  virtual emcCalFEM* clone(void) const = 0;

  virtual emcCalFEM* create(void) const = 0;

  bool operator==(const emcCalFEM& obj) const
  {
    return IsEqual(obj);
  }

  bool operator!=(const emcCalFEM& obj) const
  {
    return !IsEqual(obj);
  }

  int AbsolutePosition(void) const
  {
    return fAbsPosition;
  }

  virtual float DefaultReturnValue(void) const
  {
    return 0.0;
  }

  std::string Description(void) const
  {
    return fDescription;
  }

  virtual const char* GetCategory(void) const = 0;


  virtual float getValue(int ichannel) const
  {
    return getValueFast(ichannel);
  }

  virtual float getValue(int ichannel, time_t x) const
  {
    return getValueFast(ichannel, x);
  }

  virtual float getValue(int ichannel, int x) const
  {
    return getValueFast(ichannel, x);
  }

  virtual float getValue(int ichannel, int amucell, const char* kind) const
  {
    return getValueFast(ichannel, amucell, std::string(kind));
  }

  virtual float getValue(int /*ichannel*/, int /*amucell*/, 
                         const std::string& /*kind*/) const
  {
    return DefaultReturnValue();
  }

  virtual float getValue(int /*i*/, const std::string& /*kind*/, 
                         float& output) const
  {
    output = 0.0;
    return DefaultReturnValue();
  }

  virtual float getValue(int i, const char* kind, float& output) const
  {
    return getValue(i, std::string(kind), output);
  }

  //@name getValueFast = without bound checking.*/

  virtual float getValueFast(int /*ichannel*/) const
  {
    return DefaultReturnValue();
  }

  virtual float getValueFast(int /*ichannel*/, time_t /*x*/) const
  {
    return DefaultReturnValue();
  }

  virtual float getValueFast(int /*ichannel*/, int /*x*/) const
  {
    return DefaultReturnValue();
  }

  virtual float getValueFast(int ichannel, int amucell,
                             const char* kind) const
  {
    return getValueFast(ichannel, amucell, std::string(kind));
  }

  virtual float getValueFast(int /*ichannel*/, int /*amucell*/, 
                             const std::string& /*kind*/)
    const
  {
    return DefaultReturnValue();
  }

  virtual float getValueFast(int /*ichannel*/, const std::string& /*kind*/, 
                             float& output) const
  {
    output = 0.0;
    return DefaultReturnValue();
  }

  virtual float getValueFast(int i, const char* kind, float& output) const
  {
    return getValueFast(i, std::string(kind), output);
  }



  const PHTimeStamp& GetEndValTime(void) const
  {
    return fEnd;
  }

  virtual size_t GetNumberOfChannels(void) const = 0;

  const PHTimeStamp& GetStartValTime(void) const
  {
    return fStart;
  }

  bool IsDefault(void) const
  {
    return fDefault;
  }

  bool IsDraft(void) const
  {
    return fDraft;
  }

  virtual bool IsEqual(const emcCalFEM&) const = 0;

  virtual bool IsValid(const PHTimeStamp& /*cwhen*/) const;

  int PinNumber(void) const
  {
    return fPinNumber;
  }

  virtual std::ostream& Print(std::ostream& out = std::cout, int level = 0) const;

  virtual void Reset(void) = 0;

  void SetDescription(const char* description)
  {
    fDescription = std::string(description);
  }

  void SetDefault(bool def = false)
  {
    fDefault = def;
  }

  void SetDraft(bool draft = false)
  {
    fDraft = draft;
  }

  virtual void SetNumberOfChannels(int /*nchannels*/ = 144)
  {}

  void SetPinNumber(int pinNumber)
  {
    fPinNumber = pinNumber;
  }

  void SetValidityPeriod(const PHTimeStamp& t1, const PHTimeStamp& t2)
  {
    fStart = t1;
    fEnd = t2;
  }

  void SetVersion(int version = 0)
  {
    fVersion = version;
  }



  time_t GetXmin(void) const
  {
    return fXmin;
  }
  time_t GetXmax(void) const
  {
    return fXmax;
  }
  void SetXmin(time_t xmin)
  {
    fXmin = xmin;
  }
  void SetXmax(time_t xmax)
  {
    fXmax = xmax;
  }


  size_t size(void) const
  {
    return GetNumberOfChannels();
  }

  virtual void updateValue(int /*ichannel*/, int /*amucell*/,
                           float /*newValue*/, const char* /*kind*/)
  {
  }


  int Version(void) const
  {
    return fVersion;
  }

  //_________________________________________________________________

  static int FEMCode(int absPosition, int pinNumber,
                     int post_pre, int tac_pre);

  static void FEMDecode(int id, int& absPosition, int& pinNumber,
                        int& post_pre, int& tac_pre);

  static int NumberOfInstances(void)
  {
    return fgNemcCalFEM;
  }
  
  
 protected:
  
  emcCalFEM(int absPosition);
  
  emcCalFEM(int absPosition,
            const PHTimeStamp& tStart,
            const PHTimeStamp& tEnd);
  
  emcCalFEM(const emcCalFEM&);
  
  emcCalFEM& operator=(const emcCalFEM&);
  
  void Copy(emcCalFEM&) const;
  
  private:
  PHTimeStamp fStart;
  PHTimeStamp fEnd;
  int fAbsPosition;
#ifndef __CINT__
  
  time_t fXmin;
  time_t fXmax;
#endif
  
  bool fDraft;
  int fVersion;
  std::string fDescription;
  int fPinNumber;
  bool fDefault;
  
 public:
    static int fgNemcCalFEM;
  
};

inline
std::ostream& operator<<(std::ostream& out, const emcCalFEM& tfem)
{
  return tfem.Print(out, 1);
}

#endif