coupledFixedValueFvPatchField.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  \\    /   O peration     |
  \\  /    A nd           | Copyright (C) 2011-2015 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 "coupledFixedValueFvPatchField.H"
#include "volFields.H"
#include "mappedPatchBase.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
    // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
    template<class Type>
        coupledFixedValueFvPatchField<Type>::coupledFixedValueFvPatchField
        (
         const fvPatch& p,
         const DimensionedField<Type, volMesh>& iF
        )
        :
            fvPatchField<Type>(p, iF)
    {}
 
 
    template<class Type>
        coupledFixedValueFvPatchField<Type>::coupledFixedValueFvPatchField
        (
         const fvPatch& p,
         const DimensionedField<Type, volMesh>& iF,
         const dictionary& dict
        )
        :
            fvPatchField<Type>(p, iF, dict, true),
            neighbourName_(dict.lookupOrDefault<word>("fieldName","U"))
    {}
 
 
    template<class Type>
        coupledFixedValueFvPatchField<Type>::coupledFixedValueFvPatchField
        (
         const coupledFixedValueFvPatchField<Type>& ptf,
         const fvPatch& p,
         const DimensionedField<Type, volMesh>& iF,
         const fvPatchFieldMapper& mapper
        )
        :
            fvPatchField<Type>(ptf, p, iF, mapper)
    {
        if (notNull(iF) && mapper.hasUnmapped())
        {
            WarningInFunction
                << "On field " << iF.name() << " patch " << p.name()
                << " patchField " << this->type()
                << " : mapper does not map all values." << nl
                << "    To avoid this warning fully specify the mapping in derived"
                << " patch fields." << endl;
        }
    }
 
 
    template<class Type>
        coupledFixedValueFvPatchField<Type>::coupledFixedValueFvPatchField
        (
         const coupledFixedValueFvPatchField<Type>& ptf
        )
        :
            fvPatchField<Type>(ptf)
    {}
 
 
    template<class Type>
        coupledFixedValueFvPatchField<Type>::coupledFixedValueFvPatchField
        (
         const coupledFixedValueFvPatchField<Type>& ptf,
         const DimensionedField<Type, volMesh>& iF
        )
        :
            fvPatchField<Type>(ptf, iF)
    {}
 
 
    // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
    template<class Type>
        tmp<Field<Type> > coupledFixedValueFvPatchField<Type>::valueInternalCoeffs
        (
         const tmp<scalarField>&
        ) const
        {
            return tmp<Field<Type> >
                (
                 new Field<Type>(this->size(), pTraits<Type>::zero)
                );
        }
 
 
    template<class Type>
        tmp<Field<Type> > coupledFixedValueFvPatchField<Type>::valueBoundaryCoeffs
        (
         const tmp<scalarField>&
        ) const
        {
            return *this;
        }
 
 
    template<class Type>
        tmp<Field<Type> > coupledFixedValueFvPatchField<Type>::gradientInternalCoeffs() const
        {
            return -pTraits<Type>::one*this->patch().deltaCoeffs();
        }
 
 
    template<class Type>
        tmp<Field<Type> > coupledFixedValueFvPatchField<Type>::gradientBoundaryCoeffs() const
        {
            return this->patch().deltaCoeffs()*(*this);
        }
 
    template<class Type>
        void coupledFixedValueFvPatchField<Type>::updateCoeffs()
        {
            if (this->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>(this->patch().patch());
            const polyMesh& nbrMesh = mpp.sampleMesh();
            const label samplePatchI = mpp.samplePolyPatch().index();
 
            //define the nbrPatch ,just a patch, not include the field
            const fvPatch& nbrPatch =
                refCast<const fvMesh>(nbrMesh).boundary()[samplePatchI];
 
            Field<Type>& Up = *this;
            //    vectorField Uc(this->patchInternalField());
            //   vectorField& Up = *this;
            if (debug_)
            {
                Info << endl<< "this patch name is : =====" << endl;
                Info << this->neighbourName_ << endl<< endl;
 
//                Info << endl<< "the parents patch(*this) is ：====" << endl;
//                Info << Up << endl<< endl;
//
//                Info << endl<< "the neighbourMesh is : =" << endl;
//                Info << nbrMesh.boundaryMesh() << endl << endl;
//                Info << endl<< "the neighbourMesh face() is : =" << endl;
//                Info << nbrMesh.faces() << endl << endl;
//                Info << endl<< "the neighbourMesh point() is : =" << endl;
//                Info << nbrMesh.points() << endl << endl;
//                Info << endl<< "the neighbourMesh typeName is : =" << endl;
//                Info << nbrMesh.typeName << endl << endl;
//                Info << endl<< "the neighbourMesh faceOwner is : =" << endl;
//                Info << nbrMesh.faceOwner() << endl << endl;
//                Info << endl<< "the neighbourMesh faceNeighbour() is : =" << endl;
//                Info << nbrMesh.faceNeighbour() << endl << endl;
 
 
                Info << endl<< "the neighbourPatch Index is =======" << endl;
                Info << samplePatchI << endl << endl;
 
//                Info << "this parearnt patch.patch() is =========" << endl;
//                Info << this->patch().patch() << endl << endl;
 
                Info <<"neighbourPatch Name is : " <<  nbrPatch.name()<<endl;
//                Info <<"neighbourPatch patch() is : ============ " << endl <<  nbrPatch.patch()<<endl;
//                Info <<"neighbourPatch start() is : " <<  nbrPatch.start()<<endl;
//                Info <<"neighbourPatch size() is : " <<  nbrPatch.size()<<endl;
//                Info <<"neighbourPatch type() is : " <<  nbrPatch.type()<<endl;
                Info <<"neighbourPatch TypeName is : " <<  nbrPatch.typeName_()<<endl;
            }
            //Info <<"neighbourPatch field is : " <<  nbrPatch.patchField<GeometricField<Type, fvPatchField, volMesh>,Type>()<<endl;
            //define the nbrField
            const coupledFixedValueFvPatchField&
                nbrField = refCast
                <const coupledFixedValueFvPatchField>
                (
                 nbrPatch.lookupPatchField<GeometricField<Type, fvPatchField, volMesh>, Type>(this->neighbourName_)
                );
            if (debug_)
            {
//                Info << "==== neighbourPatch Field from lookupPatchField: " << endl << nbrField << endl;
                Info << "==== neighbourPatch Field typeName_ is : " << nbrField.fvPatchField<Type>::typeName_() << endl;
                Info << "==== neighbourPatch Field fixesvalue is : " << nbrField.fixesValue() << endl;
                Info << "==== neighbourPatch Field internalField() is : " << nbrField.internalField() << endl;
 //               Info << "==== neighbourPatch Field grandientBoundaryCoeffs is : " << nbrField.gradientBoundaryCoeffs() << endl;
//                Info << "==== neighbourPatch Field grandientInternalCoeffs is : " << nbrField.gradientInternalCoeffs() << endl;
 
            }
            //  Field<Type> Utmpi = Field<Type>(this->size(), pTraits<Type>::zero));
            Field<Type> Utmp =Field<Type>(this->size(), pTraits<Type>::one);
            Utmp=nbrPatch.lookupPatchField<GeometricField<Type, fvPatchField, volMesh>, Type>(this->neighbourName_);
 
            if (debug_)
            {
                Info << "patchField Utmp is ========" << endl;
                Info <<  Utmp    << endl;
            }
 
            mpp.distribute(Utmp);
 
            if (debug_)
            {
//                Info<< "mpp mode() is " << endl;
//                Info << mpp.mode() <<endl;
//                Info<< "mpp sampleRegion() is " << endl;
//                Info << mpp.sameRegion() <<endl;
//                Info<< "mpp sampleMesh() is " << endl;
//                Info << mpp.sampleMesh()<<endl;
//                Info<< "mpp typeName_ is " << endl;
//                Info << mpp.typeName_() <<endl;
//                Info<< "mpp typeName is " << endl;
//                Info << mpp.typeName <<endl;
//                Info<< "mpp samplePatch() is " << endl;
//                Info << mpp.samplePatch() <<endl;
            }
            //            Info << "==== neighbourPatch Field patchNeighbourField() is : " << nbrField.patchNeighbourField() << endl;
            //Info << "==== neighbourPatch Field value is : " << nbrField.component << endl;
 
            // Swap to obtain full local values of neighbour internal field
            //   vectorField UcNbr(nbrField.patchInternalField());
            //   mpp.distribute(UcNbr);
 
            // Evaluate the variable field
             Up =Utmp;//nbrPatch.patchInternalField();//nbrPatch.patchField();
            //        Up = nbrField();
            if (debug_)
            {
                Info << endl<< "after get the data from neighbour patch, the parents patch(*this) now is ：====" << endl;
                Info << Up << endl;
                Info << "update the value of Up successfully!" << endl;
                Info << "=============================" << endl;
                Info << "=============================" << endl;
            }
 
            // Restore tag
            UPstream::msgType() = oldTag;
            this->fvPatchField<Type>::updateCoeffs();
            //fvPatchField<type>::updateCoeffs();
        }
 
 
    template<class Type>
        void coupledFixedValueFvPatchField<Type>::evaluate(const Pstream::commsTypes)
        {
            if (!this->updated())
            {
                this->updateCoeffs();
            }
 
            //     Field<Type>::operator=
            //     (
            //         valueFraction_*refValue_
            //       +
            //         (1.0 - valueFraction_)*
            //         (
            //             this->patchInternalField()
            //           + refGrad_/this->patch().deltaCoeffs()
            //         )
            //     );
            fvPatchField<Type>::operator==(this->patchInternalField());
            fvPatchField<Type>::evaluate();
        }
 
 
    template<class Type>
        void coupledFixedValueFvPatchField<Type>::write(Ostream& os) const
        {
            fvPatchField<Type>::write(os);
            this->writeEntry("value", os);
        }
 
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// ************************************************************************* //