mesh_base.h

Go to the documentation of this file.

// $Id: mesh_base.h 3547 2009-11-08 22:22:13Z benkirk $

// The libMesh Finite Element Library.
// Copyright (C) 2002-2008 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
  
// 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 along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



#ifndef __mesh_base_h__
#define __mesh_base_h__



// C++ Includes   -----------------------------------
#include <string>

// forward declarations
class Elem;
class Node;
class Point;
class BoundaryInfo;
class PointLocatorBase;
class MeshData;

// Local Includes -----------------------------------
#include "auto_ptr.h"
#include "dof_object.h" // for invalid_processor_id
#include "enum_elem_type.h"
#include "libmesh_common.h"
#include "multi_predicates.h"
#include "partitioner.h"
#include "variant_filter_iterator.h"




// ------------------------------------------------------------
// MeshBase class definition
class MeshBase
{
public:

  MeshBase (unsigned int d);
  
  MeshBase (const MeshBase& other_mesh);

  virtual AutoPtr<MeshBase> clone() const = 0;

  virtual ~MeshBase ();

  AutoPtr<BoundaryInfo> boundary_info;

  virtual AutoPtr<Partitioner> &partitioner() { return _partitioner; }
  
  virtual void clear ();
  
  bool is_prepared () const
  { return _is_prepared; }
  
  virtual bool is_serial () const 
  { return true; }
  
  virtual void allgather () {}
  
  virtual void delete_remote_elements () {}
  
  unsigned int mesh_dimension () const
  { return static_cast<unsigned int>(_dim); }
  
  void set_mesh_dimension (unsigned int d)
  { libmesh_assert(!this->n_elem()); _dim = d; }
  
  unsigned int spatial_dimension () const
  { return static_cast<unsigned int>(LIBMESH_DIM); }
  
  virtual unsigned int n_nodes () const = 0; 

  unsigned int n_nodes_on_proc (const unsigned int proc) const;

  unsigned int n_local_nodes () const
  { return this->n_nodes_on_proc (libMesh::processor_id()); }

  unsigned int n_unpartitioned_nodes () const
  { return this->n_nodes_on_proc (DofObject::invalid_processor_id); }

  virtual unsigned int max_node_id () const = 0;

  virtual void reserve_nodes (const unsigned int nn) = 0; 
  
  virtual unsigned int n_elem () const = 0; 

  virtual unsigned int max_elem_id () const = 0;

  virtual void reserve_elem (const unsigned int ne) = 0; 

  virtual void update_parallel_id_counts () = 0;

  virtual unsigned int n_active_elem () const = 0;

  unsigned int n_elem_on_proc (const unsigned int proc) const;

  unsigned int n_local_elem () const
  { return this->n_elem_on_proc (libMesh::processor_id()); }

  unsigned int n_unpartitioned_elem () const
  { return this->n_elem_on_proc (DofObject::invalid_processor_id); }

  unsigned int n_active_elem_on_proc (const unsigned int proc) const;

  unsigned int n_active_local_elem () const
  { return this->n_active_elem_on_proc (libMesh::processor_id()); }
  
  unsigned int n_sub_elem () const;

  unsigned int n_active_sub_elem () const;
  
  virtual const Point& point (const unsigned int i) const = 0;

  virtual const Node& node (const unsigned int i) const = 0;
  
  virtual Node& node (const unsigned int i) = 0;
  
  virtual const Node* node_ptr (const unsigned int i) const = 0;

  virtual Node* & node_ptr (const unsigned int i) = 0;

  virtual Elem* elem (const unsigned int i) const = 0;

  virtual Node* add_point (const Point& p,
                           const unsigned int id = DofObject::invalid_id,
                           const unsigned int proc_id =
                             DofObject::invalid_processor_id) = 0;

  virtual Node* add_node (Node* n) = 0;

  virtual void delete_node (Node* n) = 0;
  
  virtual void renumber_node (unsigned int old_id, unsigned int new_id) = 0;
                      
  virtual Elem* add_elem (Elem* e) = 0;

  virtual Elem* insert_elem (Elem* e) = 0;

  virtual void delete_elem (Elem* e) = 0;

  virtual void renumber_elem (unsigned int old_id, unsigned int new_id) = 0;

  virtual void find_neighbors (const bool reset_remote_elements = false,
                               const bool reset_current_list    = true) = 0;
  
  virtual void renumber_nodes_and_elements () = 0;    

#ifdef LIBMESH_ENABLE_AMR

  virtual bool contract () = 0;
#endif

  void prepare_for_use (const bool skip_renumber_nodes_and_elements=false);
  
  void partition (const unsigned int n_parts=libMesh::n_processors());
  
  unsigned int n_subdomains () const;

  unsigned int n_partitions () const
  { return _n_parts; }
  
  unsigned int n_processors () const
  { return libMesh::n_processors(); }

  unsigned int processor_id () const
  { return libMesh::processor_id(); }

  std::string get_info () const;

  void print_info (std::ostream& os=std::cout) const;

  friend std::ostream& operator << (std::ostream& os, const MeshBase& m);

  virtual void read  (const std::string& name, MeshData* mesh_data=NULL,
                      bool skip_renumber_nodes_and_elements=false) = 0;
  virtual void write (const std::string& name, MeshData* mesh_data=NULL) = 0;

  virtual void all_first_order () = 0;

  virtual void all_second_order (const bool full_ordered=true) = 0;

  typedef Predicates::multi_predicate Predicate;

  struct element_iterator;
  struct const_element_iterator;

  struct node_iterator;
  struct const_node_iterator;

  unsigned int recalculate_n_partitions();

  const PointLocatorBase & point_locator () const;

  void clear_point_locator ();



public:


  
  virtual element_iterator elements_begin                   () = 0;
  virtual element_iterator elements_end                     () = 0;
  virtual element_iterator active_elements_begin            () = 0;
  virtual element_iterator active_elements_end              () = 0;
  virtual element_iterator ancestor_elements_begin          () = 0;
  virtual element_iterator ancestor_elements_end            () = 0;
  virtual element_iterator subactive_elements_begin         () = 0;
  virtual element_iterator subactive_elements_end           () = 0;
  virtual element_iterator not_active_elements_begin        () = 0;
  virtual element_iterator not_active_elements_end          () = 0;
  virtual element_iterator not_ancestor_elements_begin      () = 0;
  virtual element_iterator not_ancestor_elements_end        () = 0;
  virtual element_iterator not_subactive_elements_begin     () = 0;
  virtual element_iterator not_subactive_elements_end       () = 0;
  virtual element_iterator local_elements_begin             () = 0;
  virtual element_iterator local_elements_end               () = 0;
  virtual element_iterator not_local_elements_begin         () = 0;
  virtual element_iterator not_local_elements_end           () = 0;
  virtual element_iterator active_local_elements_begin      () = 0;
  virtual element_iterator active_local_elements_end        () = 0;
  virtual element_iterator active_not_local_elements_begin  () = 0;
  virtual element_iterator active_not_local_elements_end    () = 0;
  virtual element_iterator level_elements_begin             (const unsigned int level  ) = 0;
  virtual element_iterator level_elements_end               (const unsigned int level  ) = 0;
  virtual element_iterator not_level_elements_begin         (const unsigned int level  ) = 0;
  virtual element_iterator not_level_elements_end           (const unsigned int level  ) = 0;
  virtual element_iterator local_level_elements_begin       (const unsigned int level  ) = 0;
  virtual element_iterator local_level_elements_end         (const unsigned int level  ) = 0;
  virtual element_iterator local_not_level_elements_begin   (const unsigned int level  ) = 0;
  virtual element_iterator local_not_level_elements_end     (const unsigned int level  ) = 0;
  virtual element_iterator pid_elements_begin               (const unsigned int proc_id) = 0;
  virtual element_iterator pid_elements_end                 (const unsigned int proc_id) = 0;
  virtual element_iterator type_elements_begin              (const ElemType type       ) = 0;
  virtual element_iterator type_elements_end                (const ElemType type       ) = 0;
  virtual element_iterator active_type_elements_begin       (const ElemType type       ) = 0;
  virtual element_iterator active_type_elements_end         (const ElemType type       ) = 0;
  virtual element_iterator active_pid_elements_begin        (const unsigned int proc_id) = 0;
  virtual element_iterator active_pid_elements_end          (const unsigned int proc_id) = 0;
  virtual element_iterator unpartitioned_elements_begin     () = 0;
  virtual element_iterator unpartitioned_elements_end       () = 0;
  virtual element_iterator active_local_subdomain_elements_begin         (const unsigned int subdomain_id) = 0;
  virtual element_iterator active_local_subdomain_elements_end           (const unsigned int subdomain_id) = 0;
  

  
  
  virtual const_element_iterator elements_begin                   () const = 0;
  virtual const_element_iterator elements_end                     () const = 0;
  virtual const_element_iterator active_elements_begin            () const = 0;
  virtual const_element_iterator active_elements_end              () const = 0;
  virtual const_element_iterator ancestor_elements_begin          () const = 0;
  virtual const_element_iterator ancestor_elements_end            () const = 0;
  virtual const_element_iterator subactive_elements_begin         () const = 0;
  virtual const_element_iterator subactive_elements_end           () const = 0;
  virtual const_element_iterator not_active_elements_begin        () const = 0;
  virtual const_element_iterator not_active_elements_end          () const = 0;
  virtual const_element_iterator not_ancestor_elements_begin      () const = 0;
  virtual const_element_iterator not_ancestor_elements_end        () const = 0;
  virtual const_element_iterator not_subactive_elements_begin     () const = 0;
  virtual const_element_iterator not_subactive_elements_end       () const = 0;
  virtual const_element_iterator local_elements_begin             () const = 0;
  virtual const_element_iterator local_elements_end               () const = 0;
  virtual const_element_iterator not_local_elements_begin         () const = 0;
  virtual const_element_iterator not_local_elements_end           () const = 0;
  virtual const_element_iterator active_local_elements_begin      () const = 0;
  virtual const_element_iterator active_local_elements_end        () const = 0;
  virtual const_element_iterator active_not_local_elements_begin  () const = 0;
  virtual const_element_iterator active_not_local_elements_end    () const = 0;
  virtual const_element_iterator level_elements_begin             (const unsigned int level)   const = 0;
  virtual const_element_iterator level_elements_end               (const unsigned int level)   const = 0;
  virtual const_element_iterator not_level_elements_begin         (const unsigned int level)   const = 0;
  virtual const_element_iterator not_level_elements_end           (const unsigned int level)   const = 0;
  virtual const_element_iterator local_level_elements_begin       (const unsigned int level)   const = 0;
  virtual const_element_iterator local_level_elements_end         (const unsigned int level)   const = 0;
  virtual const_element_iterator local_not_level_elements_begin   (const unsigned int level)   const = 0;
  virtual const_element_iterator local_not_level_elements_end     (const unsigned int level)   const = 0;
  virtual const_element_iterator pid_elements_begin               (const unsigned int proc_id) const = 0;
  virtual const_element_iterator pid_elements_end                 (const unsigned int proc_id) const = 0;
  virtual const_element_iterator type_elements_begin              (const ElemType type)        const = 0;
  virtual const_element_iterator type_elements_end                (const ElemType type)        const = 0;
  virtual const_element_iterator active_type_elements_begin       (const ElemType type)        const = 0;
  virtual const_element_iterator active_type_elements_end         (const ElemType type)        const = 0;
  virtual const_element_iterator active_pid_elements_begin        (const unsigned int proc_id) const = 0;
  virtual const_element_iterator active_pid_elements_end          (const unsigned int proc_id) const = 0;
  virtual const_element_iterator unpartitioned_elements_begin     () const = 0;
  virtual const_element_iterator unpartitioned_elements_end       () const = 0;
  virtual const_element_iterator active_local_subdomain_elements_begin (const unsigned int subdomain_id) const = 0;
  virtual const_element_iterator active_local_subdomain_elements_end   (const unsigned int subdomain_id) const = 0;

  
  virtual node_iterator nodes_begin        () = 0;
  virtual node_iterator nodes_end          () = 0;
  virtual node_iterator active_nodes_begin () = 0;
  virtual node_iterator active_nodes_end   () = 0;
  virtual node_iterator local_nodes_begin  () = 0;
  virtual node_iterator local_nodes_end    () = 0;
  virtual node_iterator pid_nodes_begin    (const unsigned int proc_id) = 0;
  virtual node_iterator pid_nodes_end      (const unsigned int proc_id) = 0;


  virtual const_node_iterator nodes_begin        () const = 0;
  virtual const_node_iterator nodes_end          () const = 0;
  virtual const_node_iterator active_nodes_begin () const = 0;
  virtual const_node_iterator active_nodes_end   () const = 0;
  virtual const_node_iterator local_nodes_begin  () const = 0;
  virtual const_node_iterator local_nodes_end    () const = 0;
  virtual const_node_iterator pid_nodes_begin    (const unsigned int proc_id) const = 0;
  virtual const_node_iterator pid_nodes_end      (const unsigned int proc_id) const = 0;


  
protected:



  
  

  unsigned int& set_n_partitions ()
  { return _n_parts; }
  
  unsigned int _n_parts;
  
  unsigned int _dim;

  bool _is_prepared;
  
  mutable AutoPtr<PointLocatorBase> _point_locator;

  AutoPtr<Partitioner> _partitioner;
  
  friend class Partitioner;

  friend class BoundaryInfo;

};











struct
MeshBase::element_iterator :
variant_filter_iterator<MeshBase::Predicate,
                        Elem*>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  element_iterator (const IterType& d,
                    const IterType& e,
                    const PredType& p ) :
    variant_filter_iterator<MeshBase::Predicate,
                            Elem*>(d,e,p) {}
};




struct
MeshBase::const_element_iterator :
variant_filter_iterator<MeshBase::Predicate,
                        Elem* const,
                        Elem* const&,
                        Elem* const*>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  const_element_iterator (const IterType& d,
                          const IterType& e,
                          const PredType& p ) :
    variant_filter_iterator<MeshBase::Predicate,
                            Elem* const,
                            Elem* const&,
                            Elem* const*>(d,e,p)  {}


  // The conversion-to-const ctor.  Takes a regular iterator and calls the appropriate
  // variant_filter_iterator copy constructor.  Note that this one is *not* templated!
  const_element_iterator (const MeshBase::element_iterator& rhs) :
    variant_filter_iterator<Predicate,
                            Elem* const,
                            Elem* const&,
                            Elem* const*>(rhs)
  {
    // std::cout << "Called element_iterator conversion-to-const ctor." << std::endl;
  }
};







struct
MeshBase::node_iterator :
variant_filter_iterator<MeshBase::Predicate,
                        Node*>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  node_iterator (const IterType& d,
                 const IterType& e,
                 const PredType& p ) :
    variant_filter_iterator<MeshBase::Predicate,
                            Node*>(d,e,p) {}
};




struct
MeshBase::const_node_iterator :
variant_filter_iterator<MeshBase::Predicate,
                        Node* const,
                        Node* const &,
                        Node* const *>
{
  // Templated forwarding ctor -- forwards to appropriate variant_filter_iterator ctor
  template <typename PredType, typename IterType>
  const_node_iterator (const IterType& d,
                       const IterType& e,
                       const PredType& p ) :
    variant_filter_iterator<MeshBase::Predicate,
                            Node* const,
                            Node* const &,
                            Node* const *>(d,e,p)  {}


  // The conversion-to-const ctor.  Takes a regular iterator and calls the appropriate
  // variant_filter_iterator copy constructor.  Note that this one is *not* templated!
  const_node_iterator (const MeshBase::node_iterator& rhs) :
    variant_filter_iterator<Predicate,
                            Node* const,
                            Node* const &,
                            Node* const *>(rhs)
  {
    // std::cout << "Called node_iterator conversion-to-const ctor." << std::endl;
  }
};


#endif