includeLinks/MsqMeshEntity.hpp

Go to the documentation of this file.

/* ***************************************************************** 
    MESQUITE -- The Mesh Quality Improvement Toolkit

    Copyright 2004 Sandia Corporation and Argonne National
    Laboratory.  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.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License 
    (lgpl.txt) along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
    diachin2@llnl.gov, djmelan@sandia.gov, mbrewer@sandia.gov, 
    pknupp@sandia.gov, tleurent@mcs.anl.gov, tmunson@mcs.anl.gov      
   
  ***************************************************************** */

#ifndef MSQMESHENTITY_HPP
#define MSQMESHENTITY_HPP

#include "Mesquite.hpp"
#include "QualityMetric.hpp"
#include "TopologyInfo.hpp"

#ifdef MSQ_USE_OLD_STD_HEADERS
#  include <vector.h>
#else
#  include <vector>
#endif

#ifdef MSQ_USE_OLD_C_HEADERS
#  include <string.h>
#  include <assert.h>
#else
#  include <cstring>
#  include <cassert>
#endif


namespace Mesquite
{
  class PatchData;

  class MsqMeshEntity
  {
  public:
    
    MsqMeshEntity()
      : mType(MIXED), vertexIndices(0), numVertexIndices(0)
      {}

    inline EntityTopology get_element_type() const
      { return mType; }
    
    inline msq_stdc::size_t vertex_count() const;
    inline msq_stdc::size_t node_count() const 
      { return numVertexIndices; }
    
    void get_vertex_indices(msq_std::vector<msq_stdc::size_t> &vertex_list) const;
    void append_vertex_indices(msq_std::vector<msq_stdc::size_t> &vertex_list) const;
    void get_node_indices(msq_std::vector<msq_stdc::size_t> &vertex_list) const;
    void append_node_indices(msq_std::vector<msq_stdc::size_t> &vertex_list) const;
    inline const msq_stdc::size_t *get_vertex_index_array() const;
    inline msq_stdc::size_t *get_vertex_index_array();
    
    void set_element_type(EntityTopology type)
      { mType = type; }

    void set_connectivity( msq_stdc::size_t *indices, size_t num_vertices);

    msq_stdc::size_t get_vertex_index(msq_stdc::size_t vertex_in_element) const;
    
      //fills array of Vector3D's with the jacobian vectors and the 
      //number of jacobian vectors
    void compute_weighted_jacobian(PatchData &pd, Vector3D& sample_point,
                                   Vector3D jacobian_vectors[],
                                   short &num_jacobian_vectors,
                                   MsqError &err );
    
    void get_sample_points(QualityMetric::ElementEvaluationMode mode,
                           msq_std::vector<Vector3D> &coords,
                           MsqError &err);

    void get_centroid(Vector3D& centroid, const PatchData &pd, MsqError &err) const;
    
    void get_connected_vertices(msq_stdc::size_t vertex_index,
                                msq_std::vector<msq_stdc::size_t> &vert_indices,
                                MsqError &err);
    
    double compute_unsigned_area(PatchData &pd, MsqError &err );
    
    double compute_unsigned_volume(PatchData &pd, MsqError &err );
    
    double compute_signed_area(PatchData &pd, MsqError &err );

    double compute_signed_volume(PatchData &pd, MsqError &err );
    
    //void compute_corner_normal( msq_stdc::size_t corner_pt, 
    //                            Vector3D &normal,
    //                            PatchData &pd, 
    //                            MsqError &err);
    void compute_corner_normals( Vector3D normals[], PatchData& pd, MsqError& err );

    void compute_corner_matrices(PatchData &pd, Matrix3D A[], int num_m3d, MsqError &err );

  private:
    static void get_linear_quad_jac(Vector3D *sp,
                                    Vector3D &coord0, Vector3D &coord1,
                                    Vector3D &coord2, Vector3D &coord3,
                                    Vector3D* jac);
    
    EntityTopology mType;
    size_t* vertexIndices;  
    size_t numVertexIndices;
    
      // output operator for debugging.
    friend msq_stdio::ostream& operator<<(msq_stdio::ostream &stream, 
                                          const MsqMeshEntity &entity);
    
  };
  
  
    // Returns the number of vertices in this type
    // of element, or 0 if a variable number.
  inline size_t MsqMeshEntity::vertex_count() const
  { return mType == POLYGON || mType == POLYHEDRON ? 
           node_count() : TopologyInfo::corners( mType ); }

  inline void MsqMeshEntity::set_connectivity( msq_stdc::size_t *indices,
                                               size_t num_vertices )
  {
    vertexIndices = indices;
    numVertexIndices = num_vertices;
  }
  
  inline const msq_stdc::size_t *MsqMeshEntity::get_vertex_index_array() const
  { return vertexIndices; }
  
  inline msq_stdc::size_t *MsqMeshEntity::get_vertex_index_array()
  { return vertexIndices; }
 
  inline msq_stdc::size_t 
  MsqMeshEntity::get_vertex_index(msq_stdc::size_t vertex_in_element) const
  {
      // Make sure we're in range
    assert(vertex_in_element < vertex_count());
      // Return the index
    return vertexIndices[vertex_in_element];
  }

  inline void MsqMeshEntity::get_linear_quad_jac(Vector3D *sp,
                                                 Vector3D &coord0,
                                                 Vector3D &coord1,
                                                 Vector3D &coord2,
                                                 Vector3D &coord3,
                                                 Vector3D* jac)
  {
    jac[0]=coord1-coord0+(*sp)[1]*(coord2+coord0-coord3-coord1);
    jac[1]=coord3-coord0+(*sp)[0]*(coord2+coord0-coord3-coord1);
  }
} //namespace


#endif // MsqMeshEntity_hpp