Calibrate.cpp

Go to the documentation of this file.

#include "Calibrate.h"
#include <iostream>
bool Calibrate::validCalibrationDataFound=false;

Calibrate::Calibrate():Tool(){validCalibrationDataFound=false;}
bool Calibrate::Initialise(std::string configfile, DataModel &data){
  if(configfile!="")  m_variables.Initialise(configfile);
//m_variables.Print();
  m_variables.Get("verbose", m_verbose);
//Setup and start the stopwatch
  bool use_stopwatch = false;
  m_variables.Get("use_stopwatch", use_stopwatch);
  m_stopwatch = use_stopwatch ? new util::Stopwatch("Calibrate") : 0;
  m_variables.Get("stopwatch_file", m_stopwatch_file_name);
  if(m_stopwatch) m_stopwatch->Start();
  m_data= &data;
// Find the calibration_file configuration line and read in the calibration information
  m_variables.Get("calibration_file", m_calibration_file_name);
  if(m_verbose>INFO)std::cout<<"Read Calibration Information from "<<m_calibration_file_name<<std::endl;
  readCalibration(m_calibration_file_name);
  if(m_stopwatch) Log(m_stopwatch->Result("Initialise"), INFO, m_verbose);
  return true;
}
bool Calibrate::Execute(){
  if(m_stopwatch) m_stopwatch->Start();
// Dump hits for debugging purposes
  if(m_verbose>DEBUG2){
    std::cout<<" Dump of all hits before  calibration."<<std::endl;
    DumpHits(m_data->IDSamples);
  }
 // Apply calibration to the inner detector data

  ApplyCalibration(m_data->IDSamples);

// For debug purposes, dump all hits after calibration  
  if(m_verbose>DEBUG2){

    std::cout<<" Dump of all hits after calibration. "<<std::endl;

    DumpHits(m_data->IDSamples);
  }
  if(m_stopwatch) m_stopwatch->Stop();
  return true;
}
// Finish off, nothing special/
bool Calibrate::Finalise(){
  if(m_stopwatch) {
    Log(m_stopwatch->Result("Execute", m_stopwatch_file_name), INFO, m_verbose);
    m_stopwatch->Start();
  }
  if(m_stopwatch) {
    Log(m_stopwatch->Result("Finalise"), INFO, m_verbose);
    delete m_stopwatch;
  }
  return true;
}
// Apply calibration to a single photomultiplier 
void Calibrate::ApplyCalibration(const int& PMTid, float& charge, TimeDelta::short_time_t& time,bool& masked)
{
  if(m_verbose>DEBUG1)std::cout<<" Apply calibration to PMT with ID "<<PMTid<<std::endl;
  auto location=calibrationInformation.find(PMTid);
  if(location != calibrationInformation.end())
  {
    if(m_verbose>DEBUG1)
      std::cout<<" apply calibration, masked : "<<location->second.masked<<" and charge scaling "<<location->second.chargeScaling<<std::endl;
    masked=location->second.masked;
    charge*=location->second.chargeScaling;
  }
}
// Apply calibration to a vector of SubSample objects
void Calibrate::ApplyCalibration(std::vector<SubSample> &samples)
{
  for (auto& sample : samples )
  {
    // Loop over all hits in this sample and apply calibration to each one
    for(int hit=sample.m_first_unique;hit<sample.m_PMTid.size();hit++)
    {
      bool masked=sample.m_masked[hit];
      if(not masked ){
        ApplyCalibration(sample.m_PMTid[hit],
          sample.m_charge[hit],
          sample.m_time[hit],
          masked);
        sample.m_masked[hit]=masked;
      }
    }
  }
  
}
// Read in calibration data and store it in memory.
void Calibrate::readCalibration(std::string calibrationFileName)
{
  validCalibrationDataFound=false;

  std::ifstream input(calibrationFileName);
  if(!input)
  {
    if(m_verbose>=WARN)
      std::cout<<"Failed to open "<<calibrationFileName<<" to read in calibration information "<<std::endl;
  }
  else
  {
// First read in the header to check the file is valid
    std::string headerName ;
    float headerVersion;
    float calibrationVersion;
    input >>headerName ;
    if(headerName.compare("HKDAQCalibration")!=0)
    {
      if(m_verbose>=WARN)
        std::cout<<" Calibration data header does not start with HKDAQCalibration - no calibration possible "<<std::endl;
      return;
    }
    // Read in versions of file format and calibration data
    validCalibrationDataFound=true;
    input >>headerVersion;
    input >>calibrationVersion;

    if(m_verbose>INFO)
    {
      std::ios oldState(nullptr);
      oldState.copyfmt(std::cout);
      std::cout<<" Calibration information read from "<<calibrationFileName<<std::endl<<
      " File format "<<std::fixed<<std::setprecision( 2 )<<headerVersion<<" calibrationVersion "<<calibrationVersion <<std::endl<<
      " PMT Channel ID : masked? : charge scaling factor "<<std::endl;
      std::cout.copyfmt(oldState);
    }
    // Loop through the file and populate calibrationInformation map
    while(!input.eof())
    {
      PMTChannelID ID;
      input >>ID;
      calibrationData data;
      input >>data.masked ;
      input >>data.chargeScaling ;
      calibrationInformation[ID]=data;
      if(m_verbose>INFO)
      {
        std::cout<<ID<<" "<<data.masked<<" "<<data.chargeScaling<<std::endl;
      }
    }
    if(m_verbose>DEBUG1)
      for (auto element : calibrationInformation)
      {
        std::cout<<element.first<<" "<<element.second.masked<<" "<<element.second.chargeScaling<<std::endl;
      }
    }
    return;
  }

// Dump Hits - for debugging 
void Calibrate::DumpHits(std::vector<SubSample> &samples)
{
  std::cout<<" loop over "<<samples.size()<<" values "<<std::endl;
  for (auto sample : samples)
  {
    std::cout<<" loop over "<<sample.m_PMTid.size()<<" hits "<<std::endl;

    for(int hit=sample.m_first_unique;hit<sample.m_PMTid.size();hit++)
    {
      bool masked=sample.m_masked[hit];
      DumpHit(sample.m_PMTid[hit],
        sample.m_charge[hit],
        sample.m_time[hit],
        masked);
    }
  }
}
// Dump one hit - for debugging
void Calibrate::DumpHit(const int& PMTid, float& charge, TimeDelta::short_time_t& time,bool& masked)
{
  std::cout<<PMTid<<" "<<charge<<" "<<time<<" mask "<<masked<<std::endl;
}