equation_systems.h

一个用来实现偏微分方程中网格的计算库

  /**
   * @returns a reference to the mesh_data
   */
  MeshData & get_mesh_data();

  /**
   * @serializes a distributed mesh and its associated
   * degree of freedom numbering for all systems
   **/
  void allgather ();


  /**
   * Data structure holding arbitrary parameters.
   */
  Parameters parameters;

  
protected:

  
  /**
   * The mesh data structure
   */
  MeshBase& _mesh;

  /**
   * A pointer to the MeshData object you would like to use.
   * Can be NULL.
   */
  MeshData* _mesh_data;

  /**
   * Data structure holding the systems.
   */
  std::map<std::string, System*> _systems;

  /**
   * Typedef for system iterators
   */
  typedef std::map<std::string, System*>::iterator       system_iterator;

  /**
   * Typedef for constatnt system iterators
   */
  typedef std::map<std::string, System*>::const_iterator const_system_iterator;

private:
  /**
   * This function is used in the implementation of add_system,
   * it loops over the nodes and elements of the Mesh, adding the
   * system to each one.  The main reason to separate this part
   * is to avoid coupling this header file to mesh.h, and elem.h.
   */
  void _add_system_to_nodes_and_elems();
};



// ------------------------------------------------------------
// EquationSystems inline methods
inline
const MeshBase & EquationSystems::get_mesh () const
{
  return _mesh;
}



inline
MeshBase & EquationSystems::get_mesh ()
{
  return _mesh;
}


inline
const MeshData & EquationSystems::get_mesh_data () const
{
  libmesh_assert (_mesh_data != NULL);
  return *_mesh_data;
}


inline
MeshData & EquationSystems::get_mesh_data ()
{
  libmesh_assert (_mesh_data != NULL);
  return *_mesh_data;
}

inline
bool EquationSystems::has_mesh_data () const 
{
  return (_mesh_data!=NULL);
}


inline
unsigned int EquationSystems::n_systems () const
{
  return _systems.size();
}




template <typename T_sys>
inline
T_sys & EquationSystems::add_system (const std::string& name)
{
  T_sys* ptr = NULL;
  
  if (!_systems.count(name))
    {
      ptr = new T_sys(*this, name, this->n_systems());

      _systems.insert (std::make_pair(name, ptr));   

      // Tell all the \p DofObject entities to add a system.
      this->_add_system_to_nodes_and_elems();
    }
  else
    {
      // We now allow redundant add_system calls, to make it
      // easier to load data from files for user-derived system
      // subclasses
//      std::cerr << "ERROR: There was already a system"
//		<< " named " << name
//		<< std::endl;

//      libmesh_error();

      ptr = &(this->get_system<T_sys>(name));
    }

  // Return a dynamically casted reference to the newly added System.
  return *ptr;
}



inline
bool EquationSystems::has_system (const std::string& name) const
{
  if (_systems.find(name) == _systems.end())
    return false;
  return true;
}




template <typename T_sys>
inline
const T_sys & EquationSystems::get_system (const unsigned int num) const
{
  libmesh_assert (num < this->n_systems());


  const_system_iterator       pos = _systems.begin();
  const const_system_iterator end = _systems.end();

  for (; pos != end; ++pos)
    if (pos->second->number() == num)
      break;

  // Check for errors
  if (pos == end)
    {
      std::cerr << "ERROR: no system number " << num << " found!"
		<< std::endl;
      libmesh_error();
    }

  // Attempt dynamic cast
  T_sys* ptr = dynamic_cast<T_sys*>(pos->second);

  // Check for failure of dynamic cast
  if (ptr == NULL)
    {
      std::cerr << "ERROR: cannot convert system "
		<< num << " to requested type!"
		<< std::endl;
      libmesh_error();
    }
  
  return *ptr;
}




template <typename T_sys>
inline
T_sys & EquationSystems::get_system (const unsigned int num)
{
  libmesh_assert (num < this->n_systems());
  
  const_system_iterator       pos = _systems.begin();
  const const_system_iterator end = _systems.end();

  for (; pos != end; ++pos)
    if (pos->second->number() == num)
      break;

  // Check for errors
  if (pos == end)
    {
      std::cerr << "ERROR: no system number " << num << " found!"
		<< std::endl;
      libmesh_error();
    }

  // Attempt dynamic cast
  T_sys* ptr = dynamic_cast<T_sys*>(pos->second);

  // Check for failure of dynamic cast
  if (ptr == NULL)
    {
      std::cerr << "ERROR: cannot convert system "
		<< num << " to requested type!"
		<< std::endl;
      libmesh_error();
    }

  return *ptr; 
}






template <typename T_sys>
inline
const T_sys & EquationSystems::get_system (const std::string& name) const
{
  const_system_iterator pos = _systems.find(name);

  // Check for errors
  if (pos == _systems.end())
    {
      std::cerr << "ERROR: no system named \"" << name << "\" found!"
		<< std::endl;
      libmesh_error();
    }

  // Attempt dynamic cast
  T_sys* ptr = dynamic_cast<T_sys*>(pos->second);

  // Check for failure of dynamic cast
  if (ptr == NULL)
    {
      std::cerr << "ERROR: cannot convert system \""
		<< name << "\" to requested type!"
		<< std::endl;
      libmesh_error();
    }

  return *ptr; 
}






template <typename T_sys>
inline
T_sys & EquationSystems::get_system (const std::string& name)
{
  system_iterator pos = _systems.find(name);

  // Check for errors
  if (pos == _systems.end())
    {
      std::cerr << "ERROR: no system named " << name << " found!"
		<< std::endl;
      libmesh_error();
    }

  // Attempt dynamic cast
  T_sys* ptr = dynamic_cast<T_sys*>(pos->second);

  // Check for failure of dynamic cast
  if (ptr == NULL)
    {
      std::cerr << "ERROR: cannot convert system \""
		<< name << "\" to requested type!"
		<< std::endl;
      libmesh_error();
    }

  return *ptr; 
}







inline
const System & EquationSystems::get_system (const std::string& name) const
{
  return this->get_system<System>(name);
}



inline
System & EquationSystems::get_system (const std::string& name)
{
  return this->get_system<System>(name);
}



inline
const System & EquationSystems::get_system (const unsigned int num) const
{
  return this->get_system<System>(num);
}



inline
System & EquationSystems::get_system (const unsigned int num)
{
  return this->get_system<System>(num);
}



#endif