Cppcheck - HTML report

#ifndef MOAB_ELEM_UTIL_HPP
#define MOAB_ELEM_UTIL_HPP

#include "moab/CartVect.hpp"
#include <vector>
#include "moab/Matrix3.hpp"

// to access data structures for spectral elements

extern "C" {
#include "moab/FindPtFuncs.h"
}

namespace moab
{
namespace ElemUtil
{

    bool nat_coords_trilinear_hex( const CartVect* hex_corners, const CartVect& x, CartVect& xi, double tol );
    bool point_in_trilinear_hex( const CartVect* hex_corners, const CartVect& xyz, double etol );

    bool point_in_trilinear_hex( const CartVect* hex_corners,
                                 const CartVect& xyz,
                                 const CartVect& box_min,
                                 const CartVect& box_max,
                                 double etol );

    // wrapper to hex_findpt
    void nat_coords_trilinear_hex2( const CartVect* hex_corners, const CartVect& x, CartVect& xi, double til );

    void hex_findpt( double* xm[3], int n, CartVect xyz, CartVect& rst, double& dist );

    void hex_eval( double* field, int n, CartVect rst, double& value );

    bool integrate_trilinear_hex( const CartVect* hex_corners, double* corner_fields, double& field_val, int num_pts );

}  // namespace ElemUtil

namespace Element
{
    /**\brief Class representing a map (diffeomorphism) F parameterizing a 3D element by its
     * canonical preimage.*/
    /*
         Shape functions on the element can obtained by a pushforward (pullback by the inverse map)
         of the shape functions on the canonical element. This is done by extending this class.

         We further assume that the parameterizing map is defined by the location of n vertices,
         which can be set and retrieved on a Map instance.  The number of vertices is fixed at
         compile time.
    */
    class Map
    {
      public:
        /**\brief Construct a Map defined by the given std::vector of vertices. */
        Map( const std::vector< CartVect >& v )
        {
            this->vertex.resize( v.size() );
            this->set_vertices( v );
        };
        /**\brief Construct a Map defined by n vertices. */
        Map( const unsigned int n )
        {
            this->vertex = std::vector< CartVect >( n );
        };
        virtual ~Map();
        /**\brief Evaluate the map on \f$x_i\f$ (calculate \f$\vec x = F($\vec \xi)\f$ )*/
        virtual CartVect evaluate( const CartVect& xi ) const = 0;<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class
        /**\brief Evaluate the inverse map (calculate \f$\vec \xi = F^-1($\vec x)\f$ to given
         * tolerance)*/
        virtual CartVect ievaluate( const CartVect& x, double tol = 1e-6, const CartVect& x0 = CartVect( 0.0 ) ) const;<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class
        /**\brief decide if within the natural param space, with a tolerance*/
        virtual bool inside_nat_space( const CartVect& xi, double& tol ) const = 0;<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class
        /* FIX: should evaluate and ievaluate return both the value and the Jacobian (first jet)? */
        /**\brief Evaluate the map's Jacobi matrix. */
        virtual Matrix3 jacobian( const CartVect& xi ) const = 0;<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class
        /* FIX: should this be evaluated in real coordinates and be obtained as part of a Newton
         * solve? */
        /**\brief Evaluate the inverse of the Jacobi matrix. */
        virtual Matrix3 ijacobian( const CartVect& xi ) const<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class
        {
            return this->jacobian( xi ).inverse();
        };
        /* det_jacobian and det_ijacobian should be overridden for efficiency. */
        /**\brief Evaluate the determinate of the Jacobi matrix. */
        virtual double det_jacobian( const CartVect& xi ) const<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class
        {
            return this->jacobian( xi ).determinant();
        };
        /* FIX: should this be evaluated in real coordinates and be obtained as part of a Newton
         * solve? */
        /**\brief Evaluate the determinate of the inverse Jacobi matrix. */
        virtual double det_ijacobian( const CartVect& xi ) const<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class
        {
            return this->jacobian( xi ).inverse().determinant();
        };

        /**\brief Evaluate a scalar field at a point given field values at the vertices. */
        virtual double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const = 0;<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class
        /**\brief Integrate a scalar field over the element given field values at the vertices. */
        virtual double integrate_scalar_field( const double* field_vertex_values ) const = 0;<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class

        /**\brief Size of the vertices vector. */
        unsigned int size()
        {
            return this->vertex.size();
        }
        /**\brief Retrieve vertices. */
        const std::vector< CartVect >& get_vertices();
        /**\brief Set vertices.      */
        virtual void set_vertices( const std::vector< CartVect >& v );<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class

        // will look at the box formed by vertex coordinates, and before doing any NR, bail out if
        // necessary
        virtual bool inside_box( const CartVect& xi, double& tol ) const;<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class<--- Virtual function in base class

        /* Exception thrown when an evaluation fails (e.g., ievaluate fails to converge). */
        class EvaluationError
        {
          public:
            EvaluationError( const CartVect& x, const std::vector< CartVect >& verts ) : p( x ), vertices( verts )
            {
#ifndef NDEBUG
                std::cout << "p:" << p << "\n vertices.size() " << vertices.size() << "\n";
                for( size_t i = 0; i < vertices.size(); i++ )
                    std::cout << vertices[i] << "\n";
#endif
            };

          private:
            CartVect p;
            std::vector< CartVect > vertices;
        };  // class EvaluationError

        /* Exception thrown when a bad argument is encountered. */
        class ArgError
        {
          public:
            ArgError(){};
        };  // class ArgError
      protected:
        std::vector< CartVect > vertex;
    };  // class Map

    /**\brief Shape function space for trilinear hexahedron, obtained by a pushforward of the
     * canonical linear (affine) functions. */
    class LinearHex : public Map
    {
      public:
        LinearHex( const std::vector< CartVect >& vertices ) : Map( vertices ){};<--- Class 'LinearHex' has a constructor with 1 argument that is not explicit. [+]Class 'LinearHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearHex' has a constructor with 1 argument that is not explicit. [+]Class 'LinearHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearHex' has a constructor with 1 argument that is not explicit. [+]Class 'LinearHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearHex' has a constructor with 1 argument that is not explicit. [+]Class 'LinearHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearHex' has a constructor with 1 argument that is not explicit. [+]Class 'LinearHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearHex' has a constructor with 1 argument that is not explicit. [+]Class 'LinearHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        LinearHex();
        virtual ~LinearHex();

        virtual CartVect evaluate( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        // virtual CartVect ievaluate(const CartVect& x, double tol) const ;
        virtual bool inside_nat_space( const CartVect& xi, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

        virtual Matrix3 jacobian( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double integrate_scalar_field( const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

      protected:
        /* Preimages of the vertices -- "canonical vertices" -- are known as "corners". */
        static const double corner[8][3];
        static const double gauss[2][2];
        static const unsigned int corner_count = 8;
        static const unsigned int gauss_count  = 2;

    };  // class LinearHex

    /**\brief Shape function space for trilinear hexahedron, obtained by a pushforward of the
     * canonical linear (affine) functions. */
    class QuadraticHex : public Map
    {
      public:
        QuadraticHex( const std::vector< CartVect >& vertices ) : Map( vertices ){};<--- Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. [+]Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. [+]Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. [+]Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. [+]Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. [+]Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. [+]Class 'QuadraticHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        QuadraticHex();
        virtual ~QuadraticHex();
        virtual CartVect evaluate( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        // virtual CartVect ievaluate(const CartVect& x, double tol) const ;
        virtual bool inside_nat_space( const CartVect& xi, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

        virtual Matrix3 jacobian( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double integrate_scalar_field( const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

      protected:
        /* Preimages of the vertices -- "canonical vertices" -- are known as "corners".
         * there are 27 vertices for a tri-quadratic xes*/
        static const int corner[27][3];
        static const double gauss[8][2];  // TODO fix me
        static const unsigned int corner_count = 27;
        static const unsigned int gauss_count  = 2;  // TODO fix me

    };  // class QuadraticHex
    /**\brief Shape function space for a linear tetrahedron, obtained by a pushforward of the
     * canonical affine shape functions. */
    class LinearTet : public Map
    {
      public:
        LinearTet( const std::vector< CartVect >& vertices ) : Map( vertices )<--- Member variable 'LinearTet::det_T' is not initialized in the constructor.<--- Member variable 'LinearTet::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTet' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTet' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTet::det_T' is not initialized in the constructor.<--- Member variable 'LinearTet::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTet' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTet' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTet::det_T' is not initialized in the constructor.<--- Member variable 'LinearTet::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTet' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTet' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTet::det_T' is not initialized in the constructor.<--- Member variable 'LinearTet::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTet' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTet' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTet::det_T' is not initialized in the constructor.<--- Member variable 'LinearTet::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTet' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTet' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTet::det_T' is not initialized in the constructor.<--- Member variable 'LinearTet::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTet' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTet' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        {
            set_vertices( vertex );
        };
        LinearTet();
        virtual ~LinearTet();
        /* Override the evaluation routines to take advantage of the properties of P1. */
        virtual CartVect evaluate( const CartVect& xi ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->vertex[0] + this->T * xi;
        };
        virtual CartVect ievaluate( const CartVect& x, double tol = 1e-6, const CartVect& x0 = CartVect( 0.0 ) ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual Matrix3 jacobian( const CartVect& ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->T;
        };
        virtual Matrix3 ijacobian( const CartVect& ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->T_inverse;
        };
        virtual double det_jacobian( const CartVect& ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->det_T;
        };
        virtual double det_ijacobian( const CartVect& ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->det_T_inverse;
        };
        //
        virtual double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double integrate_scalar_field( const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        //
        /* Override set_vertices so we can precompute the matrices effecting the mapping to and from
         * the canonical simplex. */
        virtual void set_vertices( const std::vector< CartVect >& v );<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual bool inside_nat_space( const CartVect& xi, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

      protected:
        static const double corner[4][3];
        Matrix3 T, T_inverse;
        double det_T, det_T_inverse;
    };  // class LinearTet

    class SpectralHex : public Map
    {
      public:
        SpectralHex( const std::vector< CartVect >& vertices ) : Map( vertices )<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        {
            _xyz[0] = _xyz[1] = _xyz[2] = NULL;
        };
        SpectralHex( int order, double* x, double* y, double* z );
        SpectralHex( int order );<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralHex' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralHex' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        SpectralHex();
        virtual ~SpectralHex();
        void set_gl_points( double* x, double* y, double* z );
        virtual CartVect evaluate( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual CartVect ievaluate( const CartVect& x, double tol = 1e-6, const CartVect& x0 = CartVect( 0.0 ) ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual Matrix3 jacobian( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        double integrate_scalar_field( const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        bool inside_nat_space( const CartVect& xi, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

        // to compute the values that need to be cached for each element of order n
        void Init( int order );
        void freedata();

      protected:
        /* values that depend only on the order of the element , cached */
        /*  the order in 3 directions */
        static int _n;
        static realType* _z[3];
        static lagrange_data _ld[3];
        static opt_data_3 _data;
        static realType* _odwork;  // work area

        // flag for initialization of data
        static bool _init;

        realType* _xyz[3];

    };  // class SpectralHex

    /**\brief Shape function space for bilinear quadrilateral, obtained from the canonical linear
     * (affine) functions. */
    class LinearQuad : public Map
    {
      public:
        LinearQuad( const std::vector< CartVect >& vertices ) : Map( vertices ){};<--- Class 'LinearQuad' has a constructor with 1 argument that is not explicit. [+]Class 'LinearQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearQuad' has a constructor with 1 argument that is not explicit. [+]Class 'LinearQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearQuad' has a constructor with 1 argument that is not explicit. [+]Class 'LinearQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearQuad' has a constructor with 1 argument that is not explicit. [+]Class 'LinearQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearQuad' has a constructor with 1 argument that is not explicit. [+]Class 'LinearQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearQuad' has a constructor with 1 argument that is not explicit. [+]Class 'LinearQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        LinearQuad();
        virtual ~LinearQuad();
        virtual CartVect evaluate( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        // virtual CartVect ievaluate(const CartVect& x, double tol) const ;
        virtual bool inside_nat_space( const CartVect& xi, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

        virtual Matrix3 jacobian( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double integrate_scalar_field( const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

      protected:
        /* Preimages of the vertices -- "canonical vertices" -- are known as "corners". */
        static const double corner[4][3];
        static const double gauss[1][2];
        static const unsigned int corner_count = 4;
        static const unsigned int gauss_count  = 1;

    };  // class LinearQuad

    /**\brief Shape function space for bilinear quadrilateral on sphere, obtained from the
     *  canonical linear (affine) functions.
     *  It is mapped using gnomonic projection to a plane tangent at the first vertex
     *  It works well for edges that are great circle arcs; RLL meshes  do not have this property,
     * but HOMME or MPAS meshes do have it */
    class SphericalQuad : public LinearQuad
    {
      public:
        SphericalQuad( const std::vector< CartVect >& vertices );<--- Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        virtual ~SphericalQuad(){};
        virtual bool inside_box( const CartVect& pos, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        CartVect ievaluate( const CartVect& x, double tol = 1e-6, const CartVect& x0 = CartVect( 0.0 ) ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

      protected:
        CartVect v1;
        Matrix3 transf;  // so will have a lot of stuff, including the transf to a coordinate system
        // double tangent_plane; // at first vertex; normal to the plane is first vertex

    };  // class SphericalQuad

    /**\brief Shape function space for linear triangle, similar to linear tet. */
    class LinearTri : public Map
    {
      public:
        LinearTri( const std::vector< CartVect >& vertices ) : Map( vertices )<--- Member variable 'LinearTri::det_T' is not initialized in the constructor.<--- Member variable 'LinearTri::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTri' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTri::det_T' is not initialized in the constructor.<--- Member variable 'LinearTri::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTri' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTri::det_T' is not initialized in the constructor.<--- Member variable 'LinearTri::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTri' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTri::det_T' is not initialized in the constructor.<--- Member variable 'LinearTri::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTri' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTri::det_T' is not initialized in the constructor.<--- Member variable 'LinearTri::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTri' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Member variable 'LinearTri::det_T' is not initialized in the constructor.<--- Member variable 'LinearTri::det_T_inverse' is not initialized in the constructor.<--- Class 'LinearTri' has a constructor with 1 argument that is not explicit. [+]Class 'LinearTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        {
            set_vertices( vertex );
        };
        LinearTri();
        virtual ~LinearTri();
        /* Override the evaluation routines to take advantage of the properties of P1. */
        /* similar to tets */
        virtual CartVect evaluate( const CartVect& xi ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->vertex[0] + this->T * xi;
        };
        virtual CartVect ievaluate( const CartVect& x, double tol = 1e-6, const CartVect& x0 = CartVect( 0.0 ) ) const;<--- Function in derived class<--- Virtual function in base class<--- Function in derived class<--- Virtual function in base class<--- Function in derived class<--- Virtual function in base class<--- Function in derived class<--- Virtual function in base class<--- Function in derived class<--- Virtual function in base class<--- Function in derived class<--- Virtual function in base class
        virtual Matrix3 jacobian( const CartVect& ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->T;
        };
        virtual Matrix3 ijacobian( const CartVect& ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->T_inverse;
        };
        virtual double det_jacobian( const CartVect& ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->det_T;
        };
        virtual double det_ijacobian( const CartVect& ) const<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        {
            return this->det_T_inverse;
        };

        /* Override set_vertices so we can precompute the matrices effecting the mapping to and from
         * the canonical simplex. */
        virtual void set_vertices( const std::vector< CartVect >& v );<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual bool inside_nat_space( const CartVect& xi, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

        virtual double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double integrate_scalar_field( const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

      protected:
        /* Preimages of the vertices -- "canonical vertices" -- are known as "corners". */
        static const double corner[3][3];
        Matrix3 T, T_inverse;
        double det_T, det_T_inverse;

    };  // class LinearTri

    /**\brief Shape function space for linear triangle on sphere, obtained from the
     *  canonical linear (affine) functions.
     *  It is mapped using gnomonic projection to a plane tangent at the first vertex
     *  It works well for edges that are great circle arcs; RLL meshes  do not have this property,
     * but HOMME or MPAS meshes do have it */
    class SphericalTri : public LinearTri
    {
      public:
        SphericalTri( const std::vector< CartVect >& vertices );<--- Class 'SphericalTri' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalTri' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalTri' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalTri' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalTri' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SphericalTri' has a constructor with 1 argument that is not explicit. [+]Class 'SphericalTri' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        virtual ~SphericalTri(){};
        virtual bool inside_box( const CartVect& pos, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        CartVect ievaluate( const CartVect& x, double tol = 1e-6, const CartVect& x0 = CartVect( 0.0 ) ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

      protected:
        CartVect v1;
        Matrix3 transf;  // so will have a lot of stuff, including the transf to a coordinate system
        // double tangent_plane; // at first vertex; normal to the plane is first vertex

    };  // class SphericalTri

    /**\brief Shape function space for bilinear quadrilateral, obtained from the canonical linear
     * (affine) functions. */
    class LinearEdge : public Map
    {
      public:
        LinearEdge( const std::vector< CartVect >& vertices ) : Map( vertices ){};<--- Class 'LinearEdge' has a constructor with 1 argument that is not explicit. [+]Class 'LinearEdge' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearEdge' has a constructor with 1 argument that is not explicit. [+]Class 'LinearEdge' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearEdge' has a constructor with 1 argument that is not explicit. [+]Class 'LinearEdge' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearEdge' has a constructor with 1 argument that is not explicit. [+]Class 'LinearEdge' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearEdge' has a constructor with 1 argument that is not explicit. [+]Class 'LinearEdge' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'LinearEdge' has a constructor with 1 argument that is not explicit. [+]Class 'LinearEdge' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        LinearEdge();
        virtual CartVect evaluate( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        // virtual CartVect ievaluate(const CartVect& x, double tol) const ;
        virtual bool inside_nat_space( const CartVect& xi, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

        virtual Matrix3 jacobian( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual double integrate_scalar_field( const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

      protected:
        /* Preimages of the vertices -- "canonical vertices" -- are known as "corners". */
        static const double corner[2][3];
        static const double gauss[1][2];
        static const unsigned int corner_count = 2;
        static const unsigned int gauss_count  = 1;

    };  // class LinearEdge

    class SpectralQuad : public Map
    {
      public:
        SpectralQuad( const std::vector< CartVect >& vertices ) : Map( vertices )<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        {
            _xyz[0] = _xyz[1] = _xyz[2] = NULL;
        };
        SpectralQuad( int order, double* x, double* y, double* z );
        SpectralQuad( int order );<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
<--- Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. [+]Class 'SpectralQuad' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.
        SpectralQuad();
        virtual ~SpectralQuad();
        void set_gl_points( double* x, double* y, double* z );
        virtual CartVect evaluate( const CartVect& xi ) const;  // a 2d, so 3rd component is 0, always<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        virtual CartVect ievaluate(<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
            const CartVect& x,
            double tol         = 1e-6,
            const CartVect& x0 = CartVect( 0.0 ) ) const;  // a 2d, so 3rd component is 0, always
        virtual Matrix3 jacobian( const CartVect& xi ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        double evaluate_scalar_field( const CartVect& xi, const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        double integrate_scalar_field( const double* field_vertex_values ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class
        bool inside_nat_space( const CartVect& xi, double& tol ) const;<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class<--- Function in derived class

        // to compute the values that need to be cached for each element of order n
        void Init( int order );
        void freedata();
        // this will take node, vertex positions and compute the gl points
        void compute_gl_positions();
        void get_gl_points( double*& x, double*& y, double*& z, int& size );

      protected:
        /* values that depend only on the order of the element , cached */
        /*  the order in all 3 directions ; it is also np in HOMME lingo*/
        static int _n;
        static realType* _z[2];
        static lagrange_data _ld[2];
        static opt_data_2 _data;   // we should use only 2nd component
        static realType* _odwork;  // work area

        // flag for initialization of data
        static bool _init;
        static realType* _glpoints;  // it is a space we can use to store gl positions for elements
        // on the fly; we do not have a tag yet for them, as in Nek5000 application
        // also, these positions might need to be moved on the sphere, for HOMME grids
        // do we project them or how do we move them on the sphere?

        realType* _xyz[3];  // these are gl points; position?

    };  // class SpectralQuad

}  // namespace Element

}  // namespace moab

#endif /*MOAB_ELEM_UTIL_HPP*/
Cppcheck report - MOAB: tools/mbcoupler/ElemUtil.hpp
