viewFactorModel.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2023-2024 OpenCFD Ltd.
-------------------------------------------------------------------------------
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 "viewFactorModel.H"
#include "raySearchEngine.H"
#include "OBJstream.H"
#include "volFields.H"
#include "IOmapDistribute.H"
#include "scalarListIOList.H"
 
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
namespace Foam
{
namespace VF
{
    defineTypeNameAndDebug(viewFactorModel, 0);
    defineRunTimeSelectionTable(viewFactorModel, mesh);
}
}
 
// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
void Foam::VF::viewFactorModel::writeRays
(
    const fileName& fName,
    const pointField& compactCf,
    const labelListList& visibleFaceFaces
)
{
    OBJstream str(fName);
 
    Pout<< "Writing rays to " << str.name() << endl;
 
    forAll(visibleFaceFaces, facei)
    {
        const labelList& visibleSlots = visibleFaceFaces[facei];
 
        for (const label sloti : visibleSlots)
        {
            str.write(linePointRef(compactCf[facei], compactCf[sloti]));
        }
    }
 
    str.flush();
}
 
 
// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
Foam::VF::viewFactorModel::viewFactorModel
(
    const fvMesh& mesh,
    const dictionary& dict
)
:
    mesh_(mesh),
    searchEnginePtr_(raySearchEngine::New(mesh, dict)),
    writeViewFactors_(dict.get<bool>("writeViewFactors")),
    writeRays_(dict.getOrDefault<bool>("writeRays", false))
{}
 
 
// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
Foam::VF::viewFactorModel::~viewFactorModel()
{}
 
 
// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
void Foam::VF::viewFactorModel::calculate()
{
    const auto& searchEngine = *searchEnginePtr_;
 
    labelListList visibleFaceFaces;
    searchEngine.correct(visibleFaceFaces);
    const auto& map = searchEngine.map();
 
    // Construct data in compact addressing
    // Compact addressing has all local data, followed by remote contributions
 
    pointField compactCf;
    vectorField compactSf;
    List<List<vector>> compactFineSf;
    List<List<point>> compactFineCf;
    DynamicList<List<point>> compactPoints;
    DynamicList<label> compactPatchId;
 
    searchEngine.compactAddressing
    (
        map,
        compactCf,
        compactSf,
        compactFineSf,
        compactFineCf,
        compactPoints,
        compactPatchId
    );
 
    if (writeRays_)
    {
        // Write all rays between visible faces using .OBJ format
 
        writeRays
        (
            mesh_.time().path()/"allVisibleFaces.obj",
            compactCf,
            visibleFaceFaces
        );
    }
 
    (void)mesh_.time().cpuTimeIncrement();
 
    Info<< "\nCalculating view factors" << endl;
 
    scalarListIOList Fij
    (
        IOobject
        (
            "F",
            mesh_.facesInstance(),
            mesh_,
            IOobject::NO_READ
        ),
        calculate
        (
            visibleFaceFaces,
            compactCf,
            compactSf,
            compactFineSf,
            compactFineCf,
            compactPoints,
            compactPatchId
        )
    );
 
    const label totalPatches = mesh_.boundaryMesh().nNonProcessor();
 
    // Matrix sum in j(Fij) for each i
    // Note: if enclosure sum should = 1
    scalarSquareMatrix viewFactorPatch(totalPatches, Zero);
 
    forAll(visibleFaceFaces, startFacei)
    {
        const scalar magAi = mag(compactSf[startFacei]);
 
        const labelList& visibleSlots = visibleFaceFaces[startFacei];
        const label patchi = compactPatchId[startFacei];
 
        forAll(visibleSlots, visSloti)
        {
            const label sloti = visibleSlots[visSloti];
            const label patchj = compactPatchId[sloti];
 
            viewFactorPatch[patchi][patchj] += Fij[startFacei][visSloti]*magAi;
        }
    }
 
    reduce(viewFactorPatch, sumOp<scalarSquareMatrix>());
 
    const scalarList patchArea = searchEngine.patchAreas();
 
 
    if (UPstream::master())
    {
        Info<< "\nPatch view factor contributions:" << nl << endl;
 
        scalar vfSum = 0;
 
        const auto& patchIDs = searchEngine.patchIDs();
        const auto& patches = mesh_.boundaryMesh();
 
        for (const label patchi : patchIDs)
        {
            Info<< "    Patch " <<  patchi << ": " << patches[patchi].name()
                << endl;
 
            scalar vfPatch = 0;
            for (const label patchj: patchIDs)
            {
                scalar vf = viewFactorPatch[patchi][patchj]/patchArea[patchi];
                vfPatch += vf;
 
                Info<< "    F" << patchi << patchj << ": " << vf << endl;
            }
 
            Info<< "    Sum: " << vfPatch << nl << endl;
 
            vfSum += vfPatch;
        }
 
        Info<< "Sum(all patches) = " << vfSum << endl;
    }
 
    // Write view factors matrix in list-list form
    Info<< "\nWriting view factor matrix" << endl;
    Fij.write();
 
    if (writeViewFactors_)
    {
        Info<< "\nWriting view factor field" << endl;
 
        auto tviewFactorField =
            volScalarField::New
            (
                "viewFactorField",
                mesh_,
                dimensionedScalar(dimless, Zero)
            );
 
        auto& viewFactorField = tviewFactorField.ref();
 
        searchEngine.interpolate(viewFactorField, Fij);
 
        viewFactorField.write();
    }
 
 
    // Create globalFaceFaces needed to insert view factors
    // in F to the global matrix Fmatrix
    {
        labelListIOList IOglobalFaceFaces
        (
            IOobject
            (
                "globalFaceFaces",
                mesh_.facesInstance(),
                mesh_,
                IOobject::NO_READ
            ),
            visibleFaceFaces.size()
        );
 
        forAll(IOglobalFaceFaces, facei)
        {
            IOglobalFaceFaces[facei] = renumber
            (
                searchEngine.compactToGlobal(),
                visibleFaceFaces[facei]
            );
        }
 
        IOglobalFaceFaces.write();
    }
 
    // Write parallel map
    {
        IOmapDistribute IOmapDist
        (
            IOobject
            (
                "mapDist",
                mesh_.facesInstance(),
                mesh_,
                IOobject::NO_READ
            ),
            std::move(map)
        );
 
        IOmapDist.write();
    }
}
 
 
// ************************************************************************* //