mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
Moved the "generic" BCs into a separate library and included it only in those utilities
which need this functionality. Solvers will now check the correctness of the BCs on read.
This commit is contained in:
henry
4
src/genericPatchFields/Make/files
Normal file
4
src/genericPatchFields/Make/files
Normal file
@ -0,0 +1,4 @@
|
||||
genericFvPatchField/genericFvPatchFields.C
|
||||
genericPointPatchField/genericPointPatchFields.C
|
||||
|
||||
LIB = $(FOAM_LIBBIN)/libgenericPatchFields
|
||||
5
src/genericPatchFields/Make/options
Normal file
5
src/genericPatchFields/Make/options
Normal file
@ -0,0 +1,5 @@
|
||||
EXE_INC = \
|
||||
-I$(LIB_SRC)/finiteVolume/lnInclude
|
||||
|
||||
EXE_LIBS = \
|
||||
-lfiniteVolume
|
||||
876
src/genericPatchFields/genericFvPatchField/genericFvPatchField.C
Normal file
876
src/genericPatchFields/genericFvPatchField/genericFvPatchField.C
Normal file
@ -0,0 +1,876 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 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
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "genericFvPatchField.H"
|
||||
#include "fvPatchFieldMapper.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
|
||||
|
||||
template<class Type>
|
||||
Foam::genericFvPatchField<Type>::genericFvPatchField
|
||||
(
|
||||
const fvPatch& p,
|
||||
const DimensionedField<Type, volMesh>& iF
|
||||
)
|
||||
:
|
||||
calculatedFvPatchField<Type>(p, iF)
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch& p, const DimensionedField<Type, volMesh>& iF)"
|
||||
) << "Not Implemented\n "
|
||||
<< "Trying to construct an genericFvPatchField on patch "
|
||||
<< this->patch().name()
|
||||
<< " of field " << this->dimensionedInternalField().name()
|
||||
<< abort(FatalError);
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
Foam::genericFvPatchField<Type>::genericFvPatchField
|
||||
(
|
||||
const fvPatch& p,
|
||||
const DimensionedField<Type, volMesh>& iF,
|
||||
const dictionary& dict
|
||||
)
|
||||
:
|
||||
calculatedFvPatchField<Type>(p, iF, dict, false),
|
||||
actualTypeName_(dict.lookup("type")),
|
||||
dict_(dict)
|
||||
{
|
||||
if (!dict.found("value"))
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, const dictionary&)",
|
||||
dict
|
||||
) << "\n Cannot find 'value' entry"
|
||||
<< " on patch " << this->patch().name()
|
||||
<< " of field " << this->dimensionedInternalField().name()
|
||||
<< " in file " << this->dimensionedInternalField().objectPath()
|
||||
<< nl
|
||||
<< " which is required to set the"
|
||||
" values of the generic patch field." << nl
|
||||
<< " (Actual type " << actualTypeName_ << ")" << nl
|
||||
<< "\n Please add the 'value' entry to the write function "
|
||||
"of the user-defined boundary-condition\n"
|
||||
" or link the boundary-condition into libfoamUtil.so"
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
dictionary::const_iterator iter = dict_.begin();
|
||||
iter != dict_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
if (iter().keyword() != "type" && iter().keyword() != "value")
|
||||
{
|
||||
if
|
||||
(
|
||||
iter().isStream()
|
||||
&& iter().stream().size()
|
||||
)
|
||||
{
|
||||
ITstream& is = iter().stream();
|
||||
|
||||
// Read first token
|
||||
token firstToken(is);
|
||||
|
||||
if
|
||||
(
|
||||
firstToken.isWord()
|
||||
&& firstToken.wordToken() == "nonuniform"
|
||||
)
|
||||
{
|
||||
token fieldToken(is);
|
||||
|
||||
if (!fieldToken.isCompound())
|
||||
{
|
||||
if
|
||||
(
|
||||
fieldToken.isLabel()
|
||||
&& fieldToken.labelToken() == 0
|
||||
)
|
||||
{
|
||||
scalarFields_.insert
|
||||
(
|
||||
iter().keyword(),
|
||||
new scalarField(0)
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n token following 'nonuniform' "
|
||||
"is not a compound"
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<scalar> >::typeName
|
||||
)
|
||||
{
|
||||
scalarField* fPtr = new scalarField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast<token::Compound<List<scalar> > >
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
scalarFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<vector> >::typeName
|
||||
)
|
||||
{
|
||||
vectorField* fPtr = new vectorField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast<token::Compound<List<vector> > >
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
vectorFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<sphericalTensor> >::typeName
|
||||
)
|
||||
{
|
||||
sphericalTensorField* fPtr = new sphericalTensorField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast
|
||||
<
|
||||
token::Compound<List<sphericalTensor> >
|
||||
>
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
sphericalTensorFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<symmTensor> >::typeName
|
||||
)
|
||||
{
|
||||
symmTensorField* fPtr = new symmTensorField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast
|
||||
<
|
||||
token::Compound<List<symmTensor> >
|
||||
>
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
symmTensorFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<tensor> >::typeName
|
||||
)
|
||||
{
|
||||
tensorField* fPtr = new tensorField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast<token::Compound<List<tensor> > >
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
tensorFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n compound " << fieldToken.compoundToken()
|
||||
<< " not supported"
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
}
|
||||
else if
|
||||
(
|
||||
firstToken.isWord()
|
||||
&& firstToken.wordToken() == "uniform"
|
||||
)
|
||||
{
|
||||
token fieldToken(is);
|
||||
|
||||
if (!fieldToken.isPunctuation())
|
||||
{
|
||||
scalarFields_.insert
|
||||
(
|
||||
iter().keyword(),
|
||||
new scalarField
|
||||
(
|
||||
this->size(),
|
||||
fieldToken.scalarToken()
|
||||
)
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Read as scalarList.
|
||||
is.putBack(fieldToken);
|
||||
|
||||
scalarList l(is);
|
||||
|
||||
if (l.size() == vector::nComponents)
|
||||
{
|
||||
vector vs(l[0], l[1], l[2]);
|
||||
|
||||
vectorFields_.insert
|
||||
(
|
||||
iter().keyword(),
|
||||
new vectorField(this->size(), vs)
|
||||
);
|
||||
}
|
||||
else if (l.size() == sphericalTensor::nComponents)
|
||||
{
|
||||
sphericalTensor vs(l[0]);
|
||||
|
||||
sphericalTensorFields_.insert
|
||||
(
|
||||
iter().keyword(),
|
||||
new sphericalTensorField(this->size(), vs)
|
||||
);
|
||||
}
|
||||
else if (l.size() == symmTensor::nComponents)
|
||||
{
|
||||
symmTensor vs(l[0], l[1], l[2], l[3], l[4], l[5]);
|
||||
|
||||
symmTensorFields_.insert
|
||||
(
|
||||
iter().keyword(),
|
||||
new symmTensorField(this->size(), vs)
|
||||
);
|
||||
}
|
||||
else if (l.size() == tensor::nComponents)
|
||||
{
|
||||
tensor vs
|
||||
(
|
||||
l[0], l[1], l[2],
|
||||
l[3], l[4], l[5],
|
||||
l[6], l[7], l[8]
|
||||
);
|
||||
|
||||
tensorFields_.insert
|
||||
(
|
||||
iter().keyword(),
|
||||
new tensorField(this->size(), vs)
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::genericFvPatchField"
|
||||
"(const fvPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n unrecognised native type " << l
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
Foam::genericFvPatchField<Type>::genericFvPatchField
|
||||
(
|
||||
const genericFvPatchField<Type>& ptf,
|
||||
const fvPatch& p,
|
||||
const DimensionedField<Type, volMesh>& iF,
|
||||
const fvPatchFieldMapper& mapper
|
||||
)
|
||||
:
|
||||
calculatedFvPatchField<Type>(ptf, p, iF, mapper),
|
||||
actualTypeName_(ptf.actualTypeName_),
|
||||
dict_(ptf.dict_)
|
||||
{
|
||||
for
|
||||
(
|
||||
HashPtrTable<scalarField>::const_iterator iter =
|
||||
ptf.scalarFields_.begin();
|
||||
iter != ptf.scalarFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
scalarFields_.insert(iter.key(), new scalarField(*iter(), mapper));
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<vectorField>::const_iterator iter =
|
||||
ptf.vectorFields_.begin();
|
||||
iter != ptf.vectorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
vectorFields_.insert(iter.key(), new vectorField(*iter(), mapper));
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<sphericalTensorField>::const_iterator iter =
|
||||
ptf.sphericalTensorFields_.begin();
|
||||
iter != ptf.sphericalTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
sphericalTensorFields_.insert
|
||||
(
|
||||
iter.key(),
|
||||
new sphericalTensorField(*iter(), mapper)
|
||||
);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<symmTensorField>::const_iterator iter =
|
||||
ptf.symmTensorFields_.begin();
|
||||
iter != ptf.symmTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
symmTensorFields_.insert
|
||||
(
|
||||
iter.key(),
|
||||
new symmTensorField(*iter(), mapper)
|
||||
);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<tensorField>::const_iterator iter =
|
||||
ptf.tensorFields_.begin();
|
||||
iter != ptf.tensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
tensorFields_.insert(iter.key(), new tensorField(*iter(), mapper));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
Foam::genericFvPatchField<Type>::genericFvPatchField
|
||||
(
|
||||
const genericFvPatchField<Type>& ptf
|
||||
)
|
||||
:
|
||||
calculatedFvPatchField<Type>(ptf),
|
||||
actualTypeName_(ptf.actualTypeName_),
|
||||
dict_(ptf.dict_),
|
||||
scalarFields_(ptf.scalarFields_),
|
||||
vectorFields_(ptf.vectorFields_),
|
||||
sphericalTensorFields_(ptf.sphericalTensorFields_),
|
||||
symmTensorFields_(ptf.symmTensorFields_),
|
||||
tensorFields_(ptf.tensorFields_)
|
||||
{}
|
||||
|
||||
|
||||
template<class Type>
|
||||
Foam::genericFvPatchField<Type>::genericFvPatchField
|
||||
(
|
||||
const genericFvPatchField<Type>& ptf,
|
||||
const DimensionedField<Type, volMesh>& iF
|
||||
)
|
||||
:
|
||||
calculatedFvPatchField<Type>(ptf, iF),
|
||||
actualTypeName_(ptf.actualTypeName_),
|
||||
dict_(ptf.dict_),
|
||||
scalarFields_(ptf.scalarFields_),
|
||||
vectorFields_(ptf.vectorFields_),
|
||||
sphericalTensorFields_(ptf.sphericalTensorFields_),
|
||||
symmTensorFields_(ptf.symmTensorFields_),
|
||||
tensorFields_(ptf.tensorFields_)
|
||||
{}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
template<class Type>
|
||||
void Foam::genericFvPatchField<Type>::autoMap
|
||||
(
|
||||
const fvPatchFieldMapper& m
|
||||
)
|
||||
{
|
||||
calculatedFvPatchField<Type>::autoMap(m);
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<scalarField>::iterator iter = scalarFields_.begin();
|
||||
iter != scalarFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<vectorField>::iterator iter = vectorFields_.begin();
|
||||
iter != vectorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<sphericalTensorField>::iterator iter =
|
||||
sphericalTensorFields_.begin();
|
||||
iter != sphericalTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<symmTensorField>::iterator iter =
|
||||
symmTensorFields_.begin();
|
||||
iter != symmTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<tensorField>::iterator iter = tensorFields_.begin();
|
||||
iter != tensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
void Foam::genericFvPatchField<Type>::rmap
|
||||
(
|
||||
const fvPatchField<Type>& ptf,
|
||||
const labelList& addr
|
||||
)
|
||||
{
|
||||
calculatedFvPatchField<Type>::rmap(ptf, addr);
|
||||
|
||||
const genericFvPatchField<Type>& dptf =
|
||||
refCast<const genericFvPatchField<Type> >(ptf);
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<scalarField>::iterator iter = scalarFields_.begin();
|
||||
iter != scalarFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<scalarField>::const_iterator dptfIter =
|
||||
dptf.scalarFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != dptf.scalarFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<vectorField>::iterator iter = vectorFields_.begin();
|
||||
iter != vectorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<vectorField>::const_iterator dptfIter =
|
||||
dptf.vectorFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != dptf.vectorFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<sphericalTensorField>::iterator iter =
|
||||
sphericalTensorFields_.begin();
|
||||
iter != sphericalTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<sphericalTensorField>::const_iterator dptfIter =
|
||||
dptf.sphericalTensorFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != dptf.sphericalTensorFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<symmTensorField>::iterator iter =
|
||||
symmTensorFields_.begin();
|
||||
iter != symmTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<symmTensorField>::const_iterator dptfIter =
|
||||
dptf.symmTensorFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != dptf.symmTensorFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<tensorField>::iterator iter = tensorFields_.begin();
|
||||
iter != tensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<tensorField>::const_iterator dptfIter =
|
||||
dptf.tensorFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != dptf.tensorFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
Foam::tmp<Foam::Field<Type> >
|
||||
Foam::genericFvPatchField<Type>::valueInternalCoeffs
|
||||
(
|
||||
const tmp<scalarField>&
|
||||
) const
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::"
|
||||
"valueInternalCoeffs(const tmp<scalarField>&) const"
|
||||
) << "\n "
|
||||
"valueInternalCoeffs cannot be called for a genericFvPatchField"
|
||||
" (actual type " << actualTypeName_ << ")"
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field " << this->dimensionedInternalField().name()
|
||||
<< " in file " << this->dimensionedInternalField().objectPath()
|
||||
<< "\n You are probably trying to solve for a field with a "
|
||||
"generic boundary condition."
|
||||
<< exit(FatalError);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
Foam::tmp<Foam::Field<Type> >
|
||||
Foam::genericFvPatchField<Type>::valueBoundaryCoeffs
|
||||
(
|
||||
const tmp<scalarField>&
|
||||
) const
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::"
|
||||
"valueBoundaryCoeffs(const tmp<scalarField>&) const"
|
||||
) << "\n "
|
||||
"valueBoundaryCoeffs cannot be called for a genericFvPatchField"
|
||||
" (actual type " << actualTypeName_ << ")"
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field " << this->dimensionedInternalField().name()
|
||||
<< " in file " << this->dimensionedInternalField().objectPath()
|
||||
<< "\n You are probably trying to solve for a field with a "
|
||||
"generic boundary condition."
|
||||
<< exit(FatalError);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
Foam::tmp<Foam::Field<Type> >
|
||||
Foam::genericFvPatchField<Type>::gradientInternalCoeffs() const
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::"
|
||||
"gradientInternalCoeffs() const"
|
||||
) << "\n "
|
||||
"gradientInternalCoeffs cannot be called for a genericFvPatchField"
|
||||
" (actual type " << actualTypeName_ << ")"
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field " << this->dimensionedInternalField().name()
|
||||
<< " in file " << this->dimensionedInternalField().objectPath()
|
||||
<< "\n You are probably trying to solve for a field with a "
|
||||
"generic boundary condition."
|
||||
<< exit(FatalError);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class Type>
|
||||
Foam::tmp<Foam::Field<Type> >
|
||||
Foam::genericFvPatchField<Type>::gradientBoundaryCoeffs() const
|
||||
{
|
||||
FatalErrorIn
|
||||
(
|
||||
"genericFvPatchField<Type>::"
|
||||
"gradientBoundaryCoeffs() const"
|
||||
) << "\n "
|
||||
"gradientBoundaryCoeffs cannot be called for a genericFvPatchField"
|
||||
" (actual type " << actualTypeName_ << ")"
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field " << this->dimensionedInternalField().name()
|
||||
<< " in file " << this->dimensionedInternalField().objectPath()
|
||||
<< "\n You are probably trying to solve for a field with a "
|
||||
"generic boundary condition."
|
||||
<< exit(FatalError);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
void Foam::genericFvPatchField<Type>::write(Ostream& os) const
|
||||
{
|
||||
os.writeKeyword("type") << actualTypeName_ << token::END_STATEMENT << nl;
|
||||
|
||||
for
|
||||
(
|
||||
dictionary::const_iterator iter = dict_.begin();
|
||||
iter != dict_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
if (iter().keyword() != "type" && iter().keyword() != "value")
|
||||
{
|
||||
if
|
||||
(
|
||||
iter().isStream()
|
||||
&& iter().stream().size()
|
||||
&& iter().stream()[0].isWord()
|
||||
&& iter().stream()[0].wordToken() == "nonuniform"
|
||||
)
|
||||
{
|
||||
if (scalarFields_.found(iter().keyword()))
|
||||
{
|
||||
scalarFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
else if (vectorFields_.found(iter().keyword()))
|
||||
{
|
||||
vectorFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
else if (sphericalTensorFields_.found(iter().keyword()))
|
||||
{
|
||||
sphericalTensorFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
else if (symmTensorFields_.found(iter().keyword()))
|
||||
{
|
||||
symmTensorFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
else if (tensorFields_.found(iter().keyword()))
|
||||
{
|
||||
tensorFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
iter().write(os);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this->writeEntry("value", os);
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
197
src/genericPatchFields/genericFvPatchField/genericFvPatchField.H
Normal file
197
src/genericPatchFields/genericFvPatchField/genericFvPatchField.H
Normal file
@ -0,0 +1,197 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 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
|
||||
|
||||
Class
|
||||
Foam::genericFvPatchField
|
||||
|
||||
Description
|
||||
Foam::genericFvPatchField
|
||||
|
||||
SourceFiles
|
||||
genericFvPatchField.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef genericFvPatchField_H
|
||||
#define genericFvPatchField_H
|
||||
|
||||
#include "calculatedFvPatchField.H"
|
||||
#include "HashPtrTable.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class genericFvPatch Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
template<class Type>
|
||||
class genericFvPatchField
|
||||
:
|
||||
public calculatedFvPatchField<Type>
|
||||
{
|
||||
// Private data
|
||||
|
||||
word actualTypeName_;
|
||||
dictionary dict_;
|
||||
|
||||
HashPtrTable<scalarField> scalarFields_;
|
||||
HashPtrTable<vectorField> vectorFields_;
|
||||
HashPtrTable<sphericalTensorField> sphericalTensorFields_;
|
||||
HashPtrTable<symmTensorField> symmTensorFields_;
|
||||
HashPtrTable<tensorField> tensorFields_;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
TypeName("generic");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from patch and internal field
|
||||
genericFvPatchField
|
||||
(
|
||||
const fvPatch&,
|
||||
const DimensionedField<Type, volMesh>&
|
||||
);
|
||||
|
||||
//- Construct from patch, internal field and dictionary
|
||||
genericFvPatchField
|
||||
(
|
||||
const fvPatch&,
|
||||
const DimensionedField<Type, volMesh>&,
|
||||
const dictionary&
|
||||
);
|
||||
|
||||
//- Construct by mapping given patchField<Type> onto a new patch
|
||||
genericFvPatchField
|
||||
(
|
||||
const genericFvPatchField<Type>&,
|
||||
const fvPatch&,
|
||||
const DimensionedField<Type, volMesh>&,
|
||||
const fvPatchFieldMapper&
|
||||
);
|
||||
|
||||
//- Construct as copy
|
||||
genericFvPatchField
|
||||
(
|
||||
const genericFvPatchField<Type>&
|
||||
);
|
||||
|
||||
//- Construct and return a clone
|
||||
virtual tmp<fvPatchField<Type> > clone() const
|
||||
{
|
||||
return tmp<fvPatchField<Type> >
|
||||
(
|
||||
new genericFvPatchField<Type>(*this)
|
||||
);
|
||||
}
|
||||
|
||||
//- Construct as copy setting internal field reference
|
||||
genericFvPatchField
|
||||
(
|
||||
const genericFvPatchField<Type>&,
|
||||
const DimensionedField<Type, volMesh>&
|
||||
);
|
||||
|
||||
//- Construct and return a clone setting internal field reference
|
||||
virtual tmp<fvPatchField<Type> > clone
|
||||
(
|
||||
const DimensionedField<Type, volMesh>& iF
|
||||
) const
|
||||
{
|
||||
return tmp<fvPatchField<Type> >
|
||||
(
|
||||
new genericFvPatchField<Type>(*this, iF)
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
// Member functions
|
||||
|
||||
// Mapping functions
|
||||
|
||||
//- Map (and resize as needed) from self given a mapping object
|
||||
virtual void autoMap
|
||||
(
|
||||
const fvPatchFieldMapper&
|
||||
);
|
||||
|
||||
//- Reverse map the given fvPatchField onto this fvPatchField
|
||||
virtual void rmap
|
||||
(
|
||||
const fvPatchField<Type>&,
|
||||
const labelList&
|
||||
);
|
||||
|
||||
|
||||
// Evaluation functions
|
||||
|
||||
//- Return the matrix diagonal coefficients corresponding to the
|
||||
// evaluation of the value of this patchField with given weights
|
||||
virtual tmp<Field<Type> > valueInternalCoeffs
|
||||
(
|
||||
const tmp<scalarField>&
|
||||
) const;
|
||||
|
||||
//- Return the matrix source coefficients corresponding to the
|
||||
// evaluation of the value of this patchField with given weights
|
||||
virtual tmp<Field<Type> > valueBoundaryCoeffs
|
||||
(
|
||||
const tmp<scalarField>&
|
||||
) const;
|
||||
|
||||
//- Return the matrix diagonal coefficients corresponding to the
|
||||
// evaluation of the gradient of this patchField
|
||||
tmp<Field<Type> > gradientInternalCoeffs() const;
|
||||
|
||||
//- Return the matrix source coefficients corresponding to the
|
||||
// evaluation of the gradient of this patchField
|
||||
tmp<Field<Type> > gradientBoundaryCoeffs() const;
|
||||
|
||||
|
||||
//- Write
|
||||
virtual void write(Ostream&) const;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#ifdef NoRepository
|
||||
# include "genericFvPatchField.C"
|
||||
#endif
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,44 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 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
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "genericFvPatchFields.H"
|
||||
#include "addToRunTimeSelectionTable.H"
|
||||
#include "volFields.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
|
||||
|
||||
makePatchFields(generic);
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,50 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 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
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef genericFvPatchFields_H
|
||||
#define genericFvPatchFields_H
|
||||
|
||||
#include "genericFvPatchField.H"
|
||||
#include "fieldTypes.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
makePatchTypeFieldTypedefs(generic)
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,661 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 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
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "genericPointPatchField.H"
|
||||
#include "pointPatchFieldMapper.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
template<class Type>
|
||||
genericPointPatchField<Type>::genericPointPatchField
|
||||
(
|
||||
const pointPatch& p,
|
||||
const DimensionedField<Type, pointMesh>& iF
|
||||
)
|
||||
:
|
||||
calculatedPointPatchField<Type>(p, iF)
|
||||
{
|
||||
notImplemented
|
||||
(
|
||||
"genericPointPatchField<Type>::genericPointPatchField"
|
||||
"(const pointPatch& p, const DimensionedField<Type, volMesh>& iF)"
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
genericPointPatchField<Type>::genericPointPatchField
|
||||
(
|
||||
const pointPatch& p,
|
||||
const DimensionedField<Type, pointMesh>& iF,
|
||||
const dictionary& dict
|
||||
)
|
||||
:
|
||||
calculatedPointPatchField<Type>(p, iF, dict),
|
||||
actualTypeName_(dict.lookup("type")),
|
||||
dict_(dict)
|
||||
{
|
||||
for
|
||||
(
|
||||
dictionary::const_iterator iter = dict_.begin();
|
||||
iter != dict_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
if (iter().keyword() != "type")
|
||||
{
|
||||
if
|
||||
(
|
||||
iter().isStream()
|
||||
&& iter().stream().size()
|
||||
)
|
||||
{
|
||||
ITstream& is = iter().stream();
|
||||
|
||||
// Read first token
|
||||
token firstToken(is);
|
||||
|
||||
if
|
||||
(
|
||||
firstToken.isWord()
|
||||
&& firstToken.wordToken() == "nonuniform"
|
||||
)
|
||||
{
|
||||
token fieldToken(is);
|
||||
|
||||
if (!fieldToken.isCompound())
|
||||
{
|
||||
if
|
||||
(
|
||||
fieldToken.isLabel()
|
||||
&& fieldToken.labelToken() == 0
|
||||
)
|
||||
{
|
||||
scalarFields_.insert
|
||||
(
|
||||
iter().keyword(),
|
||||
new scalarField(0)
|
||||
);
|
||||
}
|
||||
else
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericPointPatchField<Type>::"
|
||||
"genericPointPatchField"
|
||||
"(const pointPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n token following 'nonuniform' "
|
||||
"is not a compound"
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<scalar> >::typeName
|
||||
)
|
||||
{
|
||||
scalarField* fPtr = new scalarField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast<token::Compound<List<scalar> > >
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericPointPatchField<Type>::"
|
||||
"genericPointPatchField"
|
||||
"(const pointPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
scalarFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<vector> >::typeName
|
||||
)
|
||||
{
|
||||
vectorField* fPtr = new vectorField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast<token::Compound<List<vector> > >
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericPointPatchField<Type>::"
|
||||
"genericPointPatchField"
|
||||
"(const pointPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
vectorFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<sphericalTensor> >::typeName
|
||||
)
|
||||
{
|
||||
sphericalTensorField* fPtr = new sphericalTensorField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast
|
||||
<
|
||||
token::Compound<List<sphericalTensor> >
|
||||
>
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericPointPatchField<Type>::"
|
||||
"genericPointPatchField"
|
||||
"(const pointPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
sphericalTensorFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<symmTensor> >::typeName
|
||||
)
|
||||
{
|
||||
symmTensorField* fPtr = new symmTensorField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast
|
||||
<
|
||||
token::Compound<List<symmTensor> >
|
||||
>
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericPointPatchField<Type>::"
|
||||
"genericPointPatchField"
|
||||
"(const pointPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
symmTensorFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else if
|
||||
(
|
||||
fieldToken.compoundToken().type()
|
||||
== token::Compound<List<tensor> >::typeName
|
||||
)
|
||||
{
|
||||
tensorField* fPtr = new tensorField;
|
||||
fPtr->transfer
|
||||
(
|
||||
dynamicCast<token::Compound<List<tensor> > >
|
||||
(
|
||||
fieldToken.transferCompoundToken()
|
||||
)
|
||||
);
|
||||
|
||||
if (fPtr->size() != this->size())
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericPointPatchField<Type>::"
|
||||
"genericPointPatchField"
|
||||
"(const pointPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n size of field " << iter().keyword()
|
||||
<< " (" << fPtr->size() << ')'
|
||||
<< " is not the same size as the patch ("
|
||||
<< this->size() << ')'
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
|
||||
tensorFields_.insert(iter().keyword(), fPtr);
|
||||
}
|
||||
else
|
||||
{
|
||||
FatalIOErrorIn
|
||||
(
|
||||
"genericPointPatchField<Type>::"
|
||||
"genericPointPatchField"
|
||||
"(const pointPatch&, const Field<Type>&, "
|
||||
"const dictionary&)",
|
||||
dict
|
||||
) << "\n compound " << fieldToken.compoundToken()
|
||||
<< " not supported"
|
||||
<< "\n on patch " << this->patch().name()
|
||||
<< " of field "
|
||||
<< this->dimensionedInternalField().name()
|
||||
<< " in file "
|
||||
<< this->dimensionedInternalField().objectPath()
|
||||
<< exit(FatalIOError);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
genericPointPatchField<Type>::genericPointPatchField
|
||||
(
|
||||
const genericPointPatchField<Type>& ptf,
|
||||
const pointPatch& p,
|
||||
const DimensionedField<Type, pointMesh>& iF,
|
||||
const pointPatchFieldMapper& mapper
|
||||
)
|
||||
:
|
||||
calculatedPointPatchField<Type>(ptf, p, iF, mapper),
|
||||
actualTypeName_(ptf.actualTypeName_),
|
||||
dict_(ptf.dict_)
|
||||
{
|
||||
for
|
||||
(
|
||||
HashPtrTable<scalarField>::const_iterator iter =
|
||||
ptf.scalarFields_.begin();
|
||||
iter != ptf.scalarFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
scalarFields_.insert(iter.key(), new scalarField(*iter(), mapper));
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<vectorField>::const_iterator iter =
|
||||
ptf.vectorFields_.begin();
|
||||
iter != ptf.vectorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
vectorFields_.insert(iter.key(), new vectorField(*iter(), mapper));
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<sphericalTensorField>::const_iterator iter =
|
||||
ptf.sphericalTensorFields_.begin();
|
||||
iter != ptf.sphericalTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
sphericalTensorFields_.insert
|
||||
(
|
||||
iter.key(),
|
||||
new sphericalTensorField(*iter(), mapper)
|
||||
);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<symmTensorField>::const_iterator iter =
|
||||
ptf.symmTensorFields_.begin();
|
||||
iter != ptf.symmTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
symmTensorFields_.insert
|
||||
(
|
||||
iter.key(),
|
||||
new symmTensorField(*iter(), mapper)
|
||||
);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<tensorField>::const_iterator iter =
|
||||
ptf.tensorFields_.begin();
|
||||
iter != ptf.tensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
tensorFields_.insert(iter.key(), new tensorField(*iter(), mapper));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
genericPointPatchField<Type>::genericPointPatchField
|
||||
(
|
||||
const genericPointPatchField<Type>& ptf,
|
||||
const DimensionedField<Type, pointMesh>& iF
|
||||
)
|
||||
:
|
||||
calculatedPointPatchField<Type>(ptf, iF),
|
||||
actualTypeName_(ptf.actualTypeName_),
|
||||
dict_(ptf.dict_),
|
||||
scalarFields_(ptf.scalarFields_),
|
||||
vectorFields_(ptf.vectorFields_),
|
||||
sphericalTensorFields_(ptf.sphericalTensorFields_),
|
||||
symmTensorFields_(ptf.symmTensorFields_),
|
||||
tensorFields_(ptf.tensorFields_)
|
||||
{}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
|
||||
|
||||
template<class Type>
|
||||
void genericPointPatchField<Type>::autoMap
|
||||
(
|
||||
const pointPatchFieldMapper& m
|
||||
)
|
||||
{
|
||||
for
|
||||
(
|
||||
HashPtrTable<scalarField>::iterator iter = scalarFields_.begin();
|
||||
iter != scalarFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<vectorField>::iterator iter = vectorFields_.begin();
|
||||
iter != vectorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<sphericalTensorField>::iterator iter =
|
||||
sphericalTensorFields_.begin();
|
||||
iter != sphericalTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<symmTensorField>::iterator iter =
|
||||
symmTensorFields_.begin();
|
||||
iter != symmTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<tensorField>::iterator iter = tensorFields_.begin();
|
||||
iter != tensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
iter()->autoMap(m);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
void genericPointPatchField<Type>::rmap
|
||||
(
|
||||
const pointPatchField<Type>& ptf,
|
||||
const labelList& addr
|
||||
)
|
||||
{
|
||||
const genericPointPatchField<Type>& dptf =
|
||||
refCast<const genericPointPatchField<Type> >(ptf);
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<scalarField>::iterator iter = scalarFields_.begin();
|
||||
iter != scalarFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<scalarField>::const_iterator dptfIter =
|
||||
dptf.scalarFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != scalarFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<vectorField>::iterator iter = vectorFields_.begin();
|
||||
iter != vectorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<vectorField>::const_iterator dptfIter =
|
||||
dptf.vectorFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != vectorFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<sphericalTensorField>::iterator iter =
|
||||
sphericalTensorFields_.begin();
|
||||
iter != sphericalTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<sphericalTensorField>::const_iterator dptfIter =
|
||||
dptf.sphericalTensorFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != sphericalTensorFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<symmTensorField>::iterator iter =
|
||||
symmTensorFields_.begin();
|
||||
iter != symmTensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<symmTensorField>::const_iterator dptfIter =
|
||||
dptf.symmTensorFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != symmTensorFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
|
||||
for
|
||||
(
|
||||
HashPtrTable<tensorField>::iterator iter = tensorFields_.begin();
|
||||
iter != tensorFields_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
HashPtrTable<tensorField>::const_iterator dptfIter =
|
||||
dptf.tensorFields_.find(iter.key());
|
||||
|
||||
if (dptfIter != tensorFields_.end())
|
||||
{
|
||||
iter()->rmap(*dptfIter(), addr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
template<class Type>
|
||||
void genericPointPatchField<Type>::write(Ostream& os) const
|
||||
{
|
||||
os.writeKeyword("type") << actualTypeName_ << token::END_STATEMENT << nl;
|
||||
|
||||
for
|
||||
(
|
||||
dictionary::const_iterator iter = dict_.begin();
|
||||
iter != dict_.end();
|
||||
++iter
|
||||
)
|
||||
{
|
||||
if (iter().keyword() != "type")
|
||||
{
|
||||
if
|
||||
(
|
||||
iter().isStream()
|
||||
&& iter().stream().size()
|
||||
&& iter().stream()[0].isWord()
|
||||
&& iter().stream()[0].wordToken() == "nonuniform"
|
||||
)
|
||||
{
|
||||
if (scalarFields_.found(iter().keyword()))
|
||||
{
|
||||
scalarFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
else if (vectorFields_.found(iter().keyword()))
|
||||
{
|
||||
vectorFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
else if (sphericalTensorFields_.found(iter().keyword()))
|
||||
{
|
||||
sphericalTensorFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
else if (symmTensorFields_.found(iter().keyword()))
|
||||
{
|
||||
symmTensorFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
else if (tensorFields_.found(iter().keyword()))
|
||||
{
|
||||
tensorFields_.find(iter().keyword())()
|
||||
->writeEntry(iter().keyword(), os);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
iter().write(os);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,173 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 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
|
||||
|
||||
Class
|
||||
Foam::genericPointPatchField
|
||||
|
||||
Description
|
||||
Foam::genericPointPatchField
|
||||
|
||||
SourceFiles
|
||||
genericPointPatchField.C
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef genericPointPatchField_H
|
||||
#define genericPointPatchField_H
|
||||
|
||||
#include "calculatedPointPatchField.H"
|
||||
#include "HashPtrTable.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
/*---------------------------------------------------------------------------*\
|
||||
Class genericPointPatchField Declaration
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
template<class Type>
|
||||
class genericPointPatchField
|
||||
:
|
||||
public calculatedPointPatchField<Type>
|
||||
{
|
||||
// Private data
|
||||
|
||||
word actualTypeName_;
|
||||
dictionary dict_;
|
||||
|
||||
HashPtrTable<scalarField> scalarFields_;
|
||||
HashPtrTable<vectorField> vectorFields_;
|
||||
HashPtrTable<sphericalTensorField> sphericalTensorFields_;
|
||||
HashPtrTable<symmTensorField> symmTensorFields_;
|
||||
HashPtrTable<tensorField> tensorFields_;
|
||||
|
||||
|
||||
public:
|
||||
|
||||
//- Runtime type information
|
||||
TypeName("generic");
|
||||
|
||||
|
||||
// Constructors
|
||||
|
||||
//- Construct from patch and internal field
|
||||
genericPointPatchField
|
||||
(
|
||||
const pointPatch&,
|
||||
const DimensionedField<Type, pointMesh>&
|
||||
);
|
||||
|
||||
//- Construct from patch, internal field and dictionary
|
||||
genericPointPatchField
|
||||
(
|
||||
const pointPatch&,
|
||||
const DimensionedField<Type, pointMesh>&,
|
||||
const dictionary&
|
||||
);
|
||||
|
||||
//- Construct by mapping given patchField<Type> onto a new patch
|
||||
genericPointPatchField
|
||||
(
|
||||
const genericPointPatchField<Type>&,
|
||||
const pointPatch&,
|
||||
const DimensionedField<Type, pointMesh>&,
|
||||
const pointPatchFieldMapper&
|
||||
);
|
||||
|
||||
//- Construct and return a clone
|
||||
virtual autoPtr<pointPatchField<Type> > clone() const
|
||||
{
|
||||
return autoPtr<pointPatchField<Type> >
|
||||
(
|
||||
new genericPointPatchField<Type>
|
||||
(
|
||||
*this
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
//- Construct as copy setting internal field reference
|
||||
genericPointPatchField
|
||||
(
|
||||
const genericPointPatchField<Type>&,
|
||||
const DimensionedField<Type, pointMesh>&
|
||||
);
|
||||
|
||||
//- Construct and return a clone setting internal field reference
|
||||
virtual autoPtr<pointPatchField<Type> > clone
|
||||
(
|
||||
const DimensionedField<Type, pointMesh>& iF
|
||||
) const
|
||||
{
|
||||
return autoPtr<pointPatchField<Type> >
|
||||
(
|
||||
new genericPointPatchField<Type>
|
||||
(
|
||||
*this,
|
||||
iF
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
// Member functions
|
||||
|
||||
// Mapping functions
|
||||
|
||||
//- Map (and resize as needed) from self given a mapping object
|
||||
virtual void autoMap
|
||||
(
|
||||
const pointPatchFieldMapper&
|
||||
);
|
||||
|
||||
//- Reverse map the given pointPatchField onto this pointPatchField
|
||||
virtual void rmap
|
||||
(
|
||||
const pointPatchField<Type>&,
|
||||
const labelList&
|
||||
);
|
||||
|
||||
|
||||
//- Write
|
||||
virtual void write(Ostream&) const;
|
||||
};
|
||||
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#ifdef NoRepository
|
||||
# include "genericPointPatchField.C"
|
||||
#endif
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,44 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 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
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#include "genericPointPatchFields.H"
|
||||
#include "pointPatchFields.H"
|
||||
#include "addToRunTimeSelectionTable.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
|
||||
|
||||
makePointPatchFields(generic);
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -0,0 +1,50 @@
|
||||
/*---------------------------------------------------------------------------*\
|
||||
========= |
|
||||
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
|
||||
\\ / O peration |
|
||||
\\ / A nd | Copyright (C) 1991-2009 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
|
||||
|
||||
\*---------------------------------------------------------------------------*/
|
||||
|
||||
#ifndef genericPointPatchFields_H
|
||||
#define genericPointPatchFields_H
|
||||
|
||||
#include "genericPointPatchField.H"
|
||||
#include "fieldTypes.H"
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
namespace Foam
|
||||
{
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
makePointPatchFieldTypedefs(generic);
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
} // End namespace Foam
|
||||
|
||||
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
|
||||
|
||||
#endif
|
||||
|
||||
// ************************************************************************* //
|
||||
Reference in New Issue
Block a user