Calibrator.cxx

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.cxx,v 1.30 2007/03/29 19:56:48 tagg Exp $

#include "Calibrator.h"
#include "MessageService/MsgService.h"
#include "Conventions/Munits.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include <TROOT.h>
#include <TClass.h>
#include <TH1F.h>
#include <TCanvas.h>
#include <cassert>

CVSID(" $Id: Calibrator.cxx,v 1.30 2007/03/29 19:56:48 tagg Exp $ ");

ClassImp(Calibrator)

Calibrator* Calibrator::fgInstance = 0;


Calibrator* Calibrator::CreateCustomCalibrator()
{
  MSG("Calib",Msg::kWarning) << "*  Some joker has just created a custom Calibrator object." << endl;
  MSG("Calib",Msg::kWarning) << "*  I'll do as I'm told, but doing this is usually not neccessary" << endl;
  MSG("Calib",Msg::kWarning) << "*  except for rare testing cases." << endl;
  MSG("Calib",Msg::kWarning) << "*  (Error/call statistics reporting will now be screwed up.)" << endl;
  return new Calibrator();
}


//

PlexSEIdAltLItem Calibrator::CalibStripEnd(const PlexStripEndId& seid,
                                           const PlexPixelSpotId& spotid,
                                           Int_t adc, Double_t rawtime) const
{

  MSG("Calib", Msg::kVerbose)
      << "Calibrator::CalibStripEnd" << endl;
  FloatErr seidWeight=0;                       //Will be set by the Plex
  FloatErr seidPE = this->GetPhotoElectrons(adc, seid);
  FloatErr seidSigLin = this->GetLinearized(adc, seid);
  FloatErr seidSigDrift = this->GetDriftCorrected(seidSigLin, seid);
  FloatErr seidSigCorr = this->GetStripToStripCorrected(seidSigDrift, seid);
  DoubleErr seidTime = this->GetCalibratedTime(rawtime, adc, seid);
  
  MSG("Calib", Msg::kVerbose)
    << seid  << "   ADC: "
    << adc << " PE: " << seidPE << " SigLin: " << seidSigLin
    << " SigCor: " << seidSigCorr << endl
    << " Time: " << rawtime << " TimeCor: " << seidTime << std::endl;
  
  // Used in debugging phase.
  //if((adc/seidPE)<10 ) MSG("Calib",Msg::kError) << "Abnormally high gain ( " << (adc/seidPE) << " adc/pe) returned for SEID " << seid.AsString() << endl;
  //if((adc/seidPE)>500) MSG("Calib",Msg::kError) << "Abnormally low  gain ( " << (adc/seidPE) << " adc/pe) returned for SEID " << seid.AsString() << endl;

  PlexSEIdAltLItem item(seid, spotid, seidWeight, seidPE, seidSigDrift,
                        seidSigCorr, seidTime);
  return item;  
}



FloatErr  Calibrator::GetAttenCorrectedTpos(FloatErr sigcorr, 
                                            FloatErr tpos, 
                                            const PlexStripEndId& seid) const
{ 

  FloatErr stripX = 0.;

  // Caldet and Far are both symettric.
  if(GetContext().GetDetector()!=Detector::kNear) {
    if (seid.GetPlaneView()==PlaneView::kU) {
      stripX = -tpos;
    } else {
      stripX = tpos;
    }
    return GetAttenCorrected(sigcorr, stripX, seid);
  }

  UgliGeomHandle ugli(GetContext());
  UgliStripHandle ustrip = ugli.GetStripHandle(seid);
  
  const double rsqrt2 = 1.0/sqrt(2.0);
  const TVector3 kU(rsqrt2,rsqrt2,0.);
  const TVector3 kV(-rsqrt2,rsqrt2,0.);
  
  if (seid.GetPlaneView()==PlaneView::kU) {
    float lambda = kV.Dot(ustrip.GlobalPos(0.));
    stripX = -tpos + lambda;
  } else {
    float lambda = kU.Dot(ustrip.GlobalPos(0.));
    stripX = tpos - lambda;
  }
  return GetAttenCorrected(sigcorr, stripX, seid);
}

FloatErr  Calibrator::DecalAttenCorrectedTpos(FloatErr sigmap, 
                                             FloatErr tpos, 
                                             const PlexStripEndId& seid) const
{ 

  FloatErr stripX = 0.;
    
  // Caldet and Far are both symettric.
  if(GetContext().GetDetector()!=Detector::kNear) {
    if (seid.GetPlaneView()==PlaneView::kU) {
      stripX = -tpos;
    } else {
      stripX = tpos;
    }
    return DecalAttenCorrected(sigmap, stripX, seid); 
  }

  UgliGeomHandle ugli(GetContext());
  UgliStripHandle ustrip = ugli.GetStripHandle(seid);
  
  const double rsqrt2 = 1.0/sqrt(2.0);
  const TVector3 kU(rsqrt2,rsqrt2,0.);
  const TVector3 kV(-rsqrt2,rsqrt2,0.);
  
  if (seid.GetPlaneView()==PlaneView::kU) {
    float lambda = kV.Dot(ustrip.GlobalPos(0.));
    stripX = -tpos + lambda;
  } else {
    float lambda = kU.Dot(ustrip.GlobalPos(0.));
    stripX = tpos - lambda;
  }
  return DecalAttenCorrected(sigmap, stripX, seid); 
}

// Time Calibration calls

DoubleErr Calibrator::GetCalibratedTime(DoubleErr rawtime, FloatErr charge, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kTimeCalibrator);
  if(fCalibratorIsDirty[kTimeCalibrator]) {
    // Lazy context update.
    fTimeCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kTimeCalibrator]=0;
  }
  DoubleErr result = fTimeCalibrator->GetCalibratedTime(rawtime,charge,seid);
  fEventTotal[CalScheme::kTimeCalibrator] += result;
  fEventCalls[CalScheme::kTimeCalibrator]++;
  fErrorHist[CalScheme::kTimeCalibrator]    ->Fill(result.GetError());
  fFracErrorHist[CalScheme::kTimeCalibrator]->Fill(result.GetFracError());
  return result;
}

DoubleErr Calibrator::DecalTime(DoubleErr caltime, FloatErr charge, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kTimeCalibrator);
  if(fCalibratorIsDirty[kTimeCalibrator]) {
    // Lazy context update.
    fTimeCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kTimeCalibrator]=0;
  }
   
  return fTimeCalibrator->DecalTime(caltime,charge,seid);
}     


// PE Calibration calls
FloatErr  Calibrator::GetPhotoElectrons(FloatErr rawcharge, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kPeCalibrator);
  if(fCalibratorIsDirty[kPeCalibrator]) {
    // Lazy context update.
    fPeCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kPeCalibrator]=0;
  }
   
  FloatErr result = fPeCalibrator->GetPhotoElectrons(rawcharge,seid);
  fEventTotal[CalScheme::kPeCalibrator]+= DoubleErr(result.GetValue(),result.GetError());
  fEventCalls[CalScheme::kPeCalibrator]++;
  fErrorHist[CalScheme::kPeCalibrator]    ->Fill(result.GetError());
  fFracErrorHist[CalScheme::kPeCalibrator]->Fill(result.GetFracError());
  return result;
}

void     Calibrator::DecalGainAndWidth(FloatErr& gain, FloatErr& width, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kPeCalibrator);
  if(fCalibratorIsDirty[kPeCalibrator]) {
    // Lazy context update.
    fPeCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kPeCalibrator]=0;
  }
   
  fPeCalibrator->DecalGainAndWidth(gain,width,seid);
}

void Calibrator::DecalGainAndWidth(FloatErr& gain, FloatErr& width, 
                                   const PlexPixelSpotId& psid) const
{
  CalScheme::IncrementCalls(CalScheme::kPeCalibrator);
  if(fCalibratorIsDirty[kPeCalibrator]) {
    // Lazy context update.
    fPeCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kPeCalibrator]=0;
  }
   
  fPeCalibrator->DecalGainAndWidth(gain,width,psid);
}
// VA Linearity Calibration calls
FloatErr  Calibrator::GetLinearizedVA(FloatErr rawcharge, const RawChannelId& rcid ) const
{
 
  CalScheme::IncrementCalls(CalScheme::kVALinCalibrator);
  if(fCalibratorIsDirty[kVALinCalibrator]) {
    // Lazy context update.
    fVALinCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kVALinCalibrator]=0;
  }
   
  FloatErr result = fVALinCalibrator->GetLinearizedVA(rawcharge,rcid);
  fEventTotal[CalScheme::kVALinCalibrator]+= DoubleErr(result.GetValue(),result.GetError());
  fEventCalls[CalScheme::kVALinCalibrator]++;
  fErrorHist[CalScheme::kVALinCalibrator]    ->Fill(result.GetError());
  fFracErrorHist[CalScheme::kVALinCalibrator]->Fill(result.GetFracError());
  return result;
}

FloatErr Calibrator::DecalVALinearity(FloatErr adc, const RawChannelId& rcid) const
{
  CalScheme::IncrementCalls(CalScheme::kVALinCalibrator);
  if(fCalibratorIsDirty[kVALinCalibrator]) {
    // Lazy context update.
    fVALinCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kVALinCalibrator]=0;
  }
   
  return fVALinCalibrator->DecalVALinearity(adc,rcid);
}


// Drift Calibration calls

FloatErr  Calibrator::GetDriftCorrected(FloatErr rawcharge, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kDriftCalibrator);
  if(fCalibratorIsDirty[kDriftCalibrator]) {
    // Lazy context update.
    fDriftCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kDriftCalibrator]=0;
  }
   
  FloatErr result = fDriftCalibrator->GetDriftCorrected(rawcharge,seid);
  fEventTotal[CalScheme::kDriftCalibrator]+= DoubleErr(result.GetValue(),result.GetError());
  fEventCalls[CalScheme::kDriftCalibrator]++;
  fErrorHist[CalScheme::kDriftCalibrator]    ->Fill(result.GetError());
  fFracErrorHist[CalScheme::kDriftCalibrator]->Fill(result.GetFracError());
  return result;
}

FloatErr  Calibrator::DecalDrift(FloatErr undrifted,                    const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kDriftCalibrator);
  if(fCalibratorIsDirty[kDriftCalibrator]) {
    // Lazy context update.
    fDriftCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kDriftCalibrator]=0;
  }
   
  return fDriftCalibrator->DecalDrift(undrifted,seid);
}

// Linearization Calibration calls
FloatErr  Calibrator::GetLinearized(FloatErr sigdrift, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kLinCalibrator);
  if(fCalibratorIsDirty[kLinCalibrator]) {
    // Lazy context update.
    fLinCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kLinCalibrator]=0;
  }

  FloatErr result = fLinCalibrator->GetLinearized(sigdrift,seid);  
  fEventTotal[CalScheme::kLinCalibrator]+= DoubleErr(result.GetValue(),result.GetError());
  fEventCalls[CalScheme::kLinCalibrator]++;
  fErrorHist[CalScheme::kLinCalibrator]    ->Fill(result.GetError());
  fFracErrorHist[CalScheme::kLinCalibrator]->Fill(result.GetFracError());
  return result;
}

FloatErr  Calibrator::DecalLinearity(FloatErr lin,     const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kLinCalibrator);
  if(fCalibratorIsDirty[kLinCalibrator]) {
    // Lazy context update.
    fLinCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kLinCalibrator]=0;
  }
   
  return fLinCalibrator->DecalLinearity(lin,seid);  
}

// Strip-to-Strip Calibration calls
FloatErr  Calibrator::GetStripToStripCorrected(FloatErr siglin,  const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kStripCalibrator);
  if(fCalibratorIsDirty[kStripCalibrator]) {
    // Lazy context update.
    fStripCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kStripCalibrator]=0;
  }
   
  FloatErr result = fStripCalibrator->GetStripToStripCorrected(siglin,seid);  
  fEventTotal[CalScheme::kStripCalibrator]+= DoubleErr(result.GetValue(),result.GetError());
  fEventCalls[CalScheme::kStripCalibrator]++;
  fErrorHist[CalScheme::kStripCalibrator]    ->Fill(result.GetError());
  fFracErrorHist[CalScheme::kStripCalibrator]->Fill(result.GetFracError());
  return result;
}
FloatErr  Calibrator::DecalStripToStrip(FloatErr sigcorr, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kStripCalibrator);
  if(fCalibratorIsDirty[kStripCalibrator]) {
    // Lazy context update.
    fStripCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kStripCalibrator]=0;
  }
   
  return fStripCalibrator->DecalStripToStrip(sigcorr,seid);    
}

// Strip Attenuation Correction Calibration calls
FloatErr  Calibrator::GetAttenCorrected(FloatErr sigcorr, FloatErr stripX, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kAttenCalibrator);
  if(fCalibratorIsDirty[kAttenCalibrator]) {
    // Lazy context update.
    fAttenCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kAttenCalibrator]=0;
  }
   
  FloatErr result = fAttenCalibrator->GetAttenCorrected(sigcorr,stripX,seid);     
  fEventTotal[CalScheme::kAttenCalibrator]+= DoubleErr(result.GetValue(),result.GetError());
  fEventCalls[CalScheme::kAttenCalibrator]++;
  fErrorHist[CalScheme::kAttenCalibrator]    ->Fill(result.GetError());
  fFracErrorHist[CalScheme::kAttenCalibrator]->Fill(result.GetFracError());
  return result;
}

FloatErr  Calibrator::DecalAttenCorrected(FloatErr sigmap, FloatErr stripX, const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kAttenCalibrator);
  if(fCalibratorIsDirty[kAttenCalibrator]) {
    // Lazy context update.
    fAttenCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kAttenCalibrator]=0;
  }
   
  return fAttenCalibrator->DecalAttenCorrected(sigmap,stripX,seid);      
}

// MIP Calibration calls
FloatErr  Calibrator::GetMIP(FloatErr sigmap,                        const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kMIPCalibrator);
  if(fCalibratorIsDirty[kMIPCalibrator]) {
    // Lazy context update.
    fMIPCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kMIPCalibrator]=0;
  }
   
  FloatErr result = fMIPCalibrator->GetMIP(sigmap,seid);     
  fEventTotal[CalScheme::kMIPCalibrator]+= DoubleErr(result.GetValue(),result.GetError());
  fEventCalls[CalScheme::kMIPCalibrator]++;
  fErrorHist[CalScheme::kMIPCalibrator]    ->Fill(result.GetError());
  fFracErrorHist[CalScheme::kMIPCalibrator]->Fill(result.GetFracError());
  return result;
}

FloatErr  Calibrator::DecalMIP(FloatErr sigmip,                         const PlexStripEndId& seid) const
{
  CalScheme::IncrementCalls(CalScheme::kMIPCalibrator);
  if(fCalibratorIsDirty[kMIPCalibrator]) {
    // Lazy context update.
    fMIPCalibrator->Reset(GetContext()); 
    fCalibratorIsDirty[kMIPCalibrator]=0;
  }
   
  return fMIPCalibrator->DecalMIP(sigmip,seid);     
}


// Other non-calibration calibrations
Float_t Calibrator::GetTemperature(Int_t mode) const
{
  CalScheme::IncrementCalls(CalScheme::kThermometer);
  if(fCalibratorIsDirty[kThermometer]) {
    // Lazy context update.
    fThermometer->Reset(GetContext()); 
    fCalibratorIsDirty[kThermometer]=0;
  }
   
  return fThermometer->GetTemperature(mode);
}

// Useful Global conversion calls
Double_t Calibrator::GetTDCConvert(const RawChannelId& rcid)  const
{
   // This code shamelessly lifted from AlgDigit.
  
  // Convert from 0.1*Munits:ns to standard Munits base time units (sec).
  Double_t tdc_convert = 0.1;   // REROOT, non-VA, non-QIE scale factor
  
  // Switch on type of readout electronics
  switch (rcid.GetElecType()) {
    
    // VA electronics, tick = 1.5625 ns (640MHz)
  case (ElecType::kVA):
    tdc_convert = 1.5625;
    break;

    // QIE electronics, tick = 18.832 ns (RF clock)
  case (ElecType::kQIE):
    tdc_convert =  1000./53.1;  // clock is 53.1MHz
    
    // CalDet has yet a different clock frequency
    if (rcid.GetDetector() == Detector::kCalDet)
      tdc_convert = 1.5625*16.0*58.0/77.0;
    break;
    
    // Use whatever value we started with
  default:
    break;
  }
  return tdc_convert * Munits::ns;
}

DoubleErr Calibrator::GetTimeFromTDC(Int_t tdc, const RawChannelId& rcid) const
{
  
  // Convert TDC counts to Double_t.  

  DoubleErr tdc_and_err(tdc,1.0);

  // Flag error on FD:
  //if(rcid.GetElecType==ElecType::kVA)
  //  if( (tdc & 0x1F) == 0x08 )  tdc_and_err.SetError(8.);

  DoubleErr t = tdc_and_err * GetTDCConvert(rcid);
  
  return t;
}

Int_t Calibrator::GetTDCFromTime(Double_t time, const RawChannelId& rcid) const
{

  // This code shamelessly lifted from AlgDigit.
  
  // Convert TDC counts to Double_t.  
  Double_t tdc = time / GetTDCConvert(rcid);
  
  //return (int)round(tdc);  // round() not available on IRIX
  return TMath::Nint(tdc);
}






// Context methods
void Calibrator::DoReset(const VldContext& /*context*/)
{
  for(int i=0;i<kNumberOfSchemeTypes; i++) {
    fCalibratorIsDirty[i]=1;
  }
}


// I/O, reporting, configuration.

void Calibrator::SetLogLevel(Int_t lvl)
{
  MsgService::Instance()->GetStream("Calib")->SetLogLevel((Msg::LogLevel_t)lvl);
}

const Registry& Calibrator::GetCompleteConfiguration() const 
{

  static Registry r;
  r = GetConfig();
  r.Set("TimeCalibratorConfig",  fTimeCalibrator ->GetConfig());
  r.Set("PeCalibratorConfig",    fPeCalibrator   ->GetConfig());
  r.Set("VALinCalibratorConfig", fVALinCalibrator->GetConfig());
  r.Set("DriftCalibratorConfig", fDriftCalibrator->GetConfig());
  r.Set("LinCalibratorConfig",   fLinCalibrator  ->GetConfig());
  r.Set("StripCalibratorConfig", fStripCalibrator->GetConfig());
  r.Set("AttenCalibratorConfig", fAttenCalibrator->GetConfig());
  r.Set("MIPCalibratorConfig",   fMIPCalibrator  ->GetConfig());
  r.Set("ThermometerConfig",     fThermometer  ->GetConfig());
  return r;
}

void Calibrator::PrintConfig(std::ostream& os) const
{
  // Printout of current configuration.
  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "TimeCalibrator:  " << GetConfig().GetCharString("TimeCalibrator") << endl;
  fTimeCalibrator->PrintConfig(os);

  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "PeCalibrator:    " << GetConfig().GetCharString("PeCalibrator") << endl;
  fPeCalibrator->PrintConfig(os);

  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "VALinCalibrator: " << GetConfig().GetCharString("VALinCalibrator") << endl;
  fVALinCalibrator->PrintConfig(os);

  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "DriftCalibrator: " << GetConfig().GetCharString("DriftCalibrator") << endl;
  fDriftCalibrator->PrintConfig(os);

  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "LinCalibrator:   " << GetConfig().GetCharString("LinCalibrator") << endl;
  fLinCalibrator->PrintConfig(os);
  
  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "StripCalibrator: " << GetConfig().GetCharString("StripCalibrator") << endl;
  fStripCalibrator->PrintConfig(os);

  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "AttenCalibrator: " << GetConfig().GetCharString("AttenCalibrator") << endl;
  fAttenCalibrator->PrintConfig(os);

  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "MIPCalibrator:   " << GetConfig().GetCharString("MIPCalibrator") << endl;
  fMIPCalibrator->PrintConfig(os);

  os << endl;
  os << "-----------------------------------------------------" << endl;
  os << "Thermometer:     " << GetConfig().GetCharString("Thermometer") << endl;
  fThermometer->PrintConfig(os);
}


void Calibrator::ConfigModified()
{
  
  const Registry& r = this->GetConfig();
  
  // First, create the Schema.
  SetScheme(fTimeCalibrator,   r.GetCharString("TimeCalibrator"));
  SetScheme(fPeCalibrator,     r.GetCharString("PeCalibrator"));
  SetScheme(fVALinCalibrator,  r.GetCharString("VALinCalibrator"));
  SetScheme(fDriftCalibrator,  r.GetCharString("DriftCalibrator"));
  SetScheme(fLinCalibrator,    r.GetCharString("LinCalibrator"));
  SetScheme(fStripCalibrator,  r.GetCharString("StripCalibrator"));
  SetScheme(fAttenCalibrator,  r.GetCharString("AttenCalibrator"));
  SetScheme(fMIPCalibrator,    r.GetCharString("MIPCalibrator"));
  SetScheme(fThermometer,      r.GetCharString("Thermometer"));

  // If we wanted to be good, we would now check that each scheme
  // implimented the routines we want. But that's a lot of work.
  
  // Now, merge in any configuration that we have.
  // The SubCalibrators hold the definative version of the configuration.
  // The main Calibrator object holds only _modifications_ to them.

  // Because of this, we now _delete_ any calibration we have after sending it on.
  ConfigScheme("TimeCalibratorConfig", fTimeCalibrator);
  ConfigScheme("PeCalibratorConfig",   fPeCalibrator);
  ConfigScheme("VALinCalibratorConfig",fVALinCalibrator);
  ConfigScheme("DriftCalibratorConfig",fDriftCalibrator);
  ConfigScheme("LinCalibratorConfig",  fLinCalibrator);
  ConfigScheme("StripCalibratorConfig",fStripCalibrator);
  ConfigScheme("AttenCalibratorConfig",fAttenCalibrator);
  ConfigScheme("MIPCalibratorConfig",  fMIPCalibrator); 
  ConfigScheme("ThermometerConfig",    fThermometer);

  // Make sure that all the calibrators have their contexts set:
  DoReset(GetContext());
}


void Calibrator::SetScheme(CalScheme* &scheme, const char* name)
{
  if(scheme) {
    // object exists. Is it the right kind?
    if(strcmp(scheme->GetName(),name)==0) {
      // It is. Do nothing.
      return;
    }
  }
  
  // Make a new one.
  CalScheme* newscheme = 0;
  assert(gROOT);

  TClass* theclass = gROOT->GetClass(name);
  if(!theclass) {
    MSG("Calib",Msg::kError) << "Calibrator: Unable to find requested Scheme: " << name << endl;
  } else {
    void* p = theclass->New();
    TObject* obj = (TObject*) p;
    newscheme = dynamic_cast<CalScheme*>(obj);
    if(!newscheme) {
      MSG("Calib",Msg::kError) << "Calibrator: " << name << " is not a CalScheme!" << endl;
    }
  }
  
  if(!newscheme) {
    if(!scheme) {
      MSG("Calib",Msg::kError) << " Cannot generate calibration scheme " << name 
                                    << " so I have to die! Sorry! ";
      assert(0);
    } else {
      MSG("Calib",Msg::kError) << " Cannot generate calibration scheme " << name 
                                    << " so I'll keep the old one: " << scheme->GetName() << endl;
      return;
    }
  }

  // All is well. Make the sucker.
  if(scheme) delete scheme;
  scheme = newscheme;
}


void Calibrator::ConfigScheme( const char* masterRegKey, CalScheme* scheme )
{

  Registry rs = GetConfig().GetRegistry(masterRegKey);

  if(rs.Size()<=0) return;
  scheme->Set(rs);
  
  Registry blank;
  Set(masterRegKey,blank);
}




// Constructor.

Calibrator::Calibrator() :
  fTimeCalibrator(0), 
  fPeCalibrator(0),
  fVALinCalibrator(0),
  fDriftCalibrator(0),
  fLinCalibrator(0),
  fStripCalibrator(0),
  fAttenCalibrator(0),
  fMIPCalibrator(0),
  fThermometer(0)
{
  // Use this to define global default. 
  //Load this from a file, like the AlgConfigs?
  Registry r;
  r.SetName("Calibrator");
  r.Set("TimeCalibrator", "PulserTimeCalScheme");
  r.Set("PeCalibrator",   "PEGainAggCalScheme");
  r.Set("VALinCalibrator","VaLinearityCalScheme");
  r.Set("DriftCalibrator","MuonDriftCalScheme");
  r.Set("LinCalibrator",  "PulserLinearityCalScheme");
  r.Set("StripCalibrator","StripToStripCalScheme");
  r.Set("AttenCalibrator","StripAttenCalScheme");
  r.Set("MIPCalibrator",  "MIPCalScheme");
  r.Set("Thermometer",    "TemperatureCalScheme");

  r.Set("TimeCalibratorConfig",Registry());
  r.Set("PeCalibratorConfig",Registry());
  r.Set("VALinCalibratorConfig",Registry());
  r.Set("DriftCalibratorConfig",Registry());
  r.Set("LinCalibratorConfig",Registry());
  r.Set("StripCalibratorConfig",Registry());
  r.Set("AttenCalibratorConfig",Registry());
  r.Set("MIPCalibratorConfig",Registry());
  r.Set("ThermometerConfig",Registry());
  InitializeConfig(r);
  
  for(int i=0;i<kNumberOfSchemeTypes; i++) {
    fCalibratorIsDirty[i]=1;
    fFracErrorHist[i] = 0;
    fErrorHist[i] = 0;
  }

  ResetEventStats();
  ResetHistograms();
}

// Destructor.

Calibrator::~Calibrator()
{ 
  cout << endl << "Calibrator shutting down." << endl;
  PrintErrorStats();
  if(fTimeCalibrator)  delete fTimeCalibrator;   fTimeCalibrator = 0;
  if(fPeCalibrator)    delete fPeCalibrator;     fPeCalibrator = 0;
  if(fVALinCalibrator) delete fVALinCalibrator;  fVALinCalibrator = 0;
  if(fDriftCalibrator) delete fDriftCalibrator;  fDriftCalibrator= 0;
  if(fLinCalibrator)   delete fLinCalibrator;    fLinCalibrator = 0;
  if(fStripCalibrator) delete fStripCalibrator;  fStripCalibrator = 0;
  if(fAttenCalibrator) delete fAttenCalibrator;  fAttenCalibrator = 0;
  if(fMIPCalibrator)   delete fMIPCalibrator;    fMIPCalibrator = 0;
  if(fThermometer)     delete fThermometer;      fThermometer = 0;

  for(int i=0; i<CalScheme::kNumberOfSchemeTypes; i++) {
    if(fErrorHist[i])     delete fErrorHist[i];
    if(fFracErrorHist[i]) delete fFracErrorHist[i];
  }
}


void Calibrator::ResetEventStats() 
{
  for(int i=0; i<CalScheme::kNumberOfSchemeTypes; i++) {
    fEventTotal[i].Set(0,0);
    fEventCalls[i] = 0;
  }
}

void Calibrator::ResetHistograms()
{
  for(int i=0; i<CalScheme::kNumberOfSchemeTypes; i++) {
   
    if(fErrorHist[i]) {
      fErrorHist[i]->Reset();
    } else {
      if(i==CalScheme::kTimeCalibrator) 
        fErrorHist[i] = new TH1F(Form("hError_%s",SchemeTypeName(i)),
                                 Form("Error, %s",SchemeTypeName(i)),
                                 500,0,100.*Munits::ns);
      else
        fErrorHist[i] = new TH1F(Form("hError_%s",SchemeTypeName(i)),
                                 Form("Error, %s",SchemeTypeName(i)),
                                 500,0,1e4);
      
      fErrorHist[i] -> SetXTitle(Form("Error per calibration (%s)",CalScheme::UnitName(i)));
      fErrorHist[i] -> SetYTitle("Number of calibrations");
    }
    fErrorHist[i] -> SetDirectory(0); // Make sure it's only memory-resident.
    
    if(fFracErrorHist[i]) {
      delete fFracErrorHist[i];
    } else {
      fFracErrorHist[i] = new TH1F(Form("hFracError_%s",SchemeTypeName(i)),
                                   Form("Fractional Error, %s",SchemeTypeName(i)),
                                   20,0,1.0);
      fFracErrorHist[i] -> SetXTitle("Fractional error");
      fFracErrorHist[i] -> SetYTitle("Number of calibrations");    
    }
    fFracErrorHist[i] -> SetDirectory(0); // Make sure it's only memory-resident.
    
  }
}

void Calibrator::PrintEventStats() const
{
  MSG("Calib",Msg::kInfo) << "Event statistics: ----------------------" << endl;
  
  for(int i=0; i<CalScheme::kNumberOfSchemeTypes; i++) {
    if(i==CalScheme::kUnknown) continue;
    else {
      MSG("Calib",Msg::kInfo) << Form("%16s | Total %8s: %10.1f +- %8.1f   Mean %8s: %6.1f +- %6.1f", 
                                      CalScheme::SchemeTypeName(i),
                                      CalScheme::UnitName(i),
                                      fEventTotal[i].GetValue(),
                                      fEventTotal[i].GetError(),
                                      CalScheme::UnitName(i),
                                      (fEventCalls[i]>0) ? 
                                        (fEventTotal[i]/fEventCalls[i]).GetValue()  : -1
                                      ,
                                      (fEventCalls[i]>0) ? 
                                         (fEventTotal[i]/fEventCalls[i]).GetError() : -1                                      
                                      )
                              << endl;
    }
  }
}

void Calibrator::DrawHistograms()
{
  static TCanvas* sCanvas1 = 0;
  if(!sCanvas1) sCanvas1 = new TCanvas("calCanvas1","Calibrator Summary 1");
  sCanvas1->cd();
  sCanvas1->Divide(2,4,0,0,kWhite);

  static TCanvas* sCanvas2 = 0;
  if(!sCanvas2) sCanvas2 = new TCanvas("calCanvas2","Calibrator Summary 2");
  sCanvas2->cd();
  sCanvas2->Divide(2,4,0,0,kWhite);

  int ipad = 0;
  int types[] = { CalScheme::kTimeCalibrator,
                  CalScheme::kVALinCalibrator,
                  CalScheme::kPeCalibrator,
                  CalScheme::kLinCalibrator,
                  CalScheme::kDriftCalibrator,
                  CalScheme::kStripCalibrator,
                  CalScheme::kAttenCalibrator,
                  CalScheme::kMIPCalibrator };

  for(int itype=0; itype<8; itype++) {
    int type = types[itype];

    ipad++;
    sCanvas1->cd(ipad);    
    fErrorHist[type]->Draw();
    sCanvas2->cd(ipad);    
    fFracErrorHist[type]->Draw();    
  }
}

---