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));
    }

};



}