/*---------------------------------------------------------------------------*\

========= |

\\ / F ield | OpenFOAM: The Open Source CFD Toolbox

\\ / O peration |

\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation

\\/ M anipulation |

-------------------------------------------------------------------------------

License

This file is part of OpenFOAM.

OpenFOAM is free software: you can redistribute it and/or modify it

under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

OpenFOAM is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.

\*---------------------------------------------------------------------------*/

#include "surfaceChargeCoupledFvPatchScalarField.H"

#include "addToRunTimeSelectionTable.H"

#include "fvPatchFieldMapper.H"

#include "volFields.H"

#include "mappedPatchBase.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam

{

// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //

// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //

surfaceChargeCoupledFvPatchScalarField::

surfaceChargeCoupledFvPatchScalarField

(

const fvPatch& p,

const DimensionedField<scalar, volMesh>& iF

)

:

mixedFvPatchScalarField(p, iF),

temperatureCoupledBase(patch(), "undefined", "undefined-K"),

neighbourFieldName_("undefined-neighbourFieldName"),

surfCharge_(0.0),

myEpr_(1.0),

nbrEpr_(1.0)

{

this->refValue() = 0.0;

this->refGrad() = 0.0;

this->valueFraction() = 1.0;

}

surfaceChargeCoupledFvPatchScalarField::

surfaceChargeCoupledFvPatchScalarField

(

const surfaceChargeCoupledFvPatchScalarField& ptf,

const fvPatch& p,

const DimensionedField<scalar, volMesh>& iF,

const fvPatchFieldMapper& mapper

)

:

mixedFvPatchScalarField(ptf, p, iF, mapper),

temperatureCoupledBase(patch(), ptf.KMethod(), ptf.KName()),

neighbourFieldName_(ptf.neighbourFieldName_),

surfCharge_(ptf.surfCharge_),

myEpr_(ptf.myEpr_),

nbrEpr_(ptf.nbrEpr_)

{}

surfaceChargeCoupledFvPatchScalarField::

surfaceChargeCoupledFvPatchScalarField

(

const fvPatch& p,

const DimensionedField<scalar, volMesh>& iF,

const dictionary& dict

)

:

mixedFvPatchScalarField(p, iF),

temperatureCoupledBase(patch(), dict),

neighbourFieldName_(dict.lookup("neighbourFieldName")),

surfCharge_(readScalar(dict.lookup("surfaceCharge"))),

myEpr_(readScalar(dict.lookup("myEpr"))),

nbrEpr_(readScalar(dict.lookup("nbrEpr")))

{

if (!isA<mappedPatchBase>(this->patch().patch()))

{

FatalErrorIn

(

"surfaceChargeCoupledFvPatchScalarField::"

"surfaceChargeCoupledFvPatchScalarField\n"

"(\n"

" const fvPatch& p,\n"

" const DimensionedField<scalar, volMesh>& iF,\n"

" const dictionary& dict\n"

")\n"

) << "\n patch type '" << p.type()

<< "' not type '" << mappedPatchBase::typeName << "'"

<< "\n for patch " << p.name()

<< " of field " << dimensionedInternalField().name()

<< " in file " << dimensionedInternalField().objectPath()

<< exit(FatalError);

}

fvPatchScalarField::operator=(scalarField("value", dict, p.size()));

if (dict.found("refValue"))

{

// Full restart

refValue() = scalarField("refValue", dict, p.size());

refGrad() = scalarField("refGradient", dict, p.size());

valueFraction() = scalarField("valueFraction", dict, p.size());

}

else

{

// Start from user entered data. Assume fixedValue.

refValue() = *this;

refGrad() = 0.0;

valueFraction() = 1.0;

}

}

surfaceChargeCoupledFvPatchScalarField::

surfaceChargeCoupledFvPatchScalarField

(

const surfaceChargeCoupledFvPatchScalarField& wtcsf,

const DimensionedField<scalar, volMesh>& iF

)

:

mixedFvPatchScalarField(wtcsf, iF),

temperatureCoupledBase(patch(), wtcsf.KMethod(), wtcsf.KName()),

neighbourFieldName_(wtcsf.neighbourFieldName_),

surfCharge_(wtcsf.surfCharge_),

myEpr_(wtcsf.myEpr_),

nbrEpr_(wtcsf.nbrEpr_)

{}

// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //

void surfaceChargeCoupledFvPatchScalarField::updateCoeffs()

{

if (updated())

{

return;

}

// Since we're inside initEvaluate/evaluate there might be processor

// comms underway. Change the tag we use.

int oldTag = UPstream::msgType();

UPstream::msgType() = oldTag+1;

// Get the coupling information from the mappedPatchBase

const mappedPatchBase& mpp = refCast<const mappedPatchBase>

(

patch().patch()

);

const polyMesh& nbrMesh = mpp.sampleMesh();

const fvPatch& nbrPatch = refCast<const fvMesh>

(

nbrMesh

).boundary()[mpp.samplePolyPatch().index()];

// Force recalculation of mapping and schedule

const mapDistribute& distMap = mpp.map();

tmp<scalarField> intFld = patchInternalField();

// Calculate the temperature by harmonic averaging

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

const surfaceChargeCoupledFvPatchScalarField& nbrField =

refCast

<

const surfaceChargeCoupledFvPatchScalarField

>

(

nbrPatch.lookupPatchField<volScalarField, scalar>

(

neighbourFieldName_

)

);

// Swap to obtain full local values of neighbour internal field

scalarField nbrIntFld(nbrField.patchInternalField());

distMap.distribute(nbrIntFld);

// Swap to obtain full local values of neighbour K*delta

scalarField nbrKDelta(nbrEpr_*nbrPatch.deltaCoeffs());

distMap.distribute(nbrKDelta);

tmp<scalarField> myKDelta = myEpr_*patch().deltaCoeffs();

// Both sides agree on

// - temperature : (myKDelta*fld + nbrKDelta*nbrFld)/(myKDelta+nbrKDelta)

// - gradient : (temperature-fld)*delta

// We've got a degree of freedom in how to implement this in a mixed bc.

// (what gradient, what fixedValue and mixing coefficient)

// Two reasonable choices:

// 1. specify above temperature on one side (preferentially the high side)

// and above gradient on the other. So this will switch between pure

// fixedvalue and pure fixedgradient

// 2. specify gradient and temperature such that the equations are the

// same on both sides. This leads to the choice of

// - refGradient = zeroGradient

// - refValue = neighbour value

// - mixFraction = nbrKDelta / (nbrKDelta + myKDelta())

// the implementation of the jump condition across a surface with surface

// charges by virtual of mixed boundary condition yields:

// - refGradient = sigma / myK;

// - refValue = neighbour value

// - mixFraction = nbrKDelta / (nbrKDelta + myKDelta())

this->refValue() = nbrIntFld;

this->refGrad() = surfCharge_ / myEpr_;

this->valueFraction() = nbrKDelta / (nbrKDelta + myKDelta());

mixedFvPatchScalarField::updateCoeffs();

if (debug)

{

scalar Q = gSum(myEpr_*patch().magSf()*snGrad());

Info<< patch().boundaryMesh().mesh().name() << ':'

<< patch().name() << ':'

<< this->dimensionedInternalField().name() << " <- "

<< nbrMesh.name() << ':'

<< nbrPatch.name() << ':'

<< this->dimensionedInternalField().name() << " :"

<< " heat[W]:" << Q

<< " walltemperature "

<< " min:" << gMin(*this)

<< " max:" << gMax(*this)

<< " avg:" << gAverage(*this)

<< endl;

}

// Restore tag

UPstream::msgType() = oldTag;

}

void surfaceChargeCoupledFvPatchScalarField::write

(

Ostream& os

) const

{

mixedFvPatchScalarField::write(os);

os.writeKeyword("neighbourFieldName")<< neighbourFieldName_

<< token::END_STATEMENT << nl;

os.writeKeyword("surfaceCharge")<< surfCharge_

<< token::END_STATEMENT << nl;

os.writeKeyword("myEpr")<< myEpr_

<< token::END_STATEMENT << nl;

os.writeKeyword("nbrEpr")<< nbrEpr_

<< token::END_STATEMENT << nl;

temperatureCoupledBase::write(os);

}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

makePatchTypeField

(

fvPatchScalarField,

surfaceChargeCoupledFvPatchScalarField

);

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// ************************************************************************* //