CalScheme.h

Go to the documentation of this file.

// CalScheme
//
// Abstract base class for mid-level calibrator class. 
//
// n.tagg1@physics.ox.ac.uk  N Tagg 2004, 
//
//
//
// $Id: CalScheme.h,v 1.9 2005/03/22 12:22:14 tagg Exp $

#ifndef CALSCHEME_H
#define CALSCHEME_H

#include <iostream>
#include <sstream>
#include <TObject.h>
#include "GenericThingId.h"
#include "MessageService/Msg.h"
#include "MessageService/MsgStream.h"
#include "Validity/VldContext.h"
#include "Configurable/CfgPromptConfigurable.h"
#include "Conventions/CalDigitType.h"
#include "Plex/PlexStripEndId.h"
#include "RawData/RawChannelId.h"
#include "Plex/PlexCalib.h"
#include "Plex/PlexSEIdAltLItem.h"
#include "ValueErr.h"

class CalScheme : public TObject, public CfgPromptConfigurable
{
 public:
  // NB. Use your constructor to create your default configuration, 
  // then set it with InitialzeConfig()

  CalScheme();
  virtual ~CalScheme();
  
  // Interface:
  // All of these methods are dummy classes that will cause a
  // big crash if used. Override these methods to actually do things.

  // Calibration methods.
  virtual  DoubleErr GetCalibratedTime(DoubleErr rawtime, FloatErr charge,  const PlexStripEndId& seid) const;         
  virtual  FloatErr  GetPhotoElectrons(FloatErr rawcharge, const PlexStripEndId& seid) const;
  virtual  FloatErr  GetLinearizedVA(FloatErr rawcharge, const RawChannelId& rcid) const;
  virtual  FloatErr  GetDriftCorrected(FloatErr rawcharge, const PlexStripEndId& seid) const;
  virtual  FloatErr  GetLinearized(FloatErr sigdrift,      const PlexStripEndId& seid) const;
  virtual  FloatErr  GetStripToStripCorrected(FloatErr siglin,           const PlexStripEndId& seid) const;
  virtual  FloatErr  GetAttenCorrected(FloatErr sigcorr, FloatErr stripX, const PlexStripEndId& seid) const;
  virtual  FloatErr  GetMIP(FloatErr sigmap,                        const PlexStripEndId& seid = PlexStripEndId()) const;

   // Decalibration methods
  virtual  DoubleErr DecalTime(DoubleErr caltime, FloatErr charge,  const PlexStripEndId& seid) const;      
  virtual  void      DecalGainAndWidth(FloatErr& gain, FloatErr& width, const PlexStripEndId& seid) const;
  virtual  void      DecalGainAndWidth(FloatErr& gain, FloatErr& width, const PlexPixelSpotId& psid) const;
  virtual  FloatErr  DecalVALinearity(FloatErr adc,                      const RawChannelId& rcid) const;
  virtual  FloatErr  DecalDrift(FloatErr undrifted,                    const PlexStripEndId& seid) const;
  virtual  FloatErr  DecalLinearity(FloatErr lin,                      const PlexStripEndId& seid) const;
  virtual  FloatErr  DecalStripToStrip(FloatErr sigcorr,               const PlexStripEndId& seid) const;
  virtual  FloatErr  DecalAttenCorrected(FloatErr sigmap,FloatErr stripX,const PlexStripEndId& seid) const;
  virtual  FloatErr  DecalMIP(FloatErr sigmip,                         const PlexStripEndId& seid = PlexStripEndId()) const;

  // Other things, not really calibrations:
  virtual  Float_t GetTemperature(Int_t mode = 0) const;

 protected:
  // Override this method to do your own things on a context change (i.e. table.NewQuery()).
  virtual void      DoReset( const VldContext&  ) {};

  // Configuration system. Override this to do stuff when config changes..
  virtual void      ConfigModified(){};              // Perform changes the current configuration.

 public:
  // Override this to print out your configuration:
  virtual void      PrintConfig( std::ostream& os ) const;
  
  // Things this class does:
  
  // Context stuff:
  void              Reset( const VldContext& context, Bool_t force=false );
  const VldContext& GetContext(void) const { return fContext; };

  // I/O stuff:
  void PrintConfig( MsgStream& ms ) const;
  void PrintConfig() const; // Prints to default stream.

  void  PrintErrorStats( std::ostream& os ) const;
  void  PrintErrorStats( MsgStream& ms ) const;
  void  PrintErrorStats() const; // Prints to default stream.


  friend  std::ostream& operator<<(std::ostream& os, const CalScheme& s);

 private:
  VldContext fContext;
  void Unimplimented() const;

 public:
  typedef enum ESchemeType {
    kUnknown   = 0,
    kTimeCalibrator,
    kPeCalibrator,
    kVALinCalibrator,
    kLinCalibrator,
    kDriftCalibrator,
    kStripCalibrator,
    kAttenCalibrator,
    kMIPCalibrator,
    kThermometer,
    kNumberOfSchemeTypes
  } SchemeType_t;

  static const char* SchemeTypeName(int t) {
    static const char* sTypeNames[] = {
      "Unknown",
      "TimeCalibrator",
      "PeCalibrator",
      "VALinCalibrator",
      "LinCalibrator",
      "DriftCalibrator",
      "StripCalibrator",
      "AttenCalibrator",
      "MIPCalibrator",
      "Thermometer",
      "???"};
    return sTypeNames[t%kNumberOfSchemeTypes];
  };

  static const char* UnitName(int t) {
    static const char* sUnitNames[] = {
      "Unknown",
      "Seconds",
      "PE",
      "ADC",
      "SigLin",
      "SigDrift",
      "SigCorr",
      "SigMap",
      "SigMip",
      "C",
      "???"};
    return sUnitNames[t%kNumberOfSchemeTypes];
  };
  

  typedef enum EErrorType {
    kGeneralErr   = 0,    // Catch-all catagory
    kMissingTable = 1, // Table was completely empty for context
    kMissingRow   = 2, // Table didn't have requested entry
    kFPE          = 3, // Computation generated illegal quantity.
    kDataInsufficient = 4,
    kBadInput = 5,
    kNumberOfErrorTypes
  } ErrorType_t;
  
 protected:

  static void ResetStatistics();
  static void IncrementErrors(SchemeType_t, ErrorType_t = kGeneralErr);
  static void IncrementErrors(SchemeType_t, ErrorType_t, const GenericThingId& thing);
  static void IncrementErrors(SchemeType_t, ErrorType_t, Int_t genericId);
  static void IncrementErrors(SchemeType_t, ErrorType_t, const RawChannelId& rcid);
  static void IncrementErrors(SchemeType_t, ErrorType_t, const PlexPixelSpotId& psid);
  static void IncrementErrors(SchemeType_t, ErrorType_t, const PlexStripEndId& seid);
  static void IncrementErrors(SchemeType_t, ErrorType_t, const PlexLedId& led);

  static void IncrementCalls(SchemeType_t);
  
 private:
  static Int_t             fsCalls[kNumberOfSchemeTypes]; // !
  static Int_t             fsErrors[kNumberOfSchemeTypes][kNumberOfErrorTypes]; // !
  static std::map<GenericThingId,int> fsChannelErrors; // !
  
  ClassDef(CalScheme,0);
};



#endif

---