RayleighModelOff.cc

Go to the documentation of this file.

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

#include <det/Detector.h>

#include <atm/RayleighModelOff.h>
#include <atm/ScatteringResult.h>
#include <atm/AttenuationResult.h>
#include <atm/ProfileResult.h>
#include <utl/TabulatedFunctionErrors.h>

#include <fwk/CentralConfig.h>
#include <fwk/CoordinateSystemRegistry.h>

#include <utl/Point.h>
#include <utl/AugerUnits.h>
#include <utl/Reader.h>
#include <utl/ErrorLogger.h>
#include <utl/MathConstants.h>
#include <utl/ReferenceEllipsoid.h>

using namespace det;
using namespace atm;
using namespace utl;
using namespace std;
using namespace fwk;


ScatteringResult
RayleighModelOff::EvaluateRayleighScattering(const utl::Point& /*x1*/,
                                             const utl::Point& /*x2*/,
                                             const double angle,
                                             const double /*distance*/,
                                             const vector<double>& wLength)
  const
{
  utl::TabulatedFunctionErrors frac;

  for (std::vector<double>::const_iterator it = wLength.begin();
       it != wLength.end(); ++it)
    frac.PushBack(*it, 0, 0, 0);

  return ScatteringResult(frac, angle);
}


ScatteringResult
RayleighModelOff::EvaluateRayleighScattering(const utl::Point& x1,
                                             const utl::Point& x2,
                                             const double angle,
                                             const double distance,
                                             const AttenuationResult& raylAtt)
  const
{
  // This method just delegates because the scattering disregards the
  // attenuation for "Off".
  const TabulatedFunctionErrors& attenuation = raylAtt.GetTransmissionFactor();
  vector<double> wLength(attenuation.GetNPoints());
  std::copy(attenuation.XBegin(), attenuation.XEnd(), wLength.begin());
  return EvaluateRayleighScattering(x1, x2, angle, distance, wLength);
}


AttenuationResult
RayleighModelOff::EvaluateRayleighAttenuation(const utl::Point& /*xInit*/,
                                              const utl::Point& /*xFinal*/,
                                              const vector<double>&  wLength)
  const
{
  utl::TabulatedFunctionErrors attenuation;

  for (std::vector<double>::const_iterator it = wLength.begin() ;
       it != wLength.end() ; ++it)
    attenuation.PushBack(*it, 0, 1, 0);

  return attenuation;
}


utl::TabulatedFunctionErrors
RayleighModelOff::GetAttenuationLength(const utl::Point& /*p*/,
                                       const std::vector<double>& /*wLength*/)
  const
{
  TabulatedFunctionErrors tab;
  tab.PushBack(0, 0, 0, 0);
  return tab;
}


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