SweptVertexData.hpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */
 
#ifndef SWEPT_VERTEX_DATA_HPP
#define SWEPT_VERTEX_DATA_HPP
 
//
// Class: SweptVertexData
//
// Purpose: represent a rectangular vertex block of mesh
//
// A SweptVertex represents a rectangular vertex block of mesh, including both vertices and
// the parametric space used to address those vertices.
 
#include "SequenceData.hpp"
#include "moab/HomXform.hpp"
 
namespace moab
{
 
class SweptVertexData : public SequenceData
{
 
  private:
    //! parameter min/max, in homogeneous coords ijkh (extra row for stride eventually)
    HomCoord vertexParams[3];
 
    //! difference between max and min params plus one (i.e. # VERTICES in
    //! each parametric direction)
    int dIJK[3];
 
    //! difference between max and min params (i.e. # VERTEXS in
    //! each parametric direction)
    int dIJKm1[3];
 
  public:
    //! constructor
    SweptVertexData( const EntityHandle start_vertex,
                     const int imin,
                     const int jmin,
                     const int kmin,
                     const int imax,
                     const int jmax,
                     const int kmax );
 
    virtual ~SweptVertexData() {}
 
    //! get handle of vertex at i, j, k
    EntityHandle get_vertex( const int i, const int j, const int k ) const;
 
    //! get handle of vertex at homogeneous coordinates
    EntityHandle get_vertex( const HomCoord& coords ) const;
 
    //! get the parameters of a given handle; return MB_FAILURE if vhandle not in this
    //! sequence
    ErrorCode get_params( const EntityHandle vhandle, int& i, int& j, int& k ) const;
 
    //! get min params for this vertex
    void min_params( int& i, int& j, int& k ) const;
 
    //! get max params for this vertex
    void max_params( int& i, int& j, int& k ) const;
 
    //! get the min params
    const HomCoord& min_params() const;
 
    //! get the max params
    const HomCoord& max_params() const;
 
    //! get the number of vertices in each direction, inclusive
    void param_extents( int& di, int& dj, int& dk ) const;
 
    //! convenience functions for parameter extents
    int i_min() const
    {
        return vertexParams[0].hom_coord()[0];
    }
    int j_min() const
    {
        return vertexParams[0].hom_coord()[1];
    }
    int k_min() const
    {
        return vertexParams[0].hom_coord()[2];
    }
    int i_max() const
    {
        return vertexParams[1].hom_coord()[0];
    }
    int j_max() const
    {
        return vertexParams[1].hom_coord()[1];
    }
    int k_max() const
    {
        return vertexParams[1].hom_coord()[2];
    }
 
    //! return whether this vseq's parameter space contains these parameters
    bool contains( const HomCoord& coords ) const;
    bool contains( const int i, const int j, const int k ) const;
 
    SequenceData* subset( EntityHandle start,
                          EntityHandle end,
                          const int* sequence_data_sizes,
                          const int* tag_data_sizes ) const;
};
 
inline EntityHandle SweptVertexData::get_vertex( const int i, const int j, const int k ) const
{
    return start_handle() + ( i - i_min() ) + ( j - j_min() ) * dIJK[0] + ( k - k_min() ) * dIJK[0] * dIJK[1];
}
 
inline EntityHandle SweptVertexData::get_vertex( const HomCoord& coords ) const
{
    return get_vertex( coords.hom_coord()[0], coords.hom_coord()[1], coords.hom_coord()[2] );
}
 
inline ErrorCode SweptVertexData::get_params( const EntityHandle vhandle, int& i, int& j, int& k ) const
{
    if( TYPE_FROM_HANDLE( vhandle ) != MBVERTEX ) return MB_FAILURE;
 
    int hdiff = vhandle - start_handle();
 
    k = hdiff / ( dIJK[0] * dIJK[1] );
    j = ( hdiff - ( k * dIJK[0] * dIJK[1] ) ) / dIJK[0];
    i = hdiff % dIJK[0];
 
    k += vertexParams[0].k();
    j += vertexParams[0].j();
    i += vertexParams[0].i();
 
    return ( vhandle >= start_handle() && i >= i_min() && i <= i_max() && j >= j_min() && j <= j_max() &&
             k >= k_min() && k <= k_max() )
               ? MB_SUCCESS
               : MB_FAILURE;
}
 
//! get min params for this vertex
inline void SweptVertexData::min_params( int& i, int& j, int& k ) const
{
    i = i_min();
    j = j_min();
    k = k_min();
}
 
//! get max params for this vertex
inline void SweptVertexData::max_params( int& i, int& j, int& k ) const
{
    i = i_max();
    j = j_max();
    k = k_max();
}
 
inline const HomCoord& SweptVertexData::min_params() const
{
    return vertexParams[0];
}
 
inline const HomCoord& SweptVertexData::max_params() const
{
    return vertexParams[1];
}
 
//! get the number of vertices in each direction, inclusive
inline void SweptVertexData::param_extents( int& di, int& dj, int& dk ) const
{
    di = dIJK[0];
    dj = dIJK[1];
    dk = dIJK[2];
}
 
inline bool SweptVertexData::contains( const HomCoord& coords ) const
{
    return ( coords >= vertexParams[0] && coords <= vertexParams[1] ) ? true : false;
}
 
inline bool SweptVertexData::contains( const int i, const int j, const int k ) const
{
    return contains( HomCoord( i, j, k ) );
}
 
}  // namespace moab
 
#endif