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
Files
99a10ecea60b55e1f219edabb8dd8ae84cabaf6b
openfoam/src/OpenFOAM/fields/Fields/Field/Field.C
Henry Weller 99a10ecea6 Boundary conditions: Added extrapolatedCalculatedFvPatchField 
To be used instead of zeroGradientFvPatchField for temporary fields for
which zero-gradient extrapolation is use to evaluate the boundary field
but avoiding fields derived from temporary field using field algebra
inheriting the zeroGradient boundary condition by the reuse of the
temporary field storage.

zeroGradientFvPatchField should not be used as the default patch field
for any temporary fields and should be avoided for non-temporary fields
except where it is clearly appropriate;
extrapolatedCalculatedFvPatchField and calculatedFvPatchField are
generally more suitable defaults depending on the manner in which the
boundary values are specified or evaluated.

The entire OpenFOAM-dev code-base has been updated following the above
recommendations.

Henry G. Weller
CFD Direct
2016-02-20 22:44:37 +00:00

768 lines
16 KiB
C
Raw Blame History

/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ 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 3 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, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "FieldMapper.H"
#include "FieldM.H"
#include "dictionary.H"
#include "contiguous.H"
// * * * * * * * * * * * * * * * Static Members * * * * * * * * * * * * * * //
template<class Type>
const char* const Foam::Field<Type>::typeName("Field");
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::Field<Type>::Field()
:
List<Type>()
{}
template<class Type>
Foam::Field<Type>::Field(const label size)
:
List<Type>(size)
{}
template<class Type>
Foam::Field<Type>::Field(const label size, const Type& t)
:
List<Type>(size, t)
{}
template<class Type>
Foam::Field<Type>::Field
(
const UList<Type>& mapF,
const labelUList& mapAddressing
)
:
List<Type>(mapAddressing.size())
{
map(mapF, mapAddressing);
}
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
)
:
List<Type>(mapAddressing.size())
{
map(tmapF, mapAddressing);
}
template<class Type>
Foam::Field<Type>::Field
(
const UList<Type>& mapF,
const labelListList& mapAddressing,
const scalarListList& mapWeights
)
:
List<Type>(mapAddressing.size())
{
map(mapF, mapAddressing, mapWeights);
}
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type>>& tmapF,
const labelListList& mapAddressing,
const scalarListList& mapWeights
)
:
List<Type>(mapAddressing.size())
{
map(tmapF, mapAddressing, mapWeights);
}
template<class Type>
Foam::Field<Type>::Field
(
const UList<Type>& mapF,
const FieldMapper& mapper
)
:
List<Type>(mapper.size())
{
map(mapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field
(
const UList<Type>& mapF,
const FieldMapper& mapper,
const Type& defaultValue
)
:
List<Type>(mapper.size(), defaultValue)
{
map(mapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field
(
const UList<Type>& mapF,
const FieldMapper& mapper,
const UList<Type>& defaultValues
)
:
List<Type>(defaultValues)
{
map(mapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type>>& tmapF,
const FieldMapper& mapper
)
:
List<Type>(mapper.size())
{
map(tmapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type>>& tmapF,
const FieldMapper& mapper,
const Type& defaultValue
)
:
List<Type>(mapper.size(), defaultValue)
{
map(tmapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type>>& tmapF,
const FieldMapper& mapper,
const UList<Type>& defaultValues
)
:
List<Type>(defaultValues)
{
map(tmapF, mapper);
}
template<class Type>
Foam::Field<Type>::Field(const Field<Type>& f)
:
refCount(),
List<Type>(f)
{}
template<class Type>
Foam::Field<Type>::Field(Field<Type>& f, bool reuse)
:
List<Type>(f, reuse)
{}
template<class Type>
Foam::Field<Type>::Field(const Xfer<List<Type>>& f)
:
List<Type>(f)
{}
template<class Type>
Foam::Field<Type>::Field(const Xfer<Field<Type>>& f)
:
List<Type>(f)
{}
template<class Type>
Foam::Field<Type>::Field(const UList<Type>& list)
:
List<Type>(list)
{}
// Construct as copy of tmp<Field>
#ifndef NoConstructFromTmp
template<class Type>
Foam::Field<Type>::Field(const tmp<Field<Type>>& tf)
:
List<Type>(const_cast<Field<Type>&>(tf()), tf.isTmp())
{
tf.clear();
}
#endif
template<class Type>
Foam::Field<Type>::Field(Istream& is)
:
List<Type>(is)
{}
template<class Type>
Foam::Field<Type>::Field
(
const word& keyword,
const dictionary& dict,
const label s
)
{
if (s)
{
ITstream& is = dict.lookup(keyword);
// Read first token
token firstToken(is);
if (firstToken.isWord())
{
if (firstToken.wordToken() == "uniform")
{
this->setSize(s);
operator=(pTraits<Type>(is));
}
else if (firstToken.wordToken() == "nonuniform")
{
is >> static_cast<List<Type>&>(*this);
if (this->size() != s)
{
FatalIOErrorInFunction
(
dict
) << "size " << this->size()
<< " is not equal to the given value of " << s
<< exit(FatalIOError);
}
}
else
{
FatalIOErrorInFunction
(
dict
) << "expected keyword 'uniform' or 'nonuniform', found "
<< firstToken.wordToken()
<< exit(FatalIOError);
}
}
else
{
if (is.version() == 2.0)
{
IOWarningInFunction
(
dict
) << "expected keyword 'uniform' or 'nonuniform', "
"assuming deprecated Field format from "
"Foam version 2.0." << endl;
this->setSize(s);
is.putBack(firstToken);
operator=(pTraits<Type>(is));
}
else
{
FatalIOErrorInFunction
(
dict
) << "expected keyword 'uniform' or 'nonuniform', found "
<< firstToken.info()
<< exit(FatalIOError);
}
}
}
}
template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::Field<Type>::clone() const
{
return tmp<Field<Type>>(new Field<Type>(*this));
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::Field<Type>::map
(
const UList<Type>& mapF,
const labelUList& mapAddressing
)
{
Field<Type>& f = *this;
if (f.size() != mapAddressing.size())
{
f.setSize(mapAddressing.size());
}
if (mapF.size() > 0)
{
forAll(f, i)
{
label mapI = mapAddressing[i];
if (mapI >= 0)
{
f[i] = mapF[mapI];
}
}
}
}
template<class Type>
void Foam::Field<Type>::map
(
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
)
{
map(tmapF(), mapAddressing);
tmapF.clear();
}
template<class Type>
void Foam::Field<Type>::map
(
const UList<Type>& mapF,
const labelListList& mapAddressing,
const scalarListList& mapWeights
)
{
Field<Type>& f = *this;
if (f.size() != mapAddressing.size())
{
f.setSize(mapAddressing.size());
}
if (mapWeights.size() != mapAddressing.size())
{
FatalErrorInFunction
<< mapWeights.size() << " map size: " << mapAddressing.size()
<< abort(FatalError);
}
forAll(f, i)
{
const labelList& localAddrs = mapAddressing[i];
const scalarList& localWeights = mapWeights[i];
f[i] = pTraits<Type>::zero;
forAll(localAddrs, j)
{
f[i] += localWeights[j]*mapF[localAddrs[j]];
}
}
}
template<class Type>
void Foam::Field<Type>::map
(
const tmp<Field<Type>>& tmapF,
const labelListList& mapAddressing,
const scalarListList& mapWeights
)
{
map(tmapF(), mapAddressing, mapWeights);
tmapF.clear();
}
template<class Type>
void Foam::Field<Type>::map
(
const UList<Type>& mapF,
const FieldMapper& mapper
)
{
if
(
mapper.direct()
&& notNull(mapper.directAddressing())
&& mapper.directAddressing().size()
)
{
map(mapF, mapper.directAddressing());
}
else if (!mapper.direct() && mapper.addressing().size())
{
map(mapF, mapper.addressing(), mapper.weights());
}
}
template<class Type>
void Foam::Field<Type>::map
(
const tmp<Field<Type>>& tmapF,
const FieldMapper& mapper
)
{
map(tmapF(), mapper);
tmapF.clear();
}
template<class Type>
void Foam::Field<Type>::autoMap
(
const FieldMapper& mapper
)
{
if
(
(
mapper.direct()
&& notNull(mapper.directAddressing())
&& mapper.directAddressing().size()
)
|| (!mapper.direct() && mapper.addressing().size())
)
{
Field<Type> fCpy(*this);
map(fCpy, mapper);
}
else
{
this->setSize(mapper.size());
}
}
template<class Type>
void Foam::Field<Type>::rmap
(
const UList<Type>& mapF,
const labelUList& mapAddressing
)
{
Field<Type>& f = *this;
forAll(mapF, i)
{
label mapI = mapAddressing[i];
if (mapI >= 0)
{
f[mapI] = mapF[i];
}
}
}
template<class Type>
void Foam::Field<Type>::rmap
(
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
)
{
rmap(tmapF(), mapAddressing);
tmapF.clear();
}
template<class Type>
void Foam::Field<Type>::rmap
(
const UList<Type>& mapF,
const labelUList& mapAddressing,
const UList<scalar>& mapWeights
)
{
Field<Type>& f = *this;
f = pTraits<Type>::zero;
forAll(mapF, i)
{
f[mapAddressing[i]] += mapF[i]*mapWeights[i];
}
}
template<class Type>
void Foam::Field<Type>::rmap
(
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing,
const UList<scalar>& mapWeights
)
{
rmap(tmapF(), mapAddressing, mapWeights);
tmapF.clear();
}
template<class Type>
void Foam::Field<Type>::negate()
{
TFOR_ALL_F_OP_OP_F(Type, *this, =, -, Type, *this)
}
template<class Type>
Foam::tmp<Foam::Field<typename Foam::Field<Type>::cmptType>>
Foam::Field<Type>::component
(
const direction d
) const
{
tmp<Field<cmptType>> Component(new Field<cmptType>(this->size()));
::Foam::component(Component(), *this, d);
return Component;
}
template<class Type>
void Foam::Field<Type>::replace
(
const direction d,
const UList<cmptType>& sf
)
{
TFOR_ALL_F_OP_FUNC_S_F(Type, *this, ., replace, const direction, d,
cmptType, sf)
}
template<class Type>
void Foam::Field<Type>::replace
(
const direction d,
const tmp<Field<cmptType>>& tsf
)
{
replace(d, tsf());
tsf.clear();
}
template<class Type>
void Foam::Field<Type>::replace
(
const direction d,
const cmptType& c
)
{
TFOR_ALL_F_OP_FUNC_S_S(Type, *this, ., replace, const direction, d,
cmptType, c)
}
template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::Field<Type>::T() const
{
tmp<Field<Type>> transpose(new Field<Type>(this->size()));
::Foam::T(transpose(), *this);
return transpose;
}
template<class Type>
void Foam::Field<Type>::writeEntry(const word& keyword, Ostream& os) const
{
os.writeKeyword(keyword);
bool uniform = false;
if (this->size() && contiguous<Type>())
{
uniform = true;
forAll(*this, i)
{
if (this->operator[](i) != this->operator[](0))
{
uniform = false;
break;
}
}
}
if (uniform)
{
os << "uniform " << this->operator[](0) << token::END_STATEMENT;
}
else
{
os << "nonuniform ";
List<Type>::writeEntry(os);
os << token::END_STATEMENT;
}
os << endl;
}
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
template<class Type>
void Foam::Field<Type>::operator=(const Field<Type>& rhs)
{
if (this == &rhs)
{
FatalErrorInFunction
<< "attempted assignment to self"
<< abort(FatalError);
}
List<Type>::operator=(rhs);
}
template<class Type>
void Foam::Field<Type>::operator=(const SubField<Type>& rhs)
{
List<Type>::operator=(rhs);
}
template<class Type>
void Foam::Field<Type>::operator=(const UList<Type>& rhs)
{
List<Type>::operator=(rhs);
}
template<class Type>
void Foam::Field<Type>::operator=(const tmp<Field>& rhs)
{
if (this == &(rhs()))
{
FatalErrorInFunction
<< "attempted assignment to self"
<< abort(FatalError);
}
// This is dodgy stuff, don't try it at home.
Field* fieldPtr = rhs.ptr();
List<Type>::transfer(*fieldPtr);
delete fieldPtr;
}
template<class Type>
void Foam::Field<Type>::operator=(const Type& t)
{
List<Type>::operator=(t);
}
template<class Type>
template<class Form, class Cmpt, int nCmpt>
void Foam::Field<Type>::operator=(const VectorSpace<Form,Cmpt,nCmpt>& vs)
{
TFOR_ALL_F_OP_S(Type, *this, =, VSType, vs)
}
#define COMPUTED_ASSIGNMENT(TYPE, op) \
\
template<class Type> \
void Foam::Field<Type>::operator op(const UList<TYPE>& f) \
{ \
TFOR_ALL_F_OP_F(Type, *this, op, TYPE, f) \
} \
\
template<class Type> \
void Foam::Field<Type>::operator op(const tmp<Field<TYPE>>& tf) \
{ \
operator op(tf()); \
tf.clear(); \
} \
\
template<class Type> \
void Foam::Field<Type>::operator op(const TYPE& t) \
{ \
TFOR_ALL_F_OP_S(Type, *this, op, TYPE, t) \
}
COMPUTED_ASSIGNMENT(Type, +=)
COMPUTED_ASSIGNMENT(Type, -=)
COMPUTED_ASSIGNMENT(scalar, *=)
COMPUTED_ASSIGNMENT(scalar, /=)
#undef COMPUTED_ASSIGNMENT
// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * //
template<class Type>
Foam::Ostream& Foam::operator<<(Ostream& os, const Field<Type>& f)
{
os << static_cast<const List<Type>&>(f);
return os;
}
template<class Type>
Foam::Ostream& Foam::operator<<(Ostream& os, const tmp<Field<Type>>& tf)
{
os << tf();
tf.clear();
return os;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "FieldFunctions.C"
// ************************************************************************* //
Reference in New Issue View Git Blame Copy Permalink