Framework/FDetector/Camera.cc

Go to the documentation of this file.

#include <sstream>

#include <boost/lexical_cast.hpp>

#include <fdet/Camera.h>

#include <utl/ErrorLogger.h>
#include <utl/Md5Sum.h>

#include <det/VManager.h>
#include <det/Detector.h>
#include <fdet/FDetector.h>
#include <fdet/Eye.h>
#include <fdet/Telescope.h>
#include <fdet/Pixel.h>
#include <fdet/Channel.h>

#include <fevt/Pixel.h>
#include <fevt/Channel.h>

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


Camera::Camera(const unsigned int eyeId, const unsigned int telId,
               const std::string& physEyeIdString,
               const std::string& physTelIdString) :
  fEyeId(eyeId),
  fTelescopeId(telId),
  fPhysicalEyeIdString(physEyeIdString),
  fPhysicalTelescopeIdString(physTelIdString),
  fRadiusFocal(0),
  fMercedesBase(0),
  fMercedesHeight(0),
  fSigmaNormal(0),
  fMercedesEfficiency(0),
  fMercedesReflections(0),
  fPixelEta(0),
  fCenterRow(0),
  fCenterColumn(0),
  fFieldOfView(0),
  fSLTTriggerBin(0),
  fSLTTraceLenth(0),
  fSLTBinSize(0),
  fFADCTraceLenth(0),
  fFADCBinSize(0),
  fFLTBoxCarmSumLength(0),
  fFLTProlongation(0),
  fFLTTriggerRate(0),
  fCutoffFrequency(0),
  fGainVar(0),
  fElectNoiseVar(0),
  fADCDynamicRange(0),
  fElecGain(0),
  fVirtualChannelGainRatio(0),
  fNRows(0),
  fNColumns(0)
{ }


Camera::~Camera()
{
  delete fRadiusFocal;
  delete fMercedesBase;
  delete fMercedesHeight;
  delete fSigmaNormal;
  delete fMercedesEfficiency;
  delete fMercedesReflections;
  delete fPixelEta;
  delete fCenterRow;
  delete fCenterColumn;
  delete fFieldOfView;
  delete fSLTTriggerBin;
  delete fSLTTraceLenth;
  delete fSLTBinSize;
  delete fFADCBinSize;
  delete fFADCTraceLenth;
  delete fFLTBoxCarmSumLength;
  delete fFLTProlongation;
  delete fFLTTriggerRate;
  delete fCutoffFrequency;
  delete fGainVar;
  delete fElectNoiseVar;
  delete fADCDynamicRange;
  delete fElecGain;
  delete fVirtualChannelGainRatio;
  delete fNRows;
  delete fNColumns;
}


void Camera::Update() {
}

// camera geometry/optics
double
Camera::GetMercedesBase()
  const
{
  return GetCameraData(fMercedesBase, "mercedesBase", "camera", "Mercedes base width");
}


double
Camera::GetMercedesHeight()
  const
{
  return GetCameraData(fMercedesHeight, "mercedesHeight", "camera", "Mercedes height");
}


double
Camera::GetRadiusFocal()
  const
{
  return GetCameraData(fRadiusFocal, "radiusFocal", "camera", "Radius focal");
}


double
Camera::GetSigmaNormal()
  const
{
  return GetCameraData(fSigmaNormal, "sigmaNormal", "camera", "sigma normal");
}


double
Camera::GetMercedesEfficiency()
  const
{
  return GetCameraData(fMercedesEfficiency, "mercedesEfficiency", "camera", "mercedes efficiency");
}

double
Camera::GetMercedesReflections()
  const
{
  return GetCameraDataDiaphragm(fMercedesReflections, "mercedesReflections", "camera", "average number of mercedes reflections");
}


double
Camera::GetFieldOfView()
  const
{
  return GetCameraData(fFieldOfView, "fieldOfView", "camera", "field of view");
}




double
Camera::GetEta()
  const
{
  return GetCameraData(fPixelEta, "eta", "camera", "pixel eta");
}

double
Camera::GetCenterRow()
  const
{
  return GetCameraData(fCenterRow, "centerRow", "camera", "center row");
}

double
Camera::GetCenterColumn()
  const
{
  return GetCameraData(fCenterColumn, "centerColumn", "camera", "center row");
}


// camera electronics

int
Camera::GetSLTTriggerBin()
  const
{
  return GetCameraData(fSLTTriggerBin, "SLTTriggerBin", "electronics", "SLT trigger bin");
}


int
Camera::GetSLTTraceLength()
  const
{
   /*
   * SLT trace langth is 100 (*1mu s) for old and new (HEAT) electronics.
   * TODO: Should be in FModelConfig!
   */
  /*
   * double size = GetSLTBinSize();
   * double tracelength = GetFADCBinSize() * GetFADCTraceLength();
   * return (int) ceil(tracelength/size);
   */

  return 100;
}

double
Camera::GetSLTBinSize()
  const
{
  return GetCameraData(fSLTBinSize, "SLTBinWidth", "electronics", "SLT bin width");
}


int
Camera::GetFADCTraceLength()
  const
{
  return GetCameraData(fFADCTraceLenth, "numTraceBins", "electronics", "FADC trace size");
}


double
Camera::GetFADCBinSize()
  const
{
  return GetCameraData(fFADCBinSize, "traceBinWidth", "electronics", "FADC bin width");
}


int
Camera::GetFLTBoxcarSumLength()
  const
{
  return GetCameraData(fFLTBoxCarmSumLength, "FLTBoxCarWidth", "electronics", "FLT boxcar length");
}

double
Camera::GetFLTTriggerRate()
  const
{
  return GetCameraData(fFLTTriggerRate, "FLTTriggerRate", "electronics", "FLT Trigger Rate");
}

int
Camera::GetFLTProlongation()
  const
{
  return GetCameraData(fFLTProlongation, "FLTProlongation", "electronics", "FLT prolongation for SLT");
}


double Camera::GetCutoffFrequency() const {
  return GetCameraData(fCutoffFrequency, "cutoffFrequency", "electronics", "Gaussian filter 3dB cutoff frequency");
}

double Camera::GetGainVariance() const {
  return GetCameraData(fGainVar, "gainVar", "electronics", "additional Gaussian fluctuantion to Poisson fluctuations");
}

double Camera::GetElectronicNoiseVariance() const {
  return GetCameraData(fElectNoiseVar, "elecNoiseVar", "electronics", "Electronic noise variance");
}

int Camera::GetADCDynamicRange() const {
  return GetCameraData(fADCDynamicRange, "ADCDynamicRange", "electronics", "ADC dynamic range w/o virtual channels");
}

double
Camera::GetElectronicsGain()
  const
{
  return GetCameraData(fElecGain, "gain", "electronics", "electronics gain");
}

double
Camera::GetVirtualChannelGainRatio()
  const
{
  return GetCameraData(fVirtualChannelGainRatio, "VirtualChannelGainRatio", "electronics",
                       "virtual channel gain ratio");
}


// camera cabling

unsigned int
Camera::GetChannelId(const unsigned int pixelId)
  const
{
  // no caching !
  int channelId;
  GetCameraPixelData(channelId, "pixel_mapping", "electronics", "pixel mapping", pixelId);
  return channelId;
}


unsigned int
Camera::GetChannelId(const fdet::Pixel& pixel)
  const
{
  // no caching !
  int channelId;
  GetCameraPixelData(channelId, "pixel_mapping", "electronics", "pixel mapping", pixel.GetId());
  return channelId;
}


unsigned int
Camera::GetChannelId(const fevt::Pixel& pixel)
  const
{
  // no caching !
  int channelId;
  GetCameraPixelData(channelId, "pixel_mapping", "electronics", "pixel mapping", pixel.GetId());
  return channelId;
}


unsigned int
Camera::GetPixelId(unsigned int channelId)
  const
{
  // no caching !
  int pixelId;
  GetCameraChannelData(pixelId, "channel_mapping", "electronics", "channel mapping", channelId);
  return pixelId;
}


unsigned int
Camera::GetPixelId(const fdet::Channel& channel)
  const
{
  // no caching !
  int pixelId;
  GetCameraChannelData(pixelId, "channel_mapping", "electronics", "channel mapping", channel.GetId());
  return pixelId;
}


unsigned int
Camera::GetPixelId(const fevt::Channel& channel)
  const
{
  // no caching
  int pixelId;
  GetCameraChannelData(pixelId, "channel_mapping", "electronics", "channel mapping", channel.GetId());
  return pixelId;
}


// Camera layout info
unsigned int
Camera::GetLastRow()
  const
{
  const int row = GetCameraData(fNRows,
                                "pixelRows", "camera", "number of pixel rows");
  return (unsigned int)row;
}


unsigned int
Camera::GetLastColumn()
  const
{
  const int col = GetCameraData(fNColumns,
                                "pixelColumns", "camera", "number of pixel columns");
  return (unsigned int)col;
}


std::string
Camera::GetThresholdConfigSignature()
  const
{
  ostringstream configString;
  configString << "Threshold:" 
               << " Gain = " << GetElectronicsGain()
               << " GainVariance = " << GetGainVariance()
               << " ElectronicNoise = " << GetElectronicNoiseVariance()
               << " CutoffFrequency = " << GetCutoffFrequency()
               << " FLTTriggerRate = " << GetFLTTriggerRate()
               << " FLTBoxcarSize = " << GetFLTBoxcarSumLength();
  if(fEyeId>0 && fEyeId<5){
    if(fTelescopeId>0 && fTelescopeId<7){
      configString << " Telescopetype = standard";
    }
  }else if(fEyeId==5){
    if(fTelescopeId>0 && fTelescopeId<4){
      configString << " Telescopetype = HEAT";
    }
  }
  return Md5Sum(configString.str()).GetHexDigest();
}

// data getters

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


template<typename T>
inline
void
Camera::GetCameraData(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["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());
  }
}

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


template<typename T>
inline
void
Camera::GetCameraDataDiaphragm(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["telescopeId"] = fPhysicalTelescopeIdString;
  indexMap["eyeId"] = fPhysicalEyeIdString;
  const fdet::FDetector& detFD = Detector::GetInstance().GetFDetector();
  const bool hasCorrectorRing =
    detFD.GetEye(fEyeId).GetTelescope(fTelescopeId).HasCorrectorRing();
  indexMap["correctorId"] = (hasCorrectorRing ? "large" : "small");

  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());
  }
}


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

  VManager::IndexMap indexMap;
  indexMap["telescopeId"] = fPhysicalTelescopeIdString;
  indexMap["eyeId"] = fPhysicalEyeIdString;
  indexMap["channelId"] = boost::lexical_cast<string>(channelId);

  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());
  }
}


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

  VManager::IndexMap indexMap;
  indexMap["telescopeId"] = fPhysicalTelescopeIdString;
  indexMap["eyeId"] = fPhysicalEyeIdString;
  indexMap["pixelId"] = boost::lexical_cast<string>(pixelId);

  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());
  }
}


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. FDetector/Camera.o -k"
// End: