LITuning.h

Go to the documentation of this file.

// Program name: LITuning.h                        
//                                                                     
// Package: LISummary                                         
//                                                                    
// Coded by Jeff Hartnell Feb-Aug/2003          
//                                                                    
// Purpose: To provide algorithms for the tuning of the LI system
//                                                                    
// Contact: jeffrey.hartnell@physics.ox.ac.uk                         

#ifndef LITUNING_H
#define LITUNING_H

#include <vector>

#include "TH2F.h"
#include "TObject.h"

#include "LIRun.h"

class LITuning : public LILookup
{
  
 public:  

  typedef enum EGcTuningType {
    kGcUnknown        = 0,
    kGcLinearInPmtAdc = 1,
    kGcLinearInPinAdc = 2
  } EGcTuningType_t;  

  LITuning();
  ~LITuning();

  //methods that do modify the object's state
  void CalculateDriftPoints();
  void CalculateGainCurve(EGcTuningType tuningType=kGcLinearInPinAdc);
  void InputDataGc(std::vector<LIRun>& gainCurve);
  //the setters
  void SetAdcAtStartOfSaturation(Double_t i){fAdcAtStartOfSaturation=i;}
  void SetdADCdPHAtSat(Double_t i) {fdADCdPHAtSat=i;}
  void SetFirstGcPointAdc(Double_t i) {fFirstGcPointAdc=i;}
  void SetIdealAdc(Int_t i) {fIdealAdc=i;}
  void SetLastGcPointAdc(Double_t i) {fLastGcPointAdc=i;}
  void SetPinHighestMaxHG(Double_t i) {fPinHighestMaxHG=i;}
  void SetPinHighestMaxLG(Double_t i) {fPinHighestMaxLG=i;}
  void SetPinLowestMaxHG(Double_t i) {fPinLowestMaxHG=i;}
  void SetPinLowestMaxLG(Double_t i) {fPinLowestMaxLG=i;}
  void SetPinLowestMinHG(Double_t i) {fPinLowestMinHG=i;}
  void SetPinLowestMinLG(Double_t i) {fPinLowestMinLG=i;}
  void SetMaxPossAdc(Double_t i) {fMaxPossAdc=i;}
  void SetMaxPossPh(Double_t i) {fMaxPossPh=i;}
  void SetMaxPossPin(Double_t i) {fMaxPossPin=i;}
  void SetMinHGdPINdPH(Double_t i) {fMinHGdPINdPH=i;}
  void SetMinLGdPINdPH(Double_t i) {fMinLGdPINdPH=i;}
  void SetMinPossAdc(Double_t i) {fMinPossAdc=i;}
  void SetMinPossPh(Double_t i) {fMinPossPh=i;}
  void SetMinPossPin(Double_t i) {fMinPossPin=i;}
  void SetNumCalibPoints(Int_t i); 
  void SetNumGainPoints(Int_t i);

  //methods that don't modify the objects state
  Float_t FindLowerFraction(std::map<Float_t,Int_t>& inputMap,
                            Float_t fraction,Int_t totalNumHits);
  Float_t FindMidFractionAv(std::map<Float_t,Int_t>& inputMap,
                            Float_t lowerFraction,Float_t upperFraction,
                            Int_t totalNumHits);
  Float_t FindUpperFraction(std::map<Float_t,Int_t>& inputMap,
                            Float_t fraction,Int_t totalNumHits);
  Bool_t GetDataGcGraphs(std::vector<TGraph*>& gGcAdc,
                         std::vector<TGraph*>& gAdcFVsPh,
                         std::vector<TGraph*>& gPinVsPh,
                         std::vector<TGraph*>& gPin2VsPh,
                         std::vector<TGraphAsymmErrors*>& gAdcErrVsPh,
                         std::vector<TGraphAsymmErrors*>& gAdcFErrVsPh);
  Bool_t GetTunedDpGraphs(TGraph*& gAdcVsLed,TGraph*& gPhVsLed,
                          TGraph*& gPinVsLed,Int_t numLedsPerPb);
  Bool_t GetTunedGcPlots(std::vector<TH2F*>& hGcAdc,
                         std::vector<TH2F*>& hGcPin,
                         std::vector<TH2F*>& hGcPh,
                         Int_t firstLed,Int_t lastLed);
  void PrintAll();
  void PrintConfig();
  void PrintLedCheckGrid(LIRun::ELIRunType LIRunType,
                         Int_t firstPb,Int_t lastPb,
                         Int_t firstLed,Int_t lastLed);
  Int_t PrintLIConfig(LIRun::ELIRunType LIRunType);

 private:

  //methods that do modify the object's state
  void CorrectInterpValues(std::vector<Double_t>::iterator adc,
                           std::vector<Double_t>::iterator ph,
                           std::vector<Double_t>::iterator pin,
                           Int_t led,Int_t pb,Double_t requiredPointAdc,
                           Double_t& interpPh,Double_t& interpPin);
  void GcLinearInPinAdc(std::vector<LIRun>::iterator gcData,
                        Int_t goodPin,
                        std::vector<LIRun>::iterator& gcTuned,
                        Double_t firstPh,Double_t lastPh,
                        Double_t firstPin,Double_t lastPin);
  void GcLinearInPmtAdc(std::vector<LIRun>::iterator gcData,
                        Int_t goodPin,
                        std::vector<LIRun>::iterator& gcTuned,
                        Double_t firstPh,Double_t lastPh,
                        Double_t firstPin,Double_t lastPin);
  void InitialiseDataMembers(Detector::Detector_t det);
    
  //methods that don't modify the objects state
  Double_t CalcAv_dPINdPH(std::vector<LIRun>::iterator gcData,
                          Int_t pinNumber);
  void CalcFirstGcPoint(std::vector<LIRun>::iterator gcData,
                        Int_t goodPin,Double_t& firstPh,
                        Double_t& firstPin);
  void CalcLastGcPoint(std::vector<LIRun>::iterator gcData,
                       Int_t goodPin,Double_t& lastPh,
                       Double_t& lastPin);
  Double_t CalcLastGcPointAdc(std::vector<LIRun>::iterator gcData);
  Bool_t DataIsOk(std::vector<LIRun>::iterator GainCurveData,
                  Int_t minNumPoints=4,Int_t maxAllowedAdc=15000);
  Int_t GoodPin(std::vector<LIRun>::iterator currentGc);
  Double_t Interpolate(Double_t y,Double_t y2,Double_t m,Double_t x2);
  void InterpolateAboveOrBelow(EGcTuningType tuningType,
                               std::vector<Double_t>::iterator adc,
                               std::vector<Double_t>::iterator ph,
                               std::vector<Double_t>::iterator pin,
                               Int_t led,Int_t pb,
                               Double_t& interpAdc,
                               Double_t& interpPh,Double_t& interpPin);
  void PrintFirstLastMsg(Double_t firstPh,Double_t lastPh,
                         Double_t firstPin,Double_t lastPin);
  void PrintPhPinMsg(std::vector<Double_t>::iterator adc,
                     std::vector<Double_t>::iterator ph,
                     std::vector<Double_t>::iterator pin,
                     Double_t interpPh,
                     Double_t interpPin);
  void PrintPhMsg(std::vector<Double_t>::iterator adc,
                  std::vector<Double_t>::iterator ph,
                  Double_t interpPh);
  void PrintPinMsg(std::vector<Double_t>::iterator pin,
                   std::vector<Double_t>::iterator ph,
                   Double_t interpAdc,Double_t interpPh);

  //data members
  Double_t fAdcAtStartOfSaturation;//the adc where saturation starts
  std::vector<LIRun> fBestDp;//to hold the calculated DPs
  std::vector<LIRun> fBestGc;//to hold the calculated GCs
  Double_t fdADCdPHAtSat;
  Detector::Detector_t fDetector;
  Double_t fFirstGcPointAdc;//lowest adc GC point
  std::vector<LIRun>* fGainCurve;//to hold the input GC (real data)
  Int_t fIdealAdc;//the adc to aim for in DP tuning
  Double_t fLastGcPointAdc;//highest adc GC point
  Int_t fNumCalibPoints;//the number of point in the input data GC
  Int_t fNumGainPoints;//the number of points required in the tuned GC
  Double_t fPinHighestMaxHG;//the max acceptable pin to calc gain curve
  Double_t fPinHighestMaxLG;
  Double_t fPinLowestMaxHG;//the lowest acceptable max 
  Double_t fPinLowestMaxLG;
  Double_t fPinLowestMinHG;//the min acceptable pin to calc gain curve
  Double_t fPinLowestMinLG;
  Double_t fMaxPossAdc;//the maximum adc possible in FD
  Double_t fMaxPossPh;//the maximum PH possible in minos
  Double_t fMaxPossPin;//the maximum adc possible in FD
  Double_t fMinHGdPINdPH;//min pin/ph gradient for high gain pin
  Double_t fMinLGdPINdPH;
  Double_t fMinPossAdc;
  Double_t fMinPossPh;
  Double_t fMinPossPin;
  std::string fS;//general purpose string

  ClassDef(LITuning,0)
};

#endif // LITUNING_H

---