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__