FDetector/Channel.cc

Go to the documentation of this file.

#include <string>
#include <sstream>

#include <boost/lexical_cast.hpp>

#include <det/VManager.h>
#include <det/Detector.h>

#include <fdet/FDetector.h>
#include <fdet/Eye.h>
#include <fdet/Telescope.h>
#include <fdet/Camera.h>
#include <fdet/Channel.h>

#include <utl/ErrorLogger.h>

using namespace fdet;
using namespace det;
using namespace utl;
using namespace std;


Channel::Channel(const unsigned int eyeId,
                 const unsigned int telescopeId,
                 const unsigned int channelId,
                 const std::string& physEyeIdString,
                 const std::string& physTelIdString) :
  fChannelId(channelId),
  fTelescopeId(telescopeId),
  fEyeId(eyeId),
  fPhysicalEyeIdString(physEyeIdString),
  fPhysicalTelescopeIdString(physTelIdString),
  fADCVariance(0),
  fThreshold(0),
  fBaseline(0) 
{
  fChannelIdStr = boost::lexical_cast<string>(channelId);
}


Channel::~Channel()
{
  delete fADCVariance;
  delete fThreshold;
  delete fBaseline;
}

void Channel::Update() const {

  // reset time dependent parameters
  delete fADCVariance;
  delete fThreshold;
  delete fBaseline;
  fADCVariance = 0;
  fThreshold = 0;
  fBaseline = 0;
}


bool
Channel::IsVirtual()
  const
{
  const fdet::Telescope& detTel =
    det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId);
  return fChannelId > detTel.GetLastPixelId();
}


unsigned int Channel::GetVirtualChannelId() const {
  const fdet::Telescope& detTel =
    det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId);

  const int row = (fChannelId - detTel.GetFirstPixelId()) %
    detTel.GetLastRow() + detTel.GetFirstRow();
  
  const int col = (fChannelId - detTel.GetFirstPixelId()) /
    detTel.GetLastRow() + detTel.GetFirstColumn();
  
  if( (row % 2) == 0 ) { // even row
    return (detTel.GetLastPixelId() + 2) + (col - detTel.GetFirstColumn()) * 2;
  } else {            // odd row
    return (detTel.GetLastPixelId() + 1) + (col - detTel.GetFirstColumn()) * 2;
  }
}


// properties of the camera

unsigned int
Channel::GetPixelId()
  const
{
  return det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera().GetPixelId(fChannelId);
}


int
Channel::GetFLTBoxcarSumLength()
  const
{
  return det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera().GetFLTBoxcarSumLength();
}


int
Channel::GetFLTProlongation()
  const
{
  return det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera().GetFLTProlongation();
}


int
Channel::GetSLTTriggerBin()
  const
{
  return det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera().GetSLTTriggerBin();
} 


double Channel::GetGainVariance() const {
  return det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera().GetGainVariance();
}

double Channel::GetElectronicNoiseVariance() const {
  return det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera().GetElectronicNoiseVariance();
}

int
Channel::GetFADCTraceLength()
  const
{
  return det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera().GetFADCTraceLength();
}


double
Channel::GetFADCBinSize()
  const
{
  return det::Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera().GetFADCBinSize();
}



double
Channel::GetElectronicsGain()
  const
{
  const fdet::Camera& dCamera =
    Detector::GetInstance().GetFDetector().GetEye(fEyeId).GetTelescope(fTelescopeId).GetCamera();
  if (IsVirtual())
    return dCamera.GetElectronicsGain() / dCamera.GetVirtualChannelGainRatio();
  else
    return dCamera.GetElectronicsGain();
}



// real properties of the channel

double
Channel::GetADCVariance()
  const
{
  return GetChannelData(fADCVariance, "ADCVariance", "channel", "ADC variance");
}

double
Channel::GetThreshold()
  const
{
  return GetChannelData(fThreshold, "Threshold", "channel", "pixel threshold");
}

double
Channel::GetBaseline()
  const
{
  return GetChannelData(fBaseline, "Baseline", "channel", "pixel baseline");
}



template<typename T>
inline
const T&
Channel::GetChannelData(T*& requestedData,
                        const std::string& property,
                        const std::string& component,
                        const std::string& errorMsg)
  const
{  
  if (!requestedData) {
    requestedData = new T;
    GetChannelData(*requestedData, property, component, errorMsg);
  }
  return *requestedData;
}


template<typename T>
inline
void
Channel::GetChannelData(T& requestedData,
                        const std::string& property,
                        const std::string& component,
                        const std::string& errorMsg)
  const
{  
  const VManager& manager = Detector::GetInstance().GetFManagerRegister();

  VManager::IndexMap indexMap;
  indexMap["channelId"] = fChannelIdStr;
  indexMap["telescopeId"] = fPhysicalTelescopeIdString;
  indexMap["eyeId"] = fPhysicalEyeIdString;

  const VManager::Status foundFlag = manager.GetData(requestedData, property, component, indexMap);

  if (foundFlag == VManager::eNotFound) {
    ostringstream err;
    err << "Did not find requested component for " << errorMsg << "; "
        << VManager::QueryInfoMessage(property, component, indexMap);
    ERROR(err);
    throw NonExistentComponentException(err.str());
  }
}