LIRun.cxx

Go to the documentation of this file.

// Program name: LIRun.cxx                
//
// Package: LISummary          
//
// Coded by Jeff Hartnell Feb/2003                             
//
// Purpose: 
//
// Contact: jeffrey.hartnell@physics.ox.ac.uk                         

#include "TString.h"//for Form()

#include "MessageService/MsgService.h"

#include "LISummary/LIRun.h"
#include <cmath>

ClassImp(LIRun)
  
CVSID("$Id: LIRun.cxx,v 1.15 2007/11/11 08:00:53 rhatcher Exp $");

//......................................................................

LIRun::LIRun()
{
  MSG("LIRun", Msg::kVerbose) 
    <<"Running LIRun default constructor..."<<endl;
  
  this->InitialiseVariables();  
  
  MSG("LIRun", Msg::kVerbose) 
    <<"Finished LIRun default constructor"<<endl;
}

//......................................................................

LIRun::LIRun(Int_t pulserBox,Int_t led,LIRunType_t LIRunType,
             Detector::Detector_t detectorType)
{
  MSG("LIRun", Msg::kVerbose) 
    <<"Running LIRun constructor..."<<endl;
  
  this->InitialiseVariables();

  fLed=led;
  fPulserBox=pulserBox;
  fDetector=detectorType;
  fLIRunType=LIRunType;

  MSG("LIRun", Msg::kVerbose) 
    <<"Finished LIRun constructor"<<endl;
}

//......................................................................

LIRun::~LIRun()
{
  MSG("LIRun", Msg::kVerbose) 
    <<"Running LIRun destructor..."<<endl;
  
  
  MSG("LIRun", Msg::kVerbose) 
    <<"Finished LIRun destructor"<<endl;
}

//......................................................................

bool operator==(LIRun a, LIRun b)
{
  return a.GetPh()==b.GetPh();
}

//......................................................................

bool operator<(LIRun a, LIRun b)
{
  return a.GetPh().size()<b.GetPh().size();
}
//......................................................................

void LIRun::InitialiseVariables()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running InitialiseVariables method..."<<endl;

  fDetector=Detector::kUnknown;
  fLed=-1;
  fLIRunType=kUnknown;
  fMaxPin=-1;
  fMaxPin2=-1;
  fMinAdc=1e6;
  fMaxAdc=-1;
  fMinAdcF=1e6;
  fMaxAdcF=-1;
  fPulserBox=-1;
  fS="";

  fHighestPh=-1;//ph at highest required adc
  fHighestPin=-1;//pin adc at highest required adc
  fLowestPh=-1;//ph at lowest required adc
  fLowestPin=-1;//pin adc at lowest required adc

  MSG("LIRun",Msg::kVerbose) 
    <<"InitialiseVariables method finished"<<endl;
}

//......................................................................

void LIRun::SetLIInfo(Int_t pB,Int_t l,LIRunType_t LIrt)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running SetLIInfo method..."<<endl;

  fLed=l;
  fPulserBox=pB;
  fLIRunType=LIrt;

  MSG("LIRun",Msg::kVerbose) 
    <<"SetLIInfo method finished"<<endl;
}

//......................................................................

void LIRun::AddPoint(Double_t newPh,Double_t a,
                     Double_t p,Double_t p2,
                     Double_t aF,
                     Double_t aLow,Double_t aHigh,
                     Double_t aLowF,Double_t aHighF)
{
  MSG("LIRun",Msg::kVerbose)
    <<"Running AddPoint method..."<<endl;

  UInt_t insertPoint=FindInsertPoint(fPh,newPh);

  //these are the minimum two that should be filled
  SetNewPoint(fPh,newPh,insertPoint);
  SetNewPoint(fAdc,a,insertPoint);

  //fill the others if a value is given
  SetNewPoint(fPin,p,insertPoint);
  SetNewPoint(fPin2,p2,insertPoint);
  SetNewPoint(fAdcF,aF,insertPoint);
  SetNewPoint(fAdcLow,aLow,insertPoint);
  SetNewPoint(fAdcHigh,aHigh,insertPoint);
  SetNewPoint(fAdcLowF,aLowF,insertPoint);
  SetNewPoint(fAdcHighF,aHighF,insertPoint);

  //calcuate fMaxPin
  if (p>fMaxPin) fMaxPin=p;
  if (p2>fMaxPin2) fMaxPin2=p2;
  //calcuate min and max adc
  if (a>fMaxAdc) fMaxAdc=a;
  if (a<fMinAdc) fMinAdc=a;
  //calcuate min and max adc on far side of strip end
  if (aF>fMaxAdcF) fMaxAdcF=aF;
  if (aF<fMinAdcF) fMinAdcF=aF;

  MSG("LIRun",Msg::kDebug) 
    <<"Added point to LIRun object: ph="<<newPh<<", adc="<<a
    <<", pin="<<p<<", pin2="<<p2<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"AddPoint method finished"<<endl;
}

//......................................................................

Double_t LIRun::GetMaxAdc()
{
  return fMaxAdc;
}

//......................................................................

Double_t LIRun::GetMinAdc()
{
  return fMinAdc;
}

//......................................................................

Double_t LIRun::GetMaxAdcF()
{
  return fMaxAdcF;
}

//......................................................................

Double_t LIRun::GetMinAdcF()
{
  return fMinAdcF;
}

//......................................................................

Double_t LIRun::GetMaxPin()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetMaxPin method..."<<endl;
  
  if (fMaxPin==fMaxPin2){
    MSG("LIRun",Msg::kWarning) 
      <<"The two pins only have one max value, pin1="<<fMaxPin
      <<", pin2="<<fMaxPin2
      <<endl;
  }
  else if (fMaxPin>fMaxPin2){
    return fMaxPin;
  }
  else{
    return fMaxPin2;
  }

  MSG("LIRun",Msg::kVerbose) 
    <<"GetMaxPin method finished"<<endl;
  return -1;
}

//......................................................................

Double_t LIRun::GetMaxPin(Int_t pin1or2)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetMaxPin method..."<<endl;
  
  if (pin1or2==1){
    return fMaxPin;
  }
  else if (pin1or2==2){
    return fMaxPin2;
  }
  else {
    MSG("LIRun",Msg::kWarning) 
      <<"There are only 2 pins, GetMaxPin must have argument"
      <<" value of 1 or 2"<<endl;
  }

  MSG("LIRun",Msg::kVerbose) 
    <<"GetMaxPin method finished"<<endl;
  return -1;
}

//......................................................................

vector<Double_t> LIRun::GetPh()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetPh method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetPh method finished"<<endl;
  return fPh;
}

//......................................................................

Double_t LIRun::GetPh(UInt_t i)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetPh method..."<<endl;
  
  if (i<fPh.size()) return fPh[i];
  else {
    MSG("LIRun",Msg::kWarning) 
      <<"Only "<<fPh.size()<<" elements available, returning -1"<<endl;
    return -1;
  }

  MSG("LIRun",Msg::kVerbose) 
    <<"GetPh method finished"<<endl;
}

//......................................................................

vector<Double_t> LIRun::GetAdc()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetAdc method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetAdc method finished"<<endl;
  return fAdc;
}

//......................................................................

Double_t LIRun::GetAdc(UInt_t i)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetAdc method..."<<endl;
  
  if (i<fAdc.size()) return fAdc[i];
  else {
    MSG("LIRun",Msg::kWarning) 
      <<"Only "<<fAdc.size()<<" elements available, returning -1"<<endl;
    return -1;
  }

  MSG("LIRun",Msg::kVerbose) 
    <<"GetAdc method finished"<<endl;
}

//......................................................................

vector<Double_t> LIRun::GetAdcF()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetAdcF method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetAdcF method finished"<<endl;
  return fAdcF;
}

//......................................................................

vector<Double_t> LIRun::GetAdcLow()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetAdcLow method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetAdcLow method finished"<<endl;
  return fAdcLow;
}

//......................................................................

vector<Double_t> LIRun::GetAdcLowF()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetAdcLowF method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetAdcLowF method finished"<<endl;
  return fAdcLowF;
}

//......................................................................

vector<Double_t> LIRun::GetAdcHigh()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetAdcHigh method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetAdcHigh method finished"<<endl;
  return fAdcHigh;
}

//......................................................................

vector<Double_t> LIRun::GetAdcHighF()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetAdcHighF method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetAdcHighF method finished"<<endl;
  return fAdcHighF;
}

//......................................................................

vector<Double_t> LIRun::GetPin(Int_t pin1or2)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetPin method..."<<endl;

  if (pin1or2==2){
    return fPin2;
  }
  else{
    if (pin1or2!=1){
      MSG("LIRun",Msg::kWarning)
        <<"LIRun::GetPin(Int_t) must have an argument of 1 or 2"
        <<", returned pin 1 by default"<<endl;
    }
    return fPin;
  }

  MSG("LIRun",Msg::kVerbose) 
    <<"GetPin method finished"<<endl;
}

//......................................................................

Double_t LIRun::GetPin(Int_t pin1or2,UInt_t i)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetPin method..."<<endl;

  //pin2
  if (pin1or2==2){
    if (i<fPin2.size()) return fPin2[i];
    else{
      MSG("LIRun",Msg::kWarning) 
        <<"Only "<<fPin2.size()<<" elements available, returning -1"
        <<endl;
      return -1;
    }
  }
  //pin1
  else{
    if (pin1or2!=1){
      MSG("LIRun",Msg::kWarning)
        <<"LIRun::GetPin(Int_t,UInt_t) must have first argument of 1or2"
        <<", returned pin 1 by default"<<endl;
    }

    //return element of pin 1
    if (i<fPin.size()) return fPin[i];
    else{
      MSG("LIRun",Msg::kWarning) 
        <<"Only "<<fPin.size()<<" elements available, returning -1"
        <<endl;
      return -1;
    }
  }

  MSG("LIRun",Msg::kVerbose) 
    <<"GetPin method finished"<<endl;
}

//......................................................................

Detector::Detector_t LIRun::GetDetector()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetLed method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetLed method finished"<<endl;
  return fDetector;
}

//......................................................................

Int_t LIRun::GetLed()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetLed method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetLed method finished"<<endl;
  return fLed;
}

//......................................................................

Int_t LIRun::GetPb()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetPb method..."<<endl;

  MSG("LIRun",Msg::kVerbose) 
    <<"GetPb method finished"<<endl;
  return fPulserBox;
}

//......................................................................

string LIRun::GetRunTypeAsString()
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running GetRunTypeAsString method..."<<endl;

  if (fLIRunType==kUnknown) return "kUnknown";
  else if (fLIRunType==kFullCalib) return "kGainCurve";
  else if (fLIRunType==kDriftCalib) return "kDriftPoint";
  else return "RunType not valid";

  MSG("LIRun",Msg::kVerbose) 
    <<"GetRunTypeAsString method finished"<<endl;
}

//......................................................................

void LIRun::PrintAll()
{
  MSG("LIRun",Msg::kDebug) 
    <<"Running PrintAll method..."<<endl;

  //declare string
  string sConfig="";

  //decide whether to print out various information
  if (fMaxPin!=-1){
    sConfig+=", fMaxPin=";
    sConfig+=Form("%d",static_cast<Int_t>(fMaxPin));
  }
  if (fMaxPin2!=-1){
    sConfig+=", fMaxPin2=";
    sConfig+=Form("%d",static_cast<Int_t>(fMaxPin2));
  }
  if (fMaxAdc!=-1){
    sConfig+=", fMaxAdc=";
    sConfig+=Form("%d",static_cast<Int_t>(fMaxAdc));
  }
  if (fMinAdc!=1e6){
    sConfig+=", fMinAdc=";
    sConfig+=Form("%d",static_cast<Int_t>(fMinAdc));
  }
  if (fHighestPh!=-1 && fLowestPh!=-1){
    sConfig+=", (";
    sConfig+=Form("%d",static_cast<Int_t>(fLowestPh));
    sConfig+="<PH<";
    sConfig+=Form("%d",static_cast<Int_t>(fHighestPh));
    sConfig+=")";
  }
  if (fHighestPin!=-1 && fLowestPin!=-1){
    sConfig+=", (";
    sConfig+=Form("%d",static_cast<Int_t>(fLowestPin));
    sConfig+="<PinAdc<";
    sConfig+=Form("%d",static_cast<Int_t>(fHighestPin));
    sConfig+=")";
  }

  if (fPulserBox!=-1 && fLed!=-1){
    MSG("LIRun",Msg::kInfo)
      <<"("<<fPulserBox<<":"<<fLed<<") "<<GetRunTypeAsString()<<sConfig
      <<endl;  
  }

  string sVectors="";

  sVectors+=GetVectorAsString(fPh,"fPh = ");
  sVectors+=GetVectorAsString(fAdc,"fAdc = ");
  sVectors+=GetVectorAsString(fAdcF,"fAdcF = ");
  sVectors+=GetVectorAsString(fPin,"fPin = ");
  sVectors+=GetVectorAsString(fPin2,"fPin2 = ");
  sVectors+=GetVectorAsString(fAdcHigh,"fAdcHigh = ");
  sVectors+=GetVectorAsString(fAdcHighF,"fAdcHighF = ");
  sVectors+=GetVectorAsString(fAdcLow,"fAdcLow = ");
  sVectors+=GetVectorAsString(fAdcLowF,"fAdcLowF = ");

  if (sVectors!=""){
    MSG("LIRun",Msg::kInfo)<<sVectors<<endl; 
  }

  MSG("LIRun",Msg::kDebug) 
    <<"PrintAll method finished"<<endl;
}

//......................................................................

void LIRun::PrintConfig(LIRunType_t LIRunType)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running PrintConfig method..."<<endl;

  //loop and print out the list of LI run pulse heights 
  //in the desired format
  if (LIRunType==kGainCurve){
    MSG("LIRun",Msg::kInfo)<<endl<<"<fullCalib>"<<endl;
  }
  else if (LIRunType==kDriftPoint){
    MSG("LIRun",Msg::kInfo)<<endl<<"<driftCalib>"<<endl;
  }

  Int_t numGainPoints=10;
  

  for (Int_t i=0;i<NUMPULSERBOXES;i++){
    //leave a line between pulser boxes
    if (i>0) MSG("LIRun",Msg::kInfo)<<endl;
    for (Int_t j=0;j<NUMLEDS;j++){
      //Int_t l=i*NUMLEDS+j;

      string sBox="";
      sBox=Form("%d",i);
      if (i<10) sBox="0"+sBox;

      string sLed="";
      sLed=Form("%d",j+1);
      if (j<9) sLed="0"+sLed;

      fS="box"+sBox+"led"+sLed+"#I=";

      for (Int_t g=0;g<numGainPoints;g++){

        //round up pulse height
        Double_t rem=0;
        Double_t newPh=0;
        rem=modf(1.1,&newPh);
        if (rem>0.5) newPh++;//round up
        
        string sPh=Form("%d",static_cast<Int_t>(newPh));
        fS+=sPh;
        if (g<numGainPoints-1) fS+=",";
      }
      fS+=";";
      //print out the string in the required format
      MSG("LIRun",Msg::kInfo)<<fS<<endl; 
    } 
  }
  if (LIRunType==kGainCurve){
    MSG("LIRun",Msg::kInfo)<<endl<<"</fullCalib>"<<endl;
  }
  else if (LIRunType==kDriftPoint){
    MSG("LIRun",Msg::kInfo)<<endl<<"</driftCalib>"<<endl;
  }
  
  //This is the format under which the parameters are specified
  //in the config file

  // New label under which we specify LI sequence for drift calib:
  //<driftCalib>
  //box00led01#I=400;
  //box00led02#I=440;
  //box00led03#I=510;
  //[etc., etc.]
  //box15led20#I=390;
  //</driftCalib>
  
  // New label under which we specify LI sequence for gain-curve calib:
  //<fullCalib>
  //box00led01#I=100,200,300,400,500,600,700,800,900,1000;
  //box00led02#I=110,220,330,440,550,660,770,880,990,1023;
  //[etc., etc.]
  //box15led20#I=98,196,294,392,490,588,686,784,882,980;
  //</fullCalib>
  
  MSG("LIRun",Msg::kVerbose) 
    <<"PrintConfig method finished"<<endl;
}

//......................................................................

void LIRun::SetHighLowPhPoints(Double_t highestPh,Double_t lowestPh)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running SetHighLowPhPoints method..."<<endl;

  fHighestPh=highestPh;//ph at highest required adc
  fLowestPh=lowestPh;//ph at lowest required adc

  MSG("LIRun",Msg::kVerbose) 
    <<"SetHighLowPhPoints method finished"<<endl;
}

//......................................................................

void LIRun::SetHighLowPinPoints(Double_t highestPin,
                                Double_t lowestPin)
{
  MSG("LIRun",Msg::kVerbose) 
    <<"Running SetHighLowPinPoints method..."<<endl;

  fHighestPin=highestPin;//pin adc at highest required adc
  fLowestPin=lowestPin;//pin adc at lowest required adc

  MSG("LIRun",Msg::kVerbose) 
    <<"SetHighLowPinPoints method finished"<<endl;
}

//......................................................................

---