contact-solver-base.hpp

//
// Copyright (c) 2022-2024 INRIA
//
 
#ifndef __pinocchio_algorithm_contact_solver_base_hpp__
#define __pinocchio_algorithm_contact_solver_base_hpp__
 
#include "pinocchio/math/fwd.hpp"
#include "pinocchio/math/comparison-operators.hpp"
 
#ifdef PINOCCHIO_WITH_HPP_FCL
  #include <hpp/fcl/timings.h>
#endif // PINOCCHIO_WITH_HPP_FCL
 
namespace pinocchio
{
 
  template<typename _Scalar>
  struct ContactSolverBaseTpl
  {
    typedef _Scalar Scalar;
 
#ifdef PINOCCHIO_WITH_HPP_FCL
    typedef hpp::fcl::CPUTimes CPUTimes;
    typedef hpp::fcl::Timer Timer;
#endif // PINOCCHIO_WITH_HPP_FCL
 
    explicit ContactSolverBaseTpl(const int problem_size)
    : problem_size(problem_size)
    , max_it(1000)
    , it(0)
    , absolute_precision(Scalar(1e-6))
    , relative_precision(Scalar(1e-6))
    , absolute_residual(Scalar(-1))
    , relative_residual(Scalar(-1))
#ifdef PINOCCHIO_WITH_HPP_FCL
    , timer(false)
#endif // PINOCCHIO_WITH_HPP_FCL
    {
    }
 
    int getProblemSize() const
    {
      return problem_size;
    }
 
    int getIterationCount() const
    {
      return it;
    }
 
    void setMaxIterations(const int max_it)
    {
      PINOCCHIO_CHECK_INPUT_ARGUMENT(max_it > 0, "max_it should be greater than 0.");
      this->max_it = max_it;
    }
    int getMaxIterations() const
    {
      return max_it;
    }
 
    void setAbsolutePrecision(const Scalar absolute_precision)
    {
      PINOCCHIO_CHECK_INPUT_ARGUMENT(
        absolute_precision >= Scalar(0), "absolute_precision should be positive.");
      this->absolute_precision = absolute_precision;
    }
    Scalar getAbsolutePrecision() const
    {
      return absolute_precision;
    }
 
    void setRelativePrecision(const Scalar relative_precision)
    {
      PINOCCHIO_CHECK_INPUT_ARGUMENT(
        relative_precision >= Scalar(0), "relative_precision should be positive.");
      this->relative_precision = relative_precision;
    }
    Scalar getRelativePrecision() const
    {
      return relative_precision;
    }
 
    Scalar getAbsoluteConvergenceResidual() const
    {
      return absolute_residual;
    }
    Scalar getRelativeConvergenceResidual() const
    {
      return relative_residual;
    }
 
#ifdef PINOCCHIO_WITH_HPP_FCL
    CPUTimes getCPUTimes() const
    {
      return timer.elapsed();
    }
#endif // PINOCCHIO_WITH_HPP_FCL
 
  protected:
    int problem_size;
    int max_it;
    int it;
    Scalar absolute_precision;
    Scalar relative_precision;
    Scalar absolute_residual;
    Scalar relative_residual;
 
#ifdef PINOCCHIO_WITH_HPP_FCL
    Timer timer;
#endif // PINOCCHIO_WITH_HPP_FCL
 
  }; // struct ContactSolverBaseTpl
 
} // namespace pinocchio
 
#endif // ifndef __pinocchio_algorithm_contact_solver_base_hpp__