SimpleCalScheme.cxx

Go to the documentation of this file.

#include "SimpleCalScheme.h"
#include "MessageService/MsgService.h"
#include "UgliGeometry/UgliGeomHandle.h"

CVSID("$Id: SimpleCalScheme.cxx,v 1.15 2007/03/01 17:35:34 rhatcher Exp $");
ClassImp(SimpleCalScheme)


SimpleCalScheme::SimpleCalScheme()
{

  // Defaults:
  Registry r;
  r.SetName(this->GetName());
  r.Set("defaultGainFD",60.0);
  r.Set("defaultGainND",100.0);
  r.Set("defaultDrift",1.0);
  r.Set("defaultLinearity",1.0);
  r.Set("defaultStripToStrip",1.0);
  r.Set("defaultAttenLength1",1.0);
  r.Set("defaultAttenLength2",7.0);
  r.Set("defaultAttenN1",0.3333);
  r.Set("defaultSigCorPerMip",750.);
  r.Set("defaultTemp",18.0);
  this->InitializeConfig(r);
}

SimpleCalScheme::~SimpleCalScheme()
{}
  
void SimpleCalScheme::ConfigModified()
{

  // This bit of deathless code is nice because
  // it typo-checks your config to ensure that the stuff above
  // matches the stuff here.  If something is missing or is not the right
  // type, it prints a warning message.
  bool ok = true;
  ok = ok && GetConfig().Get("defaultGainFD",fDefaultGainFD);
  ok = ok && GetConfig().Get("defaultGainND",fDefaultGainND);
  ok = ok && GetConfig().Get("defaultDrift",fDefaultDrift);
  ok = ok && GetConfig().Get("defaultLinearity",fDefaultLinearity);
  ok = ok && GetConfig().Get("defaultStripToStrip",fDefaultStripToStrip);
  ok = ok && GetConfig().Get("defaultAttenLength1",fDefaultAttenLength1);
  ok = ok && GetConfig().Get("defaultAttenLength2",fDefaultAttenLength2);
  ok = ok && GetConfig().Get("defaultAttenN1",fDefaultAttenN1);
  ok = ok && GetConfig().Get("defaultSigCorPerMip",fDefaultSigCorPerMip);
  ok = ok && GetConfig().Get("defaultTemp",fDefaultTemp);
  if(!ok) MSG("Calib",Msg::kError) << "Problem configuring SimpleCalScheme. Something's missing." << endl;
}



void SimpleCalScheme::DoReset( const VldContext& context )
{

  // People who recognize this example are obviously fellow victims of a liberal education.
  // --Nathaniel

  const char* grue;

  if(context.GetTimeStamp()>VldTimeStamp(2000,1,1,0,0,0,0)) grue = "blue";
  else grue="green";
}

// Calibration methods

DoubleErr  SimpleCalScheme::GetCalibratedTime(DoubleErr rawtime,      
                                             FloatErr ,
                                             const PlexStripEndId&) const
{
 
  return rawtime + DoubleErr(0,50*Munits::ns);
}
  
FloatErr   SimpleCalScheme::GetPhotoElectrons(FloatErr rawcharge, 
                                             const PlexStripEndId&) const
{

  // Should really look up in the plex to see what kind of channel it is.
  FloatErr res(rawcharge,rawcharge); // 100% error.

  if(GetContext().GetDetector()==Detector::kNear) {
    return res/=fDefaultGainND;
  }
  
  return res/=fDefaultGainFD;
}

FloatErr  SimpleCalScheme::GetLinearizedVA(FloatErr rawcharge, const RawChannelId&  ) const
{
 
  return FloatErr(rawcharge,rawcharge);
}


FloatErr   SimpleCalScheme::GetDriftCorrected(FloatErr rawcharge, 
                                             const PlexStripEndId& ) const
{
  FloatErr result = rawcharge/(float)fDefaultDrift;
  result.SetError(result.GetValue()); // 100% error;
  return result;
}

FloatErr   SimpleCalScheme::GetLinearized(FloatErr sigdrift,      
                                          const PlexStripEndId&) const
{
  FloatErr result = sigdrift/(float)fDefaultLinearity;
  result.SetError(result.GetValue()); // 100% error;
  return result;
}


FloatErr   SimpleCalScheme::GetStripToStripCorrected(FloatErr siglin,           
                                                    const PlexStripEndId&) const
{
  float result = siglin/(float)fDefaultStripToStrip;
  return FloatErr(result,result);
}

FloatErr   SimpleCalScheme::GetAttenCorrected(FloatErr sigcorr, 
                                             FloatErr stripX, 
                                             const PlexStripEndId& seid) const
{
  UgliGeomHandle ugli(GetContext());
  UgliStripHandle ustrip = ugli.GetStripHandle(seid);

  double halfgreen = ustrip.GetHalfLength() + ustrip.WlsPigtail(seid.GetEnd());
  double wlsLen = halfgreen;
  if(seid.GetEnd()==StripEnd::kPositive) wlsLen -= stripX;
  if(seid.GetEnd()==StripEnd::kNegative) wlsLen += stripX;
  // If not +ve or -ve, do nothing.

  // The correction is for the center of the strip to the new position
  // on the strip.
  
  float a = fDefaultAttenN1 * exp(-halfgreen/fDefaultAttenLength1)
    + (1.0 - fDefaultAttenN1)* exp(-halfgreen/fDefaultAttenLength2);

  float b = fDefaultAttenN1 * exp(-wlsLen/fDefaultAttenLength1)
    + (1.0 - fDefaultAttenN1)* exp(-wlsLen/fDefaultAttenLength2);

  if(b<=0) return FloatErr(sigcorr,sigcorr);
  return FloatErr(sigcorr * (a/b), sigcorr * (a/b));
}

FloatErr   SimpleCalScheme::GetMIP(FloatErr sigmap,     
                                  const PlexStripEndId&) const
{
  float result = sigmap/(float)fDefaultSigCorPerMip;
  return FloatErr(result,result);
}  

// Decalibration methods


DoubleErr  SimpleCalScheme::DecalTime(DoubleErr caltime,
                                     FloatErr ,
                                     const PlexStripEndId&) const
{
  return caltime;
}

void      SimpleCalScheme::DecalGainAndWidth(FloatErr& gain,
                                             FloatErr& width,
                                             const PlexStripEndId&) const
{
  if(GetContext().GetDetector()==Detector::kNear) {
    gain.Set(fDefaultGainND,fDefaultGainND);
    width.Set(fDefaultGainND* 0.5,fDefaultGainND* 0.5);
 } else {
    gain.Set(fDefaultGainFD);
    width.Set(fDefaultGainFD* 0.5,fDefaultGainFD* 0.5);
  }    
}

void      SimpleCalScheme::DecalGainAndWidth(FloatErr& gain,
                                             FloatErr& width,
                                             const PlexPixelSpotId& psid) const
{
  if(psid.GetElecType()==ElecType::kQIE) {
    gain.Set(fDefaultGainND,fDefaultGainND);
    width.Set(fDefaultGainND* 0.5,fDefaultGainND* 0.5);
 } else {
    gain.Set(fDefaultGainFD);
    width.Set(fDefaultGainFD* 0.5,fDefaultGainFD* 0.5);
  }    
}

FloatErr SimpleCalScheme::DecalVALinearity(FloatErr lincharge, const RawChannelId& ) const
{
  return lincharge;
}

FloatErr   SimpleCalScheme::DecalDrift(FloatErr undrifted,
                                      const PlexStripEndId&) const
{
  float result = undrifted*(float)fDefaultDrift;
  return FloatErr(result,result);
}

FloatErr   SimpleCalScheme::DecalLinearity(FloatErr lin,
                                          const PlexStripEndId&) const
{
  float result = lin*(float)fDefaultLinearity;
  return FloatErr(result,result);
}

FloatErr   SimpleCalScheme::DecalStripToStrip(FloatErr sigcorr,
                                             const PlexStripEndId&) const
{
  float result = sigcorr*(float)fDefaultStripToStrip;
  return FloatErr(result,result);
}

FloatErr   SimpleCalScheme::DecalAttenCorrected(FloatErr sigmap,
                                               FloatErr stripX,
                                               const PlexStripEndId& seid) const
{
  UgliGeomHandle ugli(GetContext());
  UgliStripHandle ustrip = ugli.GetStripHandle(seid);

  double halfgreen = ustrip.GetHalfLength() + ustrip.WlsPigtail(seid.GetEnd());
  double wlsLen = halfgreen;
  if(seid.GetEnd()==StripEnd::kPositive) wlsLen -= stripX;
  if(seid.GetEnd()==StripEnd::kNegative) wlsLen += stripX;
  // If not +ve or -ve, do nothing.

  // The correction is for the center of the strip to the new position
  // on the strip.
  
  float a = fDefaultAttenN1 * exp(-halfgreen/fDefaultAttenLength1)
    + (1.0 - fDefaultAttenN1)* exp(-halfgreen/fDefaultAttenLength2);

  float b = fDefaultAttenN1 * exp(-wlsLen/fDefaultAttenLength1)
    + (1.0 - fDefaultAttenN1)* exp(-wlsLen/fDefaultAttenLength2);

  if(a<=0) return FloatErr(sigmap,sigmap);
  return FloatErr(sigmap * (b/a),sigmap * (b/a));
}

FloatErr   SimpleCalScheme::DecalMIP(FloatErr sigmip,
                                    const PlexStripEndId&) const
{
  float result =  sigmip*(float)fDefaultSigCorPerMip;
  return FloatErr(result,result);
}


Float_t SimpleCalScheme::GetTemperature(Int_t) const
{
  return fDefaultTemp;
}

---