JCALIBRATE::JHVGainGraph Struct Reference

Auxiliary data structure to store high-voltage versus gain data and interpolate the nominal high-voltage. More...

#include <JHVGainGraph.hh>

Inheritance diagram for JCALIBRATE::JHVGainGraph:

Public Member Functions
	JHVGainGraph (const char *name="HVGainGraph", const bool logScale=false, const double base=10.0)
	Constructor. More...
	JHVGainGraph (const TMultiGraph &object, const bool logScale, const double base=10.0)
	Copy constructor. More...
void	AddPoint (Double_t HV, Double_t gain, Double_t gainError)
	Add point to diagram. More...
void	SetPoint (Int_t i, Double_t HV, Double_t gain, Double_t gainError)
	Set point with index i. More...
const bool	checkHV (const double HV) const
	Checks whether high-voltage is within range. More...
const bool	checkHV (const double HV1, const double HV2) const
	Checks whether two high-voltage values are different. More...
const bool	checkGain (const double gain) const
	Checks if gain is within range. More...
const bool	areIncreasing (const Int_t i, const Int_t j)
	Checks whether the gains of two points are strictly increasing as function of their absolute high-voltage. More...
const bool	areValid (const Int_t i, const Int_t j)
	Checks whether two points are valid for inter-/extrapolation. More...
bool	interpolate (const double gainTarget)
	Inter-/Extrapolate the high-voltage value corresponding to the target gain value. More...
double	getTargetHV (const double gainTarget)
	Get high-voltage corresponding to given target gain value. More...
double	getTargetHVError (const double gainTarget)
	Get error estimate on high-voltage corresponding to given target gain value. More...
void	setLogLog ()
	Set log-log scale. More...
void	unsetLogLog ()
	Unset log-log scale. More...
void	setLogBase (const double base)
	Set logarithmic base for log-log scaling. More...
TGraphErrors *	getData ()
	Get graph with the input data for the interpolation. More...
TGraphErrors *	getResult ()
	Get graph with the interpolation result. More...
JHVGainGraph *	Clone (const char *newname="") const
	Clone this object. More...

Static Public Member Functions
static void	setMinHVDistance (const double minDist)
	Set minimal separation distance for high-voltage. More...
static void	setHVRange (const JRange< double > range)
	Set valid gain range. More...
static void	setGainRange (const JRange< double > range)
	Set valid gain range. More...

Private Attributes
bool	loglog
	Log-log scale toggle. More...
double	base
	Base for logarithmic scaling. More...

Static Private Attributes
static double	dHVmin = 2 * 3.14
	Minimal high-voltage difference between two points [V]. More...
static JRange< double >	hvRange = JRange<double>(-1500, -80)
	Allowed high-voltage range [V]. More...
static JRange< double >	gainRange
	Allowed gain range. More...

Detailed Description

Auxiliary data structure to store high-voltage versus gain data and interpolate the nominal high-voltage.

Definition at line 35 of file JHVGainGraph.hh.

Constructor & Destructor Documentation

JCALIBRATE::JHVGainGraph::JHVGainGraph ( const char *  name = "HVGainGraph", const bool  logScale = false, const double  base = 10.0  )

inline

Constructor.

Parameters

name	name
logScale	set logarithmic scaling
base	base for logarithmic scaling

Definition at line 45 of file JHVGainGraph.hh.

                                               :
      loglog(logScale), base(base)
    {
      this->SetName(name);

      TGraphErrors* g0 = getResult();
      TGraphErrors* g1 = getData();

      g0->SetName(HVGAINGRAPH_RESULT);
      g0->SetLineColor  (kRed);
      g0->SetMarkerColor(kRed);
      g0->SetMarkerStyle(kFullDotSmall);

      g1->SetName(HVGAINGRAPH_DATA);
      g1->SetMarkerStyle(kFullDotSmall);
    }

JCALIBRATE::JHVGainGraph::JHVGainGraph ( const TMultiGraph &  object, const bool  logScale, const double  base = 10.0  )

inline

Copy constructor.

Parameters

object	TMultiGraph object
logScale	set logarithmic scale
base	base for logarithmic scaling

Definition at line 72 of file JHVGainGraph.hh.

                                                   :
      loglog(logScale), base(base)
    {
      TList* graphs = object.GetListOfGraphs();

      if (graphs != NULL) {

        TGraphErrors* g0 = (TGraphErrors*)graphs->FindObject(HVGAINGRAPH_RESULT);
        TGraphErrors* g1 = (TGraphErrors*)graphs->FindObject(HVGAINGRAPH_DATA);

        if (g0 != NULL) {
          this->Add((TGraphErrors*)g0->Clone());
        }

        if (g1 != NULL) {
          this->Add((TGraphErrors*)g1->Clone());
        }
      }
    }

Member Function Documentation

void JCALIBRATE::JHVGainGraph::AddPoint ( Double_t  HV, Double_t  gain, Double_t  gainError  )

inline

Add point to diagram.

Parameters

HV	high-voltage [V]
gain	gain value
gainError	error on gain value

Definition at line 102 of file JHVGainGraph.hh.

    {
      TGraphErrors* g1 = getData();
      
      const Int_t   N  = g1->GetN();
      
      if (loglog) {

        g1->SetPoint     (N, log(fabs(HV)) / log(base), log(gain) / log(base));
        g1->SetPointError(N, 0.0,                       gainError / log(base) / gain);
        
      } else {

        g1->SetPoint     (N, HV,  gain);
        g1->SetPointError(N, 0.0, gainError);
      }
    }

void JCALIBRATE::JHVGainGraph::SetPoint ( Int_t  i, Double_t  HV, Double_t  gain, Double_t  gainError  )

inline

Set point with index i.

Parameters

i	index of point
HV	high-voltage [V]
gain	gain value
gainError	error on gain value

Definition at line 129 of file JHVGainGraph.hh.

    {
      TGraphErrors* g1 = getData();

      if (loglog) {
        
        g1->SetPoint     (i, log(fabs(HV)) / log(base), log(gain) / log(base));
        g1->SetPointError(i, 0.0,                       gainError / log(base) / gain);
        
      } else {

        g1->SetPoint     (i, HV,  gain);
        g1->SetPointError(i, 0.0, gainError);
      }
    }

const bool JCALIBRATE::JHVGainGraph::checkHV ( const double  HV ) const

inline

Checks whether high-voltage is within range.

Parameters

HV	high-voltage [V]

Returns

true if high-voltage is within range; else false

Definition at line 152 of file JHVGainGraph.hh.

    {
      return (HV > hvRange.getLowerLimit() &&
              HV < hvRange.getUpperLimit());
    }

const bool JCALIBRATE::JHVGainGraph::checkHV ( const double  HV1, const double  HV2  ) const

inline

Checks whether two high-voltage values are different.

Parameters

HV1	first high-voltage [V]
HV2	second high-voltage [V]

Returns

true if absolute difference is greater than minimal required difference; else false

Definition at line 166 of file JHVGainGraph.hh.

    {
      return (fabs(HV1 - HV2) > dHVmin);
    }

const bool JCALIBRATE::JHVGainGraph::checkGain ( const double  gain ) const

inline

Checks if gain is within range.

Parameters

gain	gain value

Returns

true if gain within allowed range; else false

Definition at line 178 of file JHVGainGraph.hh.

    {
      return (gain > gainRange.getLowerLimit() &&
              gain < gainRange.getUpperLimit());
    }

const bool JCALIBRATE::JHVGainGraph::areIncreasing ( const Int_t  i, const Int_t  j  )

inline

Checks whether the gains of two points are strictly increasing as function of their absolute high-voltage.

Parameters

i	index of first point
j	index of second point

Returns

true if gains of given points are strictly increasing
as function of the absolute high-voltage; else false

Definition at line 193 of file JHVGainGraph.hh.

    {
      TGraphErrors* g1 = getData();
      
      if ( (g1 != NULL) && ((i >= 0 && i < g1->GetN()) &&
                            (j >= 0 && i < g1->GetN())) ) {

        if (loglog) {
          
          return ((g1->GetPointX(i) > g1->GetPointX(j) && g1->GetPointY(i) > g1->GetPointY(j)) ||
                  (g1->GetPointX(i) < g1->GetPointX(j) && g1->GetPointY(i) < g1->GetPointY(j)));
          
        } else {
          
          return ((g1->GetPointX(i) < g1->GetPointX(j) && g1->GetPointY(i) > g1->GetPointY(j)) ||
                  (g1->GetPointX(i) > g1->GetPointX(j) && g1->GetPointY(i) < g1->GetPointY(j)));
        }
        
      } else {

        return false;
      }
    }

const bool JCALIBRATE::JHVGainGraph::areValid ( const Int_t  i, const Int_t  j  )

inline

Checks whether two points are valid for inter-/extrapolation.

Parameters

i	index of first point
j	index of second point

Returns

true if valid for inter-/extrapolation; else false

Definition at line 225 of file JHVGainGraph.hh.

    {
      TGraphErrors* g1 = getData();
      
      if ((i >= 0 && i < g1->GetN()) &&
          (j >= 0 && i < g1->GetN())) {
        
        double HV_i, HV_j, gain_i, gain_j;
        
        if (loglog) {

          HV_i   = -pow(base, g1->GetPointX(i));
          HV_j   = -pow(base, g1->GetPointX(j));
          gain_i =  pow(base, g1->GetPointY(i));
          gain_j =  pow(base, g1->GetPointY(j));

        } else {

          HV_i   = g1->GetPointX(i);
          HV_j   = g1->GetPointX(j);
          gain_i = g1->GetPointY(i);
          gain_j = g1->GetPointY(j);
        }
        
        return (areIncreasing(   i,    j) && checkHV(HV_i) && checkGain(gain_i) &&
                checkHV      (HV_i, HV_j) && checkHV(HV_j) && checkGain(gain_j));
        
      } else {
        
        return false;
      }
    }

bool JCALIBRATE::JHVGainGraph::interpolate ( const double  gainTarget )

inline

Inter-/Extrapolate the high-voltage value corresponding to the target gain value.

Parameters

gainTarget

target gain value for inter-/extrapolation

Returns

true if inter-/extrapolation successful; else false

Definition at line 265 of file JHVGainGraph.hh.

    {
      TGraphErrors* g1 = getData();
      
      if (g1->GetN() < 2 || !checkGain(gainTarget)) {
        return false;
      }
      
      const bool isLogLog = loglog;
      
      if (!isLogLog) {
        setLogLog();
      }
      
      // Search for valid inter-/extrapolation points
      
      Int_t i = 0;
      Int_t j = 1;
      
      const double logGainTarget = log(gainTarget) / log(base);

      for (Int_t k = 1; k < g1->GetN(); ++k) {

        const double dlogG_i = fabs(g1->GetPointY(i) - logGainTarget);
        const double dlogG_j = fabs(g1->GetPointY(j) - logGainTarget);  
        const double dlogG_k = fabs(g1->GetPointY(k) - logGainTarget);
        
        if         (dlogG_k < dlogG_i) {
          
          j = (areValid(i, k) ? i : j);
          i = k;
          
        } else if ((dlogG_k < dlogG_j || !areValid(i, j)) &&
                   areValid(i, k)) {
          j = k;
        }
      }

      // Inter-/Extrapolate high-voltage corresponding to given gain

      bool valid = areValid(i, j);
      
      if (valid) {
        
        const double logHV0    = g1->GetPointX(i);
        const double logHV1    = g1->GetPointX(j);
        
        const double logG0     = g1->GetPointY(i);
        const double logG1     = g1->GetPointY(j);
        const double elogG0    = g1->GetErrorY(i);
        const double elogG1    = g1->GetErrorY(j);
        
        const double dlogG0    = logGainTarget - logG0;
        const double dlogG1    = logGainTarget - logG1;
        
        const double slope     = (logG1 - logG0) / (logHV1 - logHV0);
        
        const double logHVnom  = dlogG0 / slope + logHV0;
        const double elogHVnom = sqrt(dlogG1 * dlogG1 * elogG0 * elogG0 +
                                      dlogG0 * dlogG0 * elogG1 * elogG1) / fabs(slope * (logG1 - logG0));
        
        const double distance  = fabs((logHVnom - logHV0) / (logHV0 - logHV1));

        static const double maxDist = 2.0;
        
        valid = (logHVnom > 0.0 && checkHV(-pow(base, logHVnom)) && distance < maxDist);
        
        if (valid) {
          
          TGraphErrors* g0 = getResult();
          
          g0->SetPoint     (0, logHVnom,  logGainTarget);
          g0->SetPointError(0, elogHVnom, 0.0);
        }
      }
      
      if (!isLogLog) {
        unsetLogLog();
      }
      
      return valid;
    }

double JCALIBRATE::JHVGainGraph::getTargetHV ( const double  gainTarget )

inline

Get high-voltage corresponding to given target gain value.

Parameters

gainTarget

target gain value for inter-/extrapolation

Returns

inter-/extrapolated high-voltage
corresponding to target gain value [V]

Definition at line 356 of file JHVGainGraph.hh.

    {
      static const double precision = 1e-3;

      const double target = (loglog ? log(gainTarget) / log(base) : gainTarget);
      
      TGraphErrors* g0 = getResult();
      
      if ((g0->GetN() > 0 && fabs(g0->GetPointY(0) - target < precision)) || interpolate(gainTarget)) {
        
        return (loglog ? -pow(base, g0->GetPointX(0)) : g0->GetPointX(0));
        
      } else {

        THROW(JValueOutOfRange, "JHVGainGraph::getTargetError(): No valid inter-/extrapolation candidate found for given target gain.");
      }
    }

double JCALIBRATE::JHVGainGraph::getTargetHVError ( const double  gainTarget )

inline

Get error estimate on high-voltage corresponding to given target gain value.

Parameters

gainTarget

target gain value for inter-/extrapolation

Returns

error on inter-/extrapolated high-voltage
corresponding to the target gain value [V]

Definition at line 382 of file JHVGainGraph.hh.

    {
      static const double precision = 1e-3;

      const double target = (loglog ? log(gainTarget) / log(base) : gainTarget);
      
      TGraphErrors* g0 = getResult();
      
      if ((g0->GetN() > 0 && fabs(g0->GetPointY(0) - target) < precision) || interpolate(gainTarget)) {

        return (loglog ? g0->GetErrorX(0) * pow(base, g0->GetPointX(0)) * log(base) : g0->GetErrorX(0));
        
      } else {

        THROW(JValueOutOfRange, "JHVGainGraph::getTargetError(): No valid inter-/extrapolation candidate found for given target gain.");        
      }
    }

void JCALIBRATE::JHVGainGraph::setLogLog ( )

inline

Set log-log scale.

Definition at line 404 of file JHVGainGraph.hh.

    {
      if (!loglog) {
        
        TIter next(this->GetListOfGraphs());
      
        while (TGraphErrors* graph = (TGraphErrors*)next()) {

          if (graph != NULL) {
            
            for (Int_t i = 0; i < graph->GetN(); ++i) {
       
              Double_t absLogHV      = log(fabs(graph->GetPointX(i))) / log(base);
              Double_t logGain       = log(graph->GetPointY(i))       / log(base);

              Double_t absLogHVerror = graph->GetErrorX(i) / fabs(graph->GetPointX(i)) / log(base);
              Double_t logGainError  = graph->GetErrorY(i) / fabs(graph->GetPointY(i)) / log(base);
              
              graph->SetPoint     (i, absLogHV,      logGain);
              graph->SetPointError(i, absLogHVerror, logGainError);
            }
          }
        }

        loglog = true;
      }
    }

void JCALIBRATE::JHVGainGraph::unsetLogLog ( )

inline

Unset log-log scale.

Definition at line 436 of file JHVGainGraph.hh.

    {
      if (loglog) {

        TIter next(this->GetListOfGraphs());
        
        while (TGraphErrors* graph = (TGraphErrors*)next()) {

          if (graph != NULL) {
            
            for (Int_t i = 0; i < graph->GetN(); ++i) {
       
              Double_t HV            = -pow(base, graph->GetPointX(i));
              Double_t gain          =  pow(base, graph->GetPointY(i));

              Double_t HVerror       = graph->GetErrorX(i) * -HV  * log(base);
              Double_t gainError     = graph->GetErrorY(i) * gain * log(base);
              
              graph->SetPoint     (i, HV,      gain);
              graph->SetPointError(i, HVerror, gainError);
            }
          }
        }

        loglog = false;
      } 
    }

void JCALIBRATE::JHVGainGraph::setLogBase ( const double  base )

inline

Set logarithmic base for log-log scaling.

Parameters

base	logarithmic base for scaling

Definition at line 470 of file JHVGainGraph.hh.

    {
      if (loglog) {
        
        TIter next(this->GetListOfGraphs());
      
        while (TGraphErrors* graph = (TGraphErrors*)next()) {

          if (graph != NULL) {
            
            for (Int_t i = 0; i < graph->GetN(); ++i) {
       
              Double_t absLogHV      = graph->GetPointX(i) * log(this->base) / log(base);
              Double_t logGain       = graph->GetPointY(i) * log(this->base) / log(base);
            
              Double_t abslogHVerror = graph->GetErrorX(i) * log(this->base) / log(base);
              Double_t logGainError  = graph->GetErrorY(i) * log(this->base) / log(base);
            
              graph->SetPoint     (i, absLogHV,      logGain);
              graph->SetPointError(i, abslogHVerror, logGainError);
            }
          }
        }
      }
      
      this->base = base;
    }

TGraphErrors* JCALIBRATE::JHVGainGraph::getData ( )

inline

Get graph with the input data for the interpolation.

Returns

pointer to graph with input data

Definition at line 504 of file JHVGainGraph.hh.

    {
      TGraphErrors* g1;
      
      TList* list = this->GetListOfGraphs();

      if (list != NULL && list->FindObject(HVGAINGRAPH_DATA) != NULL) {
        
        g1 = (TGraphErrors*)list->FindObject(HVGAINGRAPH_DATA);
        
      } else {
        
        g1 = new TGraphErrors();
        
        g1->SetName(HVGAINGRAPH_DATA);
        
        g1->Set(0);
        
        this->Add(g1);
      }

      return g1;
    }

TGraphErrors* JCALIBRATE::JHVGainGraph::getResult ( )

inline

Get graph with the interpolation result.

Returns

pointer to graph with the interpolation result

Definition at line 534 of file JHVGainGraph.hh.

    {
      TGraphErrors* g0;
      
      TList* list = this->GetListOfGraphs();

      if (list != NULL && list->FindObject(HVGAINGRAPH_RESULT) != NULL) {
        
        g0 = (TGraphErrors*)list->FindObject(HVGAINGRAPH_RESULT);
        
      } else {

        g0 = new TGraphErrors();

        g0->SetName(HVGAINGRAPH_RESULT);

        g0->Set(0);
        
        this->Add(g0);
      }

      return g0;
    }

JHVGainGraph* JCALIBRATE::JHVGainGraph::Clone ( const char *  newname = "" ) const

inline

Clone this object.

Parameters

newname

new name

Definition at line 564 of file JHVGainGraph.hh.

    {
      JHVGainGraph* clone = new JHVGainGraph(*this, loglog, base);
      
      clone->SetName(newname);
      
      return clone;
    }

static void JCALIBRATE::JHVGainGraph::setMinHVDistance ( const double  minDist )

inlinestatic

Set minimal separation distance for high-voltage.

Parameters

minDist

minimal separation distance for high-voltage

Definition at line 579 of file JHVGainGraph.hh.

    {
      dHVmin = minDist;
    }

static void JCALIBRATE::JHVGainGraph::setHVRange ( const JRange< double >  range )

inlinestatic

Set valid gain range.

Parameters

range

valid high-voltage range [V]

Definition at line 590 of file JHVGainGraph.hh.

    {
      hvRange = range;
    }

static void JCALIBRATE::JHVGainGraph::setGainRange ( const JRange< double >  range )

inlinestatic

Set valid gain range.

Parameters

range

valid gain range

Definition at line 601 of file JHVGainGraph.hh.

    {
      gainRange = range;
    }

Member Data Documentation

bool JCALIBRATE::JHVGainGraph::loglog

private

Log-log scale toggle.

Definition at line 609 of file JHVGainGraph.hh.

double JCALIBRATE::JHVGainGraph::base

private

Base for logarithmic scaling.

Definition at line 610 of file JHVGainGraph.hh.

double JCALIBRATE::JHVGainGraph::dHVmin = 2 * 3.14

staticprivate

Minimal high-voltage difference between two points [V].

Default values.

Definition at line 612 of file JHVGainGraph.hh.

JRange< double > JCALIBRATE::JHVGainGraph::hvRange = JRange<double>(-1500, -80)

staticprivate

Allowed high-voltage range [V].

Definition at line 613 of file JHVGainGraph.hh.

JRange< double > JCALIBRATE::JHVGainGraph::gainRange

staticprivate

Initial value:

= JRange<double>(FITTOT_GAIN_MIN,
                                                          FITTOT_GAIN_MAX)

Allowed gain range.

Definition at line 614 of file JHVGainGraph.hh.

---

The documentation for this struct was generated from the following file:

• JHVGainGraph.hh