zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Use global lookup tables for the calcEntry scalar functions.

Browse Source 
Handle leading signs on functions etc.
This commit is contained in:
Mark Olesen
2010-01-02 15:09:17 +01:00
parent f8147f5bb5
commit cf91174880
8 changed files with 314 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
applications/test/dictionary/calcEntry/addToGlobalFunctionSelectionTable.H Normal file
View File

@ -0,0 +1,53 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-2010 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
@file Foam::addToGlobalFunctionSelectionTable
Description
Macros for easy insertion into global function selection tables
\*---------------------------------------------------------------------------*/
#ifndef addToGlobalFunctionSelectionTable_H
#define addToGlobalFunctionSelectionTable_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// add to hash-table of functions with 'lookup' as the key
#define addNamedToGlobalFunctionSelectionTable\
(memberFunction,argNames,lookup,functionPtr) \
\
/* Add to the table, find by lookup name */ \
add##memberFunction##argNames##GlobalMemberFunctionToTable \
add_##lookup##_##memberFunction##argNames##GlobalMemberFunctionTo##Table_\
(#lookup, functionPtr)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

29
applications/test/dictionary/calcEntry/calcEntry.atg
View File

@ -39,10 +39,7 @@ SourceFiles
\*---------------------------------------------------------------------------*/
#include "dictionary.H"
#include "scalar.H"
#include "error.H"
#include "wchar.H"
#include "DynamicList.H"
#include "calcEntryInternal.H"
@ -56,7 +53,7 @@ COMPILER calcEntry
private:
//- The parent dictionary
mutable dictionary* dict_;
dictionary* dict_;
//- The calculation result
scalar val;
@ -196,8 +193,8 @@ Expr<scalar& val> (. scalar val2 = 0; .)
=
Term<val>
{
"+" Term<val2> (. val += val2; .)
| "-" Term<val2> (. val -= val2; .)
'+' Term<val2> (. val += val2; .)
| '-' Term<val2> (. val -= val2; .)
}
.
@ -208,20 +205,26 @@ Term<scalar& val> (. scalar val2 = 0; .)
=
Factor<val>
{
"*" Factor<val2> (. val *= val2; .)
| "/" Factor<val2> (. val /= val2; .)
'*' Factor<val2> (. val *= val2; .)
| '/' Factor<val2> (. val /= val2; .)
}
.
/*---------------------------------------------------------------------------*/
Factor<scalar& val>
// Note the treatment of the leading signs is fairly generous
// eg, "10 + - 10" is treated like "10 + -10"
//
Factor<scalar& val> (. bool negative = false; .)
=
Func<val>
['+' | '-' (. negative = true; .)
]
(
Func<val> | '(' Expr<val> ')'
| variable (. val = getDictLookup(); .)
| number (. val = coco_string_toDouble(t->val); .)
| '-' '(' Expr<val> ')' (. val = -val; .)
| '(' Expr<val> ')'
) (. if (negative) { val = -val; } .)
.
@ -242,7 +245,7 @@ Func<scalar& val>
{ ',' Expr<x> (. param.append(x); .)
}
]
')' (. val = scalarFunctions::dispatch(funcName, param); .)
')' (. val = dispatch(funcName, param); .)
.

171
applications/test/dictionary/calcEntry/calcEntryInternal.C
View File

@ -25,8 +25,7 @@ License
\*---------------------------------------------------------------------------*/
#include "calcEntryInternal.H"
#include "addToMemberFunctionSelectionTable.H"
#include "addToStaticMemberFunctionSelectionTable.H"
#include "addToGlobalFunctionSelectionTable.H"
#include "unitConversion.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -38,14 +37,66 @@ namespace functionEntries
namespace calcEntryInternal
{
defineStaticMemberFunctionSelectionTable(scalarFunctions,dispatch,ParamList);
defineGlobalFunctionSelectionTable(dispatch,ParamList);
scalar scalarFunctions::dispatch
(
const word& name,
const UList<scalar>& param
)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define globalConstant0(Name, Constant)\
scalar Name##_0(const UList<scalar>& param) \
{ \
return Constant; \
} \
addNamedToGlobalFunctionSelectionTable(dispatch,ParamList,Name##_0,&Name##_0)
#define globalFunction0(Name, Function)\
scalar Name##_0(const UList<scalar>& param) \
{ \
return Function(); \
} \
addNamedToGlobalFunctionSelectionTable(dispatch,ParamList,Name##_0,&Name##_0)
#define globalFunction1(Name, Function)\
scalar Name##_1(const UList<scalar>& param) \
{ \
return Function(param[0]); \
} \
addNamedToGlobalFunctionSelectionTable(dispatch,ParamList,Name##_1,&Name##_1)
#define globalFunction2(Name, Function)\
scalar Name##_2(const UList<scalar>& param) \
{ \
return Function(param[0], param[1]); \
} \
addNamedToGlobalFunctionSelectionTable(dispatch,ParamList,Name##_2,&Name##_2)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
globalConstant0(pi, constant::mathematical::pi);
globalFunction1(degToRad, degToRad);
globalFunction1(radToDeg, radToDeg);
globalFunction1(asin, Foam::asin);
globalFunction1(acos, Foam::acos);
globalFunction1(atan, Foam::atan);
globalFunction1(sin, Foam::sin);
globalFunction1(cos, Foam::cos);
globalFunction1(tan, Foam::tan);
globalFunction1(log, Foam::log);
globalFunction1(log10, Foam::log10);
globalFunction1(mag, Foam::mag);
globalFunction2(atan2, Foam::atan2);
globalFunction2(pow, Foam::pow);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
scalar dispatch(const word& name, const UList<scalar>& param)
{
// create lookup name with parameter count
const word lookupName = name + '_' + Foam::name(param.size());
@ -69,114 +120,10 @@ scalar scalarFunctions::dispatch
}
scalar scalarFunctions::pi_0(const UList<scalar>& param)
{
return constant::mathematical::pi;
}
scalar scalarFunctions::degToRad_1(const UList<scalar>& param)
{
return degToRad(param[0]);
}
scalar scalarFunctions::radToDeg_1(const UList<scalar>& param)
{
return radToDeg(param[0]);
}
scalar scalarFunctions::sin_1(const UList<scalar>& param)
{
return Foam::sin(param[0]);
}
scalar scalarFunctions::cos_1(const UList<scalar>& param)
{
return Foam::cos(param[0]);
}
scalar scalarFunctions::pow_2(const UList<scalar>& param)
{
return Foam::pow(param[0], param[1]);
}
scalar scalarFunctions::log_1(const UList<scalar>& param)
{
return Foam::log(param[0]);
}
scalar scalarFunctions::log10_1(const UList<scalar>& param)
{
return Foam::log10(param[0]);
}
addNamedToStaticMemberFunctionSelectionTable
(
scalarFunctions,scalarFunctions,dispatch,ParamList,
pi_0,
&scalarFunctions::pi_0
);
addNamedToStaticMemberFunctionSelectionTable
(
scalarFunctions,scalarFunctions,dispatch,ParamList,
degToRad_1,
&scalarFunctions::degToRad_1
);
addNamedToStaticMemberFunctionSelectionTable
(
scalarFunctions,scalarFunctions,dispatch,ParamList,
radToDeg_1,
&scalarFunctions::radToDeg_1
);
addNamedToStaticMemberFunctionSelectionTable
(
scalarFunctions,scalarFunctions,dispatch,ParamList,
sin_1,
&scalarFunctions::sin_1
);
addNamedToStaticMemberFunctionSelectionTable
(
scalarFunctions,scalarFunctions,dispatch,ParamList,
cos_1,
&scalarFunctions::cos_1
);
addNamedToStaticMemberFunctionSelectionTable
(
scalarFunctions,scalarFunctions,dispatch,ParamList,
pow_2,
&scalarFunctions::pow_2
);
addNamedToStaticMemberFunctionSelectionTable
(
scalarFunctions,scalarFunctions,dispatch,ParamList,
log_1,
&scalarFunctions::log_1
);
addNamedToStaticMemberFunctionSelectionTable
(
scalarFunctions,scalarFunctions,dispatch,ParamList,
log10_1,
&scalarFunctions::log10_1
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace calcEntryInternal
} // End namespace functionEntries
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //

38
applications/test/dictionary/calcEntry/calcEntryInternal.H
View File

@ -26,8 +26,7 @@ Namespace
Foam::functionEntries::calcEntryInternal
Description
This dictionary function entry may or may not do anything particularly
useful - depending upon what is currently being used to test.
Contains global functions and classes for the calcEntry.
SourceFiles
calcEntryInternal.C
@ -37,9 +36,10 @@ SourceFiles
#ifndef calcEntryInternal_H
#define calcEntryInternal_H
#include "functionEntry.H"
#include "memberFunctionSelectionTables.H"
#include "staticMemberFunctionSelectionTables.H"
#include "error.H"
#include "scalar.H"
#include "DynamicList.H"
#include "globalFunctionSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -50,20 +50,11 @@ namespace functionEntries
namespace calcEntryInternal
{
/*---------------------------------------------------------------------------*\
Class calcEntryFunctions Declaration
\*---------------------------------------------------------------------------*/
// Global Function Selectors
class scalarFunctions
{
public:
// Member Function Selectors
declareStaticMemberFunctionSelectionTable
declareGlobalFunctionSelectionTable
(
scalar,
scalarFunctions,
dispatch,
ParamList,
(
@ -72,20 +63,9 @@ public:
(param)
);
//- Calculate
static scalar dispatch(const word&, const UList<scalar>&);
static scalar pi_0(const UList<scalar>&);
static scalar degToRad_1(const UList<scalar>&);
static scalar radToDeg_1(const UList<scalar>&);
static scalar cos_1(const UList<scalar>&);
static scalar sin_1(const UList<scalar>&);
static scalar pow_2(const UList<scalar>&);
static scalar log_1(const UList<scalar>&);
static scalar log10_1(const UList<scalar>&);
};
//- Dispatch calculation to the named function
scalar dispatch(const word&, const UList<scalar>&);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

28
applications/test/dictionary/calcEntry/calcEntryParser.cpp
View File

@ -137,25 +137,29 @@ void Parser::Term(scalar& val) {
}
void Parser::Factor(scalar& val) {
bool negative = false;
if (la->kind == 7 || la->kind == 8) {
if (la->kind == 7) {
Get();
} else {
Get();
negative = true;
}
}
if (la->kind == 1) {
Func(val);
} else if (la->kind == 11) {
Get();
Expr(val);
Expect(12);
} else if (la->kind == 3) {
Get();
val = getDictLookup();
} else if (la->kind == 4) {
Get();
val = coco_string_toDouble(t->val);
} else if (la->kind == 8) {
Get();
Expect(11);
Expr(val);
Expect(12);
val = -val;
} else if (la->kind == 11) {
Get();
Expr(val);
Expect(12);
} else SynErr(16);
if (negative) { val = -val; }
}
void Parser::Func(scalar& val) {
@ -177,7 +181,7 @@ void Parser::Func(scalar& val) {
}
}
Expect(12);
val = scalarFunctions::dispatch(funcName, param);
val = dispatch(funcName, param);
}
@ -225,7 +229,7 @@ bool Parser::StartOf(int s) {
static const bool set[2][16] = {
{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
{x,T,x,T, T,x,x,x, T,x,x,T, x,x,x,x}
{x,T,x,T, T,x,x,T, T,x,x,T, x,x,x,x}
};

5
applications/test/dictionary/calcEntry/calcEntryParser.h
View File

@ -4,10 +4,7 @@
#define COCO_calcEntryPARSER_H__
#include "dictionary.H"
#include "scalar.H"
#include "error.H"
#include "wchar.H"
#include "DynamicList.H"
#include "calcEntryInternal.H"
@ -81,7 +78,7 @@ public:
private:
//- The parent dictionary
mutable dictionary* dict_;
dictionary* dict_;
//- The calculation result
scalar val;

145
applications/test/dictionary/calcEntry/globalFunctionSelectionTables.H Normal file
View File

@ -0,0 +1,145 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-2010 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
@file Foam::globalFunctionSelectionTables
Description
Macros to enable the easy declaration of global function selection tables.
\*---------------------------------------------------------------------------*/
#ifndef globalMemberFunctionSelectionTables_H
#define globalMemberFunctionSelectionTables_H
#include "memberFunctionSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// external use:
// ~~~~~~~~~~~~~
// declare a run-time selection:
#define declareGlobalFunctionSelectionTable\
(returnType,memberFunction,argNames,argList,parList) \
\
/* Construct from argList function pointer type */ \
typedef returnType (*memberFunction##argNames##MemberFunctionPtr)argList; \
\
/* Construct from argList function table type */ \
typedef HashTable \
<memberFunction##argNames##MemberFunctionPtr, word, string::hash> \
memberFunction##argNames##MemberFunctionTable; \
\
/* Construct from argList function pointer table pointer */ \
extern memberFunction##argNames##MemberFunctionTable* \
memberFunction##argNames##MemberFunctionTablePtr_; \
\
/* Table memberFunction called from the table add function */ \
void construct##memberFunction##argNames##MemberFunctionTables(); \
\
/* Table destructor called from the table add function destructor */ \
void destroy##memberFunction##argNames##MemberFunctionTables(); \
\
/* Class to add constructor from argList to table */ \
class add##memberFunction##argNames##GlobalMemberFunctionToTable \
{ \
public: \
\
add##memberFunction##argNames##GlobalMemberFunctionToTable \
( \
const word& lookup, \
memberFunction##argNames##MemberFunctionPtr function \
) \
{ \
construct##memberFunction##argNames##MemberFunctionTables(); \
memberFunction##argNames##MemberFunctionTablePtr_->insert \
( \
lookup, \
function \
); \
} \
\
~add##memberFunction##argNames##GlobalMemberFunctionToTable() \
{ \
destroy##memberFunction##argNames##MemberFunctionTables(); \
} \
}
// internal use:
// constructor/destructor aid
#define defineGlobalFunctionSelectionTableConstructDestruct\
(memberFunction,argNames) \
\
/* Table constructor called from the table add function */ \
void construct##memberFunction##argNames##MemberFunctionTables()\
{ \
static bool constructed = false; \
if (!constructed) \
{ \
constructed = true; \
memberFunction##argNames##MemberFunctionTablePtr_ \
= new memberFunction##argNames##MemberFunctionTable; \
} \
} \
\
/* Table destructor called from the table add function destructor */ \
void destroy##memberFunction##argNames##MemberFunctionTables()\
{ \
if (memberFunction##argNames##MemberFunctionTablePtr_) \
{ \
delete memberFunction##argNames##MemberFunctionTablePtr_; \
memberFunction##argNames##MemberFunctionTablePtr_ = NULL; \
} \
}
// internal use:
// create pointer to hash-table of functions
#define defineGlobalFunctionSelectionTablePtr\
(memberFunction,argNames) \
\
/* Define the memberFunction table */ \
memberFunction##argNames##MemberFunctionTable* \
memberFunction##argNames##MemberFunctionTablePtr_ = NULL
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// external use:
// ~~~~~~~~~~~~~
// define run-time selection table
#define defineGlobalFunctionSelectionTable\
(memberFunction,argNames) \
\
defineGlobalFunctionSelectionTablePtr \
(memberFunction,argNames); \
defineGlobalFunctionSelectionTableConstructDestruct \
(memberFunction,argNames)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

7
applications/test/dictionary/testDictCalc
View File

@ -39,8 +39,11 @@ is done inplace;
flowRate #calc{ $flowRatePerHour / 3600 };
sin45 #calc{ sin( 45*pi() / 180 ) };
cos45 #calc{ cos( degToRad(45) ) };
// inplace redefine
flowRate #calc{ $flowRate * 0.1 };
sin45 #calc{ sin( 45.0 * pi() / 180 ) };
cos45 #calc{ cos( degToRad(15- -15+ +15) ) };
pow #calc{ pow( $x, $y ) };
log10 #calc{ log( 1e6 ) };
// list #calc{ list() };