CopyMesh.hpp

Go to the documentation of this file.

#ifndef MESHKIT_COPY_MESH_HPP
#define MESHKIT_COPY_MESH_HPP

#include <vector>
#include <set>

#include "meshkit/Types.hpp"
#include "meshkit/Error.hpp"
#include "meshkit/MeshScheme.hpp"
#include "meshkit/ModelEnt.hpp"

#include "CESets.hpp"
#include "meshkit/LocalTag.hpp"
#include "Transform.hpp"

#include "meshkit/iMesh.hpp"

namespace MeshKit {

  class MKCore;


  class CopyMesh : public MeshScheme
  {
  public:
    CopyMesh(MKCore *mkcore, const MEntVector &me_vec);

    virtual ~CopyMesh();

    static const char* name();

    static bool can_mesh(iBase_EntityType dim);

    static bool can_mesh(ModelEnt *me);

    static const moab::EntityType* output_types();

    virtual const moab::EntityType* mesh_types_arr() const;

    virtual bool add_modelent(ModelEnt *model_ent);

    virtual void setup_this();

    virtual void execute_this();

    // CopyMesh function local //////////////////

    /* \brief Return the copyTag used to indicate set copies
     */
    iBase_TagHandle copy_tag();

    void set_transform(const Copy::Transform &transform);

    void update_sets();

    /* \brief Reset the copy and expand set lists
     */
    void reset_sets();

    /* \brief Return reference to copy sets
     */
    CESets &copy_sets();

    /* \brief Return reference to expand sets
     */
    CESets &expand_sets();

    /* \brief Tag copied sets with indicated tag from original set
     */
    void tag_copied_sets(const char **tag_names, const char **tag_vals,
                         const int num_tags);

    /* \brief Tag copied sets with indicated tag from original set
     */
    void tag_copied_sets(iMesh::TagHandle *tags, const char **tag_vals,
                         const int num_tags);
  private:
    void do_copy(iMesh::EntitySetHandle set_handle);

    //- get the copy/expand sets based on copy/expand tags
    void get_copy_expand_sets(iMesh::EntitySetHandle *&copy_sets,
                              int &num_copy_sets,
                              iMesh::EntitySetHandle *&expand_sets,
                              int &num_expand_sets);

    //- get the sets tagged with the given vector of tags/values
    void get_tagged_sets(iMesh::EntitySetHandle from_set,
                         iMesh::TagHandle *tag_handles,
                         const char **tag_vals,
                         int num_tags,
                         iMesh::EntitySetHandle *&tagged_sets,
                         int &num_tagged_sets);

    // - get structure
    int getStructure(iMesh_Instance instance,
                     iBase_EntitySetHandle set,
                     std::vector<iBase_EntityHandle> &ents,
                     std::vector<iBase_EntityHandle> &unique_adj,
                     std::vector<int> &indices,
                     std::vector<int> &offsets);

    iMesh *mesh;                // mesh instance
    LocalTag copyTag;           // tag storing copy-to tag
    Copy::Transform *transform; // transform function for copy-move

    CESets copySets;
    CESets expandSets;
  };

  void connect_the_dots(iMesh *mesh, iBase_TagHandle local_tag,
                        const std::vector<iBase_EntityHandle> &ents,
                        const std::vector<int> &indices,
                        const std::vector<int> &offsets,
                        const std::vector<iBase_EntityHandle> &verts);

  inline const char* CopyMesh::name()
  {
    return "CopyMesh";
  }

  inline bool CopyMesh::can_mesh(iBase_EntityType)
  {
    // Given just a dimension, CopyMesh can't do anything since it doesn't know
    // what to copy.
    return false;
  }

  inline bool CopyMesh::can_mesh(ModelEnt *)
  {
    return true;
  }

  inline const moab::EntityType* CopyMesh::mesh_types_arr() const
  {
    return output_types();
  }

  inline void CopyMesh::set_transform(const Copy::Transform &trans)
  {
    delete transform;
    transform = trans.clone();
  }

  inline iBase_TagHandle CopyMesh::copy_tag()
  {
    return copyTag;
  }

  inline void CopyMesh::reset_sets()
  {
    copySets.clear();
    expandSets.clear();
  }

  inline CESets &CopyMesh::copy_sets()
  {
    return copySets;
  }

  inline CESets &CopyMesh::expand_sets()
  {
    return expandSets;
  }
} // namespace MeshKit
#endif