multiRegionSimpleFoam.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/>.
 
  Application
  chtMultiRegionSimpleFoam
 
  Group
  grpHeatTransferSolvers
 
  Description
  Steady-state version of MultiRegionSimpleFoam
 
  \*---------------------------------------------------------------------------*/
 
#include "fvCFD.H"
#include "regionProperties.H"
#include "fvOptions.H"
#include "simpleControl.H"
#include "singlePhaseTransportModel.H"
#include "turbulentTransportModel.H"
//#include "turbulentBoundaryCoupledFvPatchScalarField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
int main(int argc, char *argv[])
{
#include "setRootCase.H"
#include "createTime.H"
 
    regionProperties rp(runTime);
 
    //#include "createFluidMeshes.H"
    const wordList fluidNames(rp["fluid"]);
    PtrList<fvMesh> fluidRegions(fluidNames.size());
    Info << "there are " << fluidNames.size() << " regions." << endl<< endl;
    forAll(fluidNames, i)
    {
        Info<< "Create fluid mesh for region " << fluidNames[i]
            << " for time = " << runTime.timeName() << nl << endl;
 
        fluidRegions.set
            (
             i,
             new fvMesh
             (
              IOobject
              (
               fluidNames[i],
               runTime.timeName(),
               runTime,
               IOobject::MUST_READ
              )
             )
            );
    }
    //=======================================
 
    PtrList<simpleControl> simpleFluid(fluidRegions.size());
 
    //#include "createFluidFields.H"
    // Initialise fluid field pointer lists
    PtrList<volVectorField> UFluid(fluidRegions.size());
    PtrList<surfaceScalarField> phiFluid(fluidRegions.size());
    PtrList<incompressible::turbulenceModel> turbulenceFluid(fluidRegions.size());
    PtrList<volScalarField> p_rghFluid(fluidRegions.size());
    PtrList<volScalarField> pFluid(fluidRegions.size());
    PtrList<volScalarField> TFluid(fluidRegions.size());
    PtrList<singlePhaseTransportModel> laminarTransportFluid(fluidRegions.size());
 
    List<scalar> initialMassFluid(fluidRegions.size());
    List<label> pRefCellFluid(fluidRegions.size(), 0);
    List<scalar> pRefValueFluid(fluidRegions.size(), 0.0);
    PtrList<IOMRFZoneList> MRFfluid(fluidRegions.size());
    PtrList<fv::options> fluidFvOptions(fluidRegions.size());
 
 
    // Populate fluid field pointer lists
    forAll(fluidRegions, i)
    {
        Info << "this is region Num：" << i << endl;
        Info<< "*** Reading fluid mesh  properties for region "
            << fluidRegions[i].name() << nl << endl;
 
        Info<< "    Adding to UFluid\n" << endl;
        UFluid.set
            (
             i,
             new volVectorField
             (
              IOobject
              (
               "U",
               runTime.timeName(),
               fluidRegions[i],
               IOobject::MUST_READ,
               IOobject::AUTO_WRITE
              ),
              fluidRegions[i]
             )
            );
 
        Info<< "    Adding to phiFluid\n" << endl;
        phiFluid.set
            (
             i,
             new surfaceScalarField
             (
              IOobject
              (
               "phi",
               runTime.timeName(),
               fluidRegions[i],
               IOobject::READ_IF_PRESENT,
               IOobject::AUTO_WRITE
              ),
              linearInterpolate(UFluid[i])
              & fluidRegions[i].Sf()
             )
            );
 
        Info<< "    Adding to pFluid\n" << endl;
        pFluid.set
            (
             i,
             new volScalarField
             (
              IOobject
              (
               "p",
               runTime.timeName(),
               fluidRegions[i],
               IOobject::MUST_READ,
               IOobject::AUTO_WRITE
              ),
              fluidRegions[i]
             )
            );
 
        Info<< "    Adding to p_rghFluid\n" << endl;
        p_rghFluid.set
            (
             i,
             new volScalarField
             (
              IOobject
              (
               "p_rgh",
               runTime.timeName(),
               fluidRegions[i],
               IOobject::MUST_READ,
               IOobject::AUTO_WRITE
              ),
              fluidRegions[i]
             )
            );
 
        Info<< "    Adding to TFluid\n" << endl;
        TFluid.set
            (
             i,
             new volScalarField
             (
              IOobject
              (
               "T",
               runTime.timeName(),
               fluidRegions[i],
               IOobject::MUST_READ,
               IOobject::AUTO_WRITE
              ),
              fluidRegions[i]
             )
            );
 
        Info<< "    Adding to simpleControl\n" << endl;
        simpleFluid.set
            (
             i,
             new simpleControl
             (
              fluidRegions[i]
             )
            );
 
 
 
 
 
        Info << " set refcell for pRefCell and pRefValue" << endl;
        setRefCell(pFluid[i],simpleFluid[i].dict(),pRefCellFluid[i],pRefValueFluid[i]);
        fluidRegions[i].setFluxRequired(pFluid[i].name());
 
 
        Info<< "    Adding to laminaRransportFluid\n" << endl;
        laminarTransportFluid.set
            (
             i,
             new  singlePhaseTransportModel
             (
              UFluid[i],phiFluid[i]
             )
            );
 
 
        Info<< "    Adding to turbulenceFluid\n" << endl;
        turbulenceFluid.set
            (
             i,
             incompressible::turbulenceModel::New(UFluid[i],phiFluid[i],laminarTransportFluid[i])
            );
 
        //    autoPtr<incompressible::turbulenceModel> turbulence[i]
        //        (
        //         incompressible::turbulenceModel::New(UFluid[i],phiFluid[i],laminarTransportFluid[i])
        //        );
 
 
        // createMRF.h
        Info<< " Adding MRF\n" << endl;
        MRFfluid.set
            (
             i,
             new IOMRFZoneList(fluidRegions[i])
            );
 
        //createFvOptions
        Info<< " Adding fvOptions\n" << endl;
        fluidFvOptions.set
            (
             i,
             new fv::options(fluidRegions[i])
            );
 
 
        Info << "Number" << i << "region is reading." <<endl<<endl;
        Info << turbulenceFluid[i] <<endl<<endl;
        //Info << turbulenceFluid[i].validate() <<endl<<endl;
        turbulenceFluid[i].validate();
        Info << "Number" << i << "region is read." <<endl<<endl;
    }
 
 
 
#include "initContinuityErrs.H"
 
 
    while (runTime.loop())
    {
        Info<< "Time = " << runTime.timeName() << nl << endl;
 
        forAll(fluidRegions, i)
        {
            Info<< "\nSolving for fluid region "
                << fluidRegions[i].name() << endl;
            //
            //
            //
            //
            //        #include "setRegionFluidFields.H"
            //        这里按顺序给新的引用,下面pEqn和UEqn需要使用
 
            const fvMesh& mesh = fluidRegions[i];
            volVectorField& U = UFluid[i];
            volScalarField& p = pFluid[i];
            surfaceScalarField& phi = phiFluid[i];
            incompressible::turbulenceModel& turbulence = turbulenceFluid[i];
            IOMRFZoneList& MRF = MRFfluid[i];
            fv::options& fvOptions = fluidFvOptions[i];
            const label pRefCell = pRefCellFluid[i];
            const scalar pRefValue = pRefValueFluid[i];
 
            simpleControl& simple= simpleFluid[i];
            singlePhaseTransportModel& laminarTransport=laminarTransportFluid[i];
 
            //        #include "readFluidMultiRegionSIMPLEControls.H"
            //              const dictionary& simple = fluidRegions[i].solutionDict().subDict("SIMPLE");
            //             const int nNonOrthCorr =
            //                simple.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
 
 
 
 
 
            //    Info << " set refcell for pRefCell and pRefValue" << endl;
            //    setRefCell(p,simple.dict(),pRefCell,pRefValue,false);
            //    mesh.setFluxRequired(p.name());
 
 
 
 
 
            //  #include "solveFluid.H"
            //  Pressure-velocity SIMPLE corrector
            {
                //                      p_rgh.storePrevIter();
 
#include "UEqn.H"
#include "pEqn.H"   //P方程中使用了非正交修正nNonOrthCorr
                laminarTransport.correct();
                turbulence.correct();
            }
        }
        runTime.write();
 
        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
            << nl << endl;
    }
 
    Info<< "End\n" << endl;
 
    return 0;
}
 
 
// ************************************************************************* //