ccmWriter.H

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) 2016-2025 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/>.
 
Class
    Foam::ccm::writer
 
Description
    Write OpenFOAM meshes and/or results to CCM format
 
    - partial support for interfaces
    - no monitoring (internal) boundaries
    - does not handle Lagrangian data
 
    \par Files
 
    The <tt>constant/boundaryRegion</tt> and <tt>constant/cellTable</tt> files,
    which are described in ccmReader, are used to construct the CCM
    \c ProblemDescription node.
 
    The <tt>constant/remapping</tt> file is an \c IOdictionary that is
    \c READ_IF_PRESENT and can be used to remap certain information.
    eg,
 
    \verbatim
        // map OpenFOAM scalar fields to CCM output fields
        fields
        {
            tracer0
            {
                name    CONC_001;
                Label   "tracer0";
            }
            tracer1
            {
                name    CONC_002;
                Label   "tracer1";
            }
            tracer2
            {
                name    CONC_003;
                Label   "tracer2";
            }
            divPhi
            {
                name    CONC_004;
                Label   "divPhi";
            }
            // an example with units:
            p
            {
                name    P;
                Label   "Pressure";
                units   "Pa";
            }
        }
    \endverbatim
 
Note
    This class is in development
    - any/all of the class names and members may change
 
SourceFiles
    ccmWriter.C
    ccmWriterMesh.C
    ccmWriterSolution.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef Foam_ccmWriter_H
#define Foam_ccmWriter_H
 
#include "ccmBase.H"
#include "STARCDCore.H"
 
#include "fvMesh.H"
#include "boundaryRegion.H"
#include "cellTable.H"
#include "IOobjectList.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
namespace ccm
{
 
// Forward Declarations
class ccmID;
class ccmMaps;
class ccmDimension;
class ccmGlobalState;
 
/*---------------------------------------------------------------------------*\
                         Class ccm::writer Declaration
\*---------------------------------------------------------------------------*/
 
class writer
:
    public base,
    protected fileFormats::STARCDCore
{
    // Private Data
 
    // Static Data
 
        //- The OpenFOAM -> CCM field mappings
        static dictionary defaultNameMapping;
 
 
    // Member Data
 
        //- MapIds for various components (cell, internalFaces, boundaries)
        std::unique_ptr<ccmMaps> maps_;
 
        //- mesh reference
        const polyMesh& mesh_;
 
        //- Lookup between cellModel shape and PROSTAR shape
        const Map<label> prostarShapeLookup_;
 
        //- ccm node: ProblemDescriptions/boundaryRegion
        boundaryRegion boundaryRegion_;
 
        // ccm node: ProblemDescriptions/cellType
        cellTable cellTable_;
 
 
    // Private Member Functions
 
        //- create a filled linear map with 'size' from 'start + 1'
        void addLinearMap
        (
            const std::string& mapName,
            ccmID& mapId,
            label size,
            label start = 0
        ) const;
 
        void writeBoundaryRegion(const ccmID& probNode) const;
 
        void writeCellTable(const ccmID& probNode) const;
 
        //- write out problem description
        void writeProblem(const ccmID& stateNode) const;
 
        //- Return the PROSTAR face id for the given cell/face
        label prostarCellFaceId(const label cellId, const label faceI) const;
 
        // write the faces, the number of vertices appears before each entry
        void writeFaces
        (
            const ccmID& nodeId,
            const ccmID& mapId,
            bool  isBoundary,    // boundary or internal faces
            label size,
            label start = 0
        ) const;
 
        void writeVertices(const ccmID& verticesNode) const;
 
        // - write internal faces with owner/neighbour
        void writeInternalFaces(const ccmID& topoNode) const;
 
        // - write boundary faces with owner
        void writeBoundaryFaces(const ccmID& topoNode) const;
 
        void writeCells(const ccmID& topoNode);
 
        void writeInterfaces(const ccmID& cellsNode) const;
 
        bool newFieldNode
        (
            const ccmID& phaseNode,
            const word& fieldName,
            const dictionary& nameMapping,
            const ccmDimension& ccmDim,
            ccmID& fieldNode
        ) const;
 
 
        //- Return patch named 'Default_Boundary_Region' or -1 on error
        label findDefaultBoundary() const;
 
 
public:
 
    // Static Data Members
 
        //- The name for the topology file reference
        FOAM_DLL_EXPORT
        static string defaultMeshName;
 
 
    // Generated Methods
 
        //- No copy construct
        writer(const writer&) = delete;
 
        //- No copy assignment
        void operator=(const writer&) = delete;
 
 
    // Constructors
 
        //- Open a file for writing, with backup/overwrite existing file
        FOAM_DLL_EXPORT
        writer
        (
            const fileName& file,
            const polyMesh& mesh,
            const bool backup=true
        );
 
 
    //- Destructor (closes file)
    FOAM_DLL_EXPORT
    ~writer();
 
 
    // Member Functions
 
    // Write
 
        //- Write the mesh
        FOAM_DLL_EXPORT
        void writeGeometry();
 
        //- Write the solutions
        //  provide optional remapping dictionary
        FOAM_DLL_EXPORT
        void writeSolution
        (
            const IOobjectList& objects,
            const fileName& remappingDictName = fileName::null
        );
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace ccm
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //