parsed_mapped_functions.h

Go to the documentation of this file.

//-----------------------------------------------------------
//
//    Copyright (C) 2015 by the deal2lkit authors
//
//    This file is part of the deal2lkit library.
//
//    The deal2lkit library is free software; you can use it, redistribute
//    it, and/or modify it under the terms of the GNU Lesser General
//    Public License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//    The full text of the license can be found in the file LICENSE at
//    the top level of the deal2lkit distribution.
//
//-----------------------------------------------------------

#ifndef _d2k_parsed_mapped_function_h
#define _d2k_parsed_mapped_function_h

#include <deal2lkit/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/parsed_function.h>
#include <deal2lkit/parameter_acceptor.h>
#include <deal2lkit/parsed_function.h>
#include <deal.II/fe/component_mask.h>
#include <algorithm>
#include <map>
#include <deal2lkit/utilities.h>

using namespace dealii;


D2K_NAMESPACE_OPEN

template <int spacedim>
class ParsedMappedFunctions : public ParameterAcceptor
{
public:
  ParsedMappedFunctions  (const std::string &name = "Mapped Functions",
                          const unsigned int &n_components=1,
                          const std::string &component_names = "",
                          const std::string &default_id_components = "0=ALL",
                          const std::string &default_id_functions = "",
                          const std::string &default_constants = "");

  shared_ptr<dealii::Functions::ParsedFunction<spacedim> > get_mapped_function (const unsigned int &id) const;

  shared_ptr<dealii::Functions::ParsedFunction<spacedim> > get_mapped_normal_function (const unsigned int &id,
      const unsigned int &fcv) const;

  ComponentMask get_mapped_mask (const unsigned int &id) const;

  std::vector<unsigned int> get_mapped_ids() const;

  std::vector<unsigned int> get_mapped_normal_ids() const;


  virtual void declare_parameters (ParameterHandler &prm);

  virtual void parse_parameters_call_back ();

  bool acts_on_id (unsigned int &id) const;

  void set_time (const double &t);


  DeclException2(ExcIdsMismatch, unsigned int, unsigned int,
                 << "The number of ids specified in the field "
                 <<  "'IDs and component masks' (" << arg1 << ") "
                 << "must match the number of ids "
                 << "set in the field 'IDs and expressions' (" << arg2 <<").");

  DeclException1(ExcIdNotFound, unsigned int,
                 << "No entry with the id " << arg1 << " exists.");

  DeclException1(ExcIdNotMatch, unsigned int,
                 << "No component mask associated to the id " << arg1 << " are defined.");

  DeclException3(ExcWrongComponent, unsigned int, unsigned int, unsigned int,
                 << "At id " << arg1
                 << ", wrong component number has been used: "
                 <<  arg2 << " is not in the range [0, "
                 << arg3 <<").");
  DeclException3(ExcWrongVariable, unsigned int, std::string, std::vector<std::string>,
                 << "At id " << arg1
                 << ", wrong variabile name has been used: "
                 <<  arg2 << " does not belong to the knwon variables: "
                 << print(unique(arg3)) <<".");

protected:

  void split_id_components(const std::string &parsed_idcomponents);
  void split_id_functions(const std::string &parsed_idfunctions,
                          const std::string &constants);
  void add_normal_components();

  void set_normal_functions();

  std::string name;
  std::string str_id_components;
  std::string str_id_functions;
  std::string str_component_names;
  std::string str_constants;
  std::vector<std::string> _component_names;
  std::vector<std::string> _normal_components;
  std::vector<std::string> _all_components;
  std::vector<unsigned int> ids;
  std::vector<unsigned int> normal_ids;
  std::map<unsigned int, ComponentMask> id_components;
  std::map<unsigned int, shared_ptr<dealii::Functions::ParsedFunction<spacedim> > > id_functions;
  std::map<unsigned int, std::pair<ComponentMask, shared_ptr<dealii::Functions::ParsedFunction<spacedim> > > > mapped_functions;
  std::map<std::string, std::pair<std::vector<unsigned int>, unsigned int > > mapped_normal_components; // name, (std::vector<boundary ids>, first component vector)
  std::vector<std::pair<unsigned int, std::string> > normal_components; // first component vector, variable_name+"N"
  std::map<unsigned int, std::string> id_str_functions;
  std::map<std::pair<unsigned int, unsigned int>, shared_ptr<dealii::Functions::ParsedFunction<spacedim> > > _normal_functions;

  const unsigned int n_components;
};



D2K_NAMESPACE_CLOSE

#endif