includeLinks/PatchData.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 MESQUITE_PATCHDATA_HPP
#define MESQUITE_PATCHDATA_HPP

#include "Mesquite.hpp"
#include "MsqVertex.hpp"
#include "MsqMeshEntity.hpp"
#include "MsqVertex.hpp"
#include "MeshInterface.hpp"
#include "PatchDataMem.hpp"
#include "CornerTag.hpp"
#include "TargetMatrix.hpp"


#ifndef MSQ_USE_OLD_C_HEADERS
#  include <cstddef>
#  include <cstdlib>
#else
#  include <stddef.h>
#  include <stdlib.h>
#endif

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

#ifdef MSQ_USE_OLD_IO_HEADERS
   class ostream;
#else
#  include <iosfwd>
#endif


namespace Mesquite
{
  class PatchDataVerticesMemento;
  class MeshSet;
  class TargetMatrix;
//   class SimplifiedGeometryEngine;
  
  class PatchData
  {
  public:    
      // Constructor/Destructor
    PatchData();
    ~PatchData();

  private:
    PatchData(const PatchData &pd);
    PatchData& operator=(const PatchData &pd);
    
  public:

    enum ComputedInfo {
      MIN_UNSIGNED_AREA = 0, 
      MAX_UNSIGNED_AREA, 
      MIN_EDGE_LENGTH, 
      MAX_EDGE_LENGTH, 
      MINMAX_SIGNED_DET2D, 
      MINMAX_SIGNED_DET3D, 
      AVERAGE_DET3D, 
      MAX_COMPUTED_INFO_ENUM
    };

    void clear_computed_info() { haveComputedInfos = 0; }
    
    bool have_computed_info( ComputedInfo info ) const
      { return 0 != (haveComputedInfos&(1<<info)); }
    
    void get_minmax_element_unsigned_area(double& min, double& max, MsqError &err);
    
    double get_barrier_delta(MsqError &err); 

    double get_average_Lambda_3d(MsqError &err); 

    void clear();
    void reorder();

      void allocate_storage( size_t vertex_count,
                             size_t element_count,
                             size_t vertex_use_count,
                             MsqError& err );


    void initialize_data( size_t* elem_offset_array, MsqError& err );


    size_t num_vertices() const
      { return numCornerVertices;}
    size_t num_elements() const
      { return elementArray.size(); }
    size_t num_corners() ;
    size_t num_nodes() const
      { return vertexArray.size(); }

    int num_free_vertices(MsqError &err) const;
    unsigned num_free_nodes( MsqError& err ) const;
    
    const MsqVertex* get_vertex_array( MsqError& err ) const;
    MsqVertex* get_vertex_array(MsqError &err);
    
    const MsqMeshEntity* get_element_array( MsqError& err ) const;
    MsqMeshEntity* get_element_array(MsqError &err);
    
    size_t* get_connectivity_array( )
      { return &elemConnectivityArray[0]; }
      
    const Mesh::ElementHandle* get_element_handles_array( ) const
      { return &elementHandlesArray[0]; }
    
    //const size_t* get_vertex_to_elem_array(MsqError &err);
    //const size_t* get_vertex_to_elem_offset(MsqError &err);
    
    MsqVertex& vertex_by_index(size_t index);
    MsqMeshEntity& element_by_index(size_t index);
    size_t get_vertex_index(MsqVertex* vertex);
    size_t get_element_index(MsqMeshEntity* element);
    
    void get_element_vertex_coordinates(size_t elem_index,
                                        msq_std::vector<Vector3D> &coords,
                                        MsqError &err);
    void get_element_vertex_indices(size_t elem_index,
                                    msq_std::vector<size_t> &vertex_indices,
                                    MsqError &err);
    void get_vertex_element_indices(size_t vertex_index,
                                    msq_std::vector<size_t> &elem_indices,
                                    MsqError &err);
    
    size_t* get_vertex_element_adjacencies( size_t vertex_index,
                                            size_t& array_len_out,
                                            MsqError& err );
    
    void get_adjacent_vertex_indices(size_t vertex_index,
                                     msq_std::vector<size_t> &vert_indices,
                                     MsqError &err);
    
    
    void get_adjacent_entities_via_n_dim(int n, size_t ent_ind,
                                         msq_std::vector<size_t> &adj_ents,
                                         MsqError &err);
    
    void generate_vertex_to_element_data();

    void set_vertex_coordinates(const Vector3D &coords,
                                size_t index,
                                MsqError &err);
    void snap_vertex_to_domain(size_t vertex_index, MsqError &err);

    bool domain_set()
    { return domainSet; }
    
    void get_domain_normal_at_vertex(size_t vertex_index, bool normalize,
                                     Vector3D &surf_norm,
                                     MsqError &err) ;
    
    void get_domain_normal_at_element(size_t elem_index, Vector3D &surf_norm,
                                      MsqError &err) const;

    //void get_domain_normal_at_corner( size_t elem_index,
    //                                  size_t elem_corner,
    //                                  Vector3D& normal_out,
    //                                  MsqError& err ) const;
    void get_domain_normals_at_corners( size_t element_index,
                                        Vector3D normals_out[],
                                        MsqError& err ) ;
                                        

    void get_domain_normal_at_element(MsqMeshEntity* elem_ptr,
                                      Vector3D &surf_norm, MsqError &err) const 
    { get_domain_normal_at_element(size_t(elem_ptr-&(elementArray[0])), surf_norm, err); }
    
      /*\param dk an array of directions, ordered like the vertices in
        the PatchData.
        \param nb_vtx number of vertices.
        \param step_size a scalar that multiplies the vectors given in dk.
      */
    void move_free_vertices_constrained(Vector3D dk[], size_t nb_vtx,
                                        double step_size, MsqError &err);
    
    void set_free_vertices_constrained(PatchDataVerticesMemento* memento, 
                                       Vector3D dk[], size_t nb_vtx,
                                       double step_size, MsqError &err);

    double get_max_vertex_movement_squared(PatchDataVerticesMemento* memento,
                                           MsqError &err);
    
    void update_mesh(MsqError &err);
    
    void set_all_vertices_soft_free(MsqError &err);
    void set_all_vertices_soft_fixed(MsqError &err);
    void set_free_vertices_soft_fixed(MsqError &err);
    
    void get_subpatch(size_t center_vertex_index,
                      PatchData &pd_to_fill,
                      MsqError &err);
    
    PatchDataVerticesMemento* create_vertices_memento( MsqError &err,
                                                       bool include_higher_order = false );
    
    void recreate_vertices_memento( PatchDataVerticesMemento* memento, 
                                    MsqError &err,
                                    bool include_higher_order = false );
    
    void set_to_vertices_memento(PatchDataVerticesMemento* memento,
                                 MsqError &err);
    

    enum PatchType
      {
        UNDEFINED_PATCH_TYPE,     
        VERTICES_ON_VERTEX_PATCH, 
        ELEMENTS_ON_VERTEX_PATCH, 
        GLOBAL_PATCH              
      };

    enum culling_method {
      NO_BOUNDARY_VTX = 1<<0, 
      NO_INTERIOR_VTX = 1<<1,   
      CULL_METHOD_3   = 1<<2,
      CULL_METHOD_4   = 1<<3
    };


    PatchType type() const
      { return mType; }

    void set_mesh_set(MeshSet* ms);
    
    MeshSet* get_mesh_set()
      { return meshSet; }
    
    CornerTag<TargetMatrix> targetMatrices;
    void clear_tag_data();
    
    
    friend msq_stdio::ostream& operator<<( msq_stdio::ostream&, const PatchData& );
   
   private:
   
    void note_have_info( ComputedInfo info )
      { haveComputedInfos |= (1<<info); }
      
    void update_cached_normals( MsqError& );

    friend class MeshSet;

    MeshSet* meshSet;
    bool domainSet;
    DomainHint domainHint;
    PatchType mType;
    
    PatchDataMem<MsqVertex> vertexArray;
    PatchDataMem<Mesh::VertexHandle> vertexHandlesArray;
    PatchDataMem<MsqMeshEntity> elementArray;
    PatchDataMem<Mesh::ElementHandle> elementHandlesArray;
    PatchDataMem<size_t> elemConnectivityArray;
    PatchDataMem<size_t> vertAdjacencyArray;
    PatchDataMem<size_t> vertAdjacencyOffsets;
    PatchDataMem<Vector3D> vertexNormals;
    size_t numCornerVertices;
    
      // Patch Computed Information (maxs, mins, etc ... )
    double computedInfos[MAX_COMPUTED_INFO_ENUM];
    unsigned haveComputedInfos;

  };
  
  
  class PatchDataVerticesMemento
  {
  public:
    ~PatchDataVerticesMemento()
    { delete[] vertices; }
  private:
    // Constructor accessible only to originator (i.e. PatchData)
    friend class PatchData;
    PatchDataVerticesMemento() 
      : originator(0), vertices(0), numVertices(0), arraySize(0)
    {}
    
    PatchData* originator; 
    MsqVertex *vertices; 
    size_t numVertices;
    size_t arraySize;
  };


  inline void PatchData::clear()
  {
    vertexArray.clear();
    vertexHandlesArray.clear();
    elementArray.clear();
    elementHandlesArray.clear();
    elemConnectivityArray.clear();
    vertAdjacencyArray.clear();
    vertAdjacencyOffsets.clear();
    vertexNormals.clear();
    numCornerVertices = 0;
    haveComputedInfos = 0;
    meshSet = 0;
  }
  
  
  

  inline const MsqVertex* PatchData::get_vertex_array(MsqError &err) const 
  {
    if (vertexArray.empty()) 
      MSQ_SETERR(err)( "No vertex array defined", MsqError::INVALID_STATE );
    return &vertexArray[0];
  }
  inline MsqVertex* PatchData::get_vertex_array(MsqError &err) 
  {
    if (vertexArray.empty()) 
      MSQ_SETERR(err)( "No vertex array defined", MsqError::INVALID_STATE );
    return &vertexArray[0];
  }
  
  inline const MsqMeshEntity* PatchData::get_element_array(MsqError &err) const
  {
    if (elementArray.empty()) 
      MSQ_SETERR(err)( "No element array defined", MsqError::INVALID_STATE );
    return &elementArray[0];
  }
  inline MsqMeshEntity* PatchData::get_element_array(MsqError &err)
  {
    if (elementArray.empty()) 
      MSQ_SETERR(err)( "No element array defined", MsqError::INVALID_STATE );
    return &elementArray[0];
  }
  
  inline void PatchData::set_vertex_coordinates(const Vector3D &coords,
                                                size_t index,
                                                MsqError &err) 
  {
    if (index >= vertexArray.size()) {
      MSQ_SETERR(err)( "Index bigger than numVertices.", MsqError::INVALID_ARG );
      return;
    }
    
    vertexArray[index] = coords;
  }
  
  
  //inline const size_t* PatchData::get_vertex_to_elem_offset(MsqError &/*err*/)
  //{
  //    // Make sure we've got the data
  //  if (vertAdjacencyOffsets.empty())
  //  {
  //    generate_vertex_to_element_data();
  //  }
  //  return &vertAdjacencyOffsets[0];
  //}
  
  //inline const size_t* PatchData::get_vertex_to_elem_array(MsqError &/*err*/) 
  //{
  //    // Make sure we've got the data
  //  if (vertAdjacencyArray.empty())
  //  {
  //    generate_vertex_to_element_data();
  //  }
  //  return &vertAdjacencyArray[0];
  //}
  
  inline MsqVertex& PatchData::vertex_by_index(size_t index)
  {
    return vertexArray[index];
  }
  
  inline MsqMeshEntity& PatchData::element_by_index(size_t index)
  {
    return elementArray[index];
  }
  
  inline size_t PatchData::get_vertex_index(MsqVertex* vertex)
  {
    return vertex - &vertexArray[0];
  }
  
  inline size_t PatchData::get_element_index(MsqMeshEntity* element)
  {
    return element - &elementArray[0];
  }

  
  inline PatchDataVerticesMemento* PatchData::create_vertices_memento(MsqError& /*err*/,
                                                                      bool include_higher_order)
  {
    size_t num_verts = include_higher_order ? num_nodes() : num_vertices();
    PatchDataVerticesMemento* memento = new PatchDataVerticesMemento;
    memento->originator = this;
    if (num_verts)
      memento->vertices = new MsqVertex[num_verts];
    memento->numVertices = num_verts;
    memento->arraySize = num_verts;
     
      // Copy the coordinates
    msq_stdc::memcpy(memento->vertices, &vertexArray[0], num_verts*sizeof(MsqVertex) );
    
    return memento;
  }
  
  inline void PatchData::recreate_vertices_memento(PatchDataVerticesMemento* memento, 
                                                   MsqError& /*err*/,
                                                   bool include_higher_order)
  {
    size_t num_verts = include_higher_order ? num_nodes() : num_vertices();
    memento->originator = this;
    
    if ( num_verts > memento->arraySize
         || num_verts < memento->arraySize/10)
    {
      delete[] memento->vertices;
        // Allocate the new array
      memento->vertices = new MsqVertex[num_verts];
      memento->arraySize = num_verts;
    }
    
      // Copy the coordinates
    msq_stdc::memcpy(memento->vertices, &vertexArray[0],num_verts*sizeof(MsqVertex) );
    
    memento->numVertices = num_verts;
  }
  
  inline void PatchData::set_to_vertices_memento(PatchDataVerticesMemento* memento,
                                                 MsqError &err)
  {
    if (memento->originator != this)
    {
      MSQ_SETERR(err)("Memento may only be used to restore the PatchData "
                      "object from which it was created.",
                      MsqError::INVALID_ARG);
      return;
    }
    
    if (memento->numVertices != num_vertices() &&
        memento->numVertices != num_nodes())
    {
      MSQ_SETERR(err)("Unable to restore patch coordinates.  Number of "
                      "vertices in PatchData has changed.",
                      MsqError::INVALID_STATE);
      return;
    }
    
      // copies the memento array into the PatchData array.
    msq_stdc::memcpy(&vertexArray[0], memento->vertices, memento->numVertices*sizeof(MsqVertex) );
  }
      
} // namespace


#endif