CalScheme.cxx

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.cxx,v 1.9 2005/03/22 12:22:14 tagg Exp $

#include "CalScheme.h"
#include "MessageService/MsgService.h"
#include <cassert>
#include <iostream>

CVSID( " $Id: CalScheme.cxx,v 1.9 2005/03/22 12:22:14 tagg Exp $ ");
ClassImp(CalScheme)

Int_t CalScheme::fsCalls[kNumberOfSchemeTypes]= {0};
Int_t CalScheme::fsErrors[kNumberOfSchemeTypes][kNumberOfErrorTypes] = {{0},{0}};
std::map<GenericThingId,int> CalScheme::fsChannelErrors;

std::ostream& operator<<(std::ostream& os, const CalScheme& s)
{ 
  s.PrintConfig(os);
  return os;
}

CalScheme::CalScheme() : fContext()
{
}

CalScheme::~CalScheme()
{
}

// Calibration methods

DoubleErr CalScheme::GetCalibratedTime(DoubleErr ,   FloatErr,    const PlexStripEndId& ) const
{
 Unimplimented(); 
 return 0; 
}

FloatErr  CalScheme::GetPhotoElectrons(FloatErr, const PlexStripEndId& ) const
{
 
 Unimplimented(); return 0; 
}

FloatErr  CalScheme::GetLinearizedVA(FloatErr, const RawChannelId& ) const
{
 
 Unimplimented(); return 0; 
}


FloatErr  CalScheme::GetDriftCorrected(FloatErr, const PlexStripEndId& ) const
{
 Unimplimented(); return 0; 
}

FloatErr  CalScheme::GetLinearized(FloatErr, const PlexStripEndId& ) const
{
 Unimplimented(); return 0; 
}

FloatErr  CalScheme::GetStripToStripCorrected(FloatErr, const PlexStripEndId& ) const
{
 Unimplimented(); return 0; 
}

FloatErr  CalScheme::GetAttenCorrected(FloatErr, FloatErr, const PlexStripEndId& ) const
{

 Unimplimented(); return 0; 
}

FloatErr  CalScheme::GetMIP(FloatErr,                        const PlexStripEndId&) const
{
 Unimplimented(); return 0; 
}

// Decalibration methods


DoubleErr CalScheme::DecalTime(DoubleErr , FloatErr ,    const PlexStripEndId& ) const
{
  Unimplimented(); return 0; 
}

void CalScheme::DecalGainAndWidth(FloatErr& , FloatErr& , const PlexStripEndId& ) const
{
  Unimplimented(); return; 
}

void CalScheme::DecalGainAndWidth(FloatErr& , FloatErr& , const PlexPixelSpotId& ) const
{
  Unimplimented(); return; 
}

FloatErr CalScheme::DecalVALinearity(FloatErr , const RawChannelId& ) const
{
  Unimplimented(); return 0; 
}

FloatErr CalScheme::DecalDrift(FloatErr ,                    const PlexStripEndId& ) const
{
 Unimplimented(); return 0; 
}

FloatErr CalScheme::DecalLinearity(FloatErr ,                      const PlexStripEndId& ) const
{
 
  Unimplimented(); return 0; 
}

FloatErr CalScheme::DecalStripToStrip(FloatErr ,               const PlexStripEndId& ) const
{

 Unimplimented(); return 0; 
}

FloatErr CalScheme::DecalAttenCorrected(FloatErr , FloatErr,  const PlexStripEndId& ) const
{
  
 Unimplimented(); return 0; 
}

FloatErr CalScheme::DecalMIP(FloatErr ,                         const PlexStripEndId& ) const
{
  
 Unimplimented(); return 0; 
}

// Other.
Float_t CalScheme::GetTemperature(Int_t ) const
{
  Unimplimented(); return 0;
}



// Override this method to do context reshuffle.
void CalScheme::Reset( const VldContext& context, Bool_t force)
{

  // Only perform actions if this context is a ligit one. Otherwise, don't bother
  // spamming with DB messages.
  if(context.IsValid()) {

    // Only perform actions if the context changes. Otherwise, don't
    // bother.
    if( (fContext!=context) || (force) ) {
      MSG("Calib",Msg::kVerbose) << "Resetting " << this->GetName() << "  " << context.AsString() << endl;
      fContext = context;
      this->DoReset(context);
    }
  }
}



void  CalScheme::Unimplimented() const
{
  MSG("Calib",Msg::kFatal) << this->GetName() << " called with unimplimented function. " << endl
                           << "Calibrator is not set up correctly!" << endl;
  assert(0);
}


void CalScheme::ResetStatistics()
{
  for(int i=0;i<kNumberOfSchemeTypes;i++) {
    fsCalls[i] = 0;
    for(int j=0;j<kNumberOfErrorTypes;j++)
      fsErrors[i][j] = 0;
  }
  fsChannelErrors.clear();
}

void CalScheme::IncrementErrors(SchemeType_t i, 
                                ErrorType_t j)
{

  // Mod the values by the max value to prevent buffer overflows.

  fsErrors[i % kNumberOfSchemeTypes][j % kNumberOfErrorTypes]++;
}

void CalScheme::IncrementErrors(SchemeType_t i, 
                                ErrorType_t j,
                                const GenericThingId& id)
{

  // Mod the values by the max value to prevent buffer overflows.
  IncrementErrors(i,j);
  fsChannelErrors[id]++;
}


void CalScheme::IncrementErrors(SchemeType_t i, ErrorType_t j,
                                Int_t c)
{
  IncrementErrors(i,j,GenericThingId(c));
}

void CalScheme::IncrementErrors(SchemeType_t i, ErrorType_t j,
                                const PlexStripEndId& c)
{
  IncrementErrors(i,j,GenericThingId(c));
}

void CalScheme::IncrementErrors(SchemeType_t i, ErrorType_t j,
                                const RawChannelId& c)
{
  IncrementErrors(i,j,GenericThingId(c));
}

void CalScheme::IncrementErrors(SchemeType_t i, ErrorType_t j,
                                const PlexPixelSpotId& c)
{
  IncrementErrors(i,j,GenericThingId(c));
}

void CalScheme::IncrementErrors(SchemeType_t i, ErrorType_t j,
                                const PlexLedId& c)
{
  IncrementErrors(i,j,GenericThingId(c));
}


void CalScheme::IncrementCalls(SchemeType_t i)                          
{

  // Mod by the max value to prevent buffer overflows.
  fsCalls[i % kNumberOfSchemeTypes]++;
}



void CalScheme::PrintErrorStats( std::ostream& os ) const
{
  os << "Calibrator Errors Statistics:" << endl;
  os << Form("%20s %10s ||%10s|%10s|%10s|%10s|%10s|%10s\n",
             "Calibrator","Calls","General","Miss Table","Miss Row","FP Error","Insuf.Data","Bad Input");
  for(int type = 0; type < kNumberOfSchemeTypes; type ++) {
    os << Form("%20s %10d || %8d | %8d | %8d | %8d | %8d | %8d\n",
               SchemeTypeName((SchemeType_t)type),
               fsCalls[type], 
               fsErrors[type][kGeneralErr],
               fsErrors[type][kMissingTable],
               fsErrors[type][kMissingRow],
               fsErrors[type][kFPE],
               fsErrors[type][kDataInsufficient],
               fsErrors[type][kBadInput]);
  }
  // Print out channel errors.
  // This bit of arcane code basically does an
  // insertion sort on the number of errors generated
  // in order to figure out which channels have generated
  // the most errors.

  os << "Channels with the most errors: " << endl;
  std::multimap<int,GenericThingId> sortedChannels;
  std::map<GenericThingId,int>::iterator it;
  for(it = fsChannelErrors.begin(); it!= fsChannelErrors.end(); it++) {
    sortedChannels.insert(std::pair<int,GenericThingId>(-(it->second),it->first));
  }

  std::multimap<int,GenericThingId>::iterator it2;
  it2 = sortedChannels.begin();
  int i=0;
  while((i<10) && (it2!=sortedChannels.end())) {
    os << "Errors: " << Form("%8d",-(it2->first)) << "  " << (it2->second).AsString() << endl;
    it2++; i++;
  }
}


// Override this to print out your configuration.
// Default does something sensible, but not very good.
void  CalScheme::PrintConfig(std::ostream &os) const
{
  os << "Generic CalScheme PrintConfig()" <<endl;
  const Registry& r = this->GetConfig();
  r.PrettyPrint(os);
}


// I/O wrappers.
void CalScheme::PrintConfig( MsgStream& ms ) const
{
  stringstream oss;
  PrintConfig(oss);
  ms << oss.str();
}

void CalScheme::PrintConfig() const
{
  PrintConfig(*(MsgService::Instance()->GetStream("Calib")));
}


void CalScheme::PrintErrorStats( MsgStream& ms ) const
{
  stringstream oss;
  PrintErrorStats(oss);
  ms << oss.str();
}

void CalScheme::PrintErrorStats() const
{
  PrintErrorStats(*(MsgService::Instance()->GetStream("Calib")));
}

---