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

STYLE: remove unused overset lduInterfaces code (commit 33db2dd3e2)

Browse Source
This commit is contained in:
Mark Olesen
2019-05-30 17:22:24 +02:00
committed by Andrew Heather
parent a31d0c834e
commit 375fd3d9d3
16 changed files with 0 additions and 1873 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/overset/Make/files
View File

@ -19,14 +19,6 @@ oversetPolyPatch/oversetFvsPatchFields.C
oversetPolyPatch/oversetPointPatch.C
oversetPolyPatch/oversetPointPatchFields.C
/*
oversetPolyPatch/semiImplicitOversetFvPatchFields.C
oversetPolyPatch/oversetLduInterface.C
oversetPolyPatch/oversetGAMGInterface.C
oversetPolyPatch/oversetGAMGInterfaceField.C
oversetPolyPatch/semiImplicitOversetGAMGInterfaceField.C
*/
oversetAdjustPhi/oversetAdjustPhi.C
regionsToCell/regionsToCell.C

2
src/overset/oversetPolyPatch/oversetFvPatch.C
View File

@ -39,6 +39,4 @@ namespace Foam
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// ************************************************************************* //

134
src/overset/oversetPolyPatch/oversetFvPatchField.C
View File

@ -216,140 +216,6 @@ void Foam::oversetFvPatchField<Type>::initEvaluate
}
//template<class Type>
//void Foam::oversetFvPatchField<Type>::initInterfaceMatrixUpdate
//(
// scalarField&,
// const bool add,
// const scalarField& psiInternal,
// const scalarField&,
// const direction,
// const Pstream::commsTypes commsType
//) const
//{
//// // Add remote values
////
//// const oversetFvPatch& ovp = this->oversetPatch_;
////
//// if (ovp.master())
//// {
//// const fvMesh& mesh = this->patch().boundaryMesh().mesh();
////
//// // Try to find out if the solve routine comes from the mesh
//// // TBD. This should be cleaner.
//// if (&mesh.lduAddr() == &mesh.fvMesh::lduAddr())
//// {
//// return;
//// }
////
//// const mapDistribute& map = ovp.cellInterpolationMap();
////
//// // Transfer the current state (similar to processorFvPatchField).
//// // Note
//// // use of separate tag to avoid clashes with any outstanding
//// // processor exchanges
//// if (this->pBufs_.valid())
//// {
//// this->pBufs_().clear();
//// }
//// else
//// {
//// this->pBufs_.set
//// (
//// new PstreamBuffers
//// (
//// Pstream::commsTypes::nonBlocking,
//// UPstream::msgType()+1
//// )
//// );
//// }
////
//// // Start sending
//// map.mapDistributeBase::send(this->pBufs_(), psiInternal);
//// }
//}
//
//
//template<class Type>
//void Foam::oversetFvPatchField<Type>::updateInterfaceMatrix
//(
// scalarField& result,
// const bool add,
// const scalarField& psiInternal,
// const scalarField& coeffs,
// const direction cmpt,
// const Pstream::commsTypes
//) const
//{
//// // Add remote values
////
//// const oversetFvPatch& ovp = this->oversetPatch_;
////
//// if (ovp.master())
//// {
//// const fvMesh& mesh = this->patch().boundaryMesh().mesh();
////
//// // Try to find out if the solve routine comes from the mesh
//// // TBD. This should be cleaner.
//// if (&mesh.lduAddr() == &mesh.fvMesh::lduAddr())
//// {
//// return;
//// }
////
//// const labelListList& stencil = ovp.stencil();
////
//// if (stencil.size() != psiInternal.size())
//// {
//// FatalErrorInFunction << "psiInternal:" << psiInternal.size()
//// << " stencil:" << stencil.size() << exit(FatalError);
//// }
////
//// const mapDistribute& map = ovp.cellInterpolationMap();
//// const List<scalarList>& wghts = ovp.cellInterpolationWeights();
//// const labelList& cellIDs = ovp.interpolationCells();
//// const scalarList& factor = ovp.cellInterpolationWeight();
//// const scalarField& normalisation = ovp.normalisation();
////
//// // Since we're inside initEvaluate/evaluate there might be processor
//// // comms underway. Change the tag we use.
//// //scalarField work(psiInternal);
//// //map.mapDistributeBase::distribute(work, UPstream::msgType()+1);
////
//// // Receive the outstanding data
//// scalarField work;
//// map.receive(this->pBufs_(), work);
////
//// forAll(cellIDs, i)
//// {
//// label celli = cellIDs[i];
////
//// const scalarList& w = wghts[celli];
//// const labelList& nbrs = stencil[celli];
////
//// scalar f = factor[celli];
//// const scalar norm = normalisation[celli];
////
//// // Add the non-local matrix contribution to psi. Note that the
//// // matrix coefficients are -weights
////
//// if (add)
//// {
//// f = -1.0*f;
//// }
////
//// forAll(nbrs, nbrI)
//// {
//// label slotI = nbrs[nbrI];
//// if (slotI >= psiInternal.size())
//// {
//// result[celli] += f*norm*w[nbrI]*work[slotI];
//// }
//// }
//// }
//// }
//}
template<class Type>
void Foam::oversetFvPatchField<Type>::write(Ostream& os) const
{

29
src/overset/oversetPolyPatch/oversetFvPatchField.H
View File

@ -66,9 +66,6 @@ protected:
//- Master patch ID
mutable label masterPatchID_;
//- Send/receive buffer
//mutable autoPtr<PstreamBuffers> pBufs_;
public:
@ -141,32 +138,6 @@ public:
//- Initialise the evaluation of the patch field
virtual void initEvaluate(const Pstream::commsTypes commsType);
// using LduInterfaceField<Type>::initInterfaceMatrixUpdate;
//
// //- Initialise neighbour matrix update. Add
// //- or subtract coupled contributions to matrix
// virtual void initInterfaceMatrixUpdate
// (
// scalarField&,
// const bool add,
// const scalarField&,
// const scalarField&,
// const direction,
// const Pstream::commsTypes commsType
// ) const;
//
// //- Update result field based on interface functionality
// virtual void updateInterfaceMatrix
// (
// scalarField& result,
// const bool add,
// const scalarField& psiInternal,
// const scalarField& coeffs,
// const direction cmpt,
// const Pstream::commsTypes commsType
// ) const;
// I-O
//- Write

260
src/overset/oversetPolyPatch/oversetGAMGInterface.C
View File

@ -1,260 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017-2019 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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 "oversetGAMGInterface.H"
#include "addToRunTimeSelectionTable.H"
#include "Map.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(oversetGAMGInterface, 0);
addToRunTimeSelectionTable
(
GAMGInterface,
oversetGAMGInterface,
lduInterface
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::oversetGAMGInterface::oversetGAMGInterface
(
const label index,
const lduInterfacePtrsList& coarseInterfaces,
const lduInterface& fineInterface,
const labelField& localRestrictAddressing,
const labelField& neighbourRestrictAddressing,
const label fineLevelIndex,
const label coarseComm
)
:
GAMGInterface(index, coarseInterfaces),
fineOversetInterface_
(
refCast<const oversetLduInterface>(fineInterface)
)
{
Pout<< "Constructing oversetGAMGInterface index:" << index
<< " from:" << fineOversetInterface_.name()
<< " size:" << localRestrictAddressing.size()
<< endl;
// From coarse face to coarse cell
DynamicList<label> dynFaceCells(localRestrictAddressing.size());
// From fine face to coarse face
DynamicList<label> dynFaceRestrictAddressing(dynFaceCells.size());
// From coarse cell to coarse face
Map<label> cellToCoarseFace(dynFaceCells.size());
// Construct face agglomeration from cell agglomeration
forAll(localRestrictAddressing, ffi)
{
// Get coarse cell
label coarseCelli = localRestrictAddressing[ffi];
// Do we have coarse face for it?
const auto iter = cellToCoarseFace.cfind(coarseCelli);
if (iter.found())
{
dynFaceRestrictAddressing.append(iter.val());
}
else
{
const label coarseFacei = dynFaceCells.size();
cellToCoarseFace.insert(coarseCelli, coarseFacei);
dynFaceCells.append(coarseCelli);
dynFaceRestrictAddressing.append(coarseFacei);
}
}
faceCells_.transfer(dynFaceCells);
faceRestrictAddressing_.transfer(dynFaceRestrictAddressing);
//Pout<< "** Constructed interface:" << name()
// << " of size:" << size() << endl;
// Determine this level's stencil from the fine stencil
if (master())
{
const mapDistribute& fineMap =
fineOversetInterface_.cellInterpolationMap();
const List<scalarList>& fineWghts =
fineOversetInterface_.cellInterpolationWeights();
const labelListList& fineStencil = fineOversetInterface_.stencil();
const labelList& fineCellIDs =
fineOversetInterface_.interpolationCells();
const scalarList& fineFactor =
fineOversetInterface_.cellInterpolationWeight();
const scalarField& fineNorm = fineOversetInterface_.normalisation();
const labelList& restrictMap = fineOversetInterface_.restrictMap();
if (localRestrictAddressing.size() && restrictMap.empty())
{
FatalErrorInFunction
<< "The restrict addressing has not been saved on interface "
<< this->name()
<< ". This gets stored when running internalFieldTransfer"
<< exit(FatalError);
}
// 'Interpolate' the restrict map so locally we know what the remote
// cells are going to be.
label nCoarseCells = max(restrictMap)+1;
globalIndex globalNumbering(nCoarseCells);
labelList globalCoarseIDs(globalNumbering.toGlobal(restrictMap));
fineMap.distribute(globalCoarseIDs);
//Pout<< this->name()
// << " index:" << index
// << " size:" << this->size()
// << " restrictMap:" << restrictMap.size()
// << " fineNumInterpolate:" << fineCellIDs.size()
// << " nCoarseCells:" << nCoarseCells
// << endl;
// Accumulate the coarse level stencil
// Number of fine cells contributing to the coarse cell
labelList nFineCells(nCoarseCells, Zero);
stencil_.setSize(nCoarseCells);
cellInterpolationWeights_.setSize(nCoarseCells);
cellInterpolationWeight_.setSize(nCoarseCells, 0.0);
normalisation_.setSize(nCoarseCells, 0.0);
forAll(fineCellIDs, i)
{
label fineCelli = fineCellIDs[i];
label coarseCelli = restrictMap[fineCelli];
const scalarList& w = fineWghts[fineCelli];
const labelList& nbrs = fineStencil[fineCelli];
// Accumulate stencil
labelList& coarseStencil = stencil_[coarseCelli];
scalarList& coarseWghts = cellInterpolationWeights_[coarseCelli];
label sz = coarseStencil.size();
coarseStencil.setSize(sz+nbrs.size());
coarseWghts.setSize(coarseStencil.size());
forAll(nbrs, i)
{
coarseStencil[sz] = globalCoarseIDs[nbrs[i]];
coarseWghts[sz] = w[i];
sz++;
}
// Accumulate weight
cellInterpolationWeight_[coarseCelli] += fineFactor[fineCelli];
normalisation_[coarseCelli] += fineNorm[fineCelli];
nFineCells[coarseCelli]++;
}
// Normalise weight (0 .. 1). Take average? Volume average? Min? Max?
forAll(nFineCells, coarseCelli)
{
label nAvg = nFineCells[coarseCelli];
if (nAvg > 0)
{
cellInterpolationWeight_[coarseCelli] /= nAvg;
}
}
// Work the stencil back from global cells into a mapDistribute
// + slots
List<Map<label>> compactMap;
mapPtr_.reset(new mapDistribute(globalNumbering, stencil_, compactMap));
// Determine the interpolationCells
label nInterpolate = 0;
forAll(stencil_, coarseCelli)
{
if (stencil_[coarseCelli].size())
{
nInterpolate++;
}
}
//Pout<< this->name() << " nInterpolate:" << nInterpolate << endl;
interpolationCells_.setSize(nInterpolate);
nInterpolate = 0;
forAll(stencil_, coarseCelli)
{
if (stencil_[coarseCelli].size())
{
interpolationCells_[nInterpolate++] = coarseCelli;
}
}
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::oversetGAMGInterface::~oversetGAMGInterface()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::labelField> Foam::oversetGAMGInterface::internalFieldTransfer
(
const Pstream::commsTypes,
const labelUList& restrictMap
) const
{
// Store the restrictMap. This routine gets used for
// - GAMGAgglomeration : this is the use we want to intercept.
// - GAMGProcAgglomeration : to find out the cell number on the other side
// - MGridGenGAMGAgglomeration: same
if (master())
{
restrictMap_ = restrictMap;
}
return tmp<labelField>::New(restrictMap, faceCells());
}
// ************************************************************************* //

202
src/overset/oversetPolyPatch/oversetGAMGInterface.H
View File

@ -1,202 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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/>.
Class
Foam::oversetGAMGInterface
Description
GAMG agglomerated overset interface.
SourceFiles
oversetGAMGInterface.C
\*---------------------------------------------------------------------------*/
#ifndef oversetGAMGInterface_H
#define oversetGAMGInterface_H
#include "GAMGInterface.H"
#include "oversetLduInterface.H"
#include "mapDistribute.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class oversetGAMGInterface Declaration
\*---------------------------------------------------------------------------*/
class oversetGAMGInterface
:
public GAMGInterface,
virtual public oversetLduInterface
{
// Private data
//- Reference for the oversetLduInterface from which this is
// agglomerated
const oversetLduInterface& fineOversetInterface_;
//- Temporary copy of the fine level restrict map. Cleared upon
// calculating stencils below
mutable labelList restrictMap_;
labelListList stencil_;
autoPtr<mapDistribute> mapPtr_;
List<scalarList> cellInterpolationWeights_;
scalarField normalisation_;
labelList interpolationCells_;
scalarList cellInterpolationWeight_;
// Private Member Functions
//- No copy construct
oversetGAMGInterface(const oversetGAMGInterface&) = delete;
//- No copy assignment
void operator=(const oversetGAMGInterface&) = delete;
public:
//- Runtime type information
TypeName("overset");
// Constructors
//- Construct from fine level interface,
// local and neighbour restrict addressing
oversetGAMGInterface
(
const label index,
const lduInterfacePtrsList& coarseInterfaces,
const lduInterface& fineInterface,
const labelField& localRestrictAddressing,
const labelField& neighbourRestrictAddressing,
const label fineLevelIndex,
const label coarseComm
);
//- Destructor
virtual ~oversetGAMGInterface();
// Member Functions
// Interface transfer functions
//- Transfer and return internal field adjacent to the interface
virtual tmp<labelField> internalFieldTransfer
(
const Pstream::commsTypes commsType,
const labelUList& iF
) const;
//- Overset interface functions
//- Name of lduInterface
virtual const word& name() const
{
return fineOversetInterface_.name();
}
//- Am I the master interface
virtual bool master() const
{
return fineOversetInterface_.master();
}
//- GAMG restriction (fine-to-coarse)
virtual const labelList& restrictMap() const
{
return restrictMap_;
}
//- Donor stencil
virtual const labelListList& stencil() const
{
return stencil_;
}
//- Map for obtaining data in stencil order
virtual const mapDistribute& cellInterpolationMap() const
{
return *mapPtr_;
}
//- Weights in stencil order
virtual const List<scalarList>& cellInterpolationWeights() const
{
return cellInterpolationWeights_;
}
//- Normalisation ot matrix; for explicit contributions
virtual const scalarField& normalisation() const
{
return normalisation_;
}
//- Acceptor cells
virtual const labelList& interpolationCells() const
{
return interpolationCells_;
}
//- Underrelaxation for acceptor cells
virtual const scalarList& cellInterpolationWeight() const
{
return cellInterpolationWeight_;
}
// I/O
//- Write to stream
virtual void write(Ostream&) const
{
//TBD.
NotImplemented;
}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

152
src/overset/oversetPolyPatch/oversetGAMGInterfaceField.C
View File

@ -1,152 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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 "oversetGAMGInterfaceField.H"
#include "addToRunTimeSelectionTable.H"
#include "lduMatrix.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(oversetGAMGInterfaceField, 0);
addToRunTimeSelectionTable
(
GAMGInterfaceField,
oversetGAMGInterfaceField,
lduInterfaceField
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::oversetGAMGInterfaceField::oversetGAMGInterfaceField
(
const GAMGInterface& GAMGCp,
const lduInterfaceField& fineInterface
)
:
GAMGInterfaceField(GAMGCp, fineInterface),
oversetInterface_(refCast<const oversetGAMGInterface>(GAMGCp))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::oversetGAMGInterfaceField::~oversetGAMGInterfaceField()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::oversetGAMGInterfaceField::updateInterfaceMatrix
(
scalarField& result,
const bool add,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const
{
Pout<< "oversetGAMGInterfaceField::updateInterfaceMatrix: at:"
// << oversetInterface_.name()
<< " nCells:" << result.size() << endl;
//
// // Add remote values
// if (oversetInterface_.master())
// {
// const labelListList& stencil = oversetInterface_.stencil();
//
// if (stencil.size() != psiInternal.size())
// {
// FatalErrorInFunction << "psiInternal:" << psiInternal.size()
// << " stencil:" << stencil.size() << exit(FatalError);
// }
//
// const mapDistribute& map = oversetInterface_.cellInterpolationMap();
// const List<scalarList>& wghts =
// oversetInterface_.cellInterpolationWeights();
// const labelList& cellIDs = oversetInterface_.interpolationCells();
// const scalarList& factor = oversetInterface_.cellInterpolationWeight();
// const scalarField& normalisation = oversetInterface_.normalisation();
//
// scalarField work(psiInternal);
// map.mapDistributeBase::distribute(work, UPstream::msgType()+1);
//
// forAll(cellIDs, i)
// {
// label celli = cellIDs[i];
//
// const scalarList& w = wghts[celli];
// const labelList& nbrs = stencil[celli];
// const scalar f = factor[celli];
//
// bool hasRemote = false;
// forAll(nbrs, nbrI)
// {
// label slotI = nbrs[nbrI];
// if (slotI >= psiInternal.size())
// {
// hasRemote = true;
// break;
// }
// }
//
// if (hasRemote)
// {
// //Pout<< "oversetGAMGInterfaceField : Interpolating " << celli
// // << " from remote values (if any):" << endl;
// scalar s(0.0);
// forAll(nbrs, nbrI)
// {
// label slotI = nbrs[nbrI];
// if (slotI >= psiInternal.size())
// {
// //Pout<< " remote value " << work[slotI]
// // << " from slot " << slotI << " with w:" << w[nbrI]
// // << endl;
// s += w[nbrI]*work[slotI];
// }
// }
// //Pout<< "oversetGAMGInterfaceField : Interpolated value:"
// // << s << endl;
// //scalar oldPsi = result[celli];
// if (add)
// {
// s = -1.0*s;
// }
//
// result[celli] += normalisation[celli]*f*s;
// //Pout<< "oversetGAMGInterfaceField : result was:" << oldPsi
// // << " now:" << result[celli] << endl;
// }
// }
// }
}
// ************************************************************************* //

128
src/overset/oversetPolyPatch/oversetGAMGInterfaceField.H
View File

@ -1,128 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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/>.
Class
Foam::oversetGAMGInterfaceField
Description
GAMG agglomerated processor interface field.
SourceFiles
processorGAMGInterfaceField.C
\*---------------------------------------------------------------------------*/
#ifndef oversetGAMGInterfaceField_H
#define oversetGAMGInterfaceField_H
#include "GAMGInterfaceField.H"
#include "oversetGAMGInterface.H"
#include "processorLduInterfaceField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class oversetGAMGInterfaceField Declaration
\*---------------------------------------------------------------------------*/
class oversetGAMGInterfaceField
:
public GAMGInterfaceField
{
protected:
// Protected data
//- Local reference cast into the interface
const oversetGAMGInterface& oversetInterface_;
private:
// Private Member Functions
//- No copy construct
oversetGAMGInterfaceField(const oversetGAMGInterfaceField&) = delete;
//- No copy assignment
void operator=(const oversetGAMGInterfaceField&) = delete;
public:
//- Runtime type information
TypeName("overset");
// Constructors
//- Construct from GAMG interface and fine level interface field
oversetGAMGInterfaceField
(
const GAMGInterface& GAMGCp,
const lduInterfaceField& fineInterface
);
//- Destructor
virtual ~oversetGAMGInterfaceField();
// Member Functions
// Access
//- Return size
label size() const
{
return oversetInterface_.size();
}
// Interface matrix update
//- Update result field based on interface functionality
virtual void updateInterfaceMatrix
(
scalarField& result,
const bool add,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

42
src/overset/oversetPolyPatch/oversetLduInterface.C
View File

@ -1,42 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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 "oversetLduInterface.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(oversetLduInterface, 0);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::oversetLduInterface::~oversetLduInterface()
{}
// ************************************************************************* //

111
src/overset/oversetPolyPatch/oversetLduInterface.H
View File

@ -1,111 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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/>.
Class
Foam::oversetLduInterface
Description
An abstract base class for overset coupled interfaces
SourceFiles
oversetLduInterface.C
\*---------------------------------------------------------------------------*/
#ifndef oversetLduInterface_H
#define oversetLduInterface_H
#include "mapDistribute.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class oversetLduInterface Declaration
\*---------------------------------------------------------------------------*/
class oversetLduInterface
{
public:
//- Runtime type information
TypeName("oversetLduInterface");
// Constructors
//- Construct null
oversetLduInterface()
{}
//- Destructor
virtual ~oversetLduInterface();
// Member Functions
// Access
//- Name of interface (for debugging)
virtual const word& name() const = 0;
//- Am I the master interface
virtual bool master() const = 0;
//- GAMG restriction (fine-to-coarse)
virtual const labelList& restrictMap() const = 0;
//- Donor stencil
virtual const labelListList& stencil() const = 0;
//- Map for obtaining data in stencil order
virtual const mapDistribute& cellInterpolationMap() const = 0;
//- Weights in stencil order
virtual const List<scalarList>&
cellInterpolationWeights() const = 0;
//- Normalisation of matrix; for explicit contributions
virtual const scalarField& normalisation() const = 0;
//- Acceptor cells
virtual const labelList& interpolationCells() const = 0;
//- Underrelaxation for acceptor cells
virtual const scalarList& cellInterpolationWeight() const = 0;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

274
src/overset/oversetPolyPatch/semiImplicitOversetFvPatchField.C
View File

@ -1,274 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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 "volFields.H"
#include "cellCellStencilObject.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::semiImplicitOversetFvPatchField<Type>::semiImplicitOversetFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
:
//LduInterfaceField<Type>(refCast<const oversetFvPatch>(p)),
zeroGradientFvPatchField<Type>(p, iF),
oversetPatch_(refCast<const oversetFvPatch>(p))
{}
template<class Type>
Foam::semiImplicitOversetFvPatchField<Type>::semiImplicitOversetFvPatchField
(
const semiImplicitOversetFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
//LduInterfaceField<Type>(refCast<const oversetFvPatch>(p)),
zeroGradientFvPatchField<Type>(ptf, p, iF, mapper),
oversetPatch_(refCast<const oversetFvPatch>(p))
{
if (!isA<oversetFvPatch>(this->patch()))
{
FatalErrorInFunction
<< " patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->internalField().name()
<< " in file " << this->internalField().objectPath()
<< exit(FatalIOError);
}
}
template<class Type>
Foam::semiImplicitOversetFvPatchField<Type>::semiImplicitOversetFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
//LduInterfaceField<Type>(refCast<const oversetFvPatch>(p)),
zeroGradientFvPatchField<Type>(p, iF, dict),
oversetPatch_(refCast<const oversetFvPatch>(p))
{
if (!isA<oversetFvPatch>(p))
{
FatalIOErrorInFunction(dict)
<< " patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->internalField().name()
<< " in file " << this->internalField().objectPath()
<< exit(FatalIOError);
}
if (!dict.found("value") && this->coupled())
{
this->evaluate(Pstream::commsTypes::blocking);
}
}
template<class Type>
Foam::semiImplicitOversetFvPatchField<Type>::semiImplicitOversetFvPatchField
(
const semiImplicitOversetFvPatchField<Type>& ptf
)
:
//LduInterfaceField<Type>(ptf.oversetPatch_),
zeroGradientFvPatchField<Type>(ptf),
oversetPatch_(ptf.oversetPatch_)
{}
template<class Type>
Foam::semiImplicitOversetFvPatchField<Type>::semiImplicitOversetFvPatchField
(
const semiImplicitOversetFvPatchField<Type>& ptf,
const DimensionedField<Type, volMesh>& iF
)
:
//LduInterfaceField<Type>(ptf.oversetPatch_),
zeroGradientFvPatchField<Type>(ptf, iF),
oversetPatch_(ptf.oversetPatch_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::semiImplicitOversetFvPatchField<Type>::evaluate
(
const Pstream::commsTypes
)
{
if (debug)
{
Pout<< FUNCTION_NAME << " field " << this->internalField().name()
<< " patch " << this->patch().name() << endl;
}
if (!this->updated())
{
this->updateCoeffs();
}
zeroGradientFvPatchField<Type>::evaluate();
}
template<class Type>
void Foam::semiImplicitOversetFvPatchField<Type>::initEvaluate
(
const Pstream::commsTypes commsType
)
{
if (debug)
{
Pout<< FUNCTION_NAME << " field " << this->internalField().name()
<< " patch " << this->patch().name() << endl;
}
if (this->oversetPatch().master())
{
// Trigger interpolation
const fvMesh& mesh = this->internalField().mesh();
//const dictionary& fvSchemes = mesh.schemesDict();
const word& fldName = this->internalField().name();
if (&mesh.lduAddr() != &mesh.fvMesh::lduAddr())
{
// Running extended addressing so called from within fvMatrix::solve
FatalErrorInFunction
<< "Running extended addressing is not allowed when solving "
<< fldName
<< " Please choose a dynamicFvMesh without matrix adaptation"
<< exit(FatalError);
}
else
{
if (debug)
{
Info<< "Interpolating field " << fldName << endl;
}
// Interpolate without bc update (since would trigger infinite
// recursion back to
// semiImplicitOversetFvPatchField<Type>::evaluate)
// The only problem is bcs that use the new cell values
// (e.g. zeroGradient, processor). These need to appear -after-
// the 'overset' bc.
mesh.interpolate
(
const_cast<Field<Type>&>
(
this->primitiveField()
)
);
}
}
}
//template<class Type>
//void Foam::semiImplicitOversetFvPatchField<Type>::updateInterfaceMatrix
//(
// scalarField& result,
// const bool add,
// const scalarField& psiInternal,
// const scalarField& coeffs,
// const direction cmpt,
// const Pstream::commsTypes
//) const
//{
// if (debug)
// {
// Pout<< FUNCTION_NAME << " field " << this->internalField().name()
// << " patch " << this->patch().name() << endl;
// }
//
// const oversetFvPatch& ovp = this->oversetPatch();
//
// // Set all interpolated cells
// if (ovp.master())
// {
// const cellCellStencilObject& overlap = Stencil::New(*this);
// const labelListList& cellStencil = overlap.cellStencil();
//
// if (cellStencil.size() != psiInternal.size())
// {
// FatalErrorInFunction << "psiInternal:" << psiInternal.size()
// << " stencil:" << cellStencil.size() << exit(FatalError);
// }
//
// const mapDistribute& map = overlap.cellInterpolationMap();
// const List<scalarList>& wghts = overlap.cellInterpolationWeights();
// const labelList& cellIDs = overlap.interpolationCells();
// //const scalarList& factor = overlap.cellInterpolationWeight();
//
// // Since we're inside initEvaluate/evaluate there might be processor
// // comms underway. Change the tag we use.
// scalarField work(psiInternal);
// map.mapDistributeBase::distribute(work, UPstream::msgType()+1);
//
// forAll(cellIDs, i)
// {
// label celli = cellIDs[i];
//
// const scalarList& w = wghts[celli];
// const labelList& nbrs = cellStencil[celli];
//
// //scalar f = factor[celli];
//
// scalar s(0.0);
// forAll(nbrs, nbrI)
// {
// s += w[nbrI]*work[nbrs[nbrI]];
// }
//
// //Pout<< "cell:" << celli << " interpolated value:" << s << endl;
// result[celli] = s; //(1.0-f)*result[celli] + f*s;
// }
// }
//}
template<class Type>
void Foam::semiImplicitOversetFvPatchField<Type>::write(Ostream& os) const
{
zeroGradientFvPatchField<Type>::write(os);
// Make sure to write the value for ease of postprocessing.
this->writeEntry("value", os);
}
// ************************************************************************* //

207
src/overset/oversetPolyPatch/semiImplicitOversetFvPatchField.H
View File

@ -1,207 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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/>.
Class
Foam::semiImplicitOversetFvPatchField
Group
grpCoupledBoundaryConditions
Description
Boundary condition for use on overset patches. Implements update of
interpolated cells inside the linear solvers.
SeeAlso
SourceFiles
semiImplicitOversetFvPatchField.C
\*---------------------------------------------------------------------------*/
#ifndef semiImplicitOversetFvPatchField_H
#define semiImplicitOversetFvPatchField_H
#include "oversetFvPatch.H"
#include "zeroGradientFvPatchField.H"
#include "LduInterfaceField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class semiImplicitOversetFvPatchField Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class semiImplicitOversetFvPatchField
:
//public LduInterfaceField<Type>,
public zeroGradientFvPatchField<Type>
{
protected:
// Protected data
//- Local reference cast into the overset patch
const oversetFvPatch& oversetPatch_;
//- Master patch ID
mutable label masterPatchID_;
public:
//- Runtime type information
TypeName("semiImplicitOverset");
// Constructors
//- Construct from patch and internal field
semiImplicitOversetFvPatchField
(
const fvPatch&,
const DimensionedField<Type, volMesh>&
);
//- Construct from patch, internal field and dictionary
semiImplicitOversetFvPatchField
(
const fvPatch&,
const DimensionedField<Type, volMesh>&,
const dictionary&
);
//- Construct by mapping given semiImplicitOversetFvPatchField onto a
// new patch
semiImplicitOversetFvPatchField
(
const semiImplicitOversetFvPatchField<Type>&,
const fvPatch&,
const DimensionedField<Type, volMesh>&,
const fvPatchFieldMapper&
);
//- Construct as copy
semiImplicitOversetFvPatchField
(
const semiImplicitOversetFvPatchField<Type>&
);
//- Construct and return a clone
virtual tmp<fvPatchField<Type>> clone() const
{
return tmp<fvPatchField<Type>>
(
new semiImplicitOversetFvPatchField<Type>(*this)
);
}
//- Construct as copy setting internal field reference
semiImplicitOversetFvPatchField
(
const semiImplicitOversetFvPatchField<Type>&,
const DimensionedField<Type, volMesh>&
);
//- Construct and return a clone setting internal field reference
virtual tmp<fvPatchField<Type>> clone
(
const DimensionedField<Type, volMesh>& iF
) const
{
return tmp<fvPatchField<Type>>
(
new semiImplicitOversetFvPatchField<Type>(*this, iF)
);
}
// Member functions
// Access
//- Return local reference cast into the cyclic AMI patch
const oversetFvPatch& oversetPatch() const
{
return oversetPatch_;
}
// Evaluation functions
//- Evaluate the patch field
virtual void evaluate(const Pstream::commsTypes commsType);
//- Initialise the evaluation of the patch field
virtual void initEvaluate(const Pstream::commsTypes commsType);
// //- Update result field based on interface functionality
// virtual void updateInterfaceMatrix
// (
// scalarField& result,
// const bool add,
// const scalarField& psiInternal,
// const scalarField& coeffs,
// const direction cmpt,
// const Pstream::commsTypes commsType
// ) const;
//
// //- Update result field based on interface functionality
// virtual void updateInterfaceMatrix
// (
// Field<Type>&,
// const bool add,
// const Field<Type>&,
// const scalarField&,
// const Pstream::commsTypes commsType
// ) const
// {
// NotImplemented;
// }
// I-O
//- Write
virtual void write(Ostream& os) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "semiImplicitOversetFvPatchField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

43
src/overset/oversetPolyPatch/semiImplicitOversetFvPatchFields.C
View File

@ -1,43 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016-2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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 "semiImplicitOversetFvPatchFields.H"
#include "addToRunTimeSelectionTable.H"
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
makePatchFields(semiImplicitOverset);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

49
src/overset/oversetPolyPatch/semiImplicitOversetFvPatchFields.H
View File

@ -1,49 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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/>.
\*---------------------------------------------------------------------------*/
#ifndef semiImplicitOversetFvPatchFields_H
#define semiImplicitOversetFvPatchFields_H
#include "semiImplicitOversetFvPatchField.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makePatchTypeFieldTypedefs(semiImplicitOverset);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

124
src/overset/oversetPolyPatch/semiImplicitOversetGAMGInterfaceField.C
View File

@ -1,124 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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 "semiImplicitOversetGAMGInterfaceField.H"
#include "addToRunTimeSelectionTable.H"
#include "lduMatrix.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(semiImplicitOversetGAMGInterfaceField, 0);
addToRunTimeSelectionTable
(
GAMGInterfaceField,
semiImplicitOversetGAMGInterfaceField,
lduInterfaceField
);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::semiImplicitOversetGAMGInterfaceField::
semiImplicitOversetGAMGInterfaceField
(
const GAMGInterface& GAMGCp,
const lduInterfaceField& fineInterface
)
:
oversetGAMGInterfaceField(GAMGCp, fineInterface)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::semiImplicitOversetGAMGInterfaceField::
~semiImplicitOversetGAMGInterfaceField()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::semiImplicitOversetGAMGInterfaceField::updateInterfaceMatrix
(
scalarField& result,
const bool add,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const
{
DebugVar("Here");
// Add remote values
if (oversetInterface_.master())
{
const labelListList& stencil = oversetInterface_.stencil();
if (stencil.size() != psiInternal.size())
{
FatalErrorInFunction << "psiInternal:" << psiInternal.size()
<< " stencil:" << stencil.size() << exit(FatalError);
}
const mapDistribute& map = oversetInterface_.cellInterpolationMap();
const List<scalarList>& wghts =
oversetInterface_.cellInterpolationWeights();
const labelList& cellIDs = oversetInterface_.interpolationCells();
const scalarList& factor = oversetInterface_.cellInterpolationWeight();
const scalarField& normalisation = oversetInterface_.normalisation();
scalarField work(psiInternal);
map.mapDistributeBase::distribute(work, UPstream::msgType()+1);
forAll(cellIDs, i)
{
label celli = cellIDs[i];
const scalarList& w = wghts[celli];
const labelList& nbrs = stencil[celli];
const scalar f = factor[celli];
scalar s(0.0);
forAll(nbrs, nbrI)
{
label slotI = nbrs[nbrI];
s += w[nbrI]*work[slotI];
}
if (add)
{
s = -1.0*s;
}
result[celli] += normalisation[celli]*f*s;
}
}
}
// ************************************************************************* //

108
src/overset/oversetPolyPatch/semiImplicitOversetGAMGInterfaceField.H
View File

@ -1,108 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 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/>.
Class
Foam::semiImplicitOversetGAMGInterfaceField
Description
GAMG agglomerated processor interface field.
SourceFiles
processorGAMGInterfaceField.C
\*---------------------------------------------------------------------------*/
#ifndef semiImplicitOversetGAMGInterfaceField_H
#define semiImplicitOversetGAMGInterfaceField_H
#include "oversetGAMGInterfaceField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class semiImplicitOversetGAMGInterfaceField Declaration
\*---------------------------------------------------------------------------*/
class semiImplicitOversetGAMGInterfaceField
:
public oversetGAMGInterfaceField
{
// Private Member Functions
//- No copy construct
semiImplicitOversetGAMGInterfaceField
(
const semiImplicitOversetGAMGInterfaceField&
) = delete;
//- No copy assignment
void operator=(const semiImplicitOversetGAMGInterfaceField&) = delete;
public:
//- Runtime type information
TypeName("semiImplicitOverset");
// Constructors
//- Construct from GAMG interface and fine level interface field
semiImplicitOversetGAMGInterfaceField
(
const GAMGInterface& GAMGCp,
const lduInterfaceField& fineInterface
);
//- Destructor
virtual ~semiImplicitOversetGAMGInterfaceField();
// Member Functions
//- Update result field based on interface functionality
virtual void updateInterfaceMatrix
(
scalarField& result,
const bool add,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //