coupledFreestreamFvPatchField.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  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 "coupledFreestreamFvPatchField.H"
//#include "volFields.H"
#include "mappedPatchBase.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
    // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
    template<class Type>
        coupledFreestreamFvPatchField<Type>::coupledFreestreamFvPatchField
        (
         const fvPatch& p,
         const DimensionedField<Type, volMesh>& iF
        )
        :
            freestreamFvPatchField<Type>(p, iF)
    {}
 
 
    template<class Type>
        coupledFreestreamFvPatchField<Type>::coupledFreestreamFvPatchField
        (
         const coupledFreestreamFvPatchField<Type>& ptf,
         const fvPatch& p,
         const DimensionedField<Type, volMesh>& iF,
         const fvPatchFieldMapper& mapper
        )
        :
            freestreamFvPatchField<Type>(ptf, p, iF, mapper)
    {}
 
 
    template<class Type>
        coupledFreestreamFvPatchField<Type>::coupledFreestreamFvPatchField
        (
         const fvPatch& p,
         const DimensionedField<Type, volMesh>& iF,
         const dictionary& dict
        )
        :
            freestreamFvPatchField<Type>(p, iF)
    {
        this->phiName_ = dict.lookupOrDefault<word>("phi","phi");
 
        freestreamValue() = Field<Type>("freestreamValue", dict, p.size());
 
        if (dict.found("value"))
        {
            fvPatchField<Type>::operator=
                (
                 Field<Type>("value", dict, p.size())
                );
        }
        else
        {
            fvPatchField<Type>::operator=(freestreamValue());
        }
    }
 
 
    template<class Type>
        coupledFreestreamFvPatchField<Type>::coupledFreestreamFvPatchField
        (
         const coupledFreestreamFvPatchField<Type>& ptf
        )
        :
            freestreamFvPatchField<Type>(ptf)
    {}
 
 
    template<class Type>
        coupledFreestreamFvPatchField<Type>::coupledFreestreamFvPatchField
        (
         const coupledFreestreamFvPatchField<Type>& ptf,
         const DimensionedField<Type, volMesh>& iF
        )
        :
            freestreamFvPatchField<Type>(ptf, iF)
    {}
 
 
    // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
    template<class Type>
        void Foam::coupledFreestreamFvPatchField<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];
//this->patch() = nbrPatch;
         //   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;
            }
 
 
            const Field<scalar>& phip =
                this->patch().template lookupPatchField<GeometricField<scalar, fvPatchField, volMesh>, scalar>("phi");
            //<surfaceScalarField, scalar>
            //           (
            //               "phi" //不适用phiName_这个变量了，就永远固定是phi这个字符了，通常也不会有什么更改。
            //           );
 
            this->valueFraction() = 1.0 - pos(phip);
 
            mixedFvPatchField<Type>::updateCoeffs();
 
            //     //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();
//
//
//
//
//
//
//
//
//
//
//            const Field<scalar>& phip =
//                this->patch().template lookupPatchField<surfaceScalarField, scalar>
//                (
//                 "phi" //不适用phiName_这个变量了，就永远固定是phi这个字符了，通常也不会有什么更改。
//                );
//
//            this->valueFraction() = 1.0 - pos(phip);
//
//            mixedFvPatchField<Type>::updateCoeffs();
        }
 
 
    template<class Type>
        void coupledFreestreamFvPatchField<Type>::write(Ostream& os) const
        {
            fvPatchField<Type>::write(os);
            if (this->phiName_ != "phi")
            {
                os.writeKeyword("phi")
                    << this->phiName_ << token::END_STATEMENT << nl;
            }
            freestreamValue().writeEntry("freestreamValue", os);
            this->writeEntry("value", os);
        }
 
 
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// ************************************************************************* //