application_data.h

Go to the documentation of this file.

// ------------------------------------------------------------------
//  $Id: application_data.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_APPLICATION_DATA_H_
#define _DEALII_APPFRAME_APPLICATION_DATA_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 ApplicationData
{
public:

 ~ApplicationData();

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

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

  void erase_scalar(std::string name);

  void erase_vector(std::string name);

  const double* scalar(std::string name) const;

  const FEVector* vector(std::string name) const;

  void log() const;

  GrowingVectorMemory< Vector<double> > vector_pool;

  GrowingVectorMemory<FEVector> block_vector_pool;

  typedef std::map< std::string, const double* > scalar_map;

  typedef std::map< std::string, const FEVector* > vector_map;

  DeclException2(ExcNotFound,
                 char*,
                 std::string,
                 << "A " << arg1 << " with name " << arg2 << " was not stored in this data object");

private:

  scalar_map named_scalars;

  vector_map named_vectors;
};

inline
ApplicationData::~ApplicationData()
{ }

inline
void
ApplicationData::enter(std::string name,
                       const double& s)
{
  named_scalars.insert(std::make_pair(name, &s));
}

inline
void
ApplicationData::enter(std::string name,
                       const FEVector& v)
{
  named_vectors.insert(std::make_pair(name, &v));
}

inline
void
ApplicationData::erase_scalar(std::string name)
{
  scalar_map::iterator iter = named_scalars.find(name);
  Assert(iter != named_scalars.end(), ExcNotInitialized());
  named_scalars.erase(iter);
}

inline
void
ApplicationData::erase_vector(std::string name)
{
  vector_map::iterator iter = named_vectors.find(name);
  Assert(iter != named_vectors.end(), ExcNotInitialized());
  named_vectors.erase(iter);
}

inline
const double*
ApplicationData::scalar(std::string name) const
{
  scalar_map::const_iterator iter = named_scalars.find(name);
  AssertThrow(iter != named_scalars.end(), ExcNotFound("scalar", name));
  return iter->second;
}

inline
const FEVector*
ApplicationData::vector(std::string name) const
{
  vector_map::const_iterator iter = named_vectors.find(name);
  AssertThrow(iter != named_vectors.end(), ExcNotFound("vector", name));
  return iter->second;
}

inline
void
ApplicationData::log() const
{
  deallog.push("scalar");
  for(scalar_map::const_iterator iter = named_scalars.begin(); iter != named_scalars.end(); ++iter)
    deallog << iter->first << '\t' << iter->second << std::endl;
  deallog.pop();

  deallog.push("vector");
  for(vector_map::const_iterator iter = named_vectors.begin(); iter != named_vectors.end(); ++iter)
    deallog << iter->first << '\t' << iter->second->size() << std::endl;
  deallog.pop();
}

}

#endif