libMesh::SystemSubsetBySubdomain Class Reference

#include <system_subset_by_subdomain.h>

Inheritance diagram for libMesh::SystemSubsetBySubdomain:

[legend]

List of all members.

Classes
class	SubdomainSelection
class	SubdomainSelectionByList
Public Member Functions
	SystemSubsetBySubdomain (const System &system, const SubdomainSelection &subdomain_selection, const std::set< unsigned int > *const var_nums=NULL)
	SystemSubsetBySubdomain (const System &system, const std::set< subdomain_id_type > &subdomain_ids, const std::set< unsigned int > *const var_nums=NULL)
virtual	~SystemSubsetBySubdomain ()
virtual const std::vector < unsigned int > &	dof_ids (void) const
void	init (const SubdomainSelection &subdomain_selection)
void	init (const std::set< subdomain_id_type > &subdomain_ids)
const System &	get_system (void) const
Static Public Member Functions
static std::string	get_info ()
static void	print_info (std::ostream &out=libMesh::out)
static unsigned int	n_objects ()
static void	enable_print_counter_info ()
static void	disable_print_counter_info ()
Protected Types
typedef std::map< std::string, std::pair< unsigned int, unsigned int > >	Counts
Protected Member Functions
void	set_var_nums (const std::set< unsigned int > *const var_nums)
void	increment_constructor_count (const std::string &name)
void	increment_destructor_count (const std::string &name)
Protected Attributes
std::set< unsigned int >	_var_nums
std::vector< unsigned int >	_dof_ids
const System &	_system
Static Protected Attributes
static Counts	_counts
static Threads::atomic < unsigned int >	_n_objects
static Threads::spin_mutex	_mutex
static bool	_enable_print_counter = true

---

Detailed Description

This class represents a subset of the dofs of a System, selected by the subdomain_id and possible the variable numbers. The dofs in the subset will be sorted.

Author:

Tim Kroeger, 2010.

Definition at line 46 of file system_subset_by_subdomain.h.

---

Member Typedef Documentation

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

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

Definition at line 113 of file reference_counter.h.

---

Constructor & Destructor Documentation

libMesh::SystemSubsetBySubdomain::SystemSubsetBySubdomain	(	const System &	system,
		const SubdomainSelection &	subdomain_selection,
		const std::set< unsigned int > *const	var_nums = NULL
	)

Constructor. The subset will consist of those dofs which are associated to at least one mesh element that has a subdomain id contained in the subdomain_selection. If var_nums is not a NULL pointer, dofs that are associated to a variable number that is not contained in var_nums will not contain to the subset, no matter what elements they belong to.

Definition at line 60 of file system_subset_by_subdomain.C.

References init(), and set_var_nums().

                                                                      :
    SystemSubset(system),
    _var_nums(),
    _dof_ids()
  {
    this->set_var_nums(var_nums);
    this->init(subdomain_selection);
  }

libMesh::SystemSubsetBySubdomain::SystemSubsetBySubdomain	(	const System &	system,
		const std::set< subdomain_id_type > &	subdomain_ids,
		const std::set< unsigned int > *const	var_nums = NULL
	)

Constructor. The subset will consist of those dofs which are associated to at least one mesh element that has a subdomain id contained in the set subdomain_ids. If var_nums is not a NULL pointer, dofs that are associated to a variable number that is not contained in var_nums will not contain to the subset, no matter what elements they belong to.

Definition at line 72 of file system_subset_by_subdomain.C.

References init(), and set_var_nums().

                                                                      :
    SystemSubset(system),
    _var_nums(),
    _dof_ids()
  {
    this->set_var_nums(var_nums);
    this->init(subdomain_ids);
  }

libMesh::SystemSubsetBySubdomain::~SystemSubsetBySubdomain

(

void

)

[virtual]

Destructor.

Definition at line 84 of file system_subset_by_subdomain.C.

  {
  }

---

Member Function Documentation

void libMesh::ReferenceCounter::disable_print_counter_info

(

)

[static, inherited]

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = false;
  return;
}

const std::vector< unsigned int > & libMesh::SystemSubsetBySubdomain::dof_ids

(

void

)

const [virtual]

Method that returns the actual set of dofs that the subset consists of. The result will contain local dofs on each processor only and will not contain duplictates.

Implements libMesh::SystemSubset.

Definition at line 90 of file system_subset_by_subdomain.C.

References _dof_ids.

  {
    return _dof_ids;
  }

void libMesh::ReferenceCounter::enable_print_counter_info

(

)

[static, inherited]

Methods to enable/disable the reference counter output from print_info()

Definition at line 100 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

{
  _enable_print_counter = true;
  return;
}

std::string libMesh::ReferenceCounter::get_info

(

)

[static, inherited]

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

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

  std::ostringstream oss;

  oss << '\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;

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

  oss << " ---------------------------------------------------------------------------- \n";

  return oss.str();

#else

  return "";

#endif
}

const System & libMesh::SystemSubset::get_system

(

void

)

const [inherited]

Returns the System to which we belong.

Definition at line 43 of file system_subset.C.

References libMesh::SystemSubset::_system.

Referenced by libMesh::LinearImplicitSystem::restrict_solve_to().

  {
    return _system;
  }

void libMesh::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 163 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

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

  p.first++;
}

void libMesh::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 176 of file reference_counter.h.

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

Referenced by libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

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

  p.second++;
}

void libMesh::SystemSubsetBySubdomain::init

(

const std::set< subdomain_id_type > &

subdomain_ids

)

Initializes the class. Will be called by the constructors. Can also be called manually to update the subset. This is required if (a) the subdomain ids of some elements have changed in the meantime and you want these changes to take effect, or (b) you want to use a different list of subdomain ids now.

Definition at line 196 of file system_subset_by_subdomain.C.

References init().

  {
    SubdomainSelectionByList selection(subdomain_ids);
    this->init(selection);
  }

void libMesh::SystemSubsetBySubdomain::init

(

const SubdomainSelection &

subdomain_selection

)

Initializes the class. Will be called by the constructors. Can also be called manually to update the subset. This is required if (a) the subdomain ids of some elements have changed in the meantime and you want these changes to take effect, or (b) you want to use a different SubdomainSelection object now.

Definition at line 115 of file system_subset_by_subdomain.C.

References _dof_ids, libMesh::SystemSubset::_system, _var_nums, libMesh::MeshBase::active_local_elements_begin(), libMesh::MeshBase::active_local_elements_end(), libMesh::CommWorld, libMesh::DofMap::dof_indices(), libMesh::DofMap::end_dof(), libMesh::DofMap::first_dof(), libMesh::System::get_dof_map(), libMesh::System::get_mesh(), mesh, libMesh::n_processors(), libMesh::processor_id(), libMesh::Parallel::Communicator::receive(), libMesh::Parallel::Communicator::send(), libMesh::Elem::subdomain_id(), and swap().

Referenced by init(), and SystemSubsetBySubdomain().

  {
    _dof_ids.clear();

    std::vector<std::vector<dof_id_type> > dof_ids_per_processor(libMesh::n_processors());

    const DofMap & dof_map = _system.get_dof_map();
    std::vector<dof_id_type> dof_indices;

    const MeshBase& mesh = _system.get_mesh();
    MeshBase::const_element_iterator       el     = mesh.active_local_elements_begin();
    const MeshBase::const_element_iterator end_el = mesh.active_local_elements_end();
    for ( ; el != end_el; ++el)
      {
        const Elem* elem = *el;
        if(subdomain_selection(elem->subdomain_id()))
          {
            std::set<unsigned int>::const_iterator it = _var_nums.begin();
            const std::set<unsigned int>::const_iterator itEnd = _var_nums.end();
            for (; it!=itEnd; ++it)
              {
                dof_map.dof_indices (elem, dof_indices, *it);
                for(size_t i=0; i<dof_indices.size(); i++)
                  {
                    const dof_id_type dof = dof_indices[i];
                    for(unsigned int proc=0; proc<libMesh::n_processors(); proc++)
                      {
                        if((dof>=dof_map.first_dof(proc)) && (dof<dof_map.end_dof(proc)))
                          {
                            dof_ids_per_processor[proc].push_back(dof);
                          }
                      }
                  }
              }
          }
      }

    /* Distribute information among processors.  */
    std::vector<Parallel::Request> request_per_processor(libMesh::n_processors());
    for(unsigned int proc=0; proc<libMesh::n_processors(); proc++)
      {
        if(proc!=libMesh::processor_id())
          {
            CommWorld.send(proc,dof_ids_per_processor[proc],request_per_processor[proc]);
          }
      }
    for(unsigned int proc=0; proc<libMesh::n_processors(); proc++)
      {
        std::vector<dof_id_type> received_dofs;
        if(proc==libMesh::processor_id())
          {
            received_dofs = dof_ids_per_processor[proc];
          }
        else
          {
            CommWorld.receive(proc,received_dofs);
          }
        for(unsigned int i=0; i<received_dofs.size(); i++)
          {
            _dof_ids.push_back(received_dofs[i]);
          }
      }

    /* Sort and unique the vector (using the same mechanism as in \p
       DofMap::prepare_send_list()).  */
    std::sort(_dof_ids.begin(), _dof_ids.end());
    std::vector<unsigned int>::iterator new_end = std::unique (_dof_ids.begin(), _dof_ids.end());
    std::vector<unsigned int> (_dof_ids.begin(), new_end).swap (_dof_ids);

    /* Wait for sends to be complete.  */
    for(unsigned int proc=0; proc<libMesh::n_processors(); proc++)
      {
        if(proc!=libMesh::processor_id())
          {
            request_per_processor[proc].wait();
          }
      }
  }

static unsigned int libMesh::ReferenceCounter::n_objects

(

)

[inline, static, inherited]

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

Definition at line 79 of file reference_counter.h.

References libMesh::ReferenceCounter::_n_objects.

  { return _n_objects; }

void libMesh::ReferenceCounter::print_info

(

std::ostream &

out = libMesh::out

)

[static, inherited]

Prints the reference information, by default to libMesh::out.

Definition at line 88 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

{
  if( _enable_print_counter ) out_stream << ReferenceCounter::get_info();
}

void libMesh::SystemSubsetBySubdomain::set_var_nums

(

const std::set< unsigned int > *const

var_nums

)

[protected]

Sets _var_nums to either a copy of var_nums or, if that is NULL, a set of all variable numbers that occur in the system.

Definition at line 97 of file system_subset_by_subdomain.C.

References libMesh::SystemSubset::_system, _var_nums, and libMesh::System::n_vars().

Referenced by SystemSubsetBySubdomain().

  {
    _var_nums.clear();
    if(var_nums!=NULL)
      {
        _var_nums = *var_nums;
      }
    else
      {
        for(unsigned int i=0; i<_system.n_vars(); i++)
          {
            _var_nums.insert(i);
          }
      }
  }

---

Member Data Documentation

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

Actually holds the data.

Definition at line 118 of file reference_counter.h.

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

std::vector<unsigned int> libMesh::SystemSubsetBySubdomain::_dof_ids [protected]

The actual set of the dof ids.

Definition at line 192 of file system_subset_by_subdomain.h.

Referenced by dof_ids(), and init().

bool libMesh::ReferenceCounter::_enable_print_counter = true [static, protected, inherited]

Flag to control whether reference count information is printed when print_info is called.

Definition at line 137 of file reference_counter.h.

Referenced by libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), and libMesh::ReferenceCounter::print_info().

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

Mutual exclusion object to enable thread-safe reference counting.

Definition at line 131 of file reference_counter.h.

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

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

Definition at line 126 of file reference_counter.h.

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

const System& libMesh::SystemSubset::_system [protected, inherited]

A reference to the System we belong to.

Definition at line 78 of file system_subset.h.

Referenced by libMesh::SystemSubset::get_system(), init(), and set_var_nums().

std::set<unsigned int> libMesh::SystemSubsetBySubdomain::_var_nums [protected]

The set of all variable numbers that are contained in the subset. This will be set by the constructor to either a copy of its var_nums argument or, if that is NULL, a set of all variable numbers that occur in the system.

Definition at line 187 of file system_subset_by_subdomain.h.

Referenced by init(), and set_var_nums().

---

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

• system_subset_by_subdomain.h
• system_subset_by_subdomain.C