MultiAnisoSurfaceWaveObjective.cpp

Go to the documentation of this file.

#include "MultiAnisoSurfaceWaveObjective.h"
#include "FatalException.h"
#include "convert.h"
#include <boost/bind.hpp>
#include <numeric>
namespace gplib
  {
    MultiAnisoSurfaceWaveObjective::MultiAnisoSurfaceWaveObjective()
      {
      }

    MultiAnisoSurfaceWaveObjective::~MultiAnisoSurfaceWaveObjective()
      {
      }

    void MultiAnisoSurfaceWaveObjective::AddMeasurement(
        const ParkSurfaceWaveData &Measured, const double back,
        const double avel)
      {
        boost::shared_ptr<AnisoSurfaceWaveObjective> CurrObj(
            new AnisoSurfaceWaveObjective(Measured, back, avel));
        IndividualObjectives.push_back(CurrObj);
        backazimuths.push_back(back);
      }

    void MultiAnisoSurfaceWaveObjective::PreParallel(const ttranscribed &member)
      {
        if (IndividualObjectives.empty())
          throw FatalException(
              "In Multi1DRecObjective: No Objective functions set !");
        const size_t nobjs = IndividualObjectives.size();
        for (size_t i = 0; i < nobjs; ++i)
          {
            IndividualObjectives.at(i)->SetParallelID(GetParallelID()
                + stringify(i));
            IndividualObjectives.at(i)->PreParallel(member);
          }
      }

    double MultiAnisoSurfaceWaveObjective::PostParallel(
        const ttranscribed &member)
      {
        std::vector<double> values;
        transform(IndividualObjectives.begin(), IndividualObjectives.end(),
            back_inserter(values), boost::bind(
                &AnisoSurfaceWaveObjective::PostParallel, _1, member));
        double sumsquares = inner_product(values.begin(), values.end(),
            values.begin(), 0.0);
        return sqrt(sumsquares / values.size());
      }

    void MultiAnisoSurfaceWaveObjective::SafeParallel(
        const ttranscribed &member)
      {
        for_each(IndividualObjectives.begin(), IndividualObjectives.end(),
            boost::bind(&AnisoSurfaceWaveObjective::SafeParallel, _1, member));
      }

    MultiAnisoSurfaceWaveObjective::MultiAnisoSurfaceWaveObjective(
        const MultiAnisoSurfaceWaveObjective &Old)
      {
        const size_t nobjs = Old.IndividualObjectives.size();
        IndividualObjectives.clear();
        backazimuths.clear();
        copy(Old.backazimuths.begin(), Old.backazimuths.end(), back_inserter(
            backazimuths));
        for (size_t i = 0; i < nobjs; ++i)
          {
            boost::shared_ptr<AnisoSurfaceWaveObjective> Obj(
                Old.IndividualObjectives.at(i)->clone());
            IndividualObjectives.push_back(Obj);
          }
      }

    void MultiAnisoSurfaceWaveObjective::WriteData(const std::string &filename)
      {
        const size_t nobjs = IndividualObjectives.size();
        for (size_t i = 0; i < nobjs; ++i)
          {
            IndividualObjectives.at(i)->WriteData(filename + stringify(i)); // write one output file for each BAZ
          }
      }

    // MODES : We need one model for each baz
    void MultiAnisoSurfaceWaveObjective::WriteModel(const std::string &filename)
      {
        const size_t nobjs = IndividualObjectives.size();
        for (size_t i = 0; i < nobjs; ++i)
          {
            IndividualObjectives.at(i)->WriteModel(filename + stringify(i)); // write one model file for each BAZ
          }
      }

    // MODES: we plot the inverted parameters
    void MultiAnisoSurfaceWaveObjective::WritePlot(const std::string &filename)
      {
        IndividualObjectives.front()->WritePlot(filename); //all models are the same, so we only write the first
      }

    MultiAnisoSurfaceWaveObjective& MultiAnisoSurfaceWaveObjective::operator=(
        const MultiAnisoSurfaceWaveObjective& source)
      {
        if (this == &source)
          return *this;
        const size_t nobjs = source.IndividualObjectives.size();
        IndividualObjectives.clear();
        backazimuths.clear();
        copy(source.backazimuths.begin(), source.backazimuths.end(),
            back_inserter(backazimuths));
        for (size_t i = 0; i < nobjs; ++i)
          {
            boost::shared_ptr<AnisoSurfaceWaveObjective> Obj(
                source.IndividualObjectives.at(i)->clone());
            IndividualObjectives.push_back(Obj);
          }
        return *this;
      }
  }