fe_vectors.h

Go to the documentation of this file.

// ------------------------------------------------------------------
//  $Id: fe_vectors.h 1348 2013-08-16 00:45:07Z secanell $
//
//  Copyright (C) 2006, 2007, 2008, 2009 by Guido Kanschat.
//  Copyright (C) 2012 by Valentin N. Zingan, University of Alberta.
//
//  This file is subject to QPL and may not be  distributed
//  without copyright and license information. Please refer
//  to the file deal.II/doc/license.html for the  text  and
//  further information on this license.
// ------------------------------------------------------------------

#ifndef _DEALII_APPFRAME_FE_VECTORS_H_
#define _DEALII_APPFRAME_FE_VECTORS_H_

#include <lac/vector_memory.h>
#include <lac/block_vector.h>

#include <algorithm>
#include <fstream>

using namespace dealii;

namespace AppFrame
{

typedef BlockVector<double> FEVector;

class FEVectors : public Subscriptor
{
public:

  FEVectors();

  void add_scalar(double& s,
                  const std::string& name);

  void add_vector(FEVector& v,
                  const std::string& name);

  void add_vector(const FEVector& v,
                  const std::string& name);

  void merge(FEVectors& other);

  void merge(const FEVectors& other);


  unsigned int n_scalars() const;

  unsigned int n_vectors() const;

  double& scalar(unsigned int i);

  const double& scalar(unsigned int i) const;

  FEVector& vector(unsigned int i);

  const FEVector& vector(unsigned int i) const;

  const std::string& scalar_name(unsigned int i) const;

  const std::string& vector_name(unsigned int i) const;

  unsigned int find_scalar(const std::string& name) const;

  unsigned int find_vector(const std::string& name) const;

  template<typename OUT>
  void list(OUT& out,
            unsigned int verbosity = 1) const;

  DeclException2(ExcNameMismatch,
                 int,
                 std::string,
                 << "Name at position " << arg1 << " is not equal to " << arg2);

private:

  bool is_constant;

  std::vector<double*> scalars;

  std::vector<std::string> scalar_names;

  std::vector<FEVector*> vectors;

  std::vector<std::string> vector_names;
};

inline
FEVectors::FEVectors()
:
is_constant(false)
{ }

inline
void
FEVectors::add_scalar(double& s,
                      const std::string& name)
{
  Assert(!is_constant, ExcNotImplemented());
  scalars.push_back(&s);
  scalar_names.push_back(name);
}

inline
void
FEVectors::add_vector(FEVector& v,
                      const std::string& name)
{
  Assert(!is_constant, ExcNotImplemented());
  vectors.push_back(&v);
  vector_names.push_back(name);
}

inline
void
FEVectors::add_vector(const FEVector& v,
                      const std::string& name)
{
  Assert(!is_constant, ExcNotImplemented());
  vectors.push_back(const_cast<FEVector*> (&v));
  vector_names.push_back(name);
  is_constant = true;
}

inline
void
FEVectors::merge(FEVectors& other)
{
  bool constness = is_constant;

  for(unsigned int i = 0; i < other.n_scalars(); ++i)
    add_scalar(*other.scalars[i], other.scalar_names[i]);

  for(unsigned int i = 0; i < other.n_vectors(); ++i)
    add_vector(*other.vectors[i], other.vector_names[i]);

  is_constant = constness | other.is_constant;
}

inline
void
FEVectors::merge(const FEVectors& other)
{
  for(unsigned int i = 0; i < other.n_scalars(); ++i)
    add_scalar(*other.scalars[i], other.scalar_names[i]);

  for(unsigned int i = 0; i < other.n_vectors(); ++i)
    add_vector(*other.vectors[i], other.vector_names[i]);

  is_constant = true;
}

inline
unsigned int
FEVectors::n_scalars() const
{
  return scalars.size();
}

inline
unsigned int
FEVectors::n_vectors() const
{
  return vectors.size();
}

inline
double&
FEVectors::scalar(unsigned int i)
{
  Assert(!is_constant, ExcNotImplemented());
  Assert(i < n_scalars(), ExcIndexRange(i,0,n_scalars()));
  return *scalars[i];
}

inline
const double&
FEVectors::scalar(unsigned int i) const
{
  Assert(i < n_scalars(), ExcIndexRange(i,0,n_scalars()));
  return *scalars[i];
}

inline
FEVector&
FEVectors::vector(unsigned int i)
{
  Assert(!is_constant, ExcNotImplemented());
  Assert(i < n_vectors(), ExcIndexRange(i,0,n_vectors()));
  return *vectors[i];
}

inline
const FEVector&
FEVectors::vector(unsigned int i) const
{
  Assert(i < n_vectors(), ExcIndexRange(i,0,n_vectors()));
  return *vectors[i];
}

inline
const std::string&
FEVectors::scalar_name(unsigned int i) const
{
  Assert(i < n_scalars(), ExcIndexRange(i,0,n_scalars()));
  return scalar_names[i];
}

inline
const std::string&
FEVectors::vector_name(unsigned int i) const
{
  Assert(i < n_vectors(), ExcIndexRange(i,0,n_vectors()));
  return vector_names[i];
}

inline
unsigned int
FEVectors::find_scalar(const std::string& name) const
{
  const std::vector<std::string>::const_iterator
    iter = std::find(scalar_names.begin(), scalar_names.end(), name);

  if(iter == scalar_names.end())
    return deal_II_numbers::invalid_unsigned_int;

  return iter - scalar_names.begin();
}

inline
unsigned int
FEVectors::find_vector(const std::string& name) const
{
  const std::vector<std::string>::const_iterator
    iter = std::find(vector_names.begin(), vector_names.end(), name);

  if(iter == vector_names.end())
    return deal_II_numbers::invalid_unsigned_int;

  return iter - vector_names.begin();
}

template<typename OUT>
inline
void
FEVectors::list(OUT& out,
                unsigned int verbosity) const
{
  if(verbosity == 0)
    return;
  if(verbosity == 1)
  {
        out << std::endl << "Scalars:";
        for(unsigned int i = 0; i < n_scalars(); ++i)
          out << ' ' << '\"' << scalar_names[i] << '\"';

        out << "Vectors:";
        for(unsigned int i = 0; i < n_vectors(); ++i)
          out << ' ' << '\"' << vector_names[i] << '\"';
        out << std::endl;
  }
  else
  {
        for(unsigned int i = 0; i < n_scalars(); ++i)
        {
          out << "Scalar-" << i << ' ' << scalar_names[i] << '=' << *scalars[i];
          out << std::endl;
        }
        for(unsigned int i = 0; i < n_vectors(); ++i)
        {
          out << "Vector-" << i << ' ' << vector_names[i];
          for(unsigned int b = 0; b < vectors[i]->n_blocks(); ++b)
            out << ' ' << vectors[i]->block(b).size();
          out << " Norm: " << vectors[i]->l2_norm();
          out << std::endl;
        }
  }
}

}

#endif