gsBaseUtils.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsCore/gsConfig.h>
#include <gsCore/gsDebug.h>
#include <gsUtils/gsUtils.h>
#include <gsCore/gsBoundary.h>
 
namespace gismo
{
 
struct ale_method
{
    enum method
    {
        HE = 0,         
        IHE = 1,        
        LE = 2,         
        ILE = 3,        
        TINE = 4,       
        TINE_StVK = 5,  
        BHE = 6,        
        IBHE = 7,       
    };
};
 
struct ns_assembly
{
    enum type
    {
        ossen = 0,          
        newton_update = 1,  
        newton_next = 2     
    };
};
 
struct time_integration
{
    enum scheme
    {
        explicit_ = 0,         
        explicit_lumped = 1,   
        implicit_linear = 2,   
        implicit_nonlinear = 3 
    };
};
 
struct linear_solver
{
    enum solver
    {
        LU = 0,              
        LDLT = 1,            
        CGDiagonal = 2,      
        BiCGSTABDiagonal = 3 
    };
};
 
 
struct solver_verbosity
{
    enum verbosity
    {
        none = 0,  
        some = 1,  
        all = 2    
    };
};
 
struct iteration_type
{
    enum type
    {
        update = 0, 
        next = 1    
    };
};
 
enum solver_status { converged,      
                     interrupted,    
                     working,        
                     bad_solution }; 
 
struct stress_components
{
    enum components
    {
        von_mises = 0,         
        all_2D_vector    = 1,  
        all_2D_matrix = 2,     
        normal_3D_vector = 3,  
        shear_3D_vector  = 4,  
        all_3D_matrix = 5      
    };
};
 
struct material_law
{
    enum law
    {
        mixed_hooke               = -2, 
        hooke                     = -1, 
        saint_venant_kirchhoff    = 0, 
        neo_hooke_ln              = 1, 
        neo_hooke_quad            = 2, 
        mixed_neo_hooke_ln        = 3, 
        muscle                    = 4  
    };
};
 
struct GISMO_EXPORT gsBoundaryInterface
{
    gsBoundaryInterface() {}
 
    std::vector<patchSide> sidesA;
    std::vector<patchSide> sidesB;
    std::vector<std::pair<index_t,index_t> > patches;
 
 
    void addInterfaceSide(index_t patchA, boundary::side sideA,
                          index_t patchB, boundary::side sideB)
    {
        sidesA.push_back(patchSide(patchA,sideA));
        sidesB.push_back(patchSide(patchB,sideB));
    }
 
    void addPatches(index_t patchA, index_t patchB)
    { patches.push_back(std::pair<index_t,index_t>(patchA,patchB)); }
};
 
class gsProgressBar
{
public:
    gsProgressBar(index_t width = 25) : m_width(width) {}
 
    void display(double progress)
    {
        GISMO_ENSURE(progress >= 0. && progress <= 1.,"Invalid progress value! Must be between 0 and 1.");
        index_t threshold = (index_t)(progress*m_width);
        gsInfo << "[";
        for(index_t i = 0; i < m_width; i++)
            if(i < threshold)
                gsInfo << "=";
            else if(i == threshold)
                gsInfo << ">";
            else
                gsInfo << " ";
        gsInfo << "] " << (abs(progress - 1.) < 1e-12 ? 100 : (index_t)(progress*100)) << " %\r";
        gsInfo.flush();
 
        if (abs(progress - 1.) < 1e-12)
            gsInfo << std::endl;
    }
 
    void display(index_t progress, index_t total)
    {
        GISMO_ENSURE(progress >= 0 && progress <= total && total >= 0,"Invalid progress value!");
        index_t threshold = (index_t)(1.*progress*m_width/total);
        gsInfo << "[";
        for(index_t i = 0; i < m_width; i++)
            if(i < threshold)
                gsInfo << "=";
            else if(i == threshold)
                gsInfo << ">";
            else
                gsInfo << " ";
        gsInfo << "] " << progress << "/" << total << " \r";
        gsInfo.flush();
 
        if (progress == total)
            gsInfo << std::endl;
    }
 
protected:
    index_t m_width;
};
 
template <class T>
std::string secToHMS(T sec)
{
    if (sec < 10)
        return util::to_string(sec) + "s";
 
    index_t days = (index_t)(sec)/(3600*24);
    index_t residual = (index_t)(sec)- 3600*24*days;
    index_t hours = residual/3600;
    residual -= 3600*hours;
    index_t minutes = residual/60;
    residual -= 60*minutes;
 
    std::string result = util::to_string(residual) + "s";
    if (minutes > 0)
        result = util::to_string(minutes) + "m" + result;
    if (hours > 0)
        result = util::to_string(hours) + "h" + result;
    if (days > 0)
        result = util::to_string(days) + "d" + result;
 
    return result;
}
 
}