curveMesh.h

/****************************************************************************** 

  (c) 2004-2014 Scientific Computation Research Center, 
      Rensselaer Polytechnic Institute. All rights reserved.
  
  The LICENSE-SCOREC file included with this distribution describes the terms
  of the SCOREC Non-Commercial License this program is distributed under.
 
*******************************************************************************/
#ifndef MESHADAPT_CURVEMESH_H_
#define MESHADAPT_CURVEMESH_H_

#include "CMAFwd.h"
#include "FMDBInternals.h"
#include "FMDB_cint.h"
#include "AdaptUtil.h"

#include "MeshAdapt.h"

#include <map>
#include <vector>
#include <list>

class CrvTet;
class CrvFace;
class CrvEdge;

class DSplitClpsMod;
class faceSwapMod;
class regionCollapsMod;

class NullSField;
class evalResults;
class MeanRatio;

class Field; 

class curveMesh : public meshAdapt{
public:
  static curveMesh * instance() {
    assert(m_crv_mesh_inst);
    return m_crv_mesh_inst; 
  }

  curveMesh(pMeshMdl mesh_instance, int sizefield_type, int model_type);

  virtual ~curveMesh();

  /* START OF C++ API */

  int CMA_SetModelType(int iTheMdlType);
  int CMA_CheckMesh();
  int CMA_CheckMeshQuality();
  int CMA_LockSurfaceMesh();
//  int CMA_ImproveSurfaceMesh();
//  int CMA_ImproveWorstRegion();

  int CMA_CreateHOEdges();

  int CMA_UncurveInvalidRgns();
  int CMA_SetCrvMeshQualityThreshold(double dThreshold);

  int CMA_Untangle();

  int CMA_Optimize();

  int CMA_TagDrivenUniformRefine(); 

  int CMA_Linearize();

  int CMA_GlobPtn();

  int CMA_CreateG1Mesh();

  int CMA_CreateD4C0Mesh();

  int CMA_CreateC0Mesh(int iEdgeOrder, int iFaceOrder);

  int CMA_CreateG1MeshFromAnalyticModel();

  int CMA_NumVertsOnGBdry();

  int CMA_NumVertsOnGEdge();

  double CMA_AverageEdgeLengthOnGBdry();
  double CMA_AverageEdgeLengthOnGEdge();
  double CMA_InterpErrorOnGEdge();
  /* END OF C++ API */

  bool hasCad();
 
protected:
  static curveMesh * m_crv_mesh_inst;
  apf::Mesh * m_apf_mesh;
  apf::MeshTag * m_geom_order;
  pField m_mesh_shape_field_;
  pField m_vertex_normal_field_;  

  rEdShpInfo * FindBestReShapeEdge(std::vector<rEdShpInfo*> &);

  // create mesh shape field
  int create_mesh_shape_field();
  int destroy_mesh_shape_field();  
  // create edge nodes from mesh shape field
  int create_edge_nodes_from_shape_field();

  double m_max_angle_;

  NullSField * pNullSF_;
  evalResults * pResults_;
  MeanRatio * pShpMeasure_; 
  
  // from the curving branch //
  double dShapeThresh_;

  double _GWORSTSHAPE;
 
  std::map<pRegion, crShpInfo*> invalidCurvedRgns;  //used in fromCrvBranch.cc
  pPList _invalidRgnPList;
 
  // attachable data Ids
  pMeshDataId fixedEnt_;
  pMeshDataId _onPartBdry; 
 
  // counters for various mesh mod operations
  int iOpCounts_[9];

  // internal functions

  void createInvalidRgns(double);
  void invalidRgnsInfo();

  int findBestMod(pRegion, crShpInfo *, pMeshMod *);
  int findEdgeReShape(pRegion, crShpInfo *, pMeshMod *);

//  pRegion getRgnWithLowestQs();

  void fixInvalidRgnsByMods();
  void ImproveRgnsByMods();
  void applyGlobalNodalSmoothing();
  void outPutOpsInfo();

  int isEdgeSplitModValid(edgeSplitMod *, pRegion, int &, double&);
  int isDsplitClpsModValid(DSplitClpsMod *,pRegion, double &);
  int isEdgeClpsModValid(edgeCollapsMod *, pRegion, double &);
  int isFaceSwpModValid(faceSwapMod *, pRegion, double &);
  int isEdgeSwpModValid(edgeSwapMod *, pRegion, double &);
  int isEdgeSplitClpsModValid(EsplitClpsMod *, pRegion, double &);
  int isRegionClpsModValid(regionCollapsMod *, pRegion, double &);
  int isVertexMotionModValid(vertMotionsMod *, pRegion, double &);
  int isDsplitClpsLooseModValid(pRegion, pMeshMod *);
  int isUnCurvedModValid(pRegion, crShpInfo *, pPList *);
  void updateNewReg(pPList *);
  void applyBestMod(pMeshMod *);

  // check if its OK to use high-order node smoothing
  int isExplicitHONSmoothingValid(vertMotionsMod *, pRegion, crShpInfo *, double &);
  // This implementation is limited to the case where only one edge is in model region. Mar 28, 2011. Kai
  int isExplicitNodalSmoothingValid(pRegion region, crShpInfo *, pEdge *targetEdge);

  int minDetJAmgVertices(crShpInfo *, int *edgeID, int *); // compute the minimum Det among four vertices
  // return 0 if minimum is not located at vertex control point.
  int computeMiddlePtTarget(pRegion, int, pEdge);

  void outPutEdgeVtxClassify(pRegion region);

  void unCurveInvalidRgns();
  void createInvalidRgnList(pPList &);
  // fix the input mesh ent
  void fix_entity(pEntity);
//  int isEntFixed(pEntity);

  template<class OPERATION>
  int traverse_mesh_edges_to_run();

  template<class OPERATION>
  int traverse_mesh_faces_to_run();

  template<class OPERATION>
  int traverse_mesh_rgns_to_run();

  bool is_g1();

  void set_g1();


 private:
  void call_smoothing_procedure() {
  }

  virtual bool v_use_crv_adapt() {
    return true;
  }
  std::vector<CrvTet *> m_crv_tets;

  std::vector<CrvFace *> m_crv_faces;

  std::vector<CrvEdge *> m_crv_edges;
};
typedef class curveMesh CrvMesh;

// --- templated function implementations --- //
template<class OPERATION>
int curveMesh::traverse_mesh_edges_to_run()
{

  pPart pumi_part;
  PUMI_Mesh_GetPart(pMeshInst, 0, pumi_part);
  // --- traverse mesh edges --- //
  pPartEntIter pedge_iter;
  pMeshEnt pcrnt_edge;

  int ient_end = PUMI_PartEntIter_Init(pumi_part, PUMI_EDGE, PUMI_ALLTOPO, pedge_iter);
  while(!ient_end)
  {
    // get a mesh edge
    ient_end = PUMI_PartEntIter_GetNext(pedge_iter, pcrnt_edge);
    if(ient_end)
      break;

    OPERATION * edge_op = new OPERATION(pcrnt_edge);
    edge_op->run();
    delete edge_op;

  }
  
  PUMI_PartEntIter_Del(pedge_iter);

  return 0;

}

template<class OPERATION>
int curveMesh::traverse_mesh_faces_to_run()
{

  pPart pumi_part;
  PUMI_Mesh_GetPart(pMeshInst, 0, pumi_part);
  // --- traverse mesh edges --- //
  pPartEntIter pface_iter;
  pMeshEnt pcrnt_face;

  int ient_end = PUMI_PartEntIter_Init(pumi_part, PUMI_FACE, PUMI_ALLTOPO, pface_iter);
  while(!ient_end)
  {
    // get a mesh edge
    ient_end = PUMI_PartEntIter_GetNext(pface_iter, pcrnt_face);
    if(ient_end)
      break;

    OPERATION * face_op = new OPERATION(pcrnt_face);
    face_op->run();
    delete face_op;

  }
  
  PUMI_PartEntIter_Del(pface_iter);

  return 0;

}

template<class OPERATION>
int curveMesh::traverse_mesh_rgns_to_run()
{

  pPart pumi_part;
  PUMI_Mesh_GetPart(pMeshInst, 0, pumi_part);
  // --- traverse mesh edges --- //
  pPartEntIter prgn_iter;
  pMeshEnt pcrnt_rgn;

  int ient_end = PUMI_PartEntIter_Init(pumi_part, PUMI_REGION, PUMI_ALLTOPO, prgn_iter);
  while(!ient_end)
  {
    // get a mesh edge
    ient_end = PUMI_PartEntIter_GetNext(prgn_iter, pcrnt_rgn);
    if(ient_end)
      break;

    OPERATION * rgn_op = new OPERATION(pcrnt_rgn);
    rgn_op->run();
    delete rgn_op;

  }
  
  PUMI_PartEntIter_Del(prgn_iter);

  return 0;

}

#endif//MESHADAPT_CURVEMESH_H_