libMesh::Utility Namespace Reference

Classes
struct	do_pow
struct	do_pow< 6, T >
struct	do_pow< 1, T >
struct	do_pow< 0, T >
class	ReverseBytes
Functions
template<>
ElemType	string_to_enum< ElemType > (const std::string &s)
template<>
std::string	enum_to_string< ElemType > (const ElemType e)
template<>
Order	string_to_enum< Order > (const std::string &s)
template<>
std::string	enum_to_string< Order > (const Order o)
template<>
FEFamily	string_to_enum< FEFamily > (const std::string &s)
template<>
std::string	enum_to_string< FEFamily > (const FEFamily f)
template<>
InfMapType	string_to_enum< InfMapType > (const std::string &s)
template<>
std::string	enum_to_string< InfMapType > (const InfMapType i)
template<>
QuadratureType	string_to_enum< QuadratureType > (const std::string &s)
template<>
std::string	enum_to_string< QuadratureType > (const QuadratureType i)
template<>
PreconditionerType	string_to_enum< PreconditionerType > (const std::string &s)
template<>
std::string	enum_to_string< PreconditionerType > (const PreconditionerType i)
template<>
Elem::RefinementState	string_to_enum< Elem::RefinementState > (const std::string &s)
template<>
std::string	enum_to_string< Elem::RefinementState > (const Elem::RefinementState i)
std::string	get_timestamp ()
uint32_t	hashword (const uint32_t *k, size_t length, uint32_t initval=0)
uint32_t	hashword2 (const uint32_t &first, const uint32_t &second, uint32_t initval=0)
uint64_t	hashword2 (const uint64_t first, const uint64_t second)
uint16_t	hashword2 (const uint16_t first, const uint16_t second)
uint64_t	hashword (const uint64_t *k, size_t length)
uint16_t	hashword (const uint16_t *k, size_t length)
template<typename T >
T	string_to_enum (const std::string &s)
template<typename T >
std::string	enum_to_string (const T e)
void	print_timestamp (std::ostream &target=std::cout)
std::string	system_info ()
template<typename ForwardIter , typename T >
void	iota (ForwardIter first, ForwardIter last, T value)
template<class InputIterator >
bool	is_sorted (InputIterator first, InputIterator last)
template<class ForwardIterator , class T >
ForwardIterator	binary_find (ForwardIterator first, ForwardIterator last, const T &value)
template<int N, typename T >
T	pow (const T &x)
unsigned int	factorial (unsigned int n)
template<typename T >
void	deallocate (std::vector< T > &vec)
std::string	complex_filename (const std::string &basename, unsigned int r_o_c=0)
void	prepare_complex_data (const std::vector< Complex > &source, std::vector< Real > &real_part, std::vector< Real > &imag_part)

---

Function Documentation

template<class ForwardIterator , class T >

ForwardIterator libMesh::Utility::binary_find	(	ForwardIterator	first,
		ForwardIterator	last,
		const T &	value
	)			[inline]

The STL provides binary_search() which returns true/false depending on whether the searched-for value is found. Utility::binary_find() uses a binary search on a sorted range to return an iterator to the searched-for element, or "last" if the element is not found.

Definition at line 130 of file utility.h.

Referenced by libMesh::TetGenMeshInterface::triangulate_conformingDelaunayMesh_carvehole().

  {
    ForwardIterator it = std::lower_bound(first, last, value);
    return (it == last || value < *it) ? last : it;
  }

std::string libMesh::Utility::complex_filename	(	const std::string &	basename,
		unsigned int	r_o_c = 0
	)

Returns:

for r_o_c = 0 the filename for output of the real part of complex data, and for r_o_c = 1 the filename for the imaginary part.

Definition at line 83 of file utility.C.

References libMesh::Quality::name().

Referenced by libMesh::LegacyXdrIO::read_mgf_soln(), and libMesh::LegacyXdrIO::write_mgf_soln().

{
  std::string name(basename);

  if (r_o_c == 0)
    name.append(".real");

  else
    name.append(".imag");

  return name;
}

template<typename T >

void libMesh::Utility::deallocate

(

std::vector< T > &

vec

)

[inline]

A convenient method to truly empty a vector using the "swap trick"

Definition at line 214 of file utility.h.

References swap().

Referenced by libMesh::Nemesis_IO::read().

  {
    std::vector<T>().swap(vec);
  }

template<typename T >

std::string libMesh::Utility::enum_to_string

(

const T

e

)

[inline]

Takes the enumeration e of type T and returns the matching string.

Referenced by libMesh::AbaqusIO::assign_sideset_ids(), libMesh::Elem::get_info(), and libMesh::DofMap::reinit().

template<>

std::string libMesh::Utility::enum_to_string< Elem::RefinementState >

(

const Elem::RefinementState

i

)

[inline]

template<>

std::string libMesh::Utility::enum_to_string< ElemType >

(

const ElemType

e

)

[inline]

Referenced by libMesh::MeshTools::Modification::all_tri().

template<>

std::string libMesh::Utility::enum_to_string< FEFamily >

(

const FEFamily

f

)

[inline]

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

template<>

std::string libMesh::Utility::enum_to_string< InfMapType >

(

const InfMapType

i

)

[inline]

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

template<>

std::string libMesh::Utility::enum_to_string< Order >

(

const Order

o

)

[inline]

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

template<>

std::string libMesh::Utility::enum_to_string< PreconditionerType >

(

const PreconditionerType

i

)

[inline]

template<>

std::string libMesh::Utility::enum_to_string< QuadratureType >

(

const QuadratureType

i

)

[inline]

unsigned int libMesh::Utility::factorial

(

unsigned int

n

)

[inline]

A simple implementation of the factorial.

Definition at line 194 of file utility.h.

Referenced by libMesh::FE< Dim, T >::shape(), and libMesh::FE< Dim, T >::shape_deriv().

    {

      unsigned int factorial_n = 1;

      if (n==0)
        return factorial_n;

      for (unsigned int i=1; i<n; i++)
        factorial_n *= i+1;

      return factorial_n;
    }

std::string libMesh::Utility::get_timestamp

(

)

Referenced by libMesh::PerfLog::get_info_header(), print_timestamp(), and system_info().

uint16_t libMesh::Utility::hashword	(	const uint16_t *	k,
		size_t	length
	)			[inline]

Definition at line 183 of file hashword.h.

    {
      // "big" prime number
      const uint16_t bp = 257;

      uint16_t c = 0;
      uint16_t shift=0;
      for (size_t i=0; i != length; ++i)
        {
          c = static_cast<uint16_t>
            (c + static_cast<uint16_t>(k[i] << shift) % bp);
          shift = static_cast<uint16_t>(shift+3);
        }

      return c;
    }

uint64_t libMesh::Utility::hashword	(	const uint64_t *	k,
		size_t	length
	)			[inline]

Definition at line 165 of file hashword.h.

    {
      // big prime number
      const unsigned int bp = 65449;

      uint64_t c = 0;
      unsigned int shift=0;
      for (size_t i=0; i != length; ++i)
        {
          c += (k[i] << shift) % bp;
          shift += 5;
        }

      return c;
    }

uint32_t libMesh::Utility::hashword	(	const uint32_t *	k,
		size_t	length,
		uint32_t	initval = 0
	)			[inline]

Definition at line 92 of file hashword.h.

Referenced by libMesh::Elem::compute_key().

    {
      uint32_t a,b,c;

      // Set up the internal state
      a = b = c = 0xdeadbeef + ((static_cast<uint32_t>(length))<<2) + initval;

      //------------------------------------------------- handle most of the key
      while (length > 3)
        {
          a += k[0];
          b += k[1];
          c += k[2];
          mix(a,b,c);
          length -= 3;
          k += 3;
        }

      //------------------------------------------- handle the last 3 uint32_t's
      switch(length)                     // all the case statements fall through
        {
        case 3 : c+=k[2];
        case 2 : b+=k[1];
        case 1 : a+=k[0];
          final(a,b,c);
        default:     // case 0: nothing left to add
          break;
        }

      //------------------------------------------------------ report the result
      return c;
    }

uint16_t libMesh::Utility::hashword2	(	const uint16_t	first,
		const uint16_t	second
	)			[inline]

Definition at line 155 of file hashword.h.

    {
      // "big" prime number
      const uint16_t bp = 257;

      return static_cast<uint16_t>(first%bp + (second<<3)%bp);
    }

uint64_t libMesh::Utility::hashword2	(	const uint64_t	first,
		const uint64_t	second
	)			[inline]

Definition at line 146 of file hashword.h.

    {
      // big prime number
      const unsigned int bp = 65449;

      return (first%bp + (second<<5)%bp);
    }

uint32_t libMesh::Utility::hashword2	(	const uint32_t &	first,
		const uint32_t &	second,
		uint32_t	initval = 0
	)			[inline]

Definition at line 130 of file hashword.h.

Referenced by libMesh::Elem::compute_key().

    {
      uint32_t a,b,c;

      // Set up the internal state
      a = b = c = 0xdeadbeef + 8 + initval;

      b+=second;
      a+=first;
      final(a,b,c);

      return c;
    }

template<typename ForwardIter , typename T >

void libMesh::Utility::iota	(	ForwardIter	first,
		ForwardIter	last,
		T	value
	)			[inline]

Utility::iota is a duplication of the SGI STL extension std::iota. It simply assigns sequentially increasing values to a range. That is, it assigns value to *first, value + 1 to *(first + 1) and so on. In general, each iterator i in the range [first, last) is assigned value + (i - first).

Definition at line 58 of file utility.h.

Referenced by libMesh::PetscVector< T >::create_subvector(), and libMesh::PetscVector< T >::localize().

  {
    while (first != last)
      {
        *first = value++;
        ++first;
      }
  }

template<class InputIterator >

bool libMesh::Utility::is_sorted	(	InputIterator	first,
		InputIterator	last
	)			[inline]

Utility::is_sorted mimics the behavior of the SGI STL extension std::is_sorted. Checks to see if the range [first,last) is sorted in non-decreasing order, ie. for each "i" in [first,last) *i <= *(i+1).

Definition at line 75 of file utility.h.

  {
    if ( first == last )
      return true;

    // "prev" always points to the entry just to the left of "first"
    //  [-    -    -    -    -    -]
    //   ^    ^
    // prev first
    //
    //  [-    -    -    -    -    -]
    //        ^    ^
    //      prev first
    //
    //  [-    -    -    -    -    -]
    //             ^    ^
    //           prev first
    InputIterator prev( first );
    for ( ++first; first != last; ++prev, ++first )
      if ( *first < *prev  )    // Note: this is the same as *prev > *first,
           return false;        // but we only require op< to be defined.

    // If we haven't returned yet, it's sorted!
    return true;


    // A one-liner version using adjacent_find.  This doesn't work for
    // C-style arrays, since their pointers do not have a value_type.
    //
    // Works by checking to see if adjacent entries satisfy *i >
    // *(i+1) and returns the first one which does.  If "last" is
    // returned, no such pair was found, and therefore the range must
    // be in non-decreasing order.
    //
    // return (last ==
    // std::adjacent_find(first, last,
    // std::greater< typename InputIterator::value_type >()));

    // A second one-linear attempt.  This one checks for a **strictly
    // increasing** (no duplicate entries) range.  Also doesn't work
    // with C-style arrays.
    //
    // return (last ==
    // std::adjacent_find(first, last,
    // std::not2(std::less<typename InputIterator::value_type>())));
  }

template<int N, typename T >

T libMesh::Utility::pow

(

const T &

x

)

[inline]

Definition at line 184 of file utility.h.

References libMesh::Utility::do_pow< N, T >::apply().

Referenced by libMesh::FEHermite< Dim >::hermite_raw_shape_second_deriv(), libMesh::FE< Dim, T >::shape(), libMesh::FE< Dim, T >::shape_deriv(), and libMesh::FE< Dim, T >::shape_second_deriv().

  {
    return do_pow<N,T>::apply(x);
  }

void libMesh::Utility::prepare_complex_data	(	const std::vector< Complex > &	source,
		std::vector< Real > &	real_part,
		std::vector< Real > &	imag_part
	)

Prepare complex data for writing.

Definition at line 99 of file utility.C.

Referenced by libMesh::LegacyXdrIO::read_mgf_soln(), and libMesh::LegacyXdrIO::write_mgf_soln().

{
  const unsigned int len = source.size();

  real_part.resize(len);
  imag_part.resize(len);

  for (unsigned int i=0; i<len; i++)
    {
      real_part[i] = source[i].real();
      imag_part[i] = source[i].imag();
    }
}

void libMesh::Utility::print_timestamp

(

std::ostream &

target = std::cout

)

[inline]

Definition at line 37 of file timestamp.h.

References get_timestamp().

  {
    target << get_timestamp() << std::endl;
  }

template<typename T >

T libMesh::Utility::string_to_enum

(

const std::string &

s

)

[inline]

Takes the string s and returns the matching enumeration of type T.

template<>

Elem::RefinementState libMesh::Utility::string_to_enum< Elem::RefinementState >

(

const std::string &

s

)

[inline]

template<>

ElemType libMesh::Utility::string_to_enum< ElemType >

(

const std::string &

s

)

[inline]

template<>

FEFamily libMesh::Utility::string_to_enum< FEFamily >

(

const std::string &

s

)

[inline]

template<>

InfMapType libMesh::Utility::string_to_enum< InfMapType >

(

const std::string &

s

)

[inline]

template<>

Order libMesh::Utility::string_to_enum< Order >

(

const std::string &

s

)

[inline]

template<>

PreconditionerType libMesh::Utility::string_to_enum< PreconditionerType >

(

const std::string &

s

)

[inline]

template<>

QuadratureType libMesh::Utility::string_to_enum< QuadratureType >

(

const std::string &

s

)

[inline]

Referenced by libMesh::QBase::build().

std::string libMesh::Utility::system_info

(

)

The system_info function returns information about the system you are running on.

Definition at line 45 of file utility.C.

References get_timestamp().

{
  std::ostringstream oss;

  std::string date = Utility::get_timestamp();

  // Get system information
  struct utsname sysInfo;
  uname(&sysInfo);

  // Get user information
#ifdef LIBMESH_HAVE_GETPWUID
      struct passwd* p = getpwuid(getuid());
#endif


  oss << '\n'
      << " ---------------------------------------------------------------------\n"
      << "| Time:           " << date             << '\n'
      << "| OS:             " << sysInfo.sysname  << '\n'
      << "| HostName:       " << sysInfo.nodename << '\n'
      << "| OS Release      " << sysInfo.release  << '\n'
      << "| OS Version:     " << sysInfo.version  << '\n'
      << "| Machine:        " << sysInfo.machine  << '\n'
#ifdef LIBMESH_HAVE_GETPWUID
      << "| Username:       " << p->pw_name       << '\n'
#else
      << "| Username:       " << "Unknown"        << '\n'
#endif
      << " ---------------------------------------------------------------------\n";

  return oss.str();
}