From: Luca Heltai Date: Mon, 7 Mar 2005 15:51:05 +0000 (+0000) Subject: Function Parser Interface. X-Git-Tag: v8.0.0~14499 X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=8afbbc2c28da4b20aaa2f9d2dd0f715e1453c27a;p=dealii.git Function Parser Interface. git-svn-id: https://svn.dealii.org/trunk@10029 0785d39b-7218-0410-832d-ea1e28bc413d --- diff --git a/deal.II/base/source/function_parser.cc b/deal.II/base/source/function_parser.cc new file mode 100644 index 0000000000..b0488b3f55 --- /dev/null +++ b/deal.II/base/source/function_parser.cc @@ -0,0 +1,157 @@ +//---------------------------- function_parser.cc --------------------- +// $Id$ +// Version: $Name$ +// +// Copyright (C) 2005 by the deal.II authors +// +// 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. +// +//---------------------------- function_parser.cc --------------------- + +#include +#include +#include + +template +FunctionParser::FunctionParser(const unsigned int n_components, + const double initial_time) + : Function(n_components, initial_time) +{ + fp = new fparser::FunctionParser[n_components]; +} + +template +FunctionParser::~FunctionParser() { + delete fp; +} + + + +template +void FunctionParser::initialize(const std::string variables, + const std::vector expressions, + std::map constants, + bool time_dependent, + bool use_degrees) +{ + // We distinguish between two cases: Time dependent problems, and + // not time dependent problems. In the first case the number of + // variables is given by the number of components plus one. In the + // other case, the number of variables is equal to the number of + // components. If none of this is the case, then an exception is + // thrown. + if (time_dependent) + n_vars = this->n_components+1; + else + n_vars = this->n_components; + + AssertThrow(this->n_components == expressions.size(), + ExcInvalidExpressionSize(this->n_components, + expressions.size()) ); + + for (unsigned int i=0; in_components; ++i) { + // Add the variuous constants to the parser. + ConstMapIterator + constant = constants.begin(), + endc = constants.end(); + for(;constant != endc; ++constant) { + AssertThrow( fp[i].AddConstant(constant->first, constant->second), + ExcMessage("Invalid Constant Name")); + } + + + int ret_value = fp[i].Parse(expressions[i], + variables, + use_degrees); + AssertThrow(ret_value == -1, + ExcParseError(ret_value, fp[i].ErrorMsg())); + + // The fact that the parser did not throw an error does not mean + // that everything went ok... we can still have problems with the + // number of variables... + + } + + // Let's check if the number of variables is correct... + AssertThrow(n_vars == fp[0].NVars(), + ExcDimensionMismatch(n_vars,fp[0].NVars())); + + // Now set the initialization bit. + initialized = true; +} +template +void FunctionParser::initialize(const std::string variables, + const std::string expression, + std::map constants, + bool time_dependent, + bool use_degrees) +{ + std::vector expressions(1,expression); + initialize(variables, expressions, constants, time_dependent, use_degrees); +} + +template +inline +double FunctionParser::value (const Point &p, + unsigned int component) const +{ + AssertThrow(initialized==true, ExcNotInitialized()); + AssertThrow(component < this->n_components, + ExcIndexRange(component, 0, this->n_components)); + // Statically allocates dim+1 double variables. + double vars[dim+1]; + + for(unsigned int i=0; iget_time(); + + double my_value = fp[component].Eval(vars); + + AssertThrow(fp[component].EvalError() == 0, + ExcMessage(fp[component].ErrorMsg())); + + return my_value; +} + + +template +inline +void FunctionParser::vector_value (const Point &p, + Vector &values) const +{ + AssertThrow(initialized==true, ExcNotInitialized()); + AssertThrow(values.size() == this->n_components, + ExcDimensionMismatch (values.size(), this->n_components)); + // Statically allocates dim+1 double variables. + double vars[dim+1]; + + for(unsigned int i=0; iget_time(); + + for(unsigned int component = 0; component < this->n_components; + ++component) { + values(component) = fp[component].Eval(vars); + Assert(fp[component].EvalError() == 0, + ExcMessage(fp[component].ErrorMsg())); + } +} + +// Explicit Instantiations. + +template class FunctionParser<1>; +template class FunctionParser<2>; +template class FunctionParser<3>;