sim_vel_model_impl.hpp

/* sim_vel_model_impl.hpp */
/* $Id$ */
#ifndef __sim_vel_model_impl_hpp
#define __sim_vel_model_impl_hpp

#include <iterator>
#include <stdio.h>

//------------------------------------------------------------------------------------------

template <typename ParamsT>
const sim::VmLayer1D2D sim::VelModel1D2D<ParamsT>::m_dummy_layer;

template <typename ParamsT>
const ParamsT sim::VelModel1D2D<ParamsT>::m_dummy_params;

template <typename ParamsT>
const ParamsT& sim::VelModel1D2D<ParamsT>::operator()(const Point2D &coords) const
{
  // no layers => no parameters
  if (m_lays.empty())
    {
      fprintf(stderr, "sim::VelModel1D2D<>::(): error, no layers present.\n");
      return m_dummy_params;
    }
  
  // try to find correspondent parameters
  typename std::list<std::pair<VmLayer1D2D, ParamsT> >::const_reverse_iterator rit = 
    m_lays.rbegin();
  for (;rit != m_lays.rend(); ++rit)
    {
      if (coords.z >= rit->first.zCoord(coords.x))
    break;
    }
  
  // if z < than z of the first layer => continue parameters upwards
  if (rit == m_lays.rend())
    --rit;
  
  return rit->second;
}

template <typename ParamsT>
void sim::VelModel1D2D<ParamsT>::appendLayer(const sim::VmLayer1D2D &layer, 
                         const ParamsT &params)
{
  // layers are sorted by z-ascending
  typename std::list<std::pair<VmLayer1D2D, ParamsT> >::iterator it = m_lays.begin();
  bool replaced = false;
  for (;it != m_lays.end(); ++it)
    {
      if (layer.coords().z == it->first.coords().z)
    {
      it->first = layer;
      it->second = params;
      replaced = true;
      break;
    }
      
      if (layer.coords().z < it->first.coords().z)
    break;
    }
  
  // add new layer if it is not replaced on one with equal z
  if (!replaced)
    m_lays.insert(it, std::pair<VmLayer1D2D, ParamsT>(layer, params));
}

template <typename ParamsT>
size_t sim::VelModel1D2D<ParamsT>::layersNum() const
{
  return m_lays.size();
}

template <typename ParamsT>
const sim::VmLayer1D2D& sim::VelModel1D2D<ParamsT>::layer(const size_t id) const
{
  if (id >= m_lays.size())
    {
      fprintf(stderr, 
          "sim::VelModel1D2D<>::layer: error, id=%zu out of range (%zu layers presents).\n",
          id, m_lays.size());
      return m_dummy_layer;
    }
  
  typename std::list<std::pair<VmLayer1D2D, ParamsT> >::const_iterator it = m_lays.begin();
  std::advance(it, id);
  return it->first;
}

template <typename ParamsT>
const ParamsT& sim::VelModel1D2D<ParamsT>::params(const size_t id) const
{
  if (id >= m_lays.size())
    {
      fprintf(stderr, 
          "sim::VelModel1D2D<>::params: error, id=%zu out of range (%zu layers presents).\n",
          id, m_lays.size());
      return m_dummy_params;
    }
  
  typename std::list<std::pair<VmLayer1D2D, ParamsT> >::const_iterator it = m_lays.begin();
  std::advance(it, id);
  return it->second;
}

template <typename ParamsT>
void sim::VelModel1D2D<ParamsT>::removeLayer(const size_t id)
{
  size_t size = m_lays.size();
  
  if (id >= size)
    {
      fprintf(stderr, 
          "sim::VelModel1D2D<>::removeLayer: warning, id=%zu out of range (%zu layers presents).",
          id, m_lays.size());
      
      if (size > 0)
    {
      m_lays.pop_back();
      fprintf(stderr, 
          "sim::VelModel1D2D<>::removeLayer: warning, the last layer is deleted.\n");
    }
      return;
    }
  
  typename std::list<std::pair<VmLayer1D2D, ParamsT> >::iterator it = m_lays.begin();
  std::advance(it, id);
  m_lays.erase(it);
}

template <typename ParamsT>
void sim::VelModel1D2D<ParamsT>::clear()
{
  m_lays.clear();
}

#endif /* sim_vel_model_impl.hpp */