PEGainAggCalScheme.cxx

Go to the documentation of this file.

// $Id: PEGainAggCalScheme.cxx,v 1.2 2007/04/24 18:32:18 tagg Exp $
//
// PE gain Calibrator class.
// The new version uses Minsuk's aggregated tables
//
// tagg@minos.phy.tufts.edu
#include "PEGainAggCalScheme.h"
#include "MessageService/MsgService.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexStripEndId.h"
#include "DatabaseInterface/DbiResultKey.h"

ClassImp(PEGainAggCalScheme)
CVSID("$Id: PEGainAggCalScheme.cxx,v 1.2 2007/04/24 18:32:18 tagg Exp $");

//......................................................................
PEGainAggCalScheme::PEGainAggCalScheme() :
  fDefaultRowQIE(0),
  fDefaultRowVA(0)
{
  Registry r;
  r.Set("GuessOtherSpots",1);
  r.Set("GuessOtherPixels",1);
  r.Set("DefaultGainVA",60.);
  r.Set("DefaultGainQIE",100.);
  r.Set("DefaultWidthVA",30.);
  r.Set("DefaultWidthQIE",50.);
  r.Set("TuneGainFactor",1.0);
  r.Set("UseCache",1);
  r.Set("UseLinearized",1);
  InitializeConfig(r);
  
  fLastKey= new DbiResultKey(fResPtr.GetKey());
}

PEGainAggCalScheme::~PEGainAggCalScheme()
{
  ResetCache(); 
  if(fDefaultRowQIE) delete fDefaultRowQIE; fDefaultRowQIE = 0;
  if(fDefaultRowVA ) delete fDefaultRowVA;  fDefaultRowVA= 0;
}


void PEGainAggCalScheme::ResetCache()
{
  // Deletes and wipes any cached info.
  fSpotCache.clear();
  fStripCache.clear();
  for(UInt_t i=0;i<fCacheStorage.size();i++) {
    delete fCacheStorage[i];
  }
  fCacheStorage.clear();

}

//......................................................................
void PEGainAggCalScheme::DoReset( const VldContext& context )
{
  Int_t task = 0;
  if(fUseLinearized && context.GetDetector()==Detector::kNear) task = 1;

  fResPtr.NewQuery(context,task);  
  if(fResPtr.GetNumRows()==0) {
    MAXMSG("Calib",Msg::kWarning,10) 
      << "PEGainAggCalScheme: No rows in database table with validity context "
      << context.AsString() << "  No calibration will be applied." << endl;
    IncrementErrors(kPeCalibrator,kMissingTable);
  }  


  if(fUseCache) {
    const DbiResultKey* newKey = fResPtr.GetKey();
    
    if(fLastKey!=0) 
      if(!(fLastKey->IsEqualTo(newKey) ) ) ResetCache(); 
    
    if(fLastKey) delete fLastKey;
    fLastKey = new DbiResultKey(newKey);
  } else {
    // Not using cache.
    ResetCache(); // Do it every time.
  }
  

  
}

//......................................................................
void PEGainAggCalScheme::ConfigModified()
{
  bool ok = true;
  ok = ok && GetConfig().Get("GuessOtherSpots",fGuessOtherSpots);
  ok = ok && GetConfig().Get("GuessOtherPixels",fGuessOtherPixels);
  ok = ok && GetConfig().Get("DefaultGainVA",fDefaultGainVA);
  ok = ok && GetConfig().Get("DefaultGainQIE",fDefaultGainQIE);
  ok = ok && GetConfig().Get("DefaultWidthVA",fDefaultWidthVA);
  ok = ok && GetConfig().Get("DefaultWidthQIE",fDefaultWidthQIE);
  ok = ok && GetConfig().Get("TuneGainFactor",fTuneGainFactor);
  ok = ok && GetConfig().Get("UseCache",fUseCache);
  ok = ok && GetConfig().Get("UseLinearized",fUseLinearized);
  
  if(!ok) MSG("Calib",Msg::kWarning) << "PEGainAggCalScheme couldn't configure properly!" << endl;

  if(fDefaultRowQIE) delete fDefaultRowQIE; fDefaultRowQIE = 0;
  if(fDefaultRowVA ) delete fDefaultRowVA;  fDefaultRowVA= 0;

  // 50% error on gains:
  fDefaultRowQIE = new CalADCtoPEs(0,0,fDefaultGainQIE,fDefaultGainQIE*0.5, fDefaultWidthQIE, fDefaultWidthQIE*0.3);
  fDefaultRowVA  = new CalADCtoPEs(0,0,fDefaultGainVA ,fDefaultGainVA*0.5,  fDefaultWidthVA,  fDefaultWidthVA*0.3 );

  if(fTuneGainFactor!=1.0) 
    MSG("Calib",Msg::kWarning) << "-- WARNING -- TuneGainFactor is set to " << fTuneGainFactor
                               << "  This is for calibration study only and should not be used for analysis!"
                               << std::endl;
  
}

//......................................................................
void PEGainAggCalScheme::PrintConfig( std::ostream& os ) const
{
  if(fUseLinearized)
    os << "  Will use linearity-corrected tables for the ND" << endl;
  
  if(fGuessOtherSpots) 
    os << "  Will attempt to guess unknown gains from neighboring spots." << endl;
  if(fGuessOtherPixels) 
    os << "  Will attempt to guess unknown gains from neighboring pixels." << endl;

  os << "  Default Gain (VA)   = " << fDefaultGainVA <<  " ADCs " << endl;
  os << "  Default Gain (QIE)  = " << fDefaultGainQIE <<  " ADCs " << endl;
  os << "  Default Width (VA)  = " << fDefaultWidthVA <<  " ADCs " << endl;
  os << "  Default Width (QIE) = " << fDefaultWidthQIE <<  " ADCs " << endl;
}




//......................................................................
FloatErr PEGainAggCalScheme::GetPhotoElectrons(FloatErr rawcharge, 
                                            const PlexStripEndId& seid) const
{

  const CalADCtoPEs* row = GetRow(seid);

  return rawcharge / FloatErr(row->GetGain() * fTuneGainFactor,
                              row->GetGainErr() );
}

//......................................................................
void    PEGainAggCalScheme::DecalGainAndWidth(FloatErr& gain, FloatErr& width,    
                                           const PlexStripEndId& seid) const
{

  
  const CalADCtoPEs* row = GetRow(seid);
  
  gain.Set(row->GetGain() * fTuneGainFactor,
           row->GetGainErr());
  width = row->GetSPEWidth() * fTuneGainFactor;
  // Protect against bad values:
  if(width<=0) width = gain*(float)0.5; 
}


//......................................................................
void    PEGainAggCalScheme::DecalGainAndWidth(FloatErr& gain, FloatErr& width,    
                                           const PlexPixelSpotId& psid) const
{

  const CalADCtoPEs* row = GetRow(psid);
  
  gain.Set(row->GetGain() * fTuneGainFactor,
           row->GetGainErr());
  width = row->GetSPEWidth() * fTuneGainFactor;
  // Protect against bad values:
  if(width<=0) width = gain*(float)0.5; 
}


Bool_t PEGainAggCalScheme::RowIsGood(const CalADCtoPEs* row) const
{
  if(!row) return false;
  if(row->GetGain() <= 0.0) return false;
  return true;
}




const CalADCtoPEs* PEGainAggCalScheme::GuessGainAndWidth( const PlexPixelSpotId& psid) const
{                                               

  CalADCtoPEs* output = fDefaultRowVA;
  
  if(!psid.IsValid()) {
    MAXMSG("Calib",Msg::kWarning,20) << "Attempted to find gain on invalid pixel. Return VA defaults." << endl;
    return output;
    if(GetContext().GetDetector()==Detector::kNear)  return fDefaultRowQIE;
    else                                             return fDefaultRowVA;
  }

  if(fGuessOtherSpots) {
    // Find the average gain from other spots on this pixel.

    double gaintot=0;
    double widthtot=0;
    double pixtot=0;

    PlexHandle plex(GetContext());
    for(int spot=0;spot<65;spot++) {
      PlexPixelSpotId trialspot = psid;
      trialspot.SetSpot(spot);
      PlexStripEndId seid = plex.GetStripEndId(psid);
      if(seid.IsValid()) {
        const CalADCtoPEs* row = fResPtr.GetRowByIndex(seid.BuildPlnStripEndKey());
        if(row) {
          pixtot+=1;
          gaintot+=row->GetGain();
          widthtot+=row->GetSPEWidth();
        }
      }
    }
    if(pixtot>0) {
      double gain = gaintot/pixtot;
      double width= widthtot/pixtot;
      output = new CalADCtoPEs(0,0,0, gain, gain*0.1, width); // Assume 10% error on gain.
      fCacheStorage.push_back(output);
      return output;
    }

  }

  if(fGuessOtherPixels) {
    // Find the average gain of the next and previous pixel numbers.

    double gaintot=0;
    double widthtot=0;
    double pixtot=0;
    PlexHandle plex(GetContext());

    for(int pixel=psid.GetPixel()-1; pixel<psid.GetPixel()+1; pixel+=2) {
      PlexPixelSpotId trialspot = psid;
      trialspot.SetPixel(pixel);
      PlexStripEndId seid = plex.GetStripEndId(psid);
      if(seid.IsValid()) {
        const CalADCtoPEs* row = fResPtr.GetRowByIndex(seid.BuildPlnStripEndKey());
        if(row) {
          pixtot+=1;
          gaintot+=row->GetGain();
          widthtot+=row->GetSPEWidth();
        }
      }
    }
    if(pixtot>0) {
      double gain = gaintot/pixtot;
      double width= widthtot/pixtot;
      output = new CalADCtoPEs(0,0,0, gain, gain*0.2, width); // Assume 20% error on gain.
      fCacheStorage.push_back(output);
      return output;
    }
    
  }
  

  // Ok, that didn't work. Try returning the defaults.
  if(psid.GetElecType()==ElecType::kQIE) {
    return fDefaultRowQIE;
  }
  if(psid.GetElecType()==ElecType::kVA) {
    return fDefaultRowVA;
  }

  IncrementErrors(kPeCalibrator,kGeneralErr);
  MSG("Calib",Msg::kError) << "Unknown electronics type on pixel " << psid << endl;
  
  if(GetContext().GetDetector()==Detector::kNear)  return fDefaultRowQIE;
  return fDefaultRowVA;
}


const CalADCtoPEs* PEGainAggCalScheme::GetRow(const PlexStripEndId& seid) const
{
  //
  // Look for the info in the cache, look for the gain in the DB,
  // or attempt to reconstruct the gain from the DB if it's not there.
  //
  
  if(!seid.IsValid()) {
    MAXMSG("Calib",Msg::kWarning,10) 
      << "PEGainAggCalScheme: Requested stripend " << seid.AsString() << " is invalid. \n";    
    IncrementErrors(kPeCalibrator,kBadInput,seid);    
    if(GetContext().GetDetector()==Detector::kNear) return fDefaultRowQIE;
    else                                                return fDefaultRowVA;
  } 

  if(fUseCache) {
    StripCache_t::iterator it = fStripCache.find(seid);
    if(it != fStripCache.end()) return it->second;
    
    // Look up the data. Cache it if it's good and return.
    PlexHandle plex(GetContext());
    PlexPixelSpotId psid = plex.GetPixelSpotId(seid);
  
    const CalADCtoPEs* row = fResPtr.GetRowByIndex(seid.BuildPlnStripEndKey());
    if(RowIsGood(row)) {
      fStripCache[seid] = row;
      fSpotCache[psid] = row;
      return row;
    };
    
    // The DB data isn't good.
    if(fResPtr.GetNumRows()>0) {
      MAXMSG("Calib",Msg::kWarning,10) 
        << "PEGainAggCalScheme: No database row for StripEnd " << seid.AsString() << "\n";    
      IncrementErrors(kPeCalibrator,kMissingRow,seid);
    }
    
    
    // Fallback: make a guess.
    const CalADCtoPEs* newrow = GuessGainAndWidth(psid);
    fStripCache[seid] = newrow;
    fSpotCache[psid] = newrow;
    
    return newrow;

  } else {
    // NOT using the cache

    // Look up the data. Cache it if it's good and return.
    PlexHandle plex(GetContext());
    PlexPixelSpotId psid = plex.GetPixelSpotId(seid);

    const CalADCtoPEs* row = fResPtr.GetRowByIndex(seid.BuildPlnStripEndKey());
    if(RowIsGood(row)) {
      return row;
    }    
    // The DB data isn't good.
    if(fResPtr.GetNumRows()>0) {
      MAXMSG("Calib",Msg::kWarning,10) 
        << "PEGainAggCalScheme: No database row for StripEnd " << seid.AsString() << "\n";    
    IncrementErrors(kPeCalibrator,kMissingRow,seid);
    }
    
    // Fallback: make a guess.
    const CalADCtoPEs* guess = GuessGainAndWidth(psid);
    return guess;

  }

  return NULL;
}

const CalADCtoPEs* PEGainAggCalScheme::GetRow(const PlexPixelSpotId& psid) const
{
   //
  // Look for the info in the cache, look for the gain in the DB,
  // or attempt to reconstruct the gain from the DB if it's not there.
  //
  if(! psid.IsValid()) {
    //MAXMSG("Calib",Msg::kWarning,10) 
    //  << "PEGainAggCalScheme: Requested pixelspot " << psid.AsString() << " is invalid. \n";    
    IncrementErrors(kPeCalibrator,kBadInput,psid);    
    if(GetContext().GetDetector()==Detector::kNear) return fDefaultRowQIE;
    else                                            return fDefaultRowVA;
  }

  if(fUseCache) {

    SpotCache_t::iterator it = fSpotCache.find(psid);
    if(it != fSpotCache.end()) return it->second;
    
    // Look up the data. Cache it if it's good and return.
    PlexHandle plex(GetContext());
    PlexStripEndId seid = plex.GetStripEndId(psid);
    
    const CalADCtoPEs* row = fResPtr.GetRowByIndex(seid.BuildPlnStripEndKey());
    if(RowIsGood(row)) {
      fSpotCache[psid] = row;
      fStripCache[seid] = row;
      return row;
    };
    
    // The DB data isn't good.
    if(fResPtr.GetNumRows()>0) {
      MAXMSG("Calib",Msg::kWarning,10) 
        << "PEGainAggCalScheme: No database row for StripEnd " << seid.AsString() << "\n";    
      IncrementErrors(kPeCalibrator,kMissingRow,seid);
    }
    
    const CalADCtoPEs* newrow = GuessGainAndWidth(psid);
    fStripCache[seid] = newrow;
    fSpotCache[psid] = newrow;
    
    return newrow;
  } else {
    // Look up the data. Cache it if it's good and return.
    PlexHandle plex(GetContext());
    PlexStripEndId seid = plex.GetStripEndId(psid);
    
    const CalADCtoPEs* row = fResPtr.GetRowByIndex(seid.BuildPlnStripEndKey());
    if(RowIsGood(row))  return row;

    // The DB data isn't good.
    if(fResPtr.GetNumRows()>0) {
      MAXMSG("Calib",Msg::kWarning,10) 
        << "PEGainAggCalScheme: No database row for StripEnd " << seid.AsString() << "\n";    
      IncrementErrors(kPeCalibrator,kMissingRow,seid);
    }
    
    const CalADCtoPEs* guess = GuessGainAndWidth(psid);    
    return guess;
  }

  return NULL;
}

---