MecheInterface.hpp

/*
 * This file is part of So-bogus, a C++ sparse block matrix library and
 * Second Order Cone solver.
 *
 * Copyright 2013 Gilles Daviet <gdaviet@gmail.com>
 *
 * So-bogus is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.

 * So-bogus is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with So-bogus.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <iosfwd>

#include "../Core/Utils/Signal.hpp"
#include "../Core/Utils/Timer.hpp"
#include "../Core/Utils/CppTools.hpp"

#ifndef BOGUS_MECHE_INTERFACE_HPP
#define BOGUS_MECHE_INTERFACE_HPP

namespace bogus
{

template< unsigned Dimension > struct PrimalFrictionProblem ;
template< unsigned Dimension > struct DualFrictionProblem ;

class MecheFrictionProblem
{
public:

    enum Algorithm {
        GaussSeidel = 0,
        ProjectedGradient = 1,
        MatrixFreeGaussSeidel,
        ADMM,
        DualAMA
    };

    struct Options {
        int maxThreads ;        

        unsigned maxIters ;     
        unsigned cadouxIters ;  

        double tolerance ;      
        bool useInfinityNorm ;  

        Algorithm algorithm ;   

        // Solver-specific options

        double gsRegularization ; 
        bool   gsColoring ;       

        double admmProjStepSize ;
        double admmFpStepSize ;

        Options() ;
    };

    MecheFrictionProblem() ;
    ~MecheFrictionProblem() ;


    void fromPrimal (
            unsigned int NObj, 
            const unsigned int * ndof, 
            const double *const * MassMat, 
            const double * f_in, 
            unsigned int n_in, 
            const double * mu_in, 
            const double * E_in, 
            const double * w_in, 
            const int * const ObjA, 
            const int * const ObjB, 
            const double *const HA[], 
            const double *const HB[] 
            );

    double solve(double * r, 
            double * v,      
            bool staticProblem ,          
            double problemRegularization, 
            const Options & options       
    ) ;

    double solve(double * r, 
            double * v, 
            int maxThreads = 0,               
            double tol = 0.,                  
            unsigned maxIters = 0,            
            bool staticProblem = false,       
            double regularization = 0.,       
            bool useInfinityNorm = false,     
            bool useProjectedGradient = false,
            unsigned cadouxIters = 0          
                 );

    void computeDual( double regularization ) ;

    void reset() ;

    unsigned nDegreesOfFreedom() const ;
    unsigned nContacts() const ;

    void setOutStream( std::ostream *out ) ;

    Signal< unsigned, double, double > &callback() { return m_callback ; }


    bool dumpToFile( const char* fileName, const double *r0 = BOGUS_NULL_PTR(const double) ) const ;

    bool fromFile( const char* fileName, double* &r0 ) ;

    // solvers Callback
    void ackCurrentResidual( unsigned GSIter, double err ) ;

    // Accessors

    const PrimalFrictionProblem<3u> & primal() const { return *m_primal ; }
    const DualFrictionProblem<3u> & dual() const { return *m_dual ; }

    PrimalFrictionProblem<3u> & primal() { return *m_primal ; }
    DualFrictionProblem<3u> & dual() { return *m_dual ; }

    double *f (){ return m_f  ; }
    double *w (){ return m_w  ; }
    double *mu(){ return m_mu ; }

    double lastSolveTime() const { return m_lastSolveTime ; }

protected:

    void destroy() ;

    PrimalFrictionProblem<3u> * m_primal ;
    DualFrictionProblem<3u>  * m_dual ;

    double m_lastSolveTime ;

    Signal< unsigned, double, double > m_callback ;
    Timer m_timer ;

private:
    // Non copyable, non assignable
    MecheFrictionProblem( const MecheFrictionProblem & ) ;
    MecheFrictionProblem &operator=( const MecheFrictionProblem & ) ;

    // Used to store data when loading problem from file
    double *m_f ;
    double *m_w ;
    double *m_mu ;

    std::ostream *m_out ;
} ;

}

#endif