2606/ccmWriterSolution_8C_source.html

 /*---------------------------------------------------------------------------*\
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016-2022 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 "ccmWriter.H"
 #include "dictionary.H"
 #include "IFstream.H"
 #include "StringStream.H"
 #include "volFields.H"
 #include "surfaceFields.H"
 #include "ccmInternal.H"  // include last to avoid any strange interactions


 // * * * * * * * * * * * * * * * Static Data Member  * * * * * * * * * * * * //

 // names for known field types
 Foam::dictionary Foam::ccm::writer::defaultNameMapping
 (
     IStringStream
     (
         // volScalarField
         "p   { name P; Label \"Pressure\"; units \"Pa\"; }"
      // "?? { name PTER; Label \"Thermo. Pressure\"; units \"Pa\"; }"
      // "yPlus { name YPLU; Label \"YPLUS\"; }"
      // "?? { name DIST; Label \"Normal Distance\"; units \"m\"; }"
      // "?? { name H; Label \"Enthalpy\"; units \"J/kg\"; }"
         "rho { name DENS; Label \"Density\"; units \"kg/m3\"; }"
         "T   { name T; Label \"Temperature\"; units \"K\"; }"
         "k   { name TE; Label \"Turb Kinetic Energy\"; units \"m2/s2\"; }"
         "epsilon { name ED; Label \"Dissipation Rate\"; units \"m2/s3\"; }"
         "mu  { name LAMV; Label \"Molecular Viscosity\"; units \"Pa s\"; }"
         "mut { name VIS;  Label \"Turbulent Viscosity\"; units \"Pa s\"; }"
         // volVectorField
         "U   { name ALL; Label \"Velocity\"; units \"m/s\"; }"
         // U-components:
         "_0U { name SU; Label \"Velocity Component U\"; units \"m/s\"; }"
         "_1U { name SV; Label \"Velocity Component V\"; units \"m/s\"; }"
         "_2U { name SW; Label \"Velocity Component W\"; units \"m/s\"; }"
         // surfaceScalarField
         "phi { name MassFlux; Label \"Mass Flux\"; units \"kg/s\"; }"
     )()
 );


 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //

 bool Foam::ccm::writer::newFieldNode
 (
     const ccmID& phaseNode,
     const word& fieldName,
     const dictionary& nameMapping,
     const ccmDimension& dims,
     ccmID& fieldNode
 ) const
 {
     const dictionary* subDictPtr = nameMapping.findDict(fieldName);

     if (!subDictPtr)
     {
         return false;
     }

     const dictionary& dict = *subDictPtr;

     word shortName;
     if (!dict.readIfPresent("name", shortName))
     {
         return false;
     }

     string ccmLabel(fieldName);
     dict.readIfPresent("Label", ccmLabel);

     CCMIONewField
     (
         &(globalState_->error),
         phaseNode,
         ccmLabel.c_str(),
         shortName.c_str(),
         dims(),
         &fieldNode
     );


     string units;
     if (dims() == kCCMIOScalar && dict.readIfPresent("units", units))
     {
         CCMIOWriteOptstr
         (
             &(globalState_->error),
             fieldNode,
             "Units",
             units.c_str()
         );
     }

     return true;

 }


 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //

 void Foam::ccm::writer::writeSolution
 (
     const IOobjectList& objects,
     const fileName& remappingDictName
 )
 {
     const polyBoundaryMesh& patches = mesh_.boundaryMesh();

     if (!isA<fvMesh>(mesh_))
     {
         WarningInFunction
             << "cannot write solutions with a polyMesh instead of a fvMesh"
             << endl;
         return;
     }

     dictionary remapDict;

     if (remappingDictName.empty())
     {
         remapDict = IOdictionary
         (
             IOobject
             (
                 "remapping",
                 mesh_.time().constant(),
                 mesh_,
                 IOobject::READ_IF_PRESENT,
                 IOobject::NO_WRITE,
                 IOobject::NO_REGISTER
             )
         );
     }
     else
     {
         // Specified (absolute/relative) name: treat like MUST_READ
         remapDict = dictionary(IFstream(remappingDictName)());
     }


     dictionary nameMapping(defaultNameMapping);

     // Merge without overwrite
     const dictionary* subDictPtr = remapDict.findDict("fields");

     if (subDictPtr)
     {
         nameMapping |= *subDictPtr;
     }


     ccmID stateNode, processorNode, nodeId;
     int procI = 0;

     // Create first ("default") state node
     CCMIONewState
     (
         &(globalState_->error),
         (globalState_->root),
         "default",
         nullptr,
         nullptr,
         &stateNode
     );
     assertNoError("could not create default state");

     // Use first processor or create a new one
     procI = 0;
     if
     (
         CCMIONextEntity
         (
             nullptr,
             stateNode,
             kCCMIOProcessor,
             &procI,
             &processorNode
         )
      != kCCMIONoErr
     )
     {
         CCMIONewEntity
         (
             &(globalState_->error),
             stateNode,
             kCCMIOProcessor,
             nullptr,
             &processorNode
         );
         assertNoError("could not create processor node");
     }

     // Remove old data (if it exists)
     CCMIOClearProcessor
     (
         nullptr, stateNode, processorNode,
         true,   // Clear vertices
         true,   // Clear topology
         true,   // Clear initial field
         true,   // Clear solution
         true    // Clear lagrangian
     );

     //
     // Create vertices and topology nodes
     // and references to vertices and topology files
     //
     {
         ccmID verticesNode, topoNode;
         CCMIONewEntity
         (
             &(globalState_->error),
             (globalState_->root),
             kCCMIOVertices,
             nullptr,
             &verticesNode
         );

         CCMIONewEntity
         (
             &(globalState_->error),
             (globalState_->root),
             kCCMIOTopology,
             nullptr,
             &topoNode
         );

         string topoFileName = defaultMeshName + ".ccmg";

         CCMIOWriteProcessor
         (
             &(globalState_->error),
             processorNode,
             topoFileName.c_str(), &verticesNode,// verticesFile, verticesNode
             topoFileName.c_str(), &topoNode,    // topologyFile, topologyNode
             nullptr, nullptr,   // initialField unchanged
             nullptr, nullptr    // no solutionFile, solution unchanged
         );
     }
     assertNoError("Error after writing geometry processor");

     CCMIONewState
     (
         &(globalState_->error),
         (globalState_->root),
         "Restart_1",
         nullptr,
         nullptr,
         &stateNode
     );
     assertNoError("could not create Restart_1 state");

     // Use first processor or create a new one
     procI = 0;
     if
     (
         CCMIONextEntity
         (
             nullptr,
             stateNode,
             kCCMIOProcessor,
             &procI,
             &processorNode
         )
      != kCCMIONoErr
     )
     {
         CCMIONewEntity
         (
             &(globalState_->error),
             stateNode,
             kCCMIOProcessor,
             nullptr,
             &processorNode
         );
         assertNoError("could not create 'Processor' node");
     }

     // Remove old data (if it exists)
     CCMIOClearProcessor
     (
         nullptr, stateNode, processorNode,
         true,   // Clear vertices
         true,   // Clear topology
         true,   // Clear initial field
         true,   // Clear solution
         true    // Clear lagrangian
     );

     // Write out some simple solution data
     ccmID phaseNode, fieldSetNode;

     // Use first FieldSet
     int fieldSetI = 0;
     if
     (
         CCMIONextEntity
         (
             nullptr,
             (globalState_->root),
             kCCMIOFieldSet,
             &fieldSetI,
             &fieldSetNode
         )
      != kCCMIONoErr
     )
     {
         CCMIONewEntity
         (
             &(globalState_->error),
             (globalState_->root),
             kCCMIOFieldSet,
             nullptr,
             &fieldSetNode
         );
         assertNoError("could not create FieldSet node");
     }

     // RestartInfo
     {
         ccmID restartInfoNode, restartDataNode;
         CCMIONewEntity
         (
             &(globalState_->error),
             fieldSetNode,
             kCCMIORestart,
             nullptr,
             &restartInfoNode
         );
         assertNoError("could not create restartInfoNode node");

         // Get time information
         const Time& runTime = mesh_.time();
         label timeIndex = 0;
         if
         (
             runTime.timeName() != runTime.constant()
          && runTime.timeName() != "0"
         )
         {
             IOobject io
             (
                 "time",
                 runTime.timeName(),
                 "uniform",
                 runTime,
                 IOobject::READ_IF_PRESENT,
                 IOobject::NO_WRITE,
                 IOobject::NO_REGISTER
             );

             if (io.typeHeaderOk<IOdictionary>(true))
             {
                 IOdictionary(io).readEntry("index", timeIndex);
             }
         }

         CCMIOWriteRestartInfo
         (
             &(globalState_->error),
             restartInfoNode,
             "ccm::writer",      // solverName
             timeIndex,          // iteration
             0.0,                // time
             nullptr,            // timeUnits: default  (s)
             0.0                 // startAngle: non-rotating mesh
         );

         // RestartData
         CCMIONewEntity
         (
             &(globalState_->error),
             restartInfoNode,
             kCCMIORestartData,
             nullptr,
             &restartDataNode
         );
         assertNoError("could not create restartDataNode node");

         // Minimal information required by PROSTAR

         CCMIOWriteOptf
         (
             nullptr,
             restartDataNode,
             "SCALE",
             0.001        // [m] -> [mm]: PROSTAR is still a bit buggy here
         );


         // Add Phase data
         CCMIONewIndexedEntity
         (
             &(globalState_->error),
             restartDataNode,
             kCCMIOFieldPhase,
             1,
             nullptr,
             &nodeId
         );

         // HACK:  for calculating Mach number
         // FIXME: use thermodynamicProperties /or/ thermophysicalProperties
         CCMIOWriteOptf
         (
             nullptr,
             nodeId,
             "Material Specific Heat",
             1007
         );

         CCMIOWriteOptf
         (
             nullptr,
             nodeId,
             "Material Molecular Weight",
             28.96
         );
     }

     CCMIONewIndexedEntity
     (
         &(globalState_->error),
         fieldSetNode,
         kCCMIOFieldPhase,
         1,
         "Phase_0001",
         &phaseNode
     );

     forAllConstIters(objects, iter)
     {
         const IOobject& io = *iter.val();

         const word fieldName = io.name();
         const word fieldType = io.headerClassName();

         if (!nameMapping.found(fieldName))
         {
             continue;
         }

         if (fieldType == volScalarField::typeName)
         {
             Info<< " " << fieldName << flush;

             volScalarField field
             (
                 IOobject
                 (
                     fieldName,
                     mesh_.time().timeName(),
                     mesh_,
                     IOobject::READ_IF_PRESENT,
                     IOobject::NO_WRITE,
                     IOobject::NO_REGISTER
                 ),
                 refCast<const fvMesh>(mesh_)
             );

             ccmID fieldNode;

             // Info<< " call newFieldNode " << fieldName << flush;

             if
             (
                 !newFieldNode
                 (
                     phaseNode,
                     fieldName,
                     nameMapping,
                     kCCMIOScalar,
                     fieldNode
                 )
             )
             {
                 continue;
             }

             // Write cellData first
             CCMIONewEntity
             (
                 &(globalState_->error),
                 fieldNode,
                 kCCMIOFieldData,
                 nullptr,
                 &nodeId
             );

             CCMIOWriteFieldDatad
             (
                 &(globalState_->error),
                 nodeId,
                 maps_->cells,
                 kCCMIOCell,
                 const_cast<scalar*>
                 (
                     field.primitiveField().begin()
                 ),
                 kCCMIOStart,
                 kCCMIOEnd
             );
             assertNoError("writing internalField " + fieldName);

             // Write boundaryData
             forAll(patches, patchI)
             {
                 CCMIONewEntity
                 (
                     &(globalState_->error),
                     fieldNode,
                     kCCMIOFieldData,
                     nullptr,
                     &nodeId
                 );

                 CCMIOWriteFieldDatad
                 (
                     &(globalState_->error),
                     nodeId,
                     maps_->boundary[patchI],
                     kCCMIOFace,
                     const_cast<scalar*>
                     (
                         field.boundaryField()[patchI].begin()
                     ),
                     kCCMIOStart,
                     kCCMIOEnd
                 );
             }

             assertNoError("writing boundaryField " + fieldName);
         }
         else if (fieldType == volVectorField::typeName && fieldName == "U")
         {
             Info<< " " << fieldName << flush;

             volVectorField vfield
             (
                 IOobject
                 (
                     fieldName,
                     mesh_.time().timeName(),
                     mesh_,
                     IOobject::READ_IF_PRESENT,
                     IOobject::NO_WRITE,
                     IOobject::NO_REGISTER
                 ),
                 refCast<const fvMesh>(mesh_)
             );


             ccmID vectorNode;
             newFieldNode
             (
                 phaseNode,
                 fieldName,
                 nameMapping,
                 kCCMIOVector,
                 vectorNode
             );

             for (direction cmpt=0; cmpt < pTraits<vector>::nComponents; ++cmpt)
             {
                 word componentName("_" + Foam::name(cmpt) + fieldName);
                 volScalarField field(vfield.component(cmpt));

                 CCMIOComponent ccmComponent = kCCMIOVectorX;
                 switch (cmpt)
                 {
                     case 0:
                         ccmComponent = kCCMIOVectorX;
                         break;
                     case 1:
                         ccmComponent = kCCMIOVectorY;
                         break;
                     case 2:
                         ccmComponent = kCCMIOVectorZ;
                         break;
                 }

                 ccmID componentNode;
                 if
                 (
                     !newFieldNode
                     (
                         phaseNode,
                         componentName,
                         nameMapping,
                         kCCMIOScalar,
                         componentNode
                     )
                 )
                 {
                     continue;
                 }

                 // Re-register with vector field
                 CCMIOWriteMultiDimensionalFieldData
                 (
                     &(globalState_->error),
                     vectorNode,
                     ccmComponent,
                     componentNode
                 );

                 // Write cellData first
                 CCMIONewEntity
                 (
                     &(globalState_->error),
                     componentNode,
                     kCCMIOFieldData,
                     nullptr,
                     &nodeId
                 );

                 CCMIOWriteFieldDatad
                 (
                     &(globalState_->error),
                     nodeId,
                     maps_->cells,
                     kCCMIOCell,
                     const_cast<scalar*>
                     (
                         field.primitiveField().begin()
                     ),
                     kCCMIOStart, kCCMIOEnd
                 );
                 assertNoError
                 (
                     "writing internalField " + fieldName + " " + componentName
                 );


                 // Write boundaryData
                 forAll(patches, patchI)
                 {
                     CCMIONewEntity
                     (
                         &(globalState_->error),
                         componentNode,
                         kCCMIOFieldData,
                         nullptr,
                         &nodeId
                     );

                     CCMIOWriteFieldDatad
                     (
                         &(globalState_->error),
                         nodeId,
                         maps_->boundary[patchI],
                         kCCMIOFace,
                         const_cast<scalar*>
                         (
                             field.boundaryField()[patchI].begin()
                         ),
                         kCCMIOStart, kCCMIOEnd
                     );
                 }

                 assertNoError
                 (
                     "writing boundaryField " + fieldName + " " + componentName
                 );
             }
         }
         else if (fieldType == surfaceScalarField::typeName)
         {
 #if 0
             // Still have problems reading surface fields in PROSTAR
             Info<< " " << fieldName << flush;

             surfaceScalarField field
             (
                 IOobject
                 (
                     fieldName,
                     mesh_.time().timeName(),
                     mesh_,
                     IOobject::READ_IF_PRESENT,
                     IOobject::NO_WRITE,
                     IOobject::NO_REGISTER
                 ),
                 refCast<const fvMesh>(mesh_)
             );

             ccmID fieldNode;

             // Info<< " call newFieldNode " << fieldName << flush;

             if
             (
                 !newFieldNode
                 (
                     phaseNode,
                     fieldName,
                     nameMapping,
                     kCCMIOScalar,
                     fieldNode
                 )
             )
             {
                 continue;
             }

             // Write cell faceData first
             CCMIONewEntity
             (
                 &(globalState_->error),
                 fieldNode,
                 kCCMIOFieldData,
                 nullptr,
                 &nodeId
             );

             CCMIOWriteFieldDatad
             (
                 &(globalState_->error),
                 nodeId,
                 maps_->internalFaces,
                 kCCMIOFace,
                 const_cast<scalar*>
                 (
                     field.primitiveField().cdata()
                 ),
                 kCCMIOStart,
                 kCCMIOEnd
             );
             assertNoError("writing internalField " + fieldName);

             // Write boundaryData
             forAll(patches, patchI)
             {
                 CCMIONewEntity
                 (
                     &(globalState_->error),
                     fieldNode,
                     kCCMIOFieldData,
                     nullptr,
                     &nodeId
                 );

                 CCMIOWriteFieldDatad
                 (
                     &(globalState_->error),
                     nodeId,
                     maps_->boundary[patchI],
                     kCCMIOFace,
                     const_cast<scalar*>
                     (
                         field.boundaryField()[patchI].cdata()
                     ),
                     kCCMIOStart,
                     kCCMIOEnd
                 );
             }

             assertNoError("writing boundaryField " + fieldName);
 #endif
         }
     }
     Info<< endl;

     assertNoError("Error before writing processor");

     CCMIOWriteProcessor
     (
         &(globalState_->error),
         processorNode,
         nullptr, nullptr,     // vertices
         nullptr, nullptr,     // topology
         nullptr, nullptr,     // initial field
         nullptr, &fieldSetNode
     );
     assertNoError("Error after writing processor");
 }


 // ************************************************************************* //
surfaceFields.H
Foam::surfaceFields.

dict
dictionary dict
Definition: searchingEngine.H:11

field
rDeltaTY field()

Foam::direction
uint8_t direction
Definition: direction.H:46

Foam::fileName
A class for handling file names.
Definition: fileName.H:72

Foam::IOobjectList
List of IOobjects with searching and retrieving facilities. Implemented as a HashTable, so the various sorted methods should be used if traversing in parallel.
Definition: IOobjectList.H:55

Foam::ccm::writer::writeSolution
FOAM_DLL_EXPORT void writeSolution(const IOobjectList &objects, const fileName &remappingDictName=fileName::null)
Write the solutions.
Definition: ccmWriterSolution.C:121

Foam::dictionary
A list of keyword definitions, which are a keyword followed by a number of values (eg...
Definition: dictionary.H:130

StringStream.H
Input/output from string buffers.

runTime
engineTime & runTime
Definition: createEngineTime.H:13

Foam::endl
Ostream & endl(Ostream &os)
Add newline and flush stream.
Definition: Ostream.H:518

Foam::expressions::Detail::nComponents
::Foam::direction nComponents(const expressions::valueTypeCode) noexcept
The number of components associated with given valueTypeCode.
Definition: exprTraits.C:40

Foam::IOobjectOption::NO_WRITE
Ignore writing from objectRegistry::writeObject()
Definition: IOobjectOption.H:86

Foam::volVectorField
GeometricField< vector, fvPatchField, volMesh > volVectorField
Definition: volFieldsFwd.H:76

Foam::IOdictionary
IOdictionary is derived from dictionary and IOobject to give the dictionary automatic IO functionalit...
Definition: IOdictionary.H:50

forAll
#define forAll(list, i)
Loop across all elements in list.
Definition: stdFoam.H:400

Foam::volScalarField
GeometricField< scalar, fvPatchField, volMesh > volScalarField
Definition: volFieldsFwd.H:72

Foam::name
word name(const expressions::valueTypeCode typeCode)
A word representation of a valueTypeCode. Empty for expressions::valueTypeCode::INVALID.
Definition: exprTraits.C:127

ccmWriter.H

io
const auto & io
Definition: findMeshDefinitionDict.H:139

Foam::IOobjectOption::READ_IF_PRESENT
Reading is optional [identical to LAZY_READ].
Definition: IOobjectOption.H:77

IFstream.H

Foam::polyBoundaryMesh
A polyBoundaryMesh is a polyPatch list with registered IO, a reference to the associated polyMesh...
Definition: polyBoundaryMesh.H:61

ccmInternal.H
Internal bits for wrapping libccmio - do not use directly.

Foam::DimensionedField::typeName
const word typeName("volScalarField::Internal")

Foam::flush
Ostream & flush(Ostream &os)
Flush stream.
Definition: Ostream.H:508

WarningInFunction
#define WarningInFunction
Report a warning using Foam::Warning.
Definition: messageStream.H:459

patches
const polyBoundaryMesh & patches
Definition: convertProcessorPatches.H:51

Foam::ccm::base::globalState_
std::unique_ptr< ccmGlobalState > globalState_
Maintain overall global states (error, root-node)
Definition: ccmBase.H:79

Foam::Info
messageStream Info
Information stream (stdout output on master, null elsewhere)

volFields.H

dictionary.H

writeChecksFormatType::dictionary

Foam::surfaceScalarField
GeometricField< scalar, fvsPatchField, surfaceMesh > surfaceScalarField
Definition: surfaceFieldsFwd.H:62

Foam::IOobject
Defines the attributes of an object for which implicit objectRegistry management is supported...
Definition: IOobject.H:188

Foam::IOobjectOption::NO_REGISTER
Do not request registration (bool: false)
Definition: IOobjectOption.H:99

forAllConstIters
forAllConstIters(mixture.phases(), phase)
Definition: pEqn.H:28

timeIndex
label timeIndex
Definition: getTimeIndex.H:24

Foam::dictionary::findDict
const dictionary * findDict(const word &keyword, enum keyType::option matchOpt=keyType::REGEX) const
Find and return a sub-dictionary pointer if present (and it is a dictionary) otherwise return nullptr...
Definition: dictionaryI.H:124