RDetector/Channel.cc

Go to the documentation of this file.

#include <det/Detector.h>

#include <rdet/RDetector.h>
#include <rdet/Channel.h>

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

#include <sstream>

using namespace det;
using namespace rdet;
using namespace std;
using namespace utl;


Channel::Channel(const int sid, const int cid) :
  fStationIdString(boost::lexical_cast<string>(sid)),
  fChannelIdString(boost::lexical_cast<string>(cid)),
  fChannelId(cid)
{
  fAntenna = new AntennaType(GetAntennaTypeName());
}


Channel::~Channel()
{
  delete fAntenna;
  //delete fGlobalResponse; // complex global response, tabulated in freq.
}


int
Channel::GetOkFlag()
  const
{
  return GetChannelData(fChannelOk, "Channel_OK", "RChannel", "Channel Ok data");
}


double
Channel::GetDesignLowerFreq()
  const
{
  return GetChannelData(fDesignLowerFreq, "DesignLowerFreq", "RChannel", "DesignLowerFreq");
}


double
Channel::GetDesignUpperFreq()
  const
{
  return GetChannelData(fDesignUpperFreq, "DesignUpperFreq", "RChannel", "DesignUpperFreq");
}


double
Channel::GetOrientationZenith()
  const
{
  return GetChannelData(fOrientationZenith, "OrientationZenith", "RChannel", "OrientationZenith");
}


double
Channel::GetOrientationAzimuth()
  const
{
  return GetChannelData(fOrientationAzimuth, "OrientationAzimuth", "RChannel", "OrientationAzimuth");
}


double
Channel::GetOrientationZeta()
  const
{
  return GetChannelData(fOrientationZeta, "OrientationZeta", "RChannel", "OrientationZeta");
}


const std::string&
Channel::GetChannelType()
  const
{
  return GetChannelData(fChannelType, "ChannelType", "RChannel", "ChannelType");
}


const std::string&
Channel::GetADCType()
  const
{
  return GetChannelData(fADCType, "ADCType", "RADC", "ADCType");
}


int
Channel::GetBitDepth()
  const
{
  return GetChannelData(fBitDepth, "BitDepth", "RADC", "BitDepth");
}


double
Channel::GetSamplingFrequency()
  const
{
  return GetChannelData(fSamplingFrequency, "SamplingFrequency", "RADC", "SamplingFrequency");
}


double
Channel::GetMinVoltage()
  const
{
  return GetChannelData(fMinVoltage, "MinVoltage", "RADC", "MinVoltage");
}


double
Channel::GetMaxVoltage()
  const
{
  return GetChannelData(fMaxVoltage, "MaxVoltage", "RADC", "MaxVoltage");
}


const std::string&
Channel::GetAntennaTypeName()
  const
{
  return GetChannelData(fAntennaTypeName, "AntennaType", "RChannel", "AntennaType");
}


double
Channel::GetDesignImpedance()
  const
{
  return GetChannelData(fDesignImpedance, "DesignImpedance", "RAntenna", "DesignImpedance");
}


double
Channel::GetIntegratedHorizontalGain()
  const
{
  return GetChannelData(fIntegratedHorizontalGain, "IntegratedHorizontalGain", "RAntenna", "IntegratedHorizontalGain");
}


double
Channel::GetIntegratedVerticalGain()
  const
{
  return GetChannelData(fIntegratedVerticalGain, "IntegratedVerticalGain", "RAntenna", "IntegratedVerticalGain");
}


pair<complex<double>, complex<double>>
Channel::GetElectricFieldResponse(const double theta, const double phi, const double freq,
                                  const std::string interpolationMode)
  const
{
  return fAntenna->GetElectricFieldResponse(theta, phi - GetOrientationAzimuth(), freq,
                                            interpolationMode);
  //fixme TH: antenna zeta angle is ignored, in fact a tilting of the antenna would require a resimulation of the antenna pattern
}


double
Channel::GetIntegratedEffectiveAntennaHeight(const double freq)
  const
{
  return fAntenna->GetIntegratedEffectiveAntennaHeight(freq);
}


void
Channel::Update()
  const
{
  //fixme TH: Why is the ChannelOk flag set to invalid in a Channel Update, why nothing else? Is the ChannelOk flag actually used anywhere
  fChannelOk.SetValid(false);
}


const Point&
Channel::GetPosition()
  const
{
  if (!fPosition.IsValid()) {

    Validated<vector<double> > coords;
    GetChannelData(coords, "Position", "RChannel", "Position");

    const int id = boost::lexical_cast<int>(fStationIdString);
    CoordinateSystemPtr tCS =
      Detector::GetInstance().GetRDetector().GetStation(id).GetLocalCoordinateSystem();
    Point pt(coords.Get()[0], coords.Get()[1], coords.Get()[2], tCS);
    fPosition.Set(pt);
  }
  return fPosition.Get();
}


void
Channel::NotFoundAndExit(const string& msg)
  const
{
  ostringstream err;
  err << "Did not find requested component :" << msg << "\n"
         "Requested station = " << fStationIdString << "\n"
         "Requested channel = " << fChannelIdString;
  ERROR(err);
  throw NonExistentComponentException(err.str());
}


const ResponseMap&
Channel::GetResponseMap()
  const
{
  if (!fResponseMap.IsValid()) {
    Validated<map<string, double>> m;
    GetChannelData(m, "ResponseMapEntry", "RResponseMapList", "ResponseMap");
    fResponseMap.Set(ResponseMap(m.Get()));
  }
  return fResponseMap.Get();
}


const TabulatedFunction&
Channel::GetCalibrationFunction()
  const
{
  //fixme TH: need to implement interface to the CalibrationManager
  static const TabulatedFunction foo;
  const string err = "Channel::GetCalibrationFunction() not implemented!";
  ERROR(err);
  throw NonExistentComponentException(err);
  return foo;
}