CalVaLinearity Class Reference

#include <CalVaLinearity.h>

Inheritance diagram for CalVaLinearity:

List of all members.

Public Member Functions
	CalVaLinearity ()
	CalVaLinearity (const RawChannelId &rcid, Float_t param[kPMAX])
	CalVaLinearity (UInt_t index, Float_t param[kPMAX])
	CalVaLinearity (const RawChannelId &rcid, Double_t p0=0, Double_t p1=0, Double_t p2=0, Double_t p3=0, Double_t p4=0)
virtual	~CalVaLinearity ()
Bool_t	CanL2Cache () const
UInt_t	GetIndex (UInt_t) const
void	GetParam (Double_t p[kPMAX]) const
RawChannelId	GetRawChannelId () const
UInt_t	GetVAChannel () const
Double_t	Linearize (const Double_t adc) const
Double_t	UnLinearize (const Double_t linearAdc) const
virtual DbiTableRow *	CreateTableRow () const
virtual void	Fill (DbiResultSet &rs, const DbiValidityRec *vrec)
virtual void	Store (DbiOutRowStream &ors, const DbiValidityRec *vrec) const
Static Public Member Functions
Double_t	FitFunction (Double_t *arg, Double_t *par)
UInt_t	Rcid2Index (const RawChannelId &rcid)
RawChannelId	Index2Rcid (Int_t index)
Private Types
enum	{ kPMAX = 8 }
Private Member Functions
	CalVaLinearity (const CalVaLinearity &from)
Static Private Member Functions
Int_t	CheckParameters (Double_t *par)
Double_t	Pole (Double_t x, Double_t k1, Double_t k2, Double_t sign)
Private Attributes
Double_t	fParam [kPMAX]
UInt_t	fVAChannel

---

Member Enumeration Documentation

anonymous enum [private]

Enumeration values: kPMAX  Definition at line 25 of file CalVaLinearity.h. { kPMAX = 8 }; // Total number of parameters to fit function

---

Constructor & Destructor Documentation

CalVaLinearity::CalVaLinearity (   )  [inline]

Definition at line 29 of file CalVaLinearity.h. { LEA_CTOR; }

CalVaLinearity::CalVaLinearity (  const RawChannelId &  rcid, Float_t  param[kPMAX] )  [inline]

Definition at line 30 of file CalVaLinearity.h. References fParam, fVAChannel, and Rcid2Index(). { fVAChannel = Rcid2Index(rcid); for (int i=0; i<kPMAX; i++) fParam[i] = param[i]; LEA_CTOR; }

CalVaLinearity::CalVaLinearity (  UInt_t  index, Float_t  param[kPMAX] )  [inline]

Definition at line 36 of file CalVaLinearity.h. References fParam, and fVAChannel. { fVAChannel = index; for (int i=0; i<kPMAX; i++) fParam[i] = param[i]; LEA_CTOR; }

CalVaLinearity::CalVaLinearity (  const RawChannelId &  rcid, Double_t  p0 = 0, Double_t  p1 = 0, Double_t  p2 = 0, Double_t  p3 = 0, Double_t  p4 = 0 )  [inline]

Definition at line 42 of file CalVaLinearity.h. References fParam, fVAChannel, and Rcid2Index(). { fVAChannel = Rcid2Index(rcid); fParam[0]=p0; fParam[1]=p1; fParam[2]=p2; fParam[3]=p3; fParam[4]=p4; LEA_CTOR; }

virtual CalVaLinearity::~CalVaLinearity (   )  [inline, virtual]

Definition at line 49 of file CalVaLinearity.h. { LEA_DTOR; };

CalVaLinearity::CalVaLinearity (  const CalVaLinearity &  from  )  [inline, private]

Definition at line 76 of file CalVaLinearity.h. : DbiTableRow(from) { LEA_CTOR; *this = from; }

---

Member Function Documentation

Bool_t CalVaLinearity::CanL2Cache (   )  const [inline, virtual]

Reimplemented from DbiTableRow. Definition at line 52 of file CalVaLinearity.h. { return kTRUE; }

Int_t CalVaLinearity::CheckParameters (  Double_t *  par  )  [static, private]

virtual DbiTableRow* CalVaLinearity::CreateTableRow (   )  const [inline, virtual]

Implements DbiTableRow. Definition at line 61 of file CalVaLinearity.h. { return new CalVaLinearity; }

void CalVaLinearity::Fill (  DbiResultSet &  rs, const DbiValidityRec *  vrec )  [virtual]

Implements DbiTableRow. Definition at line 71 of file CalVaLinearity.cxx. References DbiRowStream::CurColName(), fParam, fVAChannel, DbiRowStream::HasRowCounter(), DbiRowStream::IncrementCurCol(), MSG, DbiRowStream::NumCols(), and DbiRowStream::TableName(). { // Purpose: Fill object from Result Set // // Arguments: // rs in Result Set used to fill object // vrec in Associated validity record (or 0 if filling // DbiValidityRec) // o Fill object from current row of Result Set. // Program Notes // Following the template from which this was copied, this method demonstrates // both the "dumb" fill method (just load the data as it comes) and the smart // method (check column name and load according to column order). The smart method // has been 'enhanced' to include a check that all the columns got filled. It will // go kFatal if we don't because we are heading for a divide by zero if some are // incorrect. if ( rs.TableName() == "CALVALINEARITY" ) { // Dumb method. rs >> fVAChannel >> fParam[0] >> fParam[1] >> fParam[2] >> fParam[3] >> fParam[4] >> fParam[5]; fParam[6] = 0.; fParam[7] = 1.; } else { // Smart method Int_t numCol = rs.NumCols(); fVAChannel = 0; // The first column (SeqNo) has already been processed. for (Int_t curCol = rs.HasRowCounter() ? 3 : 2; curCol <= numCol; ++curCol) { string colName = rs.CurColName(); if ( colName == "VACHANNEL" ) rs >> fVAChannel; else if( colName == "FSEL" ) rs >> fParam[0]; else if( colName == "PARAM1" ) rs >> fParam[1]; else if( colName == "PARAM2" ) rs >> fParam[2]; else if( colName == "PARAM3" ) rs >> fParam[3]; else if( colName == "PARAM4" ) rs >> fParam[4]; else if( colName == "PARAM5" ) rs >> fParam[5]; else { MSG("Dbi",Msg::kDebug) << "Ignoring column " << curCol << "(" << colName << ")" << "; not part of CalVaLinearity" << endl; rs.IncrementCurCol(); } // colname if } // for } // if/else }

Double_t CalVaLinearity::FitFunction (  Double_t *  arg, Double_t *  par )  [static]

Definition at line 162 of file CalVaLinearity.cxx. References Pole(). Referenced by PulserGainFit::Fit(), PulserLinearityCalScheme::GetCorrected(), Linearize(), PulserGainFit::RunNearFarFits(), and UnLinearize(). { // Static function to fit linearity response of PIN channels // This is used by the VALinearityConstantMaker package // as well as the Calibrator package. double x = *arg; double dtype = par[0]; int type = static_cast<int>(dtype+0.1); double k1 = par[1]; double k2 = par[2]; double k3 = par[3]; double k4 = par[4]; // double k5 = par[5]; double ped = par[6]; double gain = par[7]; // ************************************************************************** // **** Pole with adjustable power and one variable high end pole kicker **** // ************************************************************************** if (x < 0.1) return x; // Do not linearise negative values if (type == 24) { double x1 = x; x1 = ped + x1 * gain ; x1 = Pole(x1,k1,k2,-1.); if ((x1-k3) > 0) { // High end kicker function x1 = (x1 - k3)/(1. - (x1-k3)/k4) + k3; } return x1; } else if (type == 25) { // Non-inverted function double x1 = x; if ((x1-k3) > 0) { // High end kicker function x1 = (x1 - k3)/(1. + (x1-k3)/k4) + k3; } x1 = Pole(x1,k1,k2,+1.); x1 = (x1-ped)/gain ; return x1; } // ************************************************************************** // Pole with adjustable power, no kicker // ************************************************************************** else if (type == 4) { double x1 = x; x1 = ped + x1 * gain ; x1 = Pole(x1,k1,k2,-1.); return x1; } else if (type == 5) { // Non-inverted function double x1 = x; x1 = Pole(x1,k1,k2,+1.); x1 = (x1-ped)/gain ; return x1; // printf("f %g %g %g %g\n",result,x,k1,k2); } // ************************************************************************** // Straight line conversion (used for fitting, not for linearization) // ************************************************************************** else if (type == 0) { return ped + x * gain ; } else if (type == 1) { return (x-ped)/gain; } // ************************************************************************** // Remedial functions // ************************************************************************** else if (type == 10) { return x; // Straight line y = x function } else if (type == 12) { return 0.; // Dead channel function } else if (type == 14) { return k1; // Saturated on main Pole } else if (type == 16) { return 1.e7; // Infinity } return x; // Default (last resort) is to return y=x function }

UInt_t CalVaLinearity::GetIndex (  UInt_t   )  const [inline, virtual]

Reimplemented from DbiTableRow. Definition at line 53 of file CalVaLinearity.h. { return fVAChannel; }

void CalVaLinearity::GetParam (  Double_t  p[kPMAX]  )  const [inline]

Definition at line 54 of file CalVaLinearity.h. References fParam. { for (int i=0; i<kPMAX; i++) p[i] = fParam[i]; }

RawChannelId CalVaLinearity::GetRawChannelId (   )  const [inline]

Definition at line 56 of file CalVaLinearity.h. References fVAChannel, and Index2Rcid(). { return Index2Rcid(fVAChannel); }

UInt_t CalVaLinearity::GetVAChannel (   )  const [inline]

Definition at line 57 of file CalVaLinearity.h. { return fVAChannel; }

RawChannelId CalVaLinearity::Index2Rcid (  Int_t  index  )  [static]

Definition at line 146 of file CalVaLinearity.cxx. Referenced by GetRawChannelId(). { // This static function produces a RawChannelId object from a channel index // The pedmode, sparsemode, commonmode bits are set to zero (by default) UInt_t crate = (index>>24)&0xf; UInt_t varc = (index>>20)&0xf; UInt_t vmm = (index>>16)&0xf; UInt_t vfb = (index>>12)&0xf; UInt_t va = (index>> 8)&0xf; UInt_t ch = (index>> 0)&0xff; return RawChannelId(Detector::kFar ,ElecType::kVA ,crate,varc,vmm,vfb,va,ch); }

Double_t CalVaLinearity::Linearize (  const Double_t  adc  )  const

Definition at line 37 of file CalVaLinearity.cxx. References FitFunction(). Referenced by LILinResp::GetLinearity(), and VaLinearityCalScheme::GetLinearizedVA(). { // From raw VA adc value to linearaized VA adc value. For data correction Double_t arg[1]; Double_t par[8]; arg[0] = adc; for (Int_t i=0; i<6; i++) par[i] = fParam[i]; par[6] = 0.; // Internal Pedestal par[7] = 1.; // Internal Gain // par[0] is the function select (normally 4 or 24) return CalVaLinearity::FitFunction(arg,par); }

Double_t CalVaLinearity::Pole (  Double_t  x, Double_t  k1, Double_t  k2, Double_t  sign )  [static, private]

Definition at line 253 of file CalVaLinearity.cxx. Referenced by FitFunction(). { // Local function to do the pole calculation. sign is either +1 or -1 // depending on wheter the function is in use for the inverse or not. // The function implemented is // x1 = x / (1 + (x1/k1)**k2 ) ** (1./k2) Double_t x1 = x; if (k1 <= 500.) { // Function is flatline [was if (k1<=0.)] x1 = 0.; } else if (sign <= 0. && k1 <= x1) { // Above pole: make function 'flatline' x1 = 0.; } else if (x1 < 0.1) { // Don't modify (x=y when x is negative) } else if (k2 <= 0.1) { // don't modify with negative power [was if (k2<=0.)] } else { Double_t a = k2*log(x1/k1); // Not negative log, both x1 and k1 checked if (a > 228.) { if (sign < 0.) { // Only happens when sign positive (print if not) //printf("pole:s x1 %g k1 %g k2 %g sign %g\n",x1,k1,k2,sign); x1 = k1; } } else { // Should not overflow exp() Double_t b = pow(1. + sign * exp(a), 1./k2); if (b > 1.0e-20) { // OK x1 = x1 / b; } else { // Very close to pole x1 = x1*1.0e20; } } } return x1; }

UInt_t CalVaLinearity::Rcid2Index (  const RawChannelId &  rcid  )  [static]

Definition at line 135 of file CalVaLinearity.cxx. References RawChannelId::GetCrate(), RawChannelId::GetDetector(), RawChannelId::GetVaAdcSel(), RawChannelId::GetVaChannel(), RawChannelId::GetVaChip(), RawChannelId::GetVarcId(), and RawChannelId::GetVmm(). Referenced by CalVaLinearity(), VaLinearityCalScheme::DecalVALinearity(), and VaLinearityCalScheme::GetLinearizedVA(). { // This static function produces a channel index (used by the database) // from a raw channel ID return ( rcid.GetDetector() <<28) | ( rcid.GetCrate() <<24) | ( rcid.GetVarcId() <<20) | ( rcid.GetVmm() <<16) | ( rcid.GetVaAdcSel() <<12) | ( rcid.GetVaChip() << 8) | ( rcid.GetVaChannel()<< 0); }

void CalVaLinearity::Store (  DbiOutRowStream &  ors, const DbiValidityRec *  vrec )  const [virtual]

Reimplemented from DbiTableRow. Definition at line 122 of file CalVaLinearity.cxx. References fParam, and fVAChannel. { // // Purpose: Stream object to output row stream // // Arguments: // ors in Output row stream. // vrec in Associated validity record (or 0 if filling ors << fVAChannel << fParam[0] << fParam[1] << fParam[2] << fParam[3] << fParam[4] << fParam[5]; }

Double_t CalVaLinearity::UnLinearize (  const Double_t  linearAdc  )  const

Definition at line 54 of file CalVaLinearity.cxx. References FitFunction(), and fParam. Referenced by VaLinearityCalScheme::DecalVALinearity(), and SimVaElectronics::GenSimulatedADC(). { // From linearized VA adc to raw adc (i.e. add the saturation in). For MC Double_t arg[1]; Double_t par[8]; arg[0] = linearAdc; for (Int_t i=0; i<6; i++) par[i] = fParam[i]; par[6] = 0.; // Internal Pedestal par[7] = 1.; // Internal Gain par[0] = par[0] + 1; // 5 or 25 is the inverse return CalVaLinearity::FitFunction(arg,par); }

---

Member Data Documentation

Double_t CalVaLinearity::fParam[kPMAX] [private]

Definition at line 84 of file CalVaLinearity.h. Referenced by CalVaLinearity(), Fill(), GetParam(), Store(), and UnLinearize().

UInt_t CalVaLinearity::fVAChannel [private]

Definition at line 85 of file CalVaLinearity.h. Referenced by CalVaLinearity(), Fill(), GetRawChannelId(), and Store().

---

The documentation for this class was generated from the following files:

• CalVaLinearity.h
• CalVaLinearity.cxx

---