SuperMieModel.cc

Go to the documentation of this file.

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

#include <det/Detector.h>
#include <atm/ParametricXMLMieModel.h>
#include <atm/ScatteringResult.h>
#include <atm/AttenuationResult.h>

#include <atm/MeasuredDBMieModel.h>
#include <atm/ParametricXMLMieModel.h>
#include <atm/SuperMieModel.h>
#include <atm/ScatteringResult.h>
#include <atm/AttenuationResult.h>

using namespace atm;
using namespace utl;
using namespace std;

SuperMieModel::SuperMieModel() : VMieModel() {
  fMeasuredDBMieModel    = new MeasuredDBMieModel();
  fParametricXMLMieModel = new ParametricXMLMieModel();
}

SuperMieModel::~SuperMieModel() {
  delete fMeasuredDBMieModel;
  delete fParametricXMLMieModel;
}


void SuperMieModel::Init() {
  fMeasuredDBMieModel->Init();
  fParametricXMLMieModel->Init();
}


ScatteringResult SuperMieModel::EvaluateMieScattering(const utl::Point& xInit,
                                                      const utl::Point& xFinal,
                                                      const double angle,
                                                      const double distance,
                                                      const vector<double>& wLength) const {

  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->EvaluateMieScattering(xInit, xFinal, angle, distance, wLength);
  else
    return fParametricXMLMieModel->EvaluateMieScattering(xInit, xFinal, angle, distance, wLength);
}


ScatteringResult SuperMieModel::EvaluateMieScattering(const utl::Point& xInit,
                                                      const utl::Point& xFinal,
                                                      const double angle,
                                                      const double distance,
                                                      const AttenuationResult& mieAttenuation) const {

  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->EvaluateMieScattering(xInit, xFinal, angle, distance, mieAttenuation);
  else
    return fParametricXMLMieModel->EvaluateMieScattering(xInit, xFinal, angle, distance, mieAttenuation);
}


double SuperMieModel::EvaluateMieScattering(const utl::Point& xInit,
                                            const utl::Point& xFinal,
                                            const double angle,
                                            const double distance,
                                            double wLength) const {

  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->EvaluateMieScattering(xInit, xFinal, angle, distance, wLength);
  else
    return fParametricXMLMieModel->EvaluateMieScattering(xInit, xFinal, angle, distance, wLength);
}


double SuperMieModel::EvaluateMieScattering(const utl::Point& xInit,
                                            const utl::Point& xFinal,
                                            const double angle,
                                            const double distance,
                                            double wLength,
                                            const double mieAttenuation) const {

  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->EvaluateMieScattering(xInit, xFinal, angle, distance, wLength, mieAttenuation);
  else
    return fParametricXMLMieModel->EvaluateMieScattering(xInit, xFinal, angle, distance, wLength, mieAttenuation);
}


AttenuationResult SuperMieModel::EvaluateMieAttenuation(const utl::Point& xInit,
                                                        const utl::Point& xFinal,
                                                        const vector<double>& wLength) const{

  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->EvaluateMieAttenuation(xInit, xFinal, wLength);
  else
    return fParametricXMLMieModel->EvaluateMieAttenuation(xInit, xFinal, wLength);
}

double SuperMieModel::EvaluateMieAttenuation(const utl::Point& xInit,
                                             const utl::Point& xFinal,
                                             double wLength) const{

  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->EvaluateMieAttenuation(xInit, xFinal, wLength);
  else
    return fParametricXMLMieModel->EvaluateMieAttenuation(xInit, xFinal, wLength);
}


double
SuperMieModel::GetVerticalAerosolOpticalDepth(const unsigned int eyeId, const double altitude) const {
  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->GetVerticalAerosolOpticalDepth(eyeId, altitude);
  else
    return fParametricXMLMieModel->GetVerticalAerosolOpticalDepth(eyeId, altitude);
}

double SuperMieModel::GetAttenuationLength(const utl::Point& p,
                                                const double wLength) const {
  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->GetAttenuationLength(p, wLength);
  else
    return fParametricXMLMieModel->GetAttenuationLength(p, wLength);
}

double SuperMieModel::EvaluateScatteringAngle(const utl::Point& p,
                                              const double angle,
                                              const double wLength) const {
  if (fMeasuredDBMieModel->HasData())
    return fMeasuredDBMieModel->EvaluateScatteringAngle(p, angle, wLength);
  else
    return fParametricXMLMieModel->EvaluateScatteringAngle(p, angle, wLength);
}


void SuperMieModel::SetUncertaintyBound(double nSigma) const {

  fMeasuredDBMieModel->SetUncertaintyBound(nSigma);

}

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