libMesh::NumericVector< T > Class Template Referenceabstract

#include <diff_context.h>

Inheritance diagram for libMesh::NumericVector< T >:

Public Member Functions

 NumericVector (const Parallel::Communicator &comm_in, const ParallelType ptype=AUTOMATIC)
 
 NumericVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const ParallelType ptype=AUTOMATIC)
 
 NumericVector (const Parallel::Communicator &comm_in, const numeric_index_type n, const numeric_index_type n_local, const ParallelType ptype=AUTOMATIC)
 
 NumericVector (const Parallel::Communicator &comm_in, const numeric_index_type N, const numeric_index_type n_local, const std::vector< numeric_index_type > &ghost, const ParallelType ptype=AUTOMATIC)
 
virtual ~NumericVector ()
 
virtual bool initialized () const
 
ParallelType type () const
 
ParallelType & type ()
 
virtual bool closed () const
 
virtual void close ()=0
 
virtual void clear ()
 
virtual void zero ()=0
 
virtual AutoPtr< NumericVector
< T > > 
zero_clone () const =0
 
virtual AutoPtr< NumericVector
< T > > 
clone () const =0
 
virtual void init (const numeric_index_type, const numeric_index_type, const bool=false, const ParallelType=AUTOMATIC)=0
 
virtual void init (const numeric_index_type, const bool=false, const ParallelType=AUTOMATIC)=0
 
virtual void init (const numeric_index_type, const numeric_index_type, const std::vector< numeric_index_type > &, const bool=false, const ParallelType=AUTOMATIC)=0
 
virtual void init (const NumericVector< T > &other, const bool fast=false)=0
 
virtual NumericVector< T > & operator= (const T s)=0
 
virtual NumericVector< T > & operator= (const NumericVector< T > &V)=0
 
virtual NumericVector< T > & operator= (const std::vector< T > &v)=0
 
virtual Real min () const =0
 
virtual Real max () const =0
 
virtual T sum () const =0
 
virtual Real l1_norm () const =0
 
virtual Real l2_norm () const =0
 
virtual Real linfty_norm () const =0
 
virtual Real subset_l1_norm (const std::set< numeric_index_type > &indices) const
 
virtual Real subset_l2_norm (const std::set< numeric_index_type > &indices) const
 
virtual Real subset_linfty_norm (const std::set< numeric_index_type > &indices) const
 
virtual numeric_index_type size () const =0
 
virtual numeric_index_type local_size () const =0
 
virtual numeric_index_type first_local_index () const =0
 
virtual numeric_index_type last_local_index () const =0
 
virtual T operator() (const numeric_index_type i) const =0
 
virtual T el (const numeric_index_type i) const
 
virtual void get (const std::vector< numeric_index_type > &index, std::vector< T > &values) const
 
virtual NumericVector< T > & operator+= (const NumericVector< T > &V)=0
 
virtual NumericVector< T > & operator-= (const NumericVector< T > &V)=0
 
NumericVector< T > & operator*= (const T a)
 
NumericVector< T > & operator/= (const T a)
 
virtual NumericVector< T > & operator/= (NumericVector< T > &)=0
 
virtual void reciprocal ()=0
 
virtual void conjugate ()=0
 
virtual void set (const numeric_index_type i, const T value)=0
 
virtual void add (const numeric_index_type i, const T value)=0
 
virtual void add (const T s)=0
 
virtual void add (const NumericVector< T > &V)=0
 
virtual void add (const T a, const NumericVector< T > &v)=0
 
virtual void add_vector (const std::vector< T > &v, const std::vector< numeric_index_type > &dof_indices)=0
 
virtual void add_vector (const NumericVector< T > &V, const std::vector< numeric_index_type > &dof_indices)=0
 
virtual void add_vector (const NumericVector< T > &, const SparseMatrix< T > &)=0
 
void add_vector (const NumericVector< T > &v, const ShellMatrix< T > &a)
 
virtual void add_vector (const DenseVector< T > &V, const std::vector< numeric_index_type > &dof_indices)=0
 
virtual void add_vector_transpose (const NumericVector< T > &, const SparseMatrix< T > &)=0
 
virtual void insert (const std::vector< T > &v, const std::vector< numeric_index_type > &dof_indices)=0
 
virtual void insert (const NumericVector< T > &V, const std::vector< numeric_index_type > &dof_indices)=0
 
virtual void insert (const DenseVector< T > &V, const std::vector< numeric_index_type > &dof_indices)=0
 
virtual void insert (const DenseSubVector< T > &V, const std::vector< numeric_index_type > &dof_indices)=0
 
virtual void scale (const T factor)=0
 
virtual void abs ()=0
 
virtual T dot (const NumericVector< T > &) const =0
 
virtual void localize (std::vector< T > &v_local) const =0
 
virtual void localize (NumericVector< T > &v_local) const =0
 
virtual void localize (NumericVector< T > &v_local, const std::vector< numeric_index_type > &send_list) const =0
 
virtual void localize (const numeric_index_type first_local_idx, const numeric_index_type last_local_idx, const std::vector< numeric_index_type > &send_list)=0
 
virtual void localize_to_one (std::vector< T > &v_local, const processor_id_type proc_id=0) const =0
 
virtual int compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
 
virtual int local_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
 
virtual int global_relative_compare (const NumericVector< T > &other_vector, const Real threshold=TOLERANCE) const
 
virtual void pointwise_mult (const NumericVector< T > &vec1, const NumericVector< T > &vec2)=0
 
virtual void print (std::ostream &os=libMesh::out) const
 
virtual void print_global (std::ostream &os=libMesh::out) const
 
virtual void print_matlab (const std::string name="NULL") const
 
virtual void create_subvector (NumericVector< T > &, const std::vector< numeric_index_type > &) const
 
virtual void swap (NumericVector< T > &v)
 
template<>
void print (std::ostream &os) const
 
template<>
void print_global (std::ostream &os) const
 
const Parallel::Communicatorcomm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 

Static Public Member Functions

static AutoPtr< NumericVector
< T > > 
build (const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
 
static AutoPtr< NumericVector
< T > > 
build (const SolverPackage solver_package=libMesh::default_solver_package())
 
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 increment_constructor_count (const std::string &name)
 
void increment_destructor_count (const std::string &name)
 

Protected Attributes

bool _is_closed
 
bool _is_initialized
 
ParallelType _type
 
const Parallel::Communicator_communicator
 

Static Protected Attributes

static Counts _counts
 
static Threads::atomic
< unsigned int > 
_n_objects
 
static Threads::spin_mutex _mutex
 
static bool _enable_print_counter = true
 

Friends

std::ostream & operator<< (std::ostream &os, const NumericVector< T > &v)
 

Detailed Description

template<typename T>
class libMesh::NumericVector< T >

Numeric vector. Provides a uniform interface to vector storage schemes for different linear algebra libraries.

Author
Benjamin S. Kirk, 2003

Definition at line 39 of file diff_context.h.

Member Typedef Documentation

typedef std::map<std::string, std::pair<unsigned int, unsigned int> > libMesh::ReferenceCounter::Counts
protectedinherited

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

template<typename T >
libMesh::NumericVector< T >::NumericVector ( const Parallel::Communicator comm_in,
const ParallelType  ptype = AUTOMATIC 
)
inlineexplicit

Dummy-Constructor. Dimension=0

Definition at line 678 of file numeric_vector.h.

679  :
680  ParallelObject(comm_in),
681  _is_closed(false),
682  _is_initialized(false),
683  _type(ptype)
684 {
685 }
template<typename T >
libMesh::NumericVector< T >::NumericVector ( const Parallel::Communicator comm_in,
const numeric_index_type  n,
const ParallelType  ptype = AUTOMATIC 
)
inlineexplicit

Constructor. Set dimension to n and initialize all elements with zero.

Definition at line 691 of file numeric_vector.h.

693  :
694  ParallelObject(comm_in),
695  _is_closed(false),
696  _is_initialized(false),
697  _type(ptype)
698 {
699  libmesh_error(); // Abstract base class!
700  // init(n, n, false, ptype);
701 }
template<typename T >
libMesh::NumericVector< T >::NumericVector ( const Parallel::Communicator comm_in,
const numeric_index_type  n,
const numeric_index_type  n_local,
const ParallelType  ptype = AUTOMATIC 
)
inline

Constructor. Set local dimension to n_local, the global dimension to n, and initialize all elements with zero.

Definition at line 707 of file numeric_vector.h.

710  :
711  ParallelObject(comm_in),
712  _is_closed(false),
713  _is_initialized(false),
714  _type(ptype)
715 {
716  libmesh_error(); // Abstract base class!
717  // init(n, n_local, false, ptype);
718 }
template<typename T >
libMesh::NumericVector< T >::NumericVector ( const Parallel::Communicator comm_in,
const numeric_index_type  N,
const numeric_index_type  n_local,
const std::vector< numeric_index_type > &  ghost,
const ParallelType  ptype = AUTOMATIC 
)
inline

Constructor. Set local dimension to n_local, the global dimension to n, but additionally reserve memory for the indices specified by the ghost argument.

Definition at line 724 of file numeric_vector.h.

728  :
729  ParallelObject(comm_in),
730  _is_closed(false),
731  _is_initialized(false),
732  _type(ptype)
733 {
734  libmesh_error(); // Abstract base class!
735  // init(n, n_local, ghost, false, ptype);
736 }
template<typename T >
libMesh::NumericVector< T >::~NumericVector ( )
inlinevirtual

Destructor, deallocates memory. Made virtual to allow for derived classes to behave properly.

Definition at line 742 of file numeric_vector.h.

743 {
744  clear ();
745 }

Member Function Documentation

template<typename T>
virtual void libMesh::NumericVector< T >::abs ( )
pure virtual

v = abs(v)... that is, each entry in v is replaced by its absolute value.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::DistributedVector< T >, and libMesh::LaspackVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::add ( const T  s)
pure virtual

$U(0-LIBMESH_DIM)+=s$. Addition of s to all components. Note that s is a scalar and not a vector.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::add ( const NumericVector< T > &  V)
pure virtual
template<typename T>
virtual void libMesh::NumericVector< T >::add ( const T  a,
const NumericVector< T > &  v 
)
pure virtual
template<typename T>
virtual void libMesh::NumericVector< T >::add_vector ( const std::vector< T > &  v,
const std::vector< numeric_index_type > &  dof_indices 
)
pure virtual
template<typename T>
virtual void libMesh::NumericVector< T >::add_vector ( const NumericVector< T > &  V,
const std::vector< numeric_index_type > &  dof_indices 
)
pure virtual

$U+=V$, where U and V are type NumericVector<T> and you want to specify WHERE to add the NumericVector<T> V

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::add_vector ( const NumericVector< T > &  ,
const SparseMatrix< T > &   
)
pure virtual
template<typename T>
void libMesh::NumericVector< T >::add_vector ( const NumericVector< T > &  v,
const ShellMatrix< T > &  a 
)

$U+=A*V$, add the product of a ShellMatrix A and a NumericVector V to this, where this=U.

Definition at line 380 of file numeric_vector.C.

References libMesh::ShellMatrix< T >::vector_mult_add().

382 {
383  a.vector_mult_add(*this,v);
384 }
template<typename T>
virtual void libMesh::NumericVector< T >::add_vector ( const DenseVector< T > &  V,
const std::vector< numeric_index_type > &  dof_indices 
)
pure virtual

$ U+=V $ where U and V are type DenseVector<T> and you want to specify WHERE to add the DenseVector<T> V

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::add_vector_transpose ( const NumericVector< T > &  ,
const SparseMatrix< T > &   
)
pure virtual

$U+=A^T*V$, add the product of the transpose of a SparseMatrix A_trans and a NumericVector V to this, where this=U.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T >
AutoPtr< NumericVector< T > > libMesh::NumericVector< T >::build ( const Parallel::Communicator comm,
const SolverPackage  solver_package = libMesh::default_solver_package() 
)
static

Builds a NumericVector on the processors in communicator comm using the linear solver package specified by solver_package

Definition at line 46 of file numeric_vector.C.

References libMeshEnums::AUTOMATIC, libMesh::EIGEN_SOLVERS, libMesh::LASPACK_SOLVERS, libMeshEnums::PETSC_SOLVERS, and libMesh::TRILINOS_SOLVERS.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::System::add_vector(), libMesh::NumericVector< T >::build(), libMesh::EquationSystems::build_solution_vector(), libMesh::System::calculate_norm(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::for(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::EquationSystems::get_solution(), and libMesh::System::project_vector().

47 {
48  // Build the appropriate vector
49  switch (solver_package)
50  {
51 
52 
53 #ifdef LIBMESH_HAVE_LASPACK
54  case LASPACK_SOLVERS:
55  {
56  AutoPtr<NumericVector<T> > ap(new LaspackVector<T>(comm, AUTOMATIC));
57  return ap;
58  }
59 #endif
60 
61 
62 #ifdef LIBMESH_HAVE_PETSC
63  case PETSC_SOLVERS:
64  {
65  AutoPtr<NumericVector<T> > ap(new PetscVector<T>(comm, AUTOMATIC));
66  return ap;
67  }
68 #endif
69 
70 
71 #ifdef LIBMESH_HAVE_TRILINOS
72  case TRILINOS_SOLVERS:
73  {
74  AutoPtr<NumericVector<T> > ap(new EpetraVector<T>(comm, AUTOMATIC));
75  return ap;
76  }
77 #endif
78 
79 
80 #ifdef LIBMESH_HAVE_EIGEN
81  case EIGEN_SOLVERS:
82  {
83  AutoPtr<NumericVector<T> > ap(new EigenSparseVector<T>(comm, AUTOMATIC));
84  return ap;
85  }
86 #endif
87 
88 
89  default:
90  AutoPtr<NumericVector<T> > ap(new DistributedVector<T>(comm, AUTOMATIC));
91  return ap;
92 
93  }
94 
95  AutoPtr<NumericVector<T> > ap(NULL);
96  return ap;
97 }
template<typename T >
AutoPtr< NumericVector< T > > libMesh::NumericVector< T >::build ( const SolverPackage  solver_package = libMesh::default_solver_package())
static

Builds a NumericVector on the processors in communicator CommWorld using the linear solver package specified by solver_package. Deprecated.

Definition at line 103 of file numeric_vector.C.

References libMesh::NumericVector< T >::build(), and libMesh::CommWorld.

104 {
105  libmesh_deprecated();
106  return NumericVector<T>::build(CommWorld, solver_package);
107 }
template<typename T>
virtual bool libMesh::NumericVector< T >::closed ( ) const
inlinevirtual
const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const
inlineinherited
Returns
a reference to the Parallel::Communicator object used by this mesh.

Definition at line 86 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

Referenced by libMesh::__libmesh_petsc_diff_solver_jacobian(), libMesh::__libmesh_petsc_diff_solver_monitor(), libMesh::__libmesh_petsc_diff_solver_residual(), libMesh::__libmesh_petsc_snes_jacobian(), libMesh::__libmesh_petsc_snes_residual(), libMesh::MeshRefinement::_coarsen_elements(), libMesh::ExactSolution::_compute_error(), libMesh::MetisPartitioner::_do_partition(), libMesh::ParmetisPartitioner::_do_repartition(), libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_get_diagonal(), libMesh::SlepcEigenSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult(), libMesh::PetscLinearSolver< T >::_petsc_shell_matrix_mult_add(), libMesh::EquationSystems::_read_impl(), libMesh::MeshRefinement::_refine_elements(), libMesh::ParallelMesh::add_elem(), libMesh::ImplicitSystem::add_matrix(), libMesh::ParallelMesh::add_node(), libMesh::System::add_vector(), libMesh::UnstructuredMesh::all_second_order(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::FEMSystem::assemble_qoi(), libMesh::MeshCommunication::assign_global_indices(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::DofMap::attach_matrix(), libMesh::MeshTools::bounding_box(), libMesh::System::calculate_norm(), libMesh::MeshRefinement::coarsen_elements(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Problem_Interface::computeF(), libMesh::Problem_Interface::computeJacobian(), libMesh::Problem_Interface::computePreconditioner(), libMesh::MeshTools::correct_node_proc_ids(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::DofMap::distribute_dofs(), DMlibMeshFunction(), DMlibMeshJacobian(), DMLibMeshSetSystem(), DMVariableBounds_libMesh(), libMesh::MeshRefinement::eliminate_unrefined_patches(), libMesh::WeightedPatchRecoveryErrorEstimator::estimate_error(), libMesh::PatchRecoveryErrorEstimator::estimate_error(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::MeshRefinement::flag_elements_by_elem_fraction(), libMesh::MeshRefinement::flag_elements_by_error_fraction(), libMesh::MeshRefinement::flag_elements_by_nelem_target(), libMesh::for(), libMesh::CondensedEigenSystem::get_eigenpair(), libMesh::ImplicitSystem::get_linear_solver(), libMesh::LocationMap< T >::init(), libMesh::PetscDiffSolver::init(), libMesh::TimeSolver::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::EigenSystem::init_data(), libMesh::EigenSystem::init_matrices(), libMesh::ParmetisPartitioner::initialize(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::ParallelMesh::libmesh_assert_valid_parallel_flags(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshRefinement::limit_level_mismatch_at_edge(), libMesh::MeshRefinement::limit_level_mismatch_at_node(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshCommunication::make_elems_parallel_consistent(), libMesh::MeshRefinement::make_flags_parallel_consistent(), libMesh::MeshCommunication::make_node_ids_parallel_consistent(), libMesh::MeshCommunication::make_node_proc_ids_parallel_consistent(), libMesh::MeshCommunication::make_nodes_parallel_consistent(), libMesh::MeshRefinement::make_refinement_compatible(), libMesh::FEMSystem::mesh_position_set(), libMesh::MeshSerializer::MeshSerializer(), libMesh::ParallelMesh::n_active_elem(), libMesh::MeshTools::n_active_levels(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::CondensedEigenSystem::n_global_non_condensed_dofs(), libMesh::MeshTools::n_levels(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::MeshTools::n_p_levels(), libMesh::ParallelMesh::parallel_max_elem_id(), libMesh::ParallelMesh::parallel_max_node_id(), libMesh::ParallelMesh::parallel_n_elem(), libMesh::ParallelMesh::parallel_n_nodes(), libMesh::Partitioner::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshBase::prepare_for_use(), libMesh::System::project_vector(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::read(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::MeshBase::recalculate_n_partitions(), libMesh::MeshRefinement::refine_and_coarsen_elements(), libMesh::MeshRefinement::refine_elements(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::MeshBase::subdomain_ids(), libMesh::BoundaryInfo::sync(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::MeshRefinement::test_level_one(), libMesh::MeshRefinement::test_unflagged(), libMesh::MeshTools::total_weight(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::UnstructuredMesh::write(), libMesh::LegacyXdrIO::write_mesh(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), and libMesh::DivaIO::write_stream().

87  { return _communicator; }
template<typename T>
int libMesh::NumericVector< T >::compare ( const NumericVector< T > &  other_vector,
const Real  threshold = TOLERANCE 
) const
virtual
Returns
-1 when this is equivalent to other_vector, up to the given threshold. When differences occur, the return value contains the first index i where the difference (a[i]-b[i]) exceeded the threshold. When no threshold is given, the libMesh TOLERANCE is used.

Definition at line 112 of file numeric_vector.C.

References std::abs(), libMesh::comm, libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::initialized(), libMesh::initialized(), libMesh::NumericVector< T >::last_local_index(), libMesh::libmesh_assert(), and std::max().

114 {
115  libmesh_assert (this->initialized());
116  libmesh_assert (other_vector.initialized());
117  libmesh_assert_equal_to (this->first_local_index(), other_vector.first_local_index());
118  libmesh_assert_equal_to (this->last_local_index(), other_vector.last_local_index());
119 
120  int first_different_i = std::numeric_limits<int>::max();
122 
123  do
124  {
125  if ( std::abs( (*this)(i) - other_vector(i) ) > threshold )
126  first_different_i = i;
127  else
128  i++;
129  }
130  while (first_different_i==std::numeric_limits<int>::max()
131  && i<last_local_index());
132 
133  // Find the correct first differing index in parallel
134  this->comm().min(first_different_i);
135 
136  if (first_different_i == std::numeric_limits<int>::max())
137  return -1;
138 
139  return first_different_i;
140 }
template<typename T>
virtual void libMesh::NumericVector< T >::conjugate ( )
pure virtual

Replace each entry v_i = real(v_i) + imag(v_i) of this vector by its complex conjugate, real(v_i) - imag(v_i)

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::create_subvector ( NumericVector< T > &  ,
const std::vector< numeric_index_type > &   
) const
inlinevirtual

Creates the subvector "subvector" from the indices in the "rows" array. Similar to the create_submatrix routine for the SparseMatrix class, it is currently only implemented for PetscVectors.

Reimplemented in libMesh::PetscVector< T >, and libMesh::EpetraVector< T >.

Definition at line 637 of file numeric_vector.h.

639  {
640  libMesh::err << "ERROR: Not Implemented in base class yet!" << std::endl;
641  libmesh_error();
642  }
void libMesh::ReferenceCounter::disable_print_counter_info ( )
staticinherited

Definition at line 106 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter.

107 {
108  _enable_print_counter = false;
109  return;
110 }
template<typename T>
virtual T libMesh::NumericVector< T >::el ( const numeric_index_type  i) const
inlinevirtual
Returns
the element U(i)

Definition at line 342 of file numeric_vector.h.

342 { return (*this)(i); }
void libMesh::ReferenceCounter::enable_print_counter_info ( )
staticinherited

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.

101 {
102  _enable_print_counter = true;
103  return;
104 }
template<typename T>
void libMesh::NumericVector< T >::get ( const std::vector< numeric_index_type > &  index,
std::vector< T > &  values 
) const
inlinevirtual

Access multiple components at once. values will be resized, if necessary, and filled. The default implementation calls operator() for each index, but some implementations may supply faster methods here.

Reimplemented in libMesh::PetscVector< T >.

Definition at line 797 of file numeric_vector.h.

Referenced by libMesh::FEMContext::pre_fe_reinit().

798 {
799  const std::size_t num = index.size();
800  values.resize(num);
801  for(std::size_t i=0; i<num; i++)
802  {
803  values[i] = (*this)(index[i]);
804  }
805 }
std::string libMesh::ReferenceCounter::get_info ( )
staticinherited

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().

48 {
49 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
50 
51  std::ostringstream oss;
52 
53  oss << '\n'
54  << " ---------------------------------------------------------------------------- \n"
55  << "| Reference count information |\n"
56  << " ---------------------------------------------------------------------------- \n";
57 
58  for (Counts::iterator it = _counts.begin();
59  it != _counts.end(); ++it)
60  {
61  const std::string name(it->first);
62  const unsigned int creations = it->second.first;
63  const unsigned int destructions = it->second.second;
64 
65  oss << "| " << name << " reference count information:\n"
66  << "| Creations: " << creations << '\n'
67  << "| Destructions: " << destructions << '\n';
68  }
69 
70  oss << " ---------------------------------------------------------------------------- \n";
71 
72  return oss.str();
73 
74 #else
75 
76  return "";
77 
78 #endif
79 }
template<typename T>
int libMesh::NumericVector< T >::global_relative_compare ( const NumericVector< T > &  other_vector,
const Real  threshold = TOLERANCE 
) const
virtual
Returns
-1 when this is equivalent to other_vector, up to the given local relative threshold. When differences occur, the return value contains the first index where the difference (a[i]-b[i])/max_j(a[j],b[j]) exceeded the threshold. When no threshold is given, the libMesh TOLERANCE is used.

Definition at line 177 of file numeric_vector.C.

References std::abs(), libMesh::comm, libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::initialized(), libMesh::initialized(), libMesh::NumericVector< T >::last_local_index(), libMesh::libmesh_assert(), libMesh::NumericVector< T >::linfty_norm(), std::max(), and libMesh::Real.

179 {
180  libmesh_assert (this->initialized());
181  libmesh_assert (other_vector.initialized());
182  libmesh_assert_equal_to (this->first_local_index(), other_vector.first_local_index());
183  libmesh_assert_equal_to (this->last_local_index(), other_vector.last_local_index());
184 
185  int first_different_i = std::numeric_limits<int>::max();
187 
188  const Real my_norm = this->linfty_norm();
189  const Real other_norm = other_vector.linfty_norm();
190  const Real abs_threshold = std::max(my_norm, other_norm) * threshold;
191 
192  do
193  {
194  if ( std::abs( (*this)(i) - other_vector(i) ) > abs_threshold )
195  first_different_i = i;
196  else
197  i++;
198  }
199  while (first_different_i==std::numeric_limits<int>::max()
200  && i<last_local_index());
201 
202  // Find the correct first differing index in parallel
203  this->comm().min(first_different_i);
204 
205  if (first_different_i == std::numeric_limits<int>::max())
206  return -1;
207 
208  return first_different_i;
209 }
void libMesh::ReferenceCounter::increment_constructor_count ( const std::string &  name)
inlineprotectedinherited

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, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

164 {
165  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
166  std::pair<unsigned int, unsigned int>& p = _counts[name];
167 
168  p.first++;
169 }
void libMesh::ReferenceCounter::increment_destructor_count ( const std::string &  name)
inlineprotectedinherited

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, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

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

177 {
178  Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
179  std::pair<unsigned int, unsigned int>& p = _counts[name];
180 
181  p.second++;
182 }
template<typename T>
virtual void libMesh::NumericVector< T >::init ( const numeric_index_type  ,
const numeric_index_type  ,
const bool  = false,
const ParallelType  = AUTOMATIC 
)
pure virtual

Change the dimension of the vector to N. The reserved memory for this vector remains unchanged if possible, to make things faster, but this may waste some memory, so take this in the back of your head. However, if N==0 all memory is freed, i.e. if you want to resize the vector and release the memory not needed, you have to first call init(0) and then init(N). This cited behaviour is analogous to that of the STL containers.

On fast==false, the vector is filled by zeros.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

Referenced by libMesh::System::add_vector(), libMesh::EquationSystems::build_solution_vector(), libMesh::AdjointRefinementEstimator::estimate_error(), libMesh::EquationSystems::get_solution(), and libMesh::System::project_vector().

template<typename T>
virtual void libMesh::NumericVector< T >::init ( const numeric_index_type  ,
const bool  = false,
const ParallelType  = AUTOMATIC 
)
pure virtual
template<typename T>
virtual void libMesh::NumericVector< T >::init ( const numeric_index_type  ,
const numeric_index_type  ,
const std::vector< numeric_index_type > &  ,
const bool  = false,
const ParallelType  = AUTOMATIC 
)
pure virtual

Create a vector that holds tha local indices plus those specified in the ghost argument.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::init ( const NumericVector< T > &  other,
const bool  fast = false 
)
pure virtual

Creates a vector that has the same dimension and storage type as other, including ghost dofs.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual bool libMesh::NumericVector< T >::initialized ( ) const
inlinevirtual
template<typename T>
virtual void libMesh::NumericVector< T >::insert ( const std::vector< T > &  v,
const std::vector< numeric_index_type > &  dof_indices 
)
pure virtual

$ U=v $ where v is a std::vector<T> and you want to specify WHERE to insert it

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::DistributedVector< T >, and libMesh::LaspackVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::insert ( const NumericVector< T > &  V,
const std::vector< numeric_index_type > &  dof_indices 
)
pure virtual

$U=V$, where U and V are type NumericVector<T> and you want to specify WHERE to insert the NumericVector<T> V

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::DistributedVector< T >, and libMesh::LaspackVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::insert ( const DenseVector< T > &  V,
const std::vector< numeric_index_type > &  dof_indices 
)
pure virtual

$ U=V $ where U and V are type DenseVector<T> and you want to specify WHERE to insert the DenseVector<T> V

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::DistributedVector< T >, and libMesh::LaspackVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::insert ( const DenseSubVector< T > &  V,
const std::vector< numeric_index_type > &  dof_indices 
)
pure virtual

$ U=V $ where V is a DenseSubVector<T> and you want to specify WHERE to insert it

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::DistributedVector< T >, and libMesh::LaspackVector< T >.

template<typename T>
virtual Real libMesh::NumericVector< T >::l1_norm ( ) const
pure virtual
template<typename T>
virtual Real libMesh::NumericVector< T >::linfty_norm ( ) const
pure virtual
template<typename T>
int libMesh::NumericVector< T >::local_relative_compare ( const NumericVector< T > &  other_vector,
const Real  threshold = TOLERANCE 
) const
virtual
Returns
-1 when this is equivalent to other_vector, up to the given local relative threshold. When differences occur, the return value contains the first index where the difference (a[i]-b[i])/max(a[i],b[i]) exceeded the threshold. When no threshold is given, the libMesh TOLERANCE is used.

Definition at line 144 of file numeric_vector.C.

References std::abs(), libMesh::comm, libMesh::NumericVector< T >::first_local_index(), libMesh::NumericVector< T >::initialized(), libMesh::initialized(), libMesh::NumericVector< T >::last_local_index(), libMesh::libmesh_assert(), and std::max().

146 {
147  libmesh_assert (this->initialized());
148  libmesh_assert (other_vector.initialized());
149  libmesh_assert_equal_to (this->first_local_index(), other_vector.first_local_index());
150  libmesh_assert_equal_to (this->last_local_index(), other_vector.last_local_index());
151 
152  int first_different_i = std::numeric_limits<int>::max();
154 
155  do
156  {
157  if ( std::abs( (*this)(i) - other_vector(i) ) > threshold *
158  std::max(std::abs((*this)(i)), std::abs(other_vector(i))))
159  first_different_i = i;
160  else
161  i++;
162  }
163  while (first_different_i==std::numeric_limits<int>::max()
164  && i<last_local_index());
165 
166  // Find the correct first differing index in parallel
167  this->comm().min(first_different_i);
168 
169  if (first_different_i == std::numeric_limits<int>::max())
170  return -1;
171 
172  return first_different_i;
173 }
template<typename T>
virtual void libMesh::NumericVector< T >::localize ( NumericVector< T > &  v_local) const
pure virtual
template<typename T>
virtual void libMesh::NumericVector< T >::localize ( NumericVector< T > &  v_local,
const std::vector< numeric_index_type > &  send_list 
) const
pure virtual

Creates a local vector v_local containing only information relevant to this processor, as defined by the send_list.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::DistributedVector< T >, and libMesh::LaspackVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::localize ( const numeric_index_type  first_local_idx,
const numeric_index_type  last_local_idx,
const std::vector< numeric_index_type > &  send_list 
)
pure virtual

Updates a local vector with selected values from neighboring processors, as defined by send_list.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::DistributedVector< T >, and libMesh::LaspackVector< T >.

template<typename T>
virtual void libMesh::NumericVector< T >::localize_to_one ( std::vector< T > &  v_local,
const processor_id_type  proc_id = 0 
) const
pure virtual

Creates a local copy of the global vector in v_local only on processor proc_id. By default the data is sent to processor 0. This method is useful for outputting data from one processor.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

Referenced by libMesh::EquationSystems::build_solution_vector(), and libMesh::EquationSystems::get_solution().

template<typename T>
virtual Real libMesh::NumericVector< T >::max ( ) const
pure virtual
Returns
the maximum element in the vector. In case of complex numbers, this returns the maximum Real part.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual Real libMesh::NumericVector< T >::min ( ) const
pure virtual
Returns
the minimum element in the vector. In case of complex numbers, this returns the minimum Real part.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

static unsigned int libMesh::ReferenceCounter::n_objects ( )
inlinestaticinherited

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.

80  { return _n_objects; }
processor_id_type libMesh::ParallelObject::n_processors ( ) const
inlineinherited
Returns
the number of processors in the group.

Definition at line 92 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

Referenced by libMesh::ParmetisPartitioner::_do_repartition(), libMesh::ParallelMesh::add_elem(), libMesh::ParallelMesh::add_node(), libMesh::LaplaceMeshSmoother::allgather_graph(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::ParallelMesh::assign_unique_ids(), libMesh::AztecLinearSolver< T >::AztecLinearSolver(), libMesh::ParallelMesh::clear(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::UnstructuredMesh::create_pid_mesh(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::EnsightIO::EnsightIO(), libMesh::MeshBase::get_info(), libMesh::EquationSystems::init(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::Nemesis_IO_Helper::initialize(), libMesh::MeshTools::libmesh_assert_valid_dof_ids(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::MeshTools::libmesh_assert_valid_refinement_flags(), libMesh::MeshBase::n_active_elem_on_proc(), libMesh::MeshBase::n_elem_on_proc(), libMesh::MeshBase::n_nodes_on_proc(), libMesh::Partitioner::partition(), libMesh::MeshBase::partition(), libMesh::Partitioner::partition_unpartitioned_elements(), libMesh::PetscLinearSolver< T >::PetscLinearSolver(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::MeshTools::processor_bounding_box(), libMesh::System::project_vector(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::UnstructuredMesh::read(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::System::read_serialized_vector(), libMesh::Partitioner::repartition(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::BoundaryInfo::sync(), libMesh::ParallelMesh::update_parallel_id_counts(), libMesh::CheckpointIO::write(), libMesh::GMVIO::write_binary(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

93  { return libmesh_cast_int<processor_id_type>(_communicator.size()); }
template<typename T>
virtual T libMesh::NumericVector< T >::operator() ( const numeric_index_type  i) const
pure virtual
template<typename T>
NumericVector<T>& libMesh::NumericVector< T >::operator*= ( const T  a)
inline

Multiplication operator. Equivalent to U.scale(a)

Definition at line 368 of file numeric_vector.h.

368 { this->scale(a); return *this; }
template<typename T>
virtual NumericVector<T>& libMesh::NumericVector< T >::operator+= ( const NumericVector< T > &  V)
pure virtual
template<typename T>
virtual NumericVector<T>& libMesh::NumericVector< T >::operator-= ( const NumericVector< T > &  V)
pure virtual
template<typename T>
NumericVector<T>& libMesh::NumericVector< T >::operator/= ( const T  a)
inline

Division operator. Equivalent to U.scale(1./a)

Definition at line 374 of file numeric_vector.h.

374 { this->scale(1./a); return *this; }
template<typename T>
virtual NumericVector<T>& libMesh::NumericVector< T >::operator/= ( NumericVector< T > &  )
pure virtual

Pointwise Division operator. ie divide every entry in this vector by the entry in v

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual NumericVector<T>& libMesh::NumericVector< T >::operator= ( const T  s)
pure virtual
template<typename T>
virtual NumericVector<T>& libMesh::NumericVector< T >::operator= ( const NumericVector< T > &  V)
pure virtual
template<typename T>
virtual NumericVector<T>& libMesh::NumericVector< T >::operator= ( const std::vector< T > &  v)
pure virtual
template<typename T>
virtual void libMesh::NumericVector< T >::pointwise_mult ( const NumericVector< T > &  vec1,
const NumericVector< T > &  vec2 
)
pure virtual

Computes the pointwise (i.e. component-wise) product of vec1 and vec2 and stores the result in *this.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

Referenced by libMesh::TensorShellMatrix< T >::get_diagonal().

template<typename T >
void libMesh::NumericVector< T >::print ( std::ostream &  os = libMesh::out) const
inlinevirtual

Prints the local contents of the vector, by default to libMesh::out

Definition at line 832 of file numeric_vector.h.

References libMesh::initialized(), and libMesh::libmesh_assert().

833 {
834  libmesh_assert (this->initialized());
835  os << "Size\tglobal = " << this->size()
836  << "\t\tlocal = " << this->local_size() << std::endl;
837 
838  os << "#\tValue" << std::endl;
839  for (numeric_index_type i=this->first_local_index(); i<this->last_local_index(); i++)
840  os << i << "\t" << (*this)(i) << std::endl;
841 }
template<>
void libMesh::NumericVector< Complex >::print ( std::ostream &  os) const
inline

Definition at line 814 of file numeric_vector.h.

References libMesh::initialized(), and libMesh::libmesh_assert().

815 {
816  libmesh_assert (this->initialized());
817  os << "Size\tglobal = " << this->size()
818  << "\t\tlocal = " << this->local_size() << std::endl;
819 
820  // std::complex<>::operator<<() is defined, but use this form
821  os << "#\tReal part\t\tImaginary part" << std::endl;
822  for (numeric_index_type i=this->first_local_index(); i<this->last_local_index(); i++)
823  os << i << "\t"
824  << (*this)(i).real() << "\t\t"
825  << (*this)(i).imag() << std::endl;
826 }
template<typename T >
void libMesh::NumericVector< T >::print_global ( std::ostream &  os = libMesh::out) const
inlinevirtual

Prints the global contents of the vector, by default to libMesh::out

Definition at line 869 of file numeric_vector.h.

References libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::processor_id().

870 {
871  libmesh_assert (this->initialized());
872 
873  std::vector<T> v(this->size());
874  this->localize(v);
875 
876  // Right now we only want one copy of the output
877  if (this->processor_id())
878  return;
879 
880  os << "Size\tglobal = " << this->size() << std::endl;
881  os << "#\tValue" << std::endl;
882  for (numeric_index_type i=0; i!=v.size(); i++)
883  os << i << "\t" << v[i] << std::endl;
884 }
template<>
void libMesh::NumericVector< Complex >::print_global ( std::ostream &  os) const
inline

Definition at line 847 of file numeric_vector.h.

References libMesh::initialized(), libMesh::libmesh_assert(), and libMesh::processor_id().

848 {
849  libmesh_assert (this->initialized());
850 
851  std::vector<Complex> v(this->size());
852  this->localize(v);
853 
854  // Right now we only want one copy of the output
855  if (this->processor_id())
856  return;
857 
858  os << "Size\tglobal = " << this->size() << std::endl;
859  os << "#\tReal part\t\tImaginary part" << std::endl;
860  for (numeric_index_type i=0; i!=v.size(); i++)
861  os << i << "\t"
862  << v[i].real() << "\t\t"
863  << v[i].imag() << std::endl;
864 }
void libMesh::ReferenceCounter::print_info ( std::ostream &  out = libMesh::out)
staticinherited

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().

89 {
91 }
template<typename T>
virtual void libMesh::NumericVector< T >::print_matlab ( const std::string  name = "NULL") const
inlinevirtual

Print the contents of the matrix in Matlab's sparse matrix format. Optionally prints the matrix to the file named name. If name is not specified it is dumped to the screen.

Reimplemented in libMesh::PetscVector< T >, and libMesh::EpetraVector< T >.

Definition at line 624 of file numeric_vector.h.

625  {
626  libMesh::err << "ERROR: Not Implemented in base class yet!" << std::endl;
627  libMesh::err << "ERROR writing MATLAB file " << name << std::endl;
628  libmesh_error();
629  }
processor_id_type libMesh::ParallelObject::processor_id ( ) const
inlineinherited
Returns
the rank of this processor in the group.

Definition at line 98 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

Referenced by libMesh::MetisPartitioner::_do_partition(), libMesh::EquationSystems::_read_impl(), libMesh::SerialMesh::active_local_elements_begin(), libMesh::ParallelMesh::active_local_elements_begin(), libMesh::SerialMesh::active_local_elements_end(), libMesh::ParallelMesh::active_local_elements_end(), libMesh::SerialMesh::active_local_subdomain_elements_begin(), libMesh::ParallelMesh::active_local_subdomain_elements_begin(), libMesh::SerialMesh::active_local_subdomain_elements_end(), libMesh::ParallelMesh::active_local_subdomain_elements_end(), libMesh::SerialMesh::active_not_local_elements_begin(), libMesh::ParallelMesh::active_not_local_elements_begin(), libMesh::SerialMesh::active_not_local_elements_end(), libMesh::ParallelMesh::active_not_local_elements_end(), libMesh::ParallelMesh::add_elem(), libMesh::DofMap::add_neighbors_to_send_list(), libMesh::ParallelMesh::add_node(), libMesh::UnstructuredMesh::all_second_order(), libMesh::ParmetisPartitioner::assign_partitioning(), libMesh::EquationSystems::build_discontinuous_solution_vector(), libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::ParmetisPartitioner::build_graph(), libMesh::InfElemBuilder::build_inf_elem(), libMesh::DofMap::build_sparsity(), libMesh::ParallelMesh::clear(), libMesh::ExodusII_IO_Helper::close(), libMesh::Nemesis_IO_Helper::compute_border_node_ids(), libMesh::Nemesis_IO_Helper::compute_communication_map_parameters(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::Nemesis_IO_Helper::compute_node_communication_maps(), libMesh::Nemesis_IO_Helper::compute_num_global_elem_blocks(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::Nemesis_IO_Helper::construct_nemesis_filename(), libMesh::ExodusII_IO_Helper::create(), libMesh::DofMap::distribute_dofs(), libMesh::DofMap::distribute_local_dofs_node_major(), libMesh::DofMap::distribute_local_dofs_var_major(), libMesh::DofMap::end_dof(), libMesh::DofMap::end_old_dof(), libMesh::EnsightIO::EnsightIO(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::DofMap::first_dof(), libMesh::DofMap::first_old_dof(), libMesh::Nemesis_IO_Helper::get_cmap_params(), libMesh::Nemesis_IO_Helper::get_eb_info_global(), libMesh::Nemesis_IO_Helper::get_elem_cmap(), libMesh::Nemesis_IO_Helper::get_elem_map(), libMesh::MeshBase::get_info(), libMesh::Nemesis_IO_Helper::get_init_global(), libMesh::Nemesis_IO_Helper::get_init_info(), libMesh::Nemesis_IO_Helper::get_loadbal_param(), libMesh::Nemesis_IO_Helper::get_node_cmap(), libMesh::Nemesis_IO_Helper::get_node_map(), libMesh::Nemesis_IO_Helper::get_ns_param_global(), libMesh::Nemesis_IO_Helper::get_ss_param_global(), libMesh::MeshFunction::gradient(), libMesh::MeshFunction::hessian(), libMesh::SystemSubsetBySubdomain::init(), libMesh::ParmetisPartitioner::initialize(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::ExodusII_IO_Helper::initialize_discontinuous(), libMesh::ExodusII_IO_Helper::initialize_element_variables(), libMesh::ExodusII_IO_Helper::initialize_global_variables(), libMesh::ExodusII_IO_Helper::initialize_nodal_variables(), libMesh::SparsityPattern::Build::join(), libMesh::DofMap::last_dof(), libMesh::MeshTools::libmesh_assert_valid_procids< Elem >(), libMesh::MeshTools::libmesh_assert_valid_procids< Node >(), libMesh::SerialMesh::local_elements_begin(), libMesh::ParallelMesh::local_elements_begin(), libMesh::SerialMesh::local_elements_end(), libMesh::ParallelMesh::local_elements_end(), libMesh::SerialMesh::local_level_elements_begin(), libMesh::ParallelMesh::local_level_elements_begin(), libMesh::SerialMesh::local_level_elements_end(), libMesh::ParallelMesh::local_level_elements_end(), libMesh::SerialMesh::local_nodes_begin(), libMesh::ParallelMesh::local_nodes_begin(), libMesh::SerialMesh::local_nodes_end(), libMesh::ParallelMesh::local_nodes_end(), libMesh::SerialMesh::local_not_level_elements_begin(), libMesh::ParallelMesh::local_not_level_elements_begin(), libMesh::SerialMesh::local_not_level_elements_end(), libMesh::ParallelMesh::local_not_level_elements_end(), libMesh::MeshRefinement::make_coarsening_compatible(), libMesh::MeshBase::n_active_local_elem(), libMesh::BoundaryInfo::n_boundary_conds(), libMesh::BoundaryInfo::n_edge_conds(), libMesh::DofMap::n_local_dofs(), libMesh::System::n_local_dofs(), libMesh::MeshBase::n_local_elem(), libMesh::MeshBase::n_local_nodes(), libMesh::BoundaryInfo::n_nodeset_conds(), libMesh::SerialMesh::not_local_elements_begin(), libMesh::ParallelMesh::not_local_elements_begin(), libMesh::SerialMesh::not_local_elements_end(), libMesh::ParallelMesh::not_local_elements_end(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::SparsityPattern::Build::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::MeshFunction::operator()(), libMesh::ParallelMesh::ParallelMesh(), libMesh::System::point_gradient(), libMesh::System::point_hessian(), libMesh::System::point_value(), libMesh::System::project_vector(), libMesh::Nemesis_IO_Helper::put_cmap_params(), libMesh::Nemesis_IO_Helper::put_elem_cmap(), libMesh::Nemesis_IO_Helper::put_elem_map(), libMesh::Nemesis_IO_Helper::put_loadbal_param(), libMesh::Nemesis_IO_Helper::put_node_cmap(), libMesh::Nemesis_IO_Helper::put_node_map(), libMesh::Nemesis_IO::read(), libMesh::CheckpointIO::read(), libMesh::XdrIO::read(), libMesh::UnstructuredMesh::read(), libMesh::CheckpointIO::read_connectivity(), libMesh::ExodusII_IO_Helper::read_elem_num_map(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::ExodusII_IO_Helper::read_node_num_map(), libMesh::System::read_parallel_data(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs(), libMesh::System::read_serialized_blocked_dof_objects(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_data(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::MeshData::read_xdr(), libMesh::Partitioner::set_node_processor_ids(), libMesh::DofMap::set_nonlocal_dof_objects(), libMesh::LaplaceMeshSmoother::smooth(), libMesh::BoundaryInfo::sync(), libMesh::MeshTools::total_weight(), libMesh::ParallelMesh::update_parallel_id_counts(), libMesh::MeshTools::weight(), libMesh::ExodusII_IO::write(), libMesh::CheckpointIO::write(), libMesh::XdrIO::write(), libMesh::UnstructuredMesh::write(), libMesh::EquationSystems::write(), libMesh::GMVIO::write_discontinuous_gmv(), libMesh::ExodusII_IO::write_element_data(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_elements_discontinuous(), libMesh::ExodusII_IO::write_global_data(), libMesh::ExodusII_IO_Helper::write_global_values(), libMesh::System::write_header(), libMesh::ExodusII_IO::write_information_records(), libMesh::ExodusII_IO_Helper::write_information_records(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates(), libMesh::ExodusII_IO_Helper::write_nodal_coordinates_discontinuous(), libMesh::UCDIO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data(), libMesh::ExodusII_IO::write_nodal_data_discontinuous(), libMesh::ExodusII_IO_Helper::write_nodal_values(), libMesh::ExodusII_IO_Helper::write_nodesets(), libMesh::Nemesis_IO_Helper::write_nodesets(), libMesh::System::write_parallel_data(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_blocked_dof_objects(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::System::write_serialized_data(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), libMesh::ExodusII_IO_Helper::write_sidesets(), libMesh::Nemesis_IO_Helper::write_sidesets(), libMesh::ExodusII_IO::write_timestep(), and libMesh::ExodusII_IO_Helper::write_timestep().

99  { return libmesh_cast_int<processor_id_type>(_communicator.rank()); }
template<typename T>
virtual void libMesh::NumericVector< T >::reciprocal ( )
pure virtual

Replace each entry v_i of this vector by its reciprocal, 1/v_i.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

template<typename T>
virtual numeric_index_type libMesh::NumericVector< T >::size ( ) const
pure virtual
template<class T >
Real libMesh::NumericVector< T >::subset_l1_norm ( const std::set< numeric_index_type > &  indices) const
virtual
Returns
the $l_1$-norm of the vector, i.e. the sum of the absolute values for the specified entries in the vector.

Note that the indices must necessary live on this processor.

Definition at line 320 of file numeric_vector.C.

References std::abs(), libMesh::comm, and libMesh::Real.

Referenced by libMesh::System::discrete_var_norm().

321 {
322  const NumericVector<T> & v = *this;
323 
324  std::set<numeric_index_type>::const_iterator it = indices.begin();
325  const std::set<numeric_index_type>::const_iterator it_end = indices.end();
326 
327  Real norm = 0;
328 
329  for(; it!=it_end; ++it)
330  norm += std::abs(v(*it));
331 
332  this->comm().sum(norm);
333 
334  return norm;
335 }
template<class T >
Real libMesh::NumericVector< T >::subset_l2_norm ( const std::set< numeric_index_type > &  indices) const
virtual
Returns
the $l_2$-norm of the vector, i.e. the square root of the sum of the squares of the elements for the specified entries in the vector.

Note that the indices must necessary live on this processor.

Definition at line 338 of file numeric_vector.C.

References libMesh::comm, libMesh::TensorTools::norm_sq(), and libMesh::Real.

Referenced by libMesh::System::discrete_var_norm().

339 {
340  const NumericVector<T> & v = *this;
341 
342  std::set<numeric_index_type>::const_iterator it = indices.begin();
343  const std::set<numeric_index_type>::const_iterator it_end = indices.end();
344 
345  Real norm = 0;
346 
347  for(; it!=it_end; ++it)
348  norm += TensorTools::norm_sq(v(*it));
349 
350  this->comm().sum(norm);
351 
352  return std::sqrt(norm);
353 }
template<class T >
Real libMesh::NumericVector< T >::subset_linfty_norm ( const std::set< numeric_index_type > &  indices) const
virtual
Returns
the maximum absolute value of the specified entries of this vector, which is the $l_\infty$-norm of a vector.

Note that the indices must necessary live on this processor.

Definition at line 356 of file numeric_vector.C.

References std::abs(), libMesh::comm, and libMesh::Real.

Referenced by libMesh::System::discrete_var_norm().

357 {
358  const NumericVector<T> & v = *this;
359 
360  std::set<numeric_index_type>::const_iterator it = indices.begin();
361  const std::set<numeric_index_type>::const_iterator it_end = indices.end();
362 
363  Real norm = 0;
364 
365  for(; it!=it_end; ++it)
366  {
367  Real value = std::abs(v(*it));
368  if(value > norm)
369  norm = value;
370  }
371 
372  this->comm().max(norm);
373 
374  return norm;
375 }
template<typename T>
virtual T libMesh::NumericVector< T >::sum ( ) const
pure virtual
template<typename T>
ParallelType& libMesh::NumericVector< T >::type ( )
inline
Returns
the type (SERIAL, PARALLEL, GHOSTED) of the vector.

Definition at line 139 of file numeric_vector.h.

139 { return _type; }
template<typename T>
virtual AutoPtr<NumericVector<T> > libMesh::NumericVector< T >::zero_clone ( ) const
pure virtual

Creates a vector which has the same type, size and partitioning as this vector, but whose data is all zero. Returns it in an AutoPtr. This must be overloaded in the derived classes.

Implemented in libMesh::PetscVector< T >, libMesh::EpetraVector< T >, libMesh::EigenSparseVector< T >, libMesh::LaspackVector< T >, and libMesh::DistributedVector< T >.

Referenced by libMesh::NewtonSolver::solve(), and libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve().

Friends And Related Function Documentation

template<typename T>
std::ostream& operator<< ( std::ostream &  os,
const NumericVector< T > &  v 
)
friend

Same as above but allows you to use stream syntax.

Definition at line 612 of file numeric_vector.h.

613  {
614  v.print_global(os);
615  return os;
616  }

Member Data Documentation

ReferenceCounter::Counts libMesh::ReferenceCounter::_counts
staticprotectedinherited
bool libMesh::ReferenceCounter::_enable_print_counter = true
staticprotectedinherited

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().

template<typename T>
bool libMesh::NumericVector< T >::_is_closed
protected

Flag to see if the Numeric assemble routines have been called yet

Definition at line 657 of file numeric_vector.h.

Referenced by libMesh::NumericVector< Number >::closed(), libMesh::DistributedVector< T >::localize(), and libMesh::DistributedVector< T >::operator=().

template<typename T>
bool libMesh::NumericVector< T >::_is_initialized
protected
Threads::spin_mutex libMesh::ReferenceCounter::_mutex
staticprotectedinherited

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
staticprotectedinherited

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().


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

Site Created By: libMesh Developers
Last modified: February 07 2014 16:57:59 UTC

Hosted By:
SourceForge.net Logo