Solver Class Reference

#include <solver.h>

Inheritance diagram for Solver:

[legend]

List of all members.

Public Types
typedef EquationSystems	sys_type
Public Member Functions
	~Solver ()
virtual void	init ()
virtual void	pre_process ()
virtual void	solve ()
virtual void	post_process ()
const sys_type &	system () const
const MeshBase &	mesh () const
Static Public Member Functions
static std::string	get_info ()
static void	print_info ()
static unsigned int	n_objects ()
Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
Protected Member Functions
	Solver (EquationSystems &es)
	Solver (EquationSystems &es, const std::string &name, const unsigned int number)
sys_type &	system ()
MeshBase &	mesh ()
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Protected Attributes
sys_type &	_system
MeshBase &	_mesh
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex

---

Detailed Description

This is a generic class that defines a solver to be used in a simulation. A user can define a solver by deriving from this class and implementing certain functions.

Author:

Benjamin S. Kirk, 2003-2004.

Definition at line 46 of file solver.h.

---

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > ReferenceCounter::Counts [protected, inherited]

Data structure to log the information. The log is identified by the class name.

Definition at line 105 of file reference_counter.h.

typedef EquationSystems Solver::sys_type

The type of system

Definition at line 76 of file solver.h.

---

Constructor & Destructor Documentation

Solver::Solver

(

EquationSystems &

es

)

[inline, protected]

Constructor. Requires a reference to the system to be solved. The constructor is protected since it should not be instantiated by users.

Definition at line 143 of file solver.h.

                                   :
  _system (es),
  _mesh   (es.get_mesh())
{
libmesh_deprecated();
}

Solver::Solver	(	EquationSystems &	es,
		const std::string &	name,
		const unsigned int	number
	)			[protected]

Constructor. Requires a reference to the EquationSystems object, a name for the system, and the system number.

Solver::~Solver

(

)

[inline]

Destructor.

Definition at line 153 of file solver.h.

{
}

---

Member Function Documentation

std::string ReferenceCounter::get_info

(

)

[static, inherited]

Gets a string containing the reference information.

Definition at line 45 of file reference_counter.C.

References ReferenceCounter::_counts, and QuadratureRules::name().

Referenced by ReferenceCounter::print_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)

  std::ostringstream out;
  
  out << '\n'
      << " ---------------------------------------------------------------------------- \n"
      << "| Reference count information                                                |\n"
      << " ---------------------------------------------------------------------------- \n";
  
  for (Counts::iterator it = _counts.begin();
       it != _counts.end(); ++it)
    {
      const std::string name(it->first);
      const unsigned int creations    = it->second.first;
      const unsigned int destructions = it->second.second;

      out << "| " << name << " reference count information:\n"
          << "|  Creations:    " << creations    << '\n'
          << "|  Destructions: " << destructions << '\n';
    }
  
  out << " ---------------------------------------------------------------------------- \n";

  return out.str();

#else

  return "";
  
#endif
}

void ReferenceCounter::increment_constructor_count

(

const std::string &

name

)

[inline, protected, inherited]

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 149 of file reference_counter.h.

References ReferenceCounter::_counts, and Threads::spin_mtx.

Referenced by ReferenceCountedObject< SparseMatrix< T > >::ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.first++;
}

void ReferenceCounter::increment_destructor_count

(

const std::string &

name

)

[inline, protected, inherited]

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 167 of file reference_counter.h.

References ReferenceCounter::_counts, and Threads::spin_mtx.

Referenced by ReferenceCountedObject< SparseMatrix< T > >::~ReferenceCountedObject().

{
  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
  std::pair<unsigned int, unsigned int>& p = _counts[name];

  p.second++;
}

void Solver::init

(

)

[inline, virtual]

The initialization function. This method is used to initialize data structures befor a simulation begins.

Definition at line 160 of file solver.h.

References EquationSystems::init(), and system().

{
  std::cout << "Initializing $Id: solver.h 3549 2009-11-09 17:39:52Z roystgnr $"
            << std::endl;
  
  // Initialize the system.
  this->system().init ();
}

MeshBase& Solver::mesh

(

)

[inline, protected]

Returns:

a reference to the Mesh.

Definition at line 124 of file solver.h.

References _mesh.

{ return _mesh; }

const MeshBase& Solver::mesh

(

)

const [inline]

Returns:

a reference to the Mesh.

Definition at line 111 of file solver.h.

References _mesh.

{ return _mesh; }

static unsigned int ReferenceCounter::n_objects

(

)

[inline, static, inherited]

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 76 of file reference_counter.h.

References ReferenceCounter::_n_objects.

  { return _n_objects; }

void Solver::post_process

(

)

[inline, virtual]

This method may be called after each solve step in order to perform any required post-processing.

Definition at line 199 of file solver.h.

Referenced by solve().

{
//  std::cout << "Post-processing"
//          << std::endl;
}

void Solver::pre_process

(

)

[inline, virtual]

This method may be called before each solve step in order to perform any required pre-processing.

Definition at line 172 of file solver.h.

Referenced by solve().

{
//  std::cout << "Pre-processing"
//          << std::endl;
}

void ReferenceCounter::print_info

(

)

[static, inherited]

Prints the reference information to std::cout.

Definition at line 83 of file reference_counter.C.

References ReferenceCounter::get_info().

{
#if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
  
  std::cout << ReferenceCounter::get_info();
  
#endif
}

void Solver::solve

(

)

[inline, virtual]

This method performs a solve step. What occurs in this method will depend on the type of solver. See the example programs for more details.

Definition at line 181 of file solver.h.

References post_process(), pre_process(), EquationSystems::solve(), and system().

{
  // Perform any necessary pre-processing
  Solver::pre_process ();
  
//  std::cout << "Solving $Id: solver.h 3549 2009-11-09 17:39:52Z roystgnr $"
//          << std::endl;

  // Solve the system
  this->system().solve ();
  
  // Perform any necessary post-processing
  Solver::post_process ();  
}

sys_type& Solver::system

(

)

[inline, protected]

Returns:

a writeable reference to the system we are solving.

Definition at line 119 of file solver.h.

References _system.

{ return _system; }

const sys_type& Solver::system

(

)

const [inline]

Returns:

a constant reference to the system we are solving.

Definition at line 106 of file solver.h.

References _system.

Referenced by init(), and solve().

{ return _system; }

---

Member Data Documentation

ReferenceCounter::Counts ReferenceCounter::_counts [static, protected, inherited]

Actually holds the data.

Definition at line 110 of file reference_counter.h.

Referenced by ReferenceCounter::get_info(), ReferenceCounter::increment_constructor_count(), and ReferenceCounter::increment_destructor_count().

MeshBase& Solver::_mesh [protected]

A reference to the Mesh for the system we are solving.

Definition at line 135 of file solver.h.

Referenced by mesh().

Threads::spin_mutex ReferenceCounter::_mutex [static, protected, inherited]

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 123 of file reference_counter.h.

Threads::atomic< unsigned int > ReferenceCounter::_n_objects [static, protected, inherited]

The number of objects. Print the reference count information when the number returns to 0.

Definition at line 118 of file reference_counter.h.

Referenced by ReferenceCounter::n_objects(), ReferenceCounter::ReferenceCounter(), and ReferenceCounter::~ReferenceCounter().

sys_type& Solver::_system [protected]

A reference to the system we are solving.

Definition at line 129 of file solver.h.

Referenced by system().

---

The documentation for this class was generated from the following file:

• solver.h