exaFOAM/foam-extend4.1-coherent-io
Archived
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Added cyclic, symmetry and slip faPatchFields

Browse source
This commit is contained in:
Zeljko Tukovic 2010-10-26 23:05:25 +02:00
parent 3bf1666dfe
commit 7dc6dd9a21
31 changed files with 2703 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/finiteArea/Make/files
View file

@ -17,6 +17,8 @@ faPatchFields = fields/faPatchFields
$(faPatchFields)/faPatchField/faPatchFields.C
basicFaPatchFields = $(faPatchFields)/basic
$(basicFaPatchFields)/basicSymmetry/basicSymmetryFaPatchFields.C
$(basicFaPatchFields)/basicSymmetry/basicSymmetryFaPatchScalarField.C
$(basicFaPatchFields)/calculated/calculatedFaPatchFields.C
$(basicFaPatchFields)/coupled/coupledFaPatchFields.C
$(basicFaPatchFields)/zeroGradient/zeroGradientFaPatchFields.C
@ -32,10 +34,13 @@ $(constraintFaPatchFields)/processor/processorFaPatchFields.C
$(constraintFaPatchFields)/processor/processorFaPatchScalarField.C
$(constraintFaPatchFields)/wedge/wedgeFaPatchFields.C
$(constraintFaPatchFields)/wedge/wedgeFaPatchScalarField.C
$(constraintFaPatchFields)/cyclic/cyclicFaPatchFields.C
$(constraintFaPatchFields)/symmetry/symmetryFaPatchFields.C
derivedFaPatchFields = $(faPatchFields)/derived
$(derivedFaPatchFields)/fixedValueOutflow/fixedValueOutflowFaPatchFields.C
$(derivedFaPatchFields)/inletOutlet/inletOutletFaPatchFields.C
$(derivedFaPatchFields)/slip/slipFaPatchFields.C
faePatchFields = fields/faePatchFields
$(faePatchFields)/faePatchField/faePatchFields.C
@ -49,7 +54,8 @@ constraintFaePatchFields = $(faePatchFields)/constraint
$(constraintFaePatchFields)/empty/emptyFaePatchFields.C
$(constraintFaePatchFields)/processor/processorFaePatchFields.C
$(constraintFaePatchFields)/wedge/wedgeFaePatchFields.C
$(constraintFaePatchFields)/cyclic/cyclicFaePatchFields.C
$(constraintFaePatchFields)/symmetry/symmetryFaePatchFields.C
fields/areaFields/areaFields.C
fields/edgeFields/edgeFields.C

152
src/finiteArea/fields/faPatchFields/basic/basicSymmetry/basicSymmetryFaPatchField.C Normal file
View file

@ -0,0 +1,152 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "basicSymmetryFaPatchField.H"
#include "symmTransformField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
basicSymmetryFaPatchField<Type>::basicSymmetryFaPatchField
(
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF
)
:
transformFaPatchField<Type>(p, iF)
{}
template<class Type>
basicSymmetryFaPatchField<Type>::basicSymmetryFaPatchField
(
const basicSymmetryFaPatchField<Type>& ptf,
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF,
const faPatchFieldMapper& mapper
)
:
transformFaPatchField<Type>(ptf, p, iF, mapper)
{}
template<class Type>
basicSymmetryFaPatchField<Type>::basicSymmetryFaPatchField
(
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF,
const dictionary& dict
)
:
transformFaPatchField<Type>(p, iF, dict)
{
this->evaluate();
}
template<class Type>
basicSymmetryFaPatchField<Type>::basicSymmetryFaPatchField
(
const basicSymmetryFaPatchField<Type>& ptf
)
:
transformFaPatchField<Type>(ptf)
{}
template<class Type>
basicSymmetryFaPatchField<Type>::basicSymmetryFaPatchField
(
const basicSymmetryFaPatchField<Type>& ptf,
const DimensionedField<Type, areaMesh>& iF
)
:
transformFaPatchField<Type>(ptf, iF)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// Return gradient at boundary
template<class Type>
tmp<Field<Type> > basicSymmetryFaPatchField<Type>::snGrad() const
{
vectorField nHat = this->patch().edgeNormals();
return
(
transform(I - 2.0*sqr(nHat), this->patchInternalField())
- this->patchInternalField()
)*(this->patch().deltaCoeffs()/2.0);
}
// Evaluate the field on the patch
template<class Type>
void basicSymmetryFaPatchField<Type>::evaluate(const Pstream::commsTypes)
{
if (!this->updated())
{
this->updateCoeffs();
}
vectorField nHat = this->patch().edgeNormals();
Field<Type>::operator=
(
(
this->patchInternalField()
+ transform(I - 2.0*sqr(nHat), this->patchInternalField())
)/2.0
);
transformFaPatchField<Type>::evaluate();
}
// Return defining fields
template<class Type>
tmp<Field<Type> > basicSymmetryFaPatchField<Type>::snGradTransformDiag() const
{
vectorField nHat = this->patch().edgeNormals();
vectorField diag(nHat.size());
diag.replace(vector::X, mag(nHat.component(vector::X)));
diag.replace(vector::Y, mag(nHat.component(vector::Y)));
diag.replace(vector::Z, mag(nHat.component(vector::Z)));
return transformFieldMask<Type>(pow<vector, pTraits<Type>::rank>(diag));
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

170
src/finiteArea/fields/faPatchFields/basic/basicSymmetry/basicSymmetryFaPatchField.H Normal file
View file

@ -0,0 +1,170 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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::basicSymmetryFaPatchField
Description
A symmetry patch
SourceFiles
basicSymmetryFaPatchField.C
\*---------------------------------------------------------------------------*/
#ifndef basicSymmetryFaPatchField_H
#define basicSymmetryFaPatchField_H
#include "transformFaPatchField.H"
#include "symmetryFaPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class basicSymmetryFaPatchField Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class basicSymmetryFaPatchField
:
public transformFaPatchField<Type>
{
public:
//- Runtime type information
TypeName(symmetryFaPatch::typeName_());
// Constructors
//- Construct from patch and internal field
basicSymmetryFaPatchField
(
const faPatch&,
const DimensionedField<Type, areaMesh>&
);
//- Construct from patch, internal field and dictionary
basicSymmetryFaPatchField
(
const faPatch&,
const DimensionedField<Type, areaMesh>&,
const dictionary&
);
//- Construct by mapping given basicSymmetryFaPatchField onto a new patch
basicSymmetryFaPatchField
(
const basicSymmetryFaPatchField<Type>&,
const faPatch&,
const DimensionedField<Type, areaMesh>&,
const faPatchFieldMapper&
);
//- Construct as copy
basicSymmetryFaPatchField
(
const basicSymmetryFaPatchField<Type>&
);
//- Construct and return a clone
virtual tmp<faPatchField<Type> > clone() const
{
return tmp<faPatchField<Type> >
(
new basicSymmetryFaPatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
basicSymmetryFaPatchField
(
const basicSymmetryFaPatchField<Type>&,
const DimensionedField<Type, areaMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<faPatchField<Type> > clone
(
const DimensionedField<Type, areaMesh>& iF
) const
{
return tmp<faPatchField<Type> >
(
new basicSymmetryFaPatchField<Type>(*this, iF)
);
}
// Member functions
// Evaluation functions
//- Return gradient at boundary
virtual tmp<Field<Type> > snGrad() const;
//- Evaluate the patch field
// Default argument needed to allow call in constructors
// HJ, 30/Jun/2009
virtual void evaluate
(
const Pstream::commsTypes commsType = Pstream::blocking
);
//- Return face-gradient transform diagonal
virtual tmp<Field<Type> > snGradTransformDiag() const;
};
// * * * * * * * * * * * Template Specialisations * * * * * * * * * * * * * //
template<>
tmp<scalarField > basicSymmetryFaPatchField<scalar>::snGrad() const;
template<>
void basicSymmetryFaPatchField<scalar>::evaluate
(
const Pstream::commsTypes commsType
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "basicSymmetryFaPatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

45
src/finiteArea/fields/faPatchFields/basic/basicSymmetry/basicSymmetryFaPatchFields.C Normal file
View file

@ -0,0 +1,45 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "basicSymmetryFaPatchFields.H"
#include "faPatchFields.H"
#include "areaMesh.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeFaPatchFields(basicSymmetry);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

50
src/finiteArea/fields/faPatchFields/basic/basicSymmetry/basicSymmetryFaPatchFields.H Normal file
View file

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 basicSymmetryFaPatchFields_H
#define basicSymmetryFaPatchFields_H
#include "basicSymmetryFaPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeFaPatchTypeFieldTypedefs(basicSymmetry)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

60
src/finiteArea/fields/faPatchFields/basic/basicSymmetry/basicSymmetryFaPatchScalarField.C Normal file
View file

@ -0,0 +1,60 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "basicSymmetryFaPatchField.H"
#include "areaFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<>
tmp<scalarField > basicSymmetryFaPatchField<scalar>::snGrad() const
{
return tmp<scalarField >(new scalarField(size(), 0.0));
}
template<>
void basicSymmetryFaPatchField<scalar>::evaluate(const Pstream::commsTypes)
{
if (!updated())
{
updateCoeffs();
}
scalarField::operator=(patchInternalField());
transformFaPatchField<scalar>::evaluate();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

217
src/finiteArea/fields/faPatchFields/constraint/cyclic/cyclicFaPatchField.C Normal file
View file

@ -0,0 +1,217 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "cyclicFaPatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
cyclicFaPatchField<Type>::cyclicFaPatchField
(
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF
)
:
coupledFaPatchField<Type>(p, iF),
cyclicPatch_(refCast<const cyclicFaPatch>(p))
{}
template<class Type>
cyclicFaPatchField<Type>::cyclicFaPatchField
(
const cyclicFaPatchField<Type>& ptf,
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF,
const faPatchFieldMapper& mapper
)
:
coupledFaPatchField<Type>(ptf, p, iF, mapper),
cyclicPatch_(refCast<const cyclicFaPatch>(p))
{
if (!isType<cyclicFaPatch>(this->patch()))
{
FatalErrorIn
(
"cyclicFaPatchField<Type>::cyclicFaPatchField\n"
"(\n"
" const cyclicFaPatchField<Type>& ptf,\n"
" const faPatch& p,\n"
" const DimensionedField<Type, areaMesh>& iF,\n"
" const faPatchFieldMapper& mapper\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
template<class Type>
cyclicFaPatchField<Type>::cyclicFaPatchField
(
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF,
const dictionary& dict
)
:
coupledFaPatchField<Type>(p, iF, dict),
cyclicPatch_(refCast<const cyclicFaPatch>(p))
{
if (!isType<cyclicFaPatch>(p))
{
FatalIOErrorIn
(
"cyclicFaPatchField<Type>::cyclicFaPatchField\n"
"(\n"
" const faPatch& p,\n"
" const Field<Type>& field,\n"
" const dictionary& dict\n"
")\n",
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
this->evaluate(Pstream::blocking);
}
template<class Type>
cyclicFaPatchField<Type>::cyclicFaPatchField
(
const cyclicFaPatchField<Type>& ptf
)
:
cyclicLduInterfaceField(),
coupledFaPatchField<Type>(ptf),
cyclicPatch_(ptf.cyclicPatch_)
{}
template<class Type>
cyclicFaPatchField<Type>::cyclicFaPatchField
(
const cyclicFaPatchField<Type>& ptf,
const DimensionedField<Type, areaMesh>& iF
)
:
coupledFaPatchField<Type>(ptf, iF),
cyclicPatch_(ptf.cyclicPatch_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
tmp<Field<Type> > cyclicFaPatchField<Type>::patchNeighbourField() const
{
const Field<Type>& iField = this->internalField();
const unallocLabelList& faceCells = cyclicPatch_.faceCells();
tmp<Field<Type> > tpnf(new Field<Type>(this->size()));
Field<Type>& pnf = tpnf();
label sizeby2 = this->size()/2;
if (doTransform())
{
for (label facei=0; facei<sizeby2; facei++)
{
pnf[facei] = transform
(
forwardT()[0], iField[faceCells[facei + sizeby2]]
);
pnf[facei + sizeby2] = transform
(
reverseT()[0], iField[faceCells[facei]]
);
}
}
else
{
for (label facei=0; facei<sizeby2; facei++)
{
pnf[facei] = iField[faceCells[facei + sizeby2]];
pnf[facei + sizeby2] = iField[faceCells[facei]];
}
}
return tpnf;
}
template<class Type>
void cyclicFaPatchField<Type>::updateInterfaceMatrix
(
const scalarField& psiInternal,
scalarField& result,
const lduMatrix&,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes
) const
{
scalarField pnf(this->size());
label sizeby2 = this->size()/2;
const unallocLabelList& faceCells = cyclicPatch_.faceCells();
for (label facei=0; facei<sizeby2; facei++)
{
pnf[facei] = psiInternal[faceCells[facei + sizeby2]];
pnf[facei + sizeby2] = psiInternal[faceCells[facei]];
}
// Transform according to the transformation tensors
transformCoupleField(pnf, cmpt);
// Multiply the field by coefficients and add into the result
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

212
src/finiteArea/fields/faPatchFields/constraint/cyclic/cyclicFaPatchField.H Normal file
View file

@ -0,0 +1,212 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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::cyclicFaPatchField
Description
Foam::cyclicFaPatchField
SourceFiles
cyclicFaPatchField.C
\*---------------------------------------------------------------------------*/
#ifndef cyclicFaPatchField_H
#define cyclicFaPatchField_H
#include "coupledFaPatchField.H"
#include "cyclicLduInterfaceField.H"
#include "cyclicFaPatch.H"
#include "areaMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cyclicFaPatch Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class cyclicFaPatchField
:
virtual public cyclicLduInterfaceField,
public coupledFaPatchField<Type>
{
// Private data
//- Local reference cast into the cyclic patch
const cyclicFaPatch& cyclicPatch_;
// Private member functions
//- Return neighbour side field given internal fields
template<class Type2>
tmp<Field<Type2> > neighbourSideField
(
const Field<Type2>&
) const;
public:
//- Runtime type information
TypeName(cyclicFaPatch::typeName_());
// Constructors
//- Construct from patch and internal field
cyclicFaPatchField
(
const faPatch&,
const DimensionedField<Type, areaMesh>&
);
//- Construct from patch, internal field and dictionary
cyclicFaPatchField
(
const faPatch&,
const DimensionedField<Type, areaMesh>&,
const dictionary&
);
//- Construct by mapping given cyclicFaPatchField onto a new patch
cyclicFaPatchField
(
const cyclicFaPatchField<Type>&,
const faPatch&,
const DimensionedField<Type, areaMesh>&,
const faPatchFieldMapper&
);
//- Construct as copy
cyclicFaPatchField
(
const cyclicFaPatchField<Type>&
);
//- Construct and return a clone
virtual tmp<faPatchField<Type> > clone() const
{
return tmp<faPatchField<Type> >
(
new cyclicFaPatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
cyclicFaPatchField
(
const cyclicFaPatchField<Type>&,
const DimensionedField<Type, areaMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<faPatchField<Type> > clone
(
const DimensionedField<Type, areaMesh>& iF
) const
{
return tmp<faPatchField<Type> >
(
new cyclicFaPatchField<Type>(*this, iF)
);
}
// Member functions
// Access
//- Retirn local reference cast into the cyclic patch
const cyclicFaPatch& cyclicPatch() const
{
return cyclicPatch_;
}
// Evaluation functions
//- Return neighbour coupled given internal cell data
virtual tmp<Field<Type> > patchNeighbourField() const;
//- Update result field based on interface functionality
virtual void updateInterfaceMatrix
(
const scalarField& psiInternal,
scalarField& result,
const lduMatrix&,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const;
//- Cyclic coupled interface functions
//- Does the patch field perform the transfromation
virtual bool doTransform() const
{
return !(cyclicPatch_.parallel() || pTraits<Type>::rank == 0);
}
//- Return face transformation tensor
virtual const tensorField& forwardT() const
{
return cyclicPatch_.forwardT();
}
//- Return neighbour-cell transformation tensor
virtual const tensorField& reverseT() const
{
return cyclicPatch_.reverseT();
}
//- Return rank of component for transform
virtual int rank() const
{
return pTraits<Type>::rank;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "cyclicFaPatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

45
src/finiteArea/fields/faPatchFields/constraint/cyclic/cyclicFaPatchFields.C Normal file
View file

@ -0,0 +1,45 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "cyclicFaPatchFields.H"
#include "addToRunTimeSelectionTable.H"
#include "areaMesh.H"
#include "areaFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeFaPatchFields(cyclic);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

50
src/finiteArea/fields/faPatchFields/constraint/cyclic/cyclicFaPatchFields.H Normal file
View file

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 cyclicFaPatchFields_H
#define cyclicFaPatchFields_H
#include "cyclicFaPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeFaPatchTypeFieldTypedefs(cyclic)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

52
src/finiteArea/fields/faPatchFields/constraint/cyclic/cyclicFaPatchFieldsFwd.H Normal file
View file

@ -0,0 +1,52 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 cyclicFaPatchFieldsFwd_H
#define cyclicFaPatchFieldsFwd_H
// #include "faPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type> class cyclicFaPatchField;
makeFaPatchTypeFieldTypedefs(cyclic)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

135
src/finiteArea/fields/faPatchFields/constraint/symmetry/symmetryFaPatchField.C Normal file
View file

@ -0,0 +1,135 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "symmetryFaPatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
symmetryFaPatchField<Type>::symmetryFaPatchField
(
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF
)
:
basicSymmetryFaPatchField<Type>(p, iF)
{}
template<class Type>
symmetryFaPatchField<Type>::symmetryFaPatchField
(
const symmetryFaPatchField<Type>& ptf,
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF,
const faPatchFieldMapper& mapper
)
:
basicSymmetryFaPatchField<Type>(ptf, p, iF, mapper)
{
if (!isType<symmetryFaPatch>(this->patch()))
{
FatalErrorIn
(
"symmetryFaPatchField<Type>::symmetryFaPatchField\n"
"(\n"
" const symmetryFaPatchField<Type>& ptf,\n"
" const faPatch& p,\n"
" const DimensionedField<Type, areaMesh>& iF,\n"
" const faPatchFieldMapper& mapper\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
template<class Type>
symmetryFaPatchField<Type>::symmetryFaPatchField
(
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF,
const dictionary& dict
)
:
basicSymmetryFaPatchField<Type>(p, iF, dict)
{
if (!isType<symmetryFaPatch>(p))
{
FatalIOErrorIn
(
"symmetryFaPatchField<Type>::symmetryFaPatchField\n"
"(\n"
" const faPatch& p,\n"
" const Field<Type>& field,\n"
" const dictionary& dict\n"
")\n",
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
template<class Type>
symmetryFaPatchField<Type>::symmetryFaPatchField
(
const symmetryFaPatchField<Type>& ptf
)
:
basicSymmetryFaPatchField<Type>(ptf)
{}
template<class Type>
symmetryFaPatchField<Type>::symmetryFaPatchField
(
const symmetryFaPatchField<Type>& ptf,
const DimensionedField<Type, areaMesh>& iF
)
:
basicSymmetryFaPatchField<Type>(ptf, iF)
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

139
src/finiteArea/fields/faPatchFields/constraint/symmetry/symmetryFaPatchField.H Normal file
View file

@ -0,0 +1,139 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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::symmetryFaPatchField
Description
Foam::symmetryFaPatchField
SourceFiles
symmetryFaPatchField.C
\*---------------------------------------------------------------------------*/
#ifndef symmetryFaPatchField_H
#define symmetryFaPatchField_H
#include "basicSymmetryFaPatchField.H"
#include "symmetryFaPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class symmetryFaPatchField Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class symmetryFaPatchField
:
public basicSymmetryFaPatchField<Type>
{
public:
//- Runtime type information
TypeName(symmetryFaPatch::typeName_());
// Constructors
//- Construct from patch and internal field
symmetryFaPatchField
(
const faPatch&,
const DimensionedField<Type, areaMesh>&
);
//- Construct from patch, internal field and dictionary
symmetryFaPatchField
(
const faPatch&,
const DimensionedField<Type, areaMesh>&,
const dictionary&
);
//- Construct by mapping given symmetryFaPatchField onto a new patch
symmetryFaPatchField
(
const symmetryFaPatchField<Type>&,
const faPatch&,
const DimensionedField<Type, areaMesh>&,
const faPatchFieldMapper&
);
//- Construct as copy
symmetryFaPatchField
(
const symmetryFaPatchField<Type>&
);
//- Construct and return a clone
virtual tmp<faPatchField<Type> > clone() const
{
return tmp<faPatchField<Type> >
(
new symmetryFaPatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
symmetryFaPatchField
(
const symmetryFaPatchField<Type>&,
const DimensionedField<Type, areaMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<faPatchField<Type> > clone
(
const DimensionedField<Type, areaMesh>& iF
) const
{
return tmp<faPatchField<Type> >
(
new symmetryFaPatchField<Type>(*this, iF)
);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "symmetryFaPatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/finiteArea/fields/faPatchFields/constraint/symmetry/symmetryFaPatchFields.C Normal file
View file

@ -0,0 +1,44 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "symmetryFaPatchFields.H"
#include "addToRunTimeSelectionTable.H"
#include "areaFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeFaPatchFields(symmetry);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

50
src/finiteArea/fields/faPatchFields/constraint/symmetry/symmetryFaPatchFields.H Normal file
View file

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 symmetryFaPatchFields_H
#define symmetryFaPatchFields_H
#include "symmetryFaPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeFaPatchTypeFieldTypedefs(symmetry)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

52
src/finiteArea/fields/faPatchFields/constraint/symmetry/symmetryFaPatchFieldsFwd.H Normal file
View file

@ -0,0 +1,52 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 symmetryFaPatchFieldsFwd_H
#define symmetryFaPatchFieldsFwd_H
#include "faPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type> class symmetryFaPatchField;
makeFaPatchTypeFieldTypedefs(symmetry)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

97
src/finiteArea/fields/faPatchFields/derived/slip/slipFaPatchField.C Normal file
View file

@ -0,0 +1,97 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "slipFaPatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
slipFaPatchField<Type>::slipFaPatchField
(
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF
)
:
basicSymmetryFaPatchField<Type>(p, iF)
{}
template<class Type>
slipFaPatchField<Type>::slipFaPatchField
(
const slipFaPatchField<Type>& ptf,
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF,
const faPatchFieldMapper& mapper
)
:
basicSymmetryFaPatchField<Type>(ptf, p, iF, mapper)
{}
template<class Type>
slipFaPatchField<Type>::slipFaPatchField
(
const faPatch& p,
const DimensionedField<Type, areaMesh>& iF,
const dictionary& dict
)
:
basicSymmetryFaPatchField<Type>(p, iF, dict)
{}
template<class Type>
slipFaPatchField<Type>::slipFaPatchField
(
const slipFaPatchField<Type>& ptf,
const DimensionedField<Type, areaMesh>& iF
)
:
basicSymmetryFaPatchField<Type>(ptf, iF)
{}
template<class Type>
slipFaPatchField<Type>::slipFaPatchField
(
const slipFaPatchField<Type>& ptf
)
:
basicSymmetryFaPatchField<Type>(ptf)
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

138
src/finiteArea/fields/faPatchFields/derived/slip/slipFaPatchField.H Normal file
View file

@ -0,0 +1,138 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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::slipFaPatchField
Description
Foam::slipFaPatchField
SourceFiles
slipFaPatchField.C
\*---------------------------------------------------------------------------*/
#ifndef slipFaPatchField_H
#define slipFaPatchField_H
#include "basicSymmetryFaPatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class slipFaPatch Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class slipFaPatchField
:
public basicSymmetryFaPatchField<Type>
{
public:
//- Runtime type information
TypeName("slip");
// Constructors
//- Construct from patch and internal field
slipFaPatchField
(
const faPatch&,
const DimensionedField<Type, areaMesh>&
);
//- Construct from patch, internal field and dictionary
slipFaPatchField
(
const faPatch&,
const DimensionedField<Type, areaMesh>&,
const dictionary&
);
//- Construct by mapping given slipFaPatchField onto a new patch
slipFaPatchField
(
const slipFaPatchField<Type>&,
const faPatch&,
const DimensionedField<Type, areaMesh>&,
const faPatchFieldMapper&
);
//- Construct as copy
slipFaPatchField
(
const slipFaPatchField<Type>&
);
//- Construct and return a clone
virtual tmp<faPatchField<Type> > clone() const
{
return tmp<faPatchField<Type> >
(
new slipFaPatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
slipFaPatchField
(
const slipFaPatchField<Type>&,
const DimensionedField<Type, areaMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<faPatchField<Type> > clone
(
const DimensionedField<Type, areaMesh>& iF
) const
{
return tmp<faPatchField<Type> >
(
new slipFaPatchField<Type>(*this, iF)
);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "slipFaPatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/finiteArea/fields/faPatchFields/derived/slip/slipFaPatchFields.C Normal file
View file

@ -0,0 +1,44 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "slipFaPatchFields.H"
#include "addToRunTimeSelectionTable.H"
#include "areaFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeFaPatchFields(slip);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

50
src/finiteArea/fields/faPatchFields/derived/slip/slipFaPatchFields.H Normal file
View file

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 slipFaPatchFields_H
#define slipFaPatchFields_H
#include "slipFaPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeFaPatchTypeFieldTypedefs(slip)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

52
src/finiteArea/fields/faPatchFields/derived/slip/slipFaPatchFieldsFwd.H Normal file
View file

@ -0,0 +1,52 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 slipFaPatchFieldsFwd_H
#define slipFaPatchFieldsFwd_H
#include "faPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type> class slipFaPatchField;
makeFaPatchTypeFieldTypedefs(slip)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

136
src/finiteArea/fields/faePatchFields/constraint/cyclic/cyclicFaePatchField.C Normal file
View file

@ -0,0 +1,136 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "cyclicFaePatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
cyclicFaePatchField<Type>::cyclicFaePatchField
(
const faPatch& p,
const DimensionedField<Type, edgeMesh>& iF
)
:
coupledFaePatchField<Type>(p, iF),
cyclicPatch_(refCast<const cyclicFaPatch>(p))
{}
template<class Type>
cyclicFaePatchField<Type>::cyclicFaePatchField
(
const cyclicFaePatchField<Type>& ptf,
const faPatch& p,
const DimensionedField<Type, edgeMesh>& iF,
const faPatchFieldMapper& mapper
)
:
coupledFaePatchField<Type>(ptf, p, iF, mapper),
cyclicPatch_(refCast<const cyclicFaPatch>(p))
{
if (!isType<cyclicFaPatch>(this->patch()))
{
FatalErrorIn
(
"cyclicFaePatchField<Type>::cyclicFaePatchField\n"
"(\n"
" const cyclicFaePatchField<Type>& ptf,\n"
" const faPatch& p,\n"
" const DimensionedField<Type, edgeMesh>& iF,\n"
" const faPatchFieldMapper& mapper\n"
")\n"
) << "Field type does not correspond to patch type for patch "
<< this->patch().index() << "." << endl
<< "Field type: " << typeName << endl
<< "Patch type: " << this->patch().type()
<< exit(FatalError);
}
}
template<class Type>
cyclicFaePatchField<Type>::cyclicFaePatchField
(
const faPatch& p,
const DimensionedField<Type, edgeMesh>& iF,
const dictionary& dict
)
:
coupledFaePatchField<Type>(p, iF, dict),
cyclicPatch_(refCast<const cyclicFaPatch>(p))
{
if (!isType<cyclicFaPatch>(p))
{
FatalIOErrorIn
(
"cyclicFaePatchField<Type>::cyclicFaePatchField\n"
"(\n"
" const faPatch& p,\n"
" const Field<Type>& field,\n"
" const dictionary& dict\n"
")\n",
dict
) << "patch " << this->patch().index() << " not cyclic type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}
template<class Type>
cyclicFaePatchField<Type>::cyclicFaePatchField
(
const cyclicFaePatchField<Type>& ptf
)
:
coupledFaePatchField<Type>(ptf),
cyclicPatch_(ptf.cyclicPatch_)
{}
template<class Type>
cyclicFaePatchField<Type>::cyclicFaePatchField
(
const cyclicFaePatchField<Type>& ptf,
const DimensionedField<Type, edgeMesh>& iF
)
:
coupledFaePatchField<Type>(ptf, iF),
cyclicPatch_(ptf.cyclicPatch_)
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

144
src/finiteArea/fields/faePatchFields/constraint/cyclic/cyclicFaePatchField.H Normal file
View file

@ -0,0 +1,144 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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::cyclicFaePatchField
Description
Foam::cyclicFaePatchField
SourceFiles
cyclicFaePatchField.C
\*---------------------------------------------------------------------------*/
#ifndef cyclicFaePatchField_H
#define cyclicFaePatchField_H
#include "coupledFaePatchField.H"
#include "cyclicFaPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cyclicFaePatch Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class cyclicFaePatchField
:
public coupledFaePatchField<Type>
{
// Private data
//- Local reference cast into the cyclic patch
const cyclicFaPatch& cyclicPatch_;
public:
//- Runtime type information
TypeName(cyclicFaPatch::typeName_());
// Constructors
//- Construct from patch and internal field
cyclicFaePatchField
(
const faPatch&,
const DimensionedField<Type, edgeMesh>&
);
//- Construct from patch, internal field and dictionary
cyclicFaePatchField
(
const faPatch&,
const DimensionedField<Type, edgeMesh>&,
const dictionary&
);
//- Construct by mapping given cyclicFaePatchField onto a new patch
cyclicFaePatchField
(
const cyclicFaePatchField<Type>&,
const faPatch&,
const DimensionedField<Type, edgeMesh>&,
const faPatchFieldMapper&
);
//- Construct as copy
cyclicFaePatchField
(
const cyclicFaePatchField<Type>&
);
//- Construct and return a clone
virtual tmp<faePatchField<Type> > clone() const
{
return tmp<faePatchField<Type> >
(
new cyclicFaePatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
cyclicFaePatchField
(
const cyclicFaePatchField<Type>&,
const DimensionedField<Type, edgeMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<faePatchField<Type> > clone
(
const DimensionedField<Type, edgeMesh>& iF
) const
{
return tmp<faePatchField<Type> >
(
new cyclicFaePatchField<Type>(*this, iF)
);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "cyclicFaePatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/finiteArea/fields/faePatchFields/constraint/cyclic/cyclicFaePatchFields.C Normal file
View file

@ -0,0 +1,44 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "cyclicFaePatchFields.H"
#include "faePatchFields.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeFaePatchFields(cyclic);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

50
src/finiteArea/fields/faePatchFields/constraint/cyclic/cyclicFaePatchFields.H Normal file
View file

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 cyclicFaePatchFields_H
#define cyclicFaePatchFields_H
#include "cyclicFaePatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeFaePatchTypeFieldTypedefs(cyclic)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

52
src/finiteArea/fields/faePatchFields/constraint/cyclic/cyclicFaePatchFieldsFwd.H Normal file
View file

@ -0,0 +1,52 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 cyclicFaePatchFieldsFwd_H
#define cyclicFaePatchFieldsFwd_H
#include "faePatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type> class cyclicFaePatchField;
makeFaePatchTypeFieldTypedefs(cyclic)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

131
src/finiteArea/fields/faePatchFields/constraint/symmetry/symmetryFaePatchField.C Normal file
View file

@ -0,0 +1,131 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "symmetryFaePatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
symmetryFaePatchField<Type>::symmetryFaePatchField
(
const faPatch& p,
const DimensionedField<Type, edgeMesh>& iF
)
:
faePatchField<Type>(p, iF)
{}
template<class Type>
symmetryFaePatchField<Type>::symmetryFaePatchField
(
const symmetryFaePatchField<Type>& ptf,
const faPatch& p,
const DimensionedField<Type, edgeMesh>& iF,
const faPatchFieldMapper& mapper
)
:
faePatchField<Type>(ptf, p, iF, mapper)
{
if (!isType<symmetryFaPatch>(this->patch()))
{
FatalErrorIn
(
"symmetryFaePatchField<Type>::symmetryFaePatchField\n"
"(\n"
" const symmetryFaePatchField<Type>& ptf,\n"
" const faPatch& p,\n"
" const DimensionedField<Type, edgeMesh>& iF,\n"
" const faPatchFieldMapper& mapper\n"
")\n"
) << "Field type does not correspond to patch type for patch "
<< this->patch().index() << "." << endl
<< "Field type: " << typeName << endl
<< "Patch type: " << this->patch().type()
<< exit(FatalError);
}
}
template<class Type>
symmetryFaePatchField<Type>::symmetryFaePatchField
(
const faPatch& p,
const DimensionedField<Type, edgeMesh>& iF,
const dictionary& dict
)
:
faePatchField<Type>(p, iF, dict)
{
if (!isType<symmetryFaPatch>(p))
{
FatalIOErrorIn
(
"symmetryFaePatchField<Type>::symmetryFaePatchField\n"
"(\n"
" const faPatch& p,\n"
" const Field<Type>& field,\n"
" const dictionary& dict\n"
")\n",
dict
) << "patch " << this->patch().index() << " not symmetry type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}
template<class Type>
symmetryFaePatchField<Type>::symmetryFaePatchField
(
const symmetryFaePatchField<Type>& ptf
)
:
faePatchField<Type>(ptf)
{}
template<class Type>
symmetryFaePatchField<Type>::symmetryFaePatchField
(
const symmetryFaePatchField<Type>& ptf,
const DimensionedField<Type, edgeMesh>& iF
)
:
faePatchField<Type>(ptf, iF)
{}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

139
src/finiteArea/fields/faePatchFields/constraint/symmetry/symmetryFaePatchField.H Normal file
View file

@ -0,0 +1,139 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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::symmetryFaePatchField
Description
Foam::symmetryFaePatchField
SourceFiles
symmetryFaePatchField.C
\*---------------------------------------------------------------------------*/
#ifndef symmetryFaePatchField_H
#define symmetryFaePatchField_H
#include "faePatchField.H"
#include "symmetryFaPatch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class symmetryFaePatch Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class symmetryFaePatchField
:
public faePatchField<Type>
{
public:
//- Runtime type information
TypeName(symmetryFaPatch::typeName_());
// Constructors
//- Construct from patch and internal field
symmetryFaePatchField
(
const faPatch&,
const DimensionedField<Type, edgeMesh>&
);
//- Construct from patch, internal field and dictionary
symmetryFaePatchField
(
const faPatch&,
const DimensionedField<Type, edgeMesh>&,
const dictionary&
);
//- Construct by mapping given symmetryFaePatchField onto a new patch
symmetryFaePatchField
(
const symmetryFaePatchField<Type>&,
const faPatch&,
const DimensionedField<Type, edgeMesh>&,
const faPatchFieldMapper&
);
//- Construct as copy
symmetryFaePatchField
(
const symmetryFaePatchField<Type>&
);
//- Construct and return a clone
virtual tmp<faePatchField<Type> > clone() const
{
return tmp<faePatchField<Type> >
(
new symmetryFaePatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
symmetryFaePatchField
(
const symmetryFaePatchField<Type>&,
const DimensionedField<Type, edgeMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<faePatchField<Type> > clone
(
const DimensionedField<Type, edgeMesh>& iF
) const
{
return tmp<faePatchField<Type> >
(
new symmetryFaePatchField<Type>(*this, iF)
);
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "symmetryFaePatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/finiteArea/fields/faePatchFields/constraint/symmetry/symmetryFaePatchFields.C Normal file
View file

@ -0,0 +1,44 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 "symmetryFaePatchFields.H"
#include "faePatchFields.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makeFaePatchFields(symmetry);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

50
src/finiteArea/fields/faePatchFields/constraint/symmetry/symmetryFaePatchFields.H Normal file
View file

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 symmetryFaePatchFields_H
#define symmetryFaePatchFields_H
#include "symmetryFaePatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeFaePatchTypeFieldTypedefs(symmetry)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

52
src/finiteArea/fields/faePatchFields/constraint/symmetry/symmetryFaePatchFieldsFwd.H Normal file
View file

@ -0,0 +1,52 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright held by original author
\\/ 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 symmetryFaePatchFieldsFwd_H
#define symmetryFaePatchFieldsFwd_H
#include "faPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type> class symmetryFaePatchField;
makeFaePatchTypeFieldTypedefs(symmetry)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //