gsAssemblerOptions.h

Go to the documentation of this file.

 
#pragma once
 
namespace gismo
{
 
struct dirichlet
{       
    enum strategy
    {
        elimination  = 11, 
 
        penalize     = 13, 
 
        nitsche      = 12, 
        
        eliminatNormal = 14,
 
        none         = 0 
    };
 
    enum values
    {
        homogeneous   = 100, 
 
        interpolation = 101, 
        
        l2Projection  = 102, 
        
        user          = 103 
    };
};
 
struct iFace
{       
    enum strategy
    {
        conforming = 1,
        glue       = 1,
 
        dg = 2,
 
        smooth = 3,
        
        none = 0
    };
 
};
 
/*
    enum iFaceTopology
    {
        nested   = 1,
 
        clamped  = 2,
    }
*/
 
struct transform
{
    enum type
    {
        Hgrad = 1, // covariant, inverse_composition
        Hdiv  = 2, // Piola
        Hcurl = 3
    };
};
 
// for mixed formulations
struct discreteSpace
{       
    enum type
    {
        taylorHood    = 1,
        //instead of raviartThomas, there should be nested_Space and BubbleElement
        //raviartThomas should go away here.
        raviartThomas = 2,
 
        none          = 0
    };
};
 
struct gsAssemblerOptions
{
public:
    // Default constructor
    gsAssemblerOptions()
        : dirValues    (dirichlet::l2Projection ),
          dirStrategy  (dirichlet::elimination  ),
          intStrategy  (iFace    ::conforming   ),
          transformType(transform::Hgrad        ),
          spaceType    (discreteSpace::taylorHood   ),
 
          bdA(2.0),
          bdB(1  ),
          memOverhead(0.33334),
          quA(1.0),
          quB(1  )
    { }
 
public:
    //gsAssemblerSetup      info;
 
    dirichlet::values    dirValues;
 
    dirichlet::strategy  dirStrategy;
 
    iFace::strategy      intStrategy;
 
    transform::type      transformType;
    discreteSpace::type   spaceType;
 
    // If set to a value different than zero, it controls the
    // allocation of the sparse matrix, ie. the maximum number of
    // non-zero entries per column (set to: A * p + B)
    double  bdA;
    int bdB;
 
    // more memory is allocated then required for efficency reasons,
    // more precise, (1+memOverhead) times the original memory is allocated
    // default value is 0.33334 -> 75% of the allocated memory is used.
    double memOverhead;
 
    // The formula for the number of quadrature points for all
    // integral computations will be set to the integer which is
    // closest to (A * p + B), where \a p is the (coordinate-wise)
    // degree of the basis
    double  quA;
    int quB;
 
public: // Utility functions that return values implied by the settings
 
 
    index_t numQuNodes(const gsBasis<real_t> & b) const
    {
        return numQuNodes(b,quA,quB);
    }
 
    static index_t numQuNodes(const gsBasis<real_t> & b,
                              double _quA, int _quB)
    {
        index_t res = 1;
        for(short_t i=0; i<b.domainDim(); ++i )
        {
            res *= static_cast<index_t>(_quA * b.degree(i) + _quB + 0.5);
        }
        
        return res;
    }
 
 
    index_t numColNz(const gsBasis<real_t> & b) const
    {
        return numColNz(b,bdA,bdB,memOverhead);
    }
 
    static index_t numColNz(const gsBasis<real_t> & b,
                            double _bdA, int _bdB, double _mem)
    {
        index_t nz = 1;
        for (short_t i = 0; i != b.dim(); ++i)
            nz *= static_cast<index_t>(_bdA * b.degree(i) + _bdB + 0.5);
        return static_cast<index_t>(nz*(1.0+_mem));
    }
 
};
 
 
 
}