gsAPALMData.h

Go to the documentation of this file.

#pragma once

#include <gsCore/gsLinearAlgebra.h>
#include <gsNurbs/gsKnotVector.h>
#include <gsIO/gsOptionList.h>
#include <gsHSplines/gsKdNode.h>
#include <deque>

namespace gismo
{

template<class T, class solution_t >
class gsAPALMData
{

public:

  ~gsAPALMData()
  {

  }

  gsAPALMData(const std::vector<T> & times, const  std::vector<solution_t> & solutions);

  gsAPALMData(const std::vector<T> & times);

  gsAPALMData();

private:

  void _defaultOptions();

  void _applyOptions();

public:

  void addStartPoint(const T & time, const solution_t & solution, bool priority = false);

  void appendPoint(bool priority = false);

  void appendData(const T & time, const solution_t & solution, bool priority=false);

  void setData(const std::vector<T> & times, const std::vector<solution_t> & solutions);

  void init(const std::vector<T> & times, const std::vector<solution_t> & solutions);

  void init();

  gsOptionList & options() { return m_options; }

  //         ID,      dt, start     , prev
  std::tuple<index_t, T , solution_t, solution_t> pop();

  bool getReferenceByTime(T time, solution_t & result);

  bool getReferenceByPar(T xi, solution_t & result);

  bool getReferenceByID(index_t ID, solution_t & result);

  void submit(index_t ID, const std::vector<T> & distances,  std::vector<solution_t> solutions, const T & upperError, const T & lowerError = 0);

  void finishJob(index_t ID);

  T jobStartTime(index_t ID);
  T jobStartPar(index_t ID);

  std::pair<T,T> jobTimes(index_t ID);
  std::pair<T,T> jobPars(index_t ID);
  index_t jobLevel(index_t ID);

  void printActiveJobs();

  bool empty();

  std::tuple<std::vector<T>,std::vector<solution_t>,std::vector<index_t>> getFlatSolution(index_t level=-1);

  void print();

  void printQueue();

  void printKnots();

  size_t nActive() { return m_jobs.size(); }
  size_t nWaiting() { return m_queue.size(); }

  size_t maxLevel() { return m_maxLevel; }

  void setLength(T dt) { m_dt = dt; }
  T getLength() { return m_dt; }

protected:
  std::tuple<T,T,index_t> _activeJob(index_t ID);

  void _buildMap();


protected:
  index_t m_points;
  index_t m_maxLevel;
  index_t m_verbose;
  bool m_initialized;

  // Default arc-length
  T m_dt;

  T m_tolerance;

  // solution map, stores the solution per parametric value
  std::map<T,std::shared_ptr<solution_t>> m_solutions;
  std::map<T,std::shared_ptr<solution_t>> m_prevs;
  // map that maps GIVEN a parametric value TO a level
  std::map<T,index_t>          m_levels;

  // map that maps GIVEN a parametric value TO a time
  std::map<T,T> m_tmap;
  // map that maps GIVEN a time TO a parametric value
  std::map<T,T> m_ximap;

  // Parametric domain
  gsKnotVector<T> m_xi;
  // Temporal domain
  gsKnotVector<T> m_t;

  // Stores [xi_i,xi_i+1,level]
  std::deque<std::tuple<T,T,index_t>>          m_queue;

  // Stores ID, [xi_i,xi_i+1,level]
  // map that maps GIVEN an ID TO a parametric interval
  std::map<index_t,std::tuple<T,T,index_t>>    m_jobs;

  mutable index_t                           m_ID = (0);

  gsOptionList m_options;

};

}

#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsAPALMData.hpp)
#endif