Calibrator.h

Go to the documentation of this file.

// Calibrator
//
// Top-level calibrator class. Slices, dices, Julienne-fries.
//
// n.tagg1@physics.ox.ac.uk  N Tagg 2004, 
//
// Lots of code based upon older calibrator classes by Ryan Nichol, 2001
//
//
// $Id: Calibrator.h,v 1.14 2006/05/18 04:08:41 tagg Exp $

#ifndef CALIBRATOR_H
#define CALIBRATOR_H

#include <TObject.h>
#include "CalScheme.h"
#include "Validity/VldContext.h"
#include "Configurable/CfgConfigurable.h"
#include "Conventions/CalDigitType.h"
#include "RawData/RawChannelId.h"
#include "Plex/PlexStripEndId.h"
#include "Plex/PlexCalib.h"
#include "Plex/PlexPixelSpotId.h"
#include "Plex/PlexSEIdAltLItem.h"
#include <iostream>
#include <cassert>

class TH1;

class Calibrator : public PlexCalib,
                   public CalScheme // The daddy of all CalSchemes.
{
public:
  // How to get a handle: 
  static Calibrator& Instance(); 

  static CalScheme& TimeCalibrator()  { return Instance().GetTimeCalibrator(); };
  static CalScheme& PeCalibrator()    { return Instance().GetPeCalibrator(); };
  static CalScheme& VALinCalibrator() { return Instance().GetVALinCalibrator(); };
  static CalScheme& DriftCalibrator() { return Instance().GetDriftCalibrator(); };
  static CalScheme& LinCalibrator()   { return Instance().GetLinCalibrator(); };
  static CalScheme& StripCalibrator() { return Instance().GetStripCalibrator(); };
  static CalScheme& AttenCalibrator() { return Instance().GetAttenCalibrator(); };
  static CalScheme& MIPCalibrator()   { return Instance().GetMIPCalibrator(); };
  static CalScheme& Thermometer()     { return Instance().GetThermometer(); };

  CalScheme& GetTimeCalibrator()  { return *fTimeCalibrator; };
  CalScheme& GetPeCalibrator()    { return *fPeCalibrator; };
  CalScheme& GetVALinCalibrator() { return *fVALinCalibrator; };
  CalScheme& GetDriftCalibrator() { return *fDriftCalibrator; };
  CalScheme& GetLinCalibrator()   { return *fLinCalibrator; };
  CalScheme& GetStripCalibrator() { return *fStripCalibrator; };
  CalScheme& GetAttenCalibrator() { return *fAttenCalibrator; };
  CalScheme& GetMIPCalibrator()   { return *fMIPCalibrator; };
  CalScheme& GetThermometer()     { return *fThermometer; };

  // Called by the DigitListModule by way of the Plex. Calibrates a strip end.
  PlexSEIdAltLItem CalibStripEnd(const PlexStripEndId& seid,
                                 const PlexPixelSpotId& spotid,
                                 Int_t adc, Double_t time) const;
  
   
  // A more useful version of GetAttenCorrected that does some complicated geometry stuff for you.
  FloatErr  GetAttenCorrectedTpos(FloatErr sigcorr, FloatErr lpos, const PlexStripEndId& seid) const;
  FloatErr  DecalAttenCorrectedTpos(FloatErr sigcorr, FloatErr lpos, const PlexStripEndId& seid) const;

  // These aren't really calibrations, but are useful calls
  // that are probably best put here.
  Float_t  GetTemperature(Int_t mode = 0) const;

  // These don't use sub-calibrators, but are coded into the Calibrator.
  DoubleErr GetTimeFromTDC(Int_t    tdc,  const RawChannelId& rcid) const;  
  Int_t     GetTDCFromTime(Double_t time, const RawChannelId& rcid) const;
  Double_t  GetTDCConvert(const RawChannelId&) const; // returns seconds per TDC tick

  
  // Used by the above, or used on their own:
  DoubleErr GetCalibratedTime(DoubleErr rawtime,  FloatErr charge,    const PlexStripEndId& seid) const;
  FloatErr  GetPhotoElectrons(FloatErr rawcharge,                const PlexStripEndId& seid) const;
  FloatErr  GetLinearizedVA(FloatErr rawcharge,                  const RawChannelId& rcid) const;
  FloatErr  GetDriftCorrected(FloatErr rawcharge,                const PlexStripEndId& seid) const;
  FloatErr  GetLinearized(FloatErr sigdrift,                     const PlexStripEndId& seid) const;
  FloatErr  GetStripToStripCorrected(FloatErr siglin,            const PlexStripEndId& seid) const;
  FloatErr  GetAttenCorrected(FloatErr sigcorr, FloatErr stripX, const PlexStripEndId& seid) const;
  FloatErr  GetMIP(FloatErr sigmap,                              const PlexStripEndId& seid = PlexStripEndId()) const;
  
  // Used by MC routines:
  DoubleErr DecalTime(DoubleErr caltime,  FloatErr charge,       const PlexStripEndId& seid) const;
  void      DecalGainAndWidth(FloatErr& gain, FloatErr& width,   const PlexStripEndId& seid) const;
  void      DecalGainAndWidth(FloatErr& gain, FloatErr& width,   const PlexPixelSpotId& psid) const;
  FloatErr  DecalVALinearity(FloatErr adc,                       const RawChannelId& rcid) const;
  FloatErr  DecalDrift(FloatErr undrifted,                       const PlexStripEndId& seid) const;
  FloatErr  DecalLinearity(FloatErr lin,                         const PlexStripEndId& seid) const;
  FloatErr  DecalStripToStrip(FloatErr sigcorr,                  const PlexStripEndId& seid) const;
  FloatErr  DecalAttenCorrected(FloatErr sigmap, FloatErr stripX, const PlexStripEndId& seid) const;
  FloatErr  DecalMIP(FloatErr sigmip,                             const PlexStripEndId& seid = PlexStripEndId()) const;
  
  // Call to set up new context (i.e. new event)
  void ReInitialise(const VldContext &vldc) { Reset(vldc); }; // alternate name, backwards compatability.
  
  // Configuration.
  const Registry& GetCompleteConfiguration() const; // Suitable for saving.


  // I/O. Reporting.
  void     SetLogLevel(Int_t lvl);  
  void     PrintConfig(std::ostream& os) const; // Printout of current configuration.

  // If you really REALLY want to, you can have your own instance.
  // However, this is not recommended and should be used only in special cases.
  static Calibrator* CreateCustomCalibrator();
  ~Calibrator();

 protected:  
  // Calibrator is a singleton, so ctor/dtor protected
  Calibrator();

  void DoReset(const VldContext &context);
  void ConfigModified();              // Perform changes the current configuration.

  // Factory utilities:
  void SetScheme(CalScheme* &scheme, const char* name);
  void ConfigScheme( const char* masterRegKey, CalScheme* scheme );


 private:
  // These methods are private and not implemented to prevent copying.
  Calibrator(const Calibrator &);
  void operator=(const Calibrator &);
  
  // This section sets up the singleton machinery.
  // Cleaner struct used to clean up singleton at end of job
  struct Cleaner {
    void UseMe() { }                  // Dummy method to quiet compiler
    ~Cleaner() {
      if (Calibrator::fgInstance != 0) {
        delete Calibrator::fgInstance;
        Calibrator::fgInstance = 0;
      } } 
  };
  friend struct Cleaner; 
  static Calibrator *fgInstance;  // Unique Calibrator object
  
  CalScheme* fTimeCalibrator;
  CalScheme* fPeCalibrator;
  CalScheme* fVALinCalibrator;
  CalScheme* fDriftCalibrator;
  CalScheme* fLinCalibrator;
  CalScheme* fStripCalibrator;
  CalScheme* fAttenCalibrator;
  CalScheme* fMIPCalibrator;   
  CalScheme* fThermometer;
  mutable Int_t fCalibratorIsDirty[CalScheme::kNumberOfSchemeTypes];
  
 public:
  void     ResetEventStats();
  void     ResetHistograms();

  void      PrintEventStats() const;
  DoubleErr GetEventTotal(CalScheme::SchemeType_t type) const { return fEventTotal[(int)type]; };
  DoubleErr GetEventCalls(CalScheme::SchemeType_t type) const { return fEventCalls[(int)type]; };
  void      DrawHistograms();

  TH1*     GetFracErrorHist(CalScheme::SchemeType_t type) { return fFracErrorHist[(int)type]; };
  TH1*     GetErrorHist(CalScheme::SchemeType_t type)     { return fErrorHist[(int)type]; };

  
  // Event statistics
  mutable DoubleErr  fEventTotal[CalScheme::kNumberOfSchemeTypes];
  mutable Double_t   fEventCalls[CalScheme::kNumberOfSchemeTypes];
  
  // Overall statistics
  mutable TH1*      fFracErrorHist[CalScheme::kNumberOfSchemeTypes];
  mutable TH1*      fErrorHist[CalScheme::kNumberOfSchemeTypes];

  ClassDef(Calibrator,0)              // Calibrator version 0
};



inline Calibrator& Calibrator::Instance()
{
  
  // Cleaner destructor calls DigitCalibrator dtor
  static Cleaner cleaner;
  
  // Calibrator mode "1" the default.  This is hardwired for now.
  if (!fgInstance) {
    cleaner.UseMe();           // dummy call to quiet compiler warnings
    fgInstance = new Calibrator();
    if(!fgInstance){
      cout << "No DigitCalibrator Instance - fatal." << endl;
      assert(fgInstance);               // Kill job is there is no instance
    }
    CalScheme::ResetStatistics();
  }
  
  return *fgInstance;
}

#endif //CALIBRATOR_H

---