### Example solidMixtureProperties Configuration

Source: https://cpp.openfoam.org/v11/solidMixtureProperties_8H_source.html

This example shows how to define a two-component solid mixture, including properties for 'C' and 'ash'. Use this configuration within your OpenFOAM case setup for solid mixture properties.

```C++
<parentDictionary>
{
    C;

    ash
    {
        //... user defined properties for ash
    }
}

```

--------------------------------

### Main Function Setup

Source: https://cpp.openfoam.org/v11/createPatch_8C_source.html

Sets up the main execution environment for the createPatch utility. Includes options for region, overwrite, and dictionary settings, and initializes the mesh.

```cpp
int main(int argc, char *argv[])
{
    #include "addOverwriteOption.H"
    #include "addRegionOption.H"
    #include "addDictOption.H"
    #include "setRootCase.H"
    #include "createTimeNoFunctionObjects.H"

    Foam::word meshRegionName = polyMesh::defaultRegion;
    args.optionReadIfPresent("region", meshRegionName);

    const bool overwrite = args.optionFound("overwrite");

    #include "createNamedPolyMesh.H"

    const word oldInstance = mesh.pointsInstance();

    const dictionary dict(systemDict("createPatchDict", args, mesh));

    // Whether to synchronise points
    const Switch pointSync(dict.lookupOrDefault("pointSync", false));

    // Whether to write cyclic matches to .OBJ files
    const Switch writeCyclicMatch
    (
        dict.lookupOrDefault("writeCyclicMatch", false)
    );


    const polyBoundaryMesh& patches = mesh.boundaryMesh();

    // If running parallel check same patches everywhere
    patches.checkParallelSync(true);


    if (writeCyclicMatch)
    {
        writeCyclicMatchObjs("initial_", mesh);
    }

    // Read patch construct info from dictionary
    PtrList<dictionary> patchSources(dict.lookup("patches"));

    HashSet<word> addedPatchNames;
    forAll(patchSources, addedI)
    {
        const dictionary& dict = patchSources[addedI];
        addedPatchNames.insert(dict.lookup("name"));
    }


    // 1. Add all new patches
    // ~~~~~~~~~~~~~~~~~~~~~~~

    if (patchSources.size())
    {
        // Old and new patches.
        DynamicList<polyPatch*> allPatches(patches.size()+patchSources.size());

        label startFacei = mesh.nInternalFaces();

        // Copy old patches.
        forAll(patches, patchi)
        {
            const polyPatch& pp = patches[patchi];

            if (!isA<processorPolyPatch>(pp))
            {
                allPatches.append
                (
                    pp.clone
                    (
                        patches,
                        patchi,
                        pp.size(),
                        startFacei
                    ).ptr()

```

--------------------------------

### Get patch start indices

Source: https://cpp.openfoam.org/v11/classFoam_1_1sampledSurfaces_1_1patch.html

Returns the starting label for each patch.

```cpp
const labelList& patchStart() const
```

--------------------------------

### OpenFOAM Main Function Setup

Source: https://cpp.openfoam.org/v11/PDRMesh_8C_source.html

This snippet shows the standard setup for the main function in an OpenFOAM application, including including necessary headers for options, root case, and mesh creation. It initializes IOdictionary for reading configuration.

```cpp
int main(int argc, char *argv[])
{
    #include "addOverwriteOption.H"
    #include "setRootCase.H"
    #include "createTimeNoFunctionObjects.H"
    #include "createMeshNoChangers.H"

    // Read control dictionary
    // ~~~~~~~~~~~~~~~~~~~~~~~~

    IOdictionary dict
    (
        IOobject
        (
            "PDRMeshDict",
            runTime.system(),
            mesh,
            IOobject::MUST_READ_IF_MODIFIED,
            IOobject::NO_WRITE
        )
    );

    // Per faceSet the patch to put the baffles into
    const List<Pair<word>> setsAndPatches(dict.lookup("blockedFaces"));

```

--------------------------------

### Get blockEdge Start Point Label

Source: https://cpp.openfoam.org/v11/classFoam_1_1blockEdges_1_1arcEdge.html

Returns the label of the start point of the blockEdge.

```cpp
label start () const
```

--------------------------------

### Reading Initial Conditions Example

Source: https://cpp.openfoam.org/v11/globals_i.html

Example of reading initial conditions from a dictionary. This is a common step in setting up a simulation.

```C++
Info<< "Reading initial conditions.\n"<< endl;
IOdictionary initialConditions(IOobject("initialConditions", runTime.constant(), mesh, IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE));
scalar p0=initialConditions.lookup< scalar >() : createFields.H
```

--------------------------------

### Get Old Patch Start Labels

Source: https://cpp.openfoam.org/v11/polyTopoChangeMap_8H_source.html

Returns a list of the starting labels for the old patches.

```cpp
const labelList& oldPatchStarts() const
{
    return oldPatchStarts_;
}
```

--------------------------------

### Get Start Time in OpenFOAM

Source: https://cpp.openfoam.org/v11/Time_8C_source.html

Returns the simulation's start time as a dimensioned scalar, similar to beginTime but specifically for the defined start time.

```cpp
Foam::dimensionedScalar Foam::Time::startTime() const
{
    return dimensionedScalar
    (
        timeName(timeToUserTime(startTime_)),
        dimTime,
        startTime_
    );
}
```

--------------------------------

### OpenFOAM Reaction-Driven Simulation Setup

Source: https://cpp.openfoam.org/v11/phaseSystems_2populationBalanceModel_2nucleationModels_2reactionDriven_2reactionDriven_8C_source.html

Setup for reaction-driven simulations in OpenFOAM. This involves defining reaction kinetics and related parameters.

```C++
reactionDriven
{
    // Reaction-driven simulation settings
}
```

--------------------------------

### Get fvPatch start label

Source: https://cpp.openfoam.org/v11/fvMeshStitcherTemplates_8C_source.html

Returns the starting label of this patch within the polyMesh face list.

```cpp
virtual label start() const
```

--------------------------------

### IOobject Constructors

Source: https://cpp.openfoam.org/v11/classFoam_1_1dragModels_1_1Gibilaro.html

Demonstrates the various ways to construct an IOobject, including initialization with name, instance, registry, and I/O options, as well as copy construction.

```APIDOC
## IOobject Constructors

### Description
Constructs an IOobject with specified parameters or from a copy of another IOobject.

### Methods
- IOobject (const word &name, const fileName &instance, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const word &name, const fileName &instance, const fileName &local, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const fileName &path, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const IOobject &io, const objectRegistry &registry)
- IOobject (const IOobject &io, const word &name)
- IOobject (const IOobject &io)=default
```

--------------------------------

### IOobject Constructors

Source: https://cpp.openfoam.org/v11/classFoam_1_1data.html

Demonstrates the various ways to construct an IOobject, including initialization with name, instance, registry, and I/O options.

```APIDOC
## IOobject Constructors

### Description
Constructs an IOobject with different sets of parameters.

### Methods
- IOobject (const word &name, const fileName &instance, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const word &name, const fileName &instance, const fileName &local, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const fileName &path, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const IOobject &io, const objectRegistry &registry)
- IOobject (const IOobject &io, const word &name)
- IOobject (const IOobject &io)=default
```

--------------------------------

### Get start point of trackedParticle

Source: https://cpp.openfoam.org/v11/classFoam_1_1trackedParticle.html

Returns a reference to the starting point of the tracked particle. This is an inline method.

```cpp
point& start()
```

--------------------------------

### searchableDisk Configuration Example

Source: https://cpp.openfoam.org/v11/searchableDisk_8H_source.html

Example specification for a searchableDisk in snappyHexMeshDict. Requires origin, normal, and radius properties.

```C++
type searchableDisk;
origin (10 10 10);
normal (0 1 0);
radius 5;
```

--------------------------------

### Get List Starts

Source: https://cpp.openfoam.org/v11/Distribution_8H_source.html

Returns the starting bin indices for each component. This is an inline function defined in DistributionI.H.

```cpp
inline const List<label>& listStarts() const;

```

--------------------------------

### IOobject Constructors

Source: https://cpp.openfoam.org/v11/classFoam_1_1compressibleTwoPhaseVoFMixture.html

Demonstrates the various ways to construct an IOobject, including initialization with name, instance, registry, and read/write options.

```APIDOC
## IOobject Constructors

### Description
Constructs an IOobject with different sets of parameters, allowing for flexible initialization based on name, instance, registry, and I/O options.

### Methods
- `IOobject(const word &name, const fileName &instance, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)`
- `IOobject(const word &name, const fileName &instance, const fileName &local, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)`
- `IOobject(const fileName &path, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)`
- `IOobject(const IOobject &io, const objectRegistry &registry)`
- `IOobject(const IOobject &io, const word &name)`
- `IOobject(const IOobject &io)=default`

### Parameters
- **name** (word) - The name of the object.
- **instance** (fileName) - The instance name of the object.
- **registry** (objectRegistry &) - The object registry.
- **r** (readOption) - Read option (default: NO_READ).
- **w** (writeOption) - Write option (default: NO_WRITE).
- **registerObject** (bool) - Whether to register the object (default: true).
- **local** (fileName) - The local path.
- **path** (fileName) - The path to the object.
- **io** (const IOobject &) - An existing IOobject to copy from.

### Response Example
```json
{
  "message": "IOobject constructed successfully"
}
```
```

--------------------------------

### Get Old Patch Starts

Source: https://cpp.openfoam.org/v11/faceMapper_8C_source.html

Returns a list indicating the starting index of each old patch in the face list.

```cpp
const Foam::labelList& Foam::faceMapper::oldPatchStarts() const
{
    return mpm_.oldPatchStarts();
}
```

--------------------------------

### Get Multiple Edge Start Index

Source: https://cpp.openfoam.org/v11/extendedFeatureEdgeMeshI_8H_source.html

Returns the starting index for multiple edges. This is an inline accessor function.

```cpp
inline Foam::label Foam::extendedFeatureEdgeMesh::multipleStart() const
{
return multipleStart_;
}
```

--------------------------------

### UniformTable Configuration Example

Source: https://cpp.openfoam.org/v11/UniformTable2_8H_source.html

Example of how to configure a uniformTable for the density of water, specifying temperature and pressure ranges and corresponding density values.

```C++
rho
{
type uniformTable;

low (1e5 280);
high (3e5 350);

values
3 2
(
(991 992)
(993 994)
(995 996)
);
}
```

--------------------------------

### Constructor (name, instance, local, registry, options)

Source: https://cpp.openfoam.org/v11/classFoam_1_1AveragingMethods_1_1Moment.html

Constructs an IOobject from name, instance, local path, registry, and IO options.

```APIDOC
## IOobject Constructor

### Description
Construct from name, instance, local, registry, io options.

### Method
`IOobject`

### Parameters
#### Path Parameters
- **name** (const word &) - Required - The name of the object.
- **instance** (const fileName &) - Required - The instance directory.
- **local** (const fileName &) - Required - The local path.
- **registry** (const objectRegistry &) - Required - The object registry.
- **r** (readOption) - Optional - The read option (default: NO_READ).
- **w** (writeOption) - Optional - The write option (default: NO_WRITE).
- **registerObject** (bool) - Optional - Whether to register the object with the registry (default: true).
```

--------------------------------

### Get Open Edge Start Index

Source: https://cpp.openfoam.org/v11/extendedFeatureEdgeMeshI_8H_source.html

Returns the starting index for open edges. This is an inline accessor function.

```cpp
inline Foam::label Foam::extendedFeatureEdgeMesh::openStart() const
{
return openStart_;
}
```

--------------------------------

### IOobject Constructors

Source: https://cpp.openfoam.org/v11/classFoam_1_1combustionModels_1_1infinitelyFastChemistry.html

Demonstrates the various ways to construct an IOobject, specifying name, instance, path, registry, and I/O options.

```APIDOC
## IOobject Constructors

### Description
Constructs an IOobject with different sets of parameters, including name, instance, path, registry, and I/O options.

### Method
Constructor

### Endpoints
N/A (Constructors)

### Parameters
- **name** (const word &) - Name of the object.
- **instance** (const fileName &) - Instance of the object (e.g., time directory).
- **local** (const fileName &) - Local path for the object.
- **registry** (const objectRegistry &) - The object registry.
- **r** (readOption) - Read option (default: NO_READ).
- **w** (writeOption) - Write option (default: NO_WRITE).
- **registerObject** (bool) - Whether to register the object with the registry (default: true).
- **path** (const fileName &) - Path to the object.

### Request Example
N/A (Constructors)

### Response
N/A (Constructors)
```

--------------------------------

### Get Flat Edge Start Index

Source: https://cpp.openfoam.org/v11/extendedFeatureEdgeMeshI_8H_source.html

Returns the starting index for flat edges. This is an inline accessor function.

```cpp
inline Foam::label Foam::extendedFeatureEdgeMesh::flatStart() const
{
return flatStart_;
}
```

--------------------------------

### Example Usage of waveForcing

Source: https://cpp.openfoam.org/v11/classFoam_1_1fv_1_1waveForcing.html

This configuration block demonstrates how to set up the waveForcing fvModel. It specifies the type, libraries, liquid phase, origin, direction, scaling, and forcing coefficient.

```C++
waveForcing
{
    type            waveForcing;

    libs            ("libwaves.so");

    liquidPhase     water;

    // Define the line along which to apply the graduation
    origin          (600 0 0);
    direction       (-1 0 0);

    // // Or, define multiple lines
    // origins         ((600 0 0) (600 -300 0) (600 300 0));
    // directions      ((-1 0 0) (0 1 0) (0 -1 0));

    scale
    {
        type        halfCosineRamp;
        start       0;
        duration    300;
    }

    lambda          0.5; // Forcing coefficient

 // lambda          2;   // Optional boundary forcing coefficient
                     // Useful when wave BCs are specified
                     // without mean flow
}

```

--------------------------------

### Get Internal Edge Start Index

Source: https://cpp.openfoam.org/v11/extendedFeatureEdgeMeshI_8H_source.html

Returns the starting index for internal edges. This is an inline accessor function.

```cpp
inline Foam::label Foam::extendedFeatureEdgeMesh::internalStart() const
{
return internalStart_;
}
```

--------------------------------

### Get External Edge Start Index

Source: https://cpp.openfoam.org/v11/extendedFeatureEdgeMeshI_8H_source.html

Returns the starting index for external edges. This is an inline accessor function.

```cpp
inline Foam::label Foam::extendedFeatureEdgeMesh::externalStart() const
{
return externalStart_;
}
```

--------------------------------

### topoSet Constructors and Static Methods

Source: https://cpp.openfoam.org/v11/topoSet_8H_source.html

Details on how to construct topoSet objects and factory methods for creating new instances.

```APIDOC
## Constructors and Static Methods

### Static Members
- `static fileName localPath(const polyMesh& mesh, const word& name)`: Returns the file path for a given set name within the mesh context.

### Runtime Selection Tables
- `declareRunTimeSelectionTable(autoPtr, topoSet, word, ...)`: For constructing from `polyMesh`, `name`, `readOption`, and `writeOption`.
- `declareRunTimeSelectionTable(autoPtr, topoSet, size, ...)`: For constructing from `polyMesh`, `name`, `label size`, and `writeOption`.
- `declareRunTimeSelectionTable(autoPtr, topoSet, set, ...)`: For constructing as a copy of another `topoSet`.

### Constructors
- `topoSet(const IOobject&, const word& wantedType)`: Construct from `IOobject`.
- `topoSet(const polyMesh& mesh, const word& wantedType, const word& name, readOption r=MUST_READ, writeOption w=NO_WRITE)`: Construct from `polyMesh`, `name`, with read/write options.
- `topoSet(const polyMesh& mesh, const word& name, const label, writeOption w=NO_WRITE)`: Construct empty set with a specified size.
- `topoSet(const polyMesh& mesh, const word& name, const labelHashSet&, writeOption w=NO_WRITE)`: Construct empty set from an existing `labelHashSet`.
- `topoSet(const IOobject&, const label size)`: Construct empty set from `IOobject` and size.
- `topoSet(const IOobject&, const labelHashSet&)`: Construct from `IOobject` and `labelHashSet`.
- `topoSet(const topoSet&) = delete`: Disallows default bitwise copy construction.

### Static Factory Methods
- `static autoPtr<topoSet> New(const word& setType, const polyMesh& mesh, const word& name, readOption r=MUST_READ, writeOption w=NO_WRITE)`: Factory method to create a `topoSet` of a specific type, read from file.
- `static autoPtr<topoSet> New(const word& setType, const polyMesh& mesh, const word& name, const label size, writeOption w=NO_WRITE)`: Factory method to create a new `topoSet` of a specific type and size.
- `static autoPtr<topoSet> New(const word& setType, const polyMesh& mesh, const word& name, const topoSet& set, writeOption w=NO_WRITE)`: Factory method to create a new `topoSet` of a specific type as a copy of another `topoSet`.

### Destructor
- `virtual ~topoSet()`: Virtual destructor.
```

--------------------------------

### IOobject Initialization Example

Source: https://cpp.openfoam.org/v11/isothermalFluid_8C_source.html

Demonstrates the initialization of an IOobject for reading data if present and automatic writing. This is commonly used for fields and dictionaries in OpenFOAM.

```cpp
IOobject
   (
      "phi",
      runTime.name(),
      mesh,
      IOobject::READ_IF_PRESENT,
      IOobject::AUTO_WRITE
   ),

```

--------------------------------

### Get Start Vertex Label of an Edge

Source: https://cpp.openfoam.org/v11/edgeI_8H_source.html

Returns the label of the starting vertex of the edge. This is a const member function.

```cpp
inline Foam::label Foam::edge::start() const
{
return operator[](0);
}
```

--------------------------------

### Get the starting point of the line

Source: https://cpp.openfoam.org/v11/classFoam_1_1line.html

Returns a reference to the starting vertex (PointRef) of the line. This function is inline and efficient.

```cpp
inline 
Return first vertex. 
Definition at line 60 of file lineI.H.
```

--------------------------------

### IOobject Constructors

Source: https://cpp.openfoam.org/v11/classFoam_1_1diameterModels_1_1SecondaryPropertyModel.html

Demonstrates the various ways to construct an IOobject, specifying name, instance, registry, and I/O options.

```APIDOC
## IOobject Constructors

### Description
Constructs an IOobject with different sets of parameters, including name, instance, registry, and I/O options.

### Methods
- IOobject (const word &name, const fileName &instance, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const word &name, const fileName &instance, const fileName &local, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const fileName &path, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const IOobject &io, const objectRegistry &registry)
- IOobject (const IOobject &io, const word &name)
- IOobject (const IOobject &io)=default
```

--------------------------------

### IOobject Constructors

Source: https://cpp.openfoam.org/v11/classFoam_1_1typeIOobject.html

Demonstrates the various ways to construct an IOobject, including initialization from existing IOobjects, names, file paths, and registry information.

```APIDOC
## IOobject Constructors

### Description
Provides multiple constructors for initializing IOobject instances with different parameters, allowing flexibility in object creation.

### Constructors

- **IOobject (const IOobject &io)**: Copy constructor.
- **IOobject (const IOobject &io, const objectRegistry &registry)**: Construct from copy resetting registry.
- **IOobject (const IOobject &io, const word &name)**: Construct from copy resetting name.
- **IOobject (const word &name, const fileName &instance, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)**: Construct from name, instance, registry, io options.
- **IOobject (const word &name, const fileName &instance, const fileName &local, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)**: Construct from name, instance, local, registry, io options.
- **IOobject (const fileName &path, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)**: Construct from path, registry, io options.
```

--------------------------------

### Get Start Point of blockEdge

Source: https://cpp.openfoam.org/v11/blockEdgeI_8H_source.html

Returns the label of the start point of the block edge. This is a const member function.

```cpp
inline Foam::label Foam::blockEdge::start() const
{
return start_;
}
```

--------------------------------

### Get Owner Start Addressing in OpenFOAM

Source: https://cpp.openfoam.org/v11/TGaussSeidelSmoother_8C_source.html

Retrieves the starting addresses for owner cells. This is part of the lduAddressing class.

```cpp
const labelUList & ownerStartAddr() const
```

--------------------------------

### OpenFOAM Main Function Setup in C++

Source: https://cpp.openfoam.org/v11/viewFactorsGen_8C_source.html

Sets up the main execution flow for an OpenFOAM application. Includes reading case options, setting root case, creating time objects, and initializing the mesh. It also checks for unsupported patch types.

```cpp
int main(int argc, char *argv[])
{
 #include "addRegionOption.H"
 #include "setRootCase.H"
 #include "createTime.H"
 #include "createNamedMesh.H"

 const polyBoundaryMesh& patches = mesh.boundaryMesh();

 forAll(patches, patchi)
 {
 const polyPatch& pp = patches[patchi];
 if
 (
 isA<cyclicTransform>(pp)
 || isA<symmetryPolyPatch>(pp)
 || isA<symmetryPlanePolyPatch>(pp)
 || isA<wedgePolyPatch>(pp)
 )
 {
 FatalErrorIn(args.executable()) << args.executable()
 << " does not currently support transforming patches: "
 << "cyclic, symmetry and wedge."
 << exit(FatalError);
 }
 }

 // Read view factor dictionary
 IOdictionary viewFactorDict
 (
 IOobject
 (
 "viewFactorsDict",
 runTime.system(),
 mesh,
 IOobject::MUST_READ_IF_MODIFIED,
 IOobject::NO_WRITE
 )
 );

 const bool writeViewFactors =
 viewFactorDict.lookupOrDefault<bool>("writeViewFactorMatrix", false);

 const bool dumpRays =
 viewFactorDict.lookupOrDefault<bool>("dumpRays", false);

 const label debug = viewFactorDict.lookupOrDefault<label>("debug", 0);

 volScalarField qr
 (
 IOobject
 (
 "qr",
 runTime.name(),
 mesh,
 IOobject::MUST_READ,
 IOobject::NO_WRITE
 ),
 mesh
 );

 // Read agglomeration map
 labelListIOList finalAgglom
 (
 IOobject
 (
 "finalAgglom",
 mesh.facesInstance(),
 mesh,
 IOobject::MUST_READ,
 IOobject::NO_WRITE,
 false
 )
 );

 // Create the coarse mesh using agglomeration
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 if (debug)
 {
 Pout << "\nCreating single cell mesh..." << endl;
 }

 singleCellFvMesh coarseMesh
 (
 IOobject
 (
 "coarse:" + mesh.name(),
 runTime.name(),
 runTime,
 IOobject::NO_READ,
 IOobject::NO_WRITE
 ),
 mesh,
 finalAgglom
 );

 if (debug)
 {
 Pout << "\nCreated single cell mesh..." << endl;
 }


 // Calculate total number of fine and coarse faces
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 label nCoarseFaces = 0; // total number of coarse faces
 label nFineFaces = 0; // total number of fine faces

 const polyBoundaryMesh& coarsePatches = coarseMesh.boundaryMesh();

 // ... rest of the main function
```

--------------------------------

### Get Injection Start Time

Source: https://cpp.openfoam.org/v11/InjectionModelI_8H_source.html

Returns the start time of the injection. This method is part of the InjectionModel class template.

```cpp
#include "InjectionModel.H"

template<class CloudType>
Foam::scalar Foam::InjectionModel<CloudType>::timeStart() const
{
 return SOI_;
}
```

--------------------------------

### Variable Initialization Example

Source: https://cpp.openfoam.org/v11/LienLeschziner_8C_source.html

Example of reading initial conditions and creating fields.

```APIDOC
## Initialization Example

### Description
Reads initial conditions for field U and creates a face flux surface scalar field.

### Endpoint
`readInitialConditions.H:91`

### Code Snippet
```cpp
Info<< "Reading field U\n"<< endl;
volVectorField U(
    IOobject("U", runTime.name(), mesh, IOobject::MUST_READ, IOobject::AUTO_WRITE),
    mesh
);
Info<< "Creating face flux\n"<< endl;
surfaceScalarField phi(
    IOobject("phi", runTime.name(), mesh, IOobject::NO_READ, IOobject::NO_WRITE),
    mesh,
    dimensionedScalar(mesh.Sf().dimensions() *U.dimensions(), 0)
);
autoPtr< viscosityModel > viscosity(viscosityModel::New(mesh))
```
```

--------------------------------

### Get Start Index of Patch

Source: https://cpp.openfoam.org/v11/nonConformalProcessorCyclicFvPatch_8C_source.html

Returns the starting label of this patch within the polyMesh face list. This function calls the start() method of the base class nonConformalFvPatch.

```cpp
Foam::label Foam::nonConformalProcessorCyclicFvPatch::start() const
{
return nonConformalFvPatch::start();
}

```

--------------------------------

### System ControlDict Configuration Example

Source: https://cpp.openfoam.org/v11/systemCall_8C_source.html

Example configuration snippet for enabling system operations in OpenFOAM's controlDict file. This allows specific system commands to be executed.

```cpp
allowSystemOperations 1
```

--------------------------------

### Timer Initialization and Reset Example

Source: https://cpp.openfoam.org/v11/timer_8C_source.html

Illustrates the initialization and reset logic for the timer, including signal handling.

```APIDOC
## Timer Initialization and Reset Example

### Description
This snippet shows the logic for resetting the timer and restoring the signal handler when a new timeout value is set.

### Code Snippet
```cpp
if (newTimeOut_ > 0)
{
    if (debug)
    {
        InfoInFunction << "timeOut=" << int(newTimeOut_)
                       << " : resetting timeOut to " << int(oldTimeOut_) << endl;
    }

    // Reset timer
    ::alarm(oldTimeOut_);
    oldTimeOut_ = 0;

    // Restore signal handler
    if (sigaction(SIGALRM, &oldAction_, nullptr) < 0)
    {
        FatalErrorInFunction << "sigaction(SIGALRM) error" << abort(FatalError);
    }
}
```

### Related Definitions
- **newTimeOut_**: unsigned int - Current time out value.
- **oldTimeOut_**: unsigned int - Previous time out value.
- **debug**: bool - Debug flag.
- **InfoInFunction**: Macro - Reports information messages.
- **endl**: Ostream & - Adds newline and flushes stream.
- **::alarm**: Function - Sets an alarm signal.
- **sigaction**: Function - Examines and changes the action taken by a signal.
- **SIGALRM**: Signal - Alarm signal.
- **FatalErrorInFunction**: Macro - Reports fatal error messages.
- **abort**: Manipulator - Error manipulator.
```

--------------------------------

### Get Start Time

Source: https://cpp.openfoam.org/v11/readConversionProperties_8H.html

Retrieves the 'startTime' value as a scalar from the 'conversionProperties' dictionary. Used to specify the start time for conversions.

```cpp
scalar startTime = conversionProperties.lookup<scalar>("startTime");
```

--------------------------------

### Main Function with Argument Parsing

Source: https://cpp.openfoam.org/v11/ideasUnvToFoam_8C_source.html

Sets up command-line arguments for file input and debugging options. Includes standard OpenFOAM headers for case setup.

```cpp
int main(int argc, char *argv[])
{
    argList::noParallel();
    argList::validArgs.append(".unv file");
    argList::addBoolOption
    (
        "dump",
        "dump boundary faces as boundaryFaces.obj (for debugging)"
    );
    argList::addOption
    (
        "region",
        "specify the mesh region"
    );

    #include "setRootCase.H"
    #include "createTime.H"

    const fileName ideasName = args[1];
    IFstream inFile(ideasName);

    if (!inFile.good())
    {
        FatalErrorInFunction
        << "Cannot open file " << ideasName
        << exit(FatalError);
    }

    // Switch on additional debug info
    const bool verbose = false; // true;

    // Unit scale factors
    scalar lengthScale = 1;
    scalar forceScale = 1;
    scalar tempScale = 1;
    scalar tempOffset = 0;

    // Points
    DynamicList<point> points;
    // Original unv point label
    DynamicList<label> unvPointID;

    // Cells
    DynamicList<cellShape> cellVerts;
    DynamicList<label> cellMat;
    DynamicList<label> cellCorrespondence;

    // Boundary faces
    DynamicList<label> boundaryFaceIndices;
    DynamicList<face> boundaryFaces;

    // Patch names and patchFace indices.
    DynamicList<word> patchNames;
    DynamicList<labelList> patchFaceIndices;
    DynamicList<labelList> dofVertIndices;


    while (inFile.good())
    {
        label tag = readTag(inFile);

        if (tag == -1)
        {
            break;
        }

        Info<< "Processing tag:" << tag << endl;

        switch (tag)
        {
            case 151:
                readHeader(inFile);
                break;

            case 164:
                readUnits
                (
                    inFile,
                    lengthScale,
                    forceScale,
                    tempScale,
                    tempOffset
                );
                break;

            case 2411:
                readPoints(inFile, points, unvPointID);
                break;

            case 2412:
                readCells
                (
                    inFile,
                    cellVerts,
                    cellMat,
                    boundaryFaceIndices,
                    boundaryFaces,
                    cellCorrespondence,
                    unvPointID
                );
                break;

            case 2452:
            case 2467:
                readSets
                (
                    inFile,
                    patchNames,
                    patchFaceIndices
                );
                break;

            case 757:
                readDOFS
                (
                    inFile,
                    patchNames,
                    dofVertIndices
                );
                break;

            default:
                Info<< "Skipping tag " << tag << " on line "
                << inFile.lineNumber() << endl;
                skipSection(inFile);
                break;
        }
        Info<< endl;
    }


    // Invert point numbering.
    label maxUnvPoint = 0;
    forAll(unvPointID, pointi)
    {
        maxUnvPoint = max(maxUnvPoint, unvPointID[pointi]);
    }
    labelList unvToFoam(invert(maxUnvPoint+1, unvPointID));


    // Renumber vertex numbers on cells

    forAll(cellVerts, celli)
    {
        labelList foamVerts
        (
            renumber
            (
                unvToFoam,
                static_cast<labelList&>(cellVerts[celli])
            )
        );

        if (findIndex(foamVerts, -1) != -1)
        {
            FatalErrorInFunction
            << "Cell " << celli
            << " unv vertices " << cellVerts[celli]
            << " has some undefined vertices " << foamVerts
            << abort(FatalError);
        }

        // Bit nasty: replace vertex list.
        cellVerts[celli].transfer(foamVerts);
    }

    // Renumber vertex numbers on boundaryFaces

    forAll(boundaryFaces, bFacei)
    {
        labelList foamVerts(renumber(unvToFoam, boundaryFaces[bFacei]));

        if (findIndex(foamVerts, -1) != -1)
        {
            FatalErrorInFunction
            << "Boundary face " << bFacei
            << " unv vertices " << boundaryFaces[bFacei]
            << " has some undefined vertices " << foamVerts
            << abort(FatalError);
        }

        // Bit nasty: replace vertex list.
        boundaryFaces[bFacei].transfer(foamVerts);
    }

```

--------------------------------

### Get Owner Start Addressing

Source: https://cpp.openfoam.org/v11/nonBlockingGaussSeidelSmoother_8C_source.html

Returns the owner start addressing information for LDU. Used in matrix and addressing operations.

```C++
const labelUList & ownerStartAddr() const

```

--------------------------------

### Property Initialization Example

Source: https://cpp.openfoam.org/v11/C3H6O_8C_source.html

Example of initializing various physical properties for a substance, likely within a constructor. This snippet shows the assignment of values to properties like vapour pressure, heat of vaporisation, heat capacity, enthalpy, etc.

```cpp
pv_("pv", 70.72, -5685, -7.351, 6.3e-06, 2.0),
hl_("hl", 508.20, 846590.909090909, 1.036, -1.294, 0.672, 0.0),
Cp_(
    "Cp",
    2334.71074380165,
    -3.04752066115702,
    0.00488464187327824,
    1.18629476584022e-05,
    0.0,
    0.0
    ),
h_(
    "h",
    -4.905296049462618e06,
    2334.71074380165,
    -1.52376033057851,
    0.00162821395775941,
    2.96573691460055e-06,
    0.0
    ),
Cpg_(
    "Cpg",
    828.512396694215,
    2830.57851239669,
    1250.0,
    1234.50413223141,
    -524.4
    ),
B_(
    "B",
    0.00190599173553719,
    -1.70798898071625,
    -525826.446280992,
    1.70282369146006e+17,
    -2.83298898071625e+20
    ),
mu_("mu", -14.918, 1023.4, 0.5961, 0.0, 0.0),
mug_("mug", 3.1005e-08, 0.9762, 23.139, 0.0),
kappa_("kappa", 0.2502, -0.000298, 0.0, 0.0, 0.0, 0.0),
kappag_("kappag", -26.8, 0.9098, -126500000, 0.0),
sigma_("sigma", 508.20, 0.0622, 1.124, 0.0, 0.0, 0.0),
D_("D", 147.18, 20.1, 58.08, 28), // note: Same as nHeptane
Hf_(h_.value(Tstd))
{}
```

--------------------------------

### Get Losort Start Addressing

Source: https://cpp.openfoam.org/v11/lduAddressing_8C_source.html

Returns the losort start addressing list. If not already calculated, it calls calcLosortStart() to compute it.

```cpp
const Foam::labelUList& Foam::lduAddressing::losortStartAddr() const
{
    if (!losortStartPtr_)
    {
        calcLosortStart();
    }

    return *losortStartPtr_;
}
```

--------------------------------

### Get Owner Start Addressing

Source: https://cpp.openfoam.org/v11/lduAddressing_8C_source.html

Returns the owner start addressing list. If not already calculated, it calls calcOwnerStart() to compute it.

```cpp
const Foam::labelUList& Foam::lduAddressing::ownerStartAddr() const
{
    if (!ownerStartPtr_)
    {
        calcOwnerStart();
    }

    return *ownerStartPtr_;
}
```

--------------------------------

### searchableSphere Configuration Example

Source: https://cpp.openfoam.org/v11/searchableSphere_8H_source.html

Example specification for a searchableSphere in the snappyHexMeshDict. Requires 'centre' and 'radius' properties.

```C++
type searchableSphere;
centre (10 10 10);
radius 5;
```

--------------------------------

### Get the starting offset for a processor's data

Source: https://cpp.openfoam.org/v11/classFoam_1_1globalIndex.html

This function returns the starting offset for data belonging to a specific processor.

```cpp
inline label offset
    (
        const label _proci_
    ) const
```

--------------------------------

### OpenFOAM Population Balance Model Setup

Source: https://cpp.openfoam.org/v11/phaseSystems_2populationBalanceModel_2nucleationModels_2reactionDriven_2reactionDriven_8C_source.html

Setup for population balance models in OpenFOAM. This defines the model and its parameters.

```C++
populationBalanceModel
{
    // Model parameters and settings
}
```

--------------------------------

### Actuation Disk Source Configuration Example

Source: https://cpp.openfoam.org/v11/classFoam_1_1fv_1_1actuationDiskSource.html

Example configuration for an actuation disk source. Specify the cell set, disk direction, coefficients, area, and upstream point.

```C++
actuationDiskSource1
{
    type            actuationDiskSource;

    select          cellSet;
    cellSet         actuationDisk1;

    diskDir         (-1 0 0);   // Disk direction
    Cp              0.1;        // Power coefficient
    Ct              0.5;        // Thrust coefficient
    diskArea        5.0;        // Disk area
    upstreamPoint   (0 0 0);    // Upstream point
}

```

--------------------------------

### Get Old Patch Starts

Source: https://cpp.openfoam.org/v11/classFoam_1_1faceMapper.html

Returns a list indicating the starting indices of old patches in the mesh before the topological change.

```cpp
virtual const labelList & oldPatchStarts () const
```

--------------------------------

### Get the starting label of a patch

Source: https://cpp.openfoam.org/v11/cellToCellStencil_8C_source.html

Returns the starting label index for this patch within the global polyMesh face list.

```cpp
label start() const

```

--------------------------------

### Cone Injection Configuration Example

Source: https://cpp.openfoam.org/v11/classFoam_1_1ConeInjection.html

This example demonstrates how to configure the coneInjection model in OpenFOAM, including parameters for timing, particle properties, geometry, and velocity.

```C++
    injectionModels
    {
        model1
        {
            type            coneInjection;

            // Times
            SOI             0;
            duration        1;

            // Quantities
            parcelsPerSecond 1000000;

            // - Inject parcels with a fixed number of particles
            nParticle       1;

            //// - Or, inject a specified mass of particles
            //massTotal       6.0e-6;
            //uniformParcelSize volume;

            // Sizes
            sizeDistribution
            {
                type        fixedValue;
                fixedValueDistribution
                {
                    value   0.0025;
                }
            }

            // Geometry
            position        (-0.15 -0.1 0);
            direction       (1 0 0);
            thetaInner      0;
            thetaOuter      45;

            // - Inject at a point
            injectionMethod point;

            //// - Or, inject over a disc:
            //injectionMethod disc;
            //dInner          0;
            //dOuter          0.05;

            // Velocity

            // - Inject with constant velocity
            flowType        constantVelocity;
            Umag            1;

            //// - Or, inject with flow rate and discharge coefficient
            ////   This also requires massTotal, dInner and dOuter
            //flowType        flowRateAndDischarge;
            //Cd              0.9;

            //// - Or, inject at a pressure
            //flowType        pressureDrivenVelocity;
            //Pinj            10e5;
        }
    }
```

--------------------------------

### lineCellFace Example Specification

Source: https://cpp.openfoam.org/v11/classFoam_1_1sampledSets_1_1lineCellFace.html

This is an example of how to specify the lineCellFace object in a dictionary. It requires the type, start point, end point, and axis.

```C++
{
    type        lineCellFace;
    start       (0.55 0.6 0.5);
    end         (0.55 -0.3 -0.1);
    axis        x;
}
```

--------------------------------

### Example Usage of accelerationSource

Source: https://cpp.openfoam.org/v11/classFoam_1_1fv_1_1accelerationSource.html

This configuration block demonstrates how to set up the accelerationSource in a OpenFOAM case. It specifies the type, selection criteria, field names, and the nature of the acceleration (e.g., scale with a ramp).

```C++
accelerationSource1
{
    type            accelerationSource;

    select          all;

    U               U;

    velocity        scale;
    value           (-2.572 0 0);
    scale
    {
        type            halfCosineRamp;
        start           0;
        duration        10;
    }
}

```

--------------------------------

### Property Initialization Examples

Source: https://cpp.openfoam.org/v11/CH4N2O_8C_source.html

Examples of initializing various physical properties for the CH4N2O class, such as density, pressure, heat capacity, and viscosity. These are typically defined within the CH4N2O.C file.

```cpp
rho_("rho", 1230.006936, 0.0, 0.0, 0.0, 0.0, 0.0),

```

```cpp
pv_
(
    "pv",
    3015.15611544,
    -185497.059684,
    -430.223621983,
    0.00017405122622,
    2.0
),

```

```cpp
hl_("hl", 705.0, 2534249.0, 0.5, 0.0, 0.0, 0.0),

```

```cpp
Cp_("Cp", 2006.46063673904, 0.0, 0.0, 0.0, 0.0, 0.0),

```

```cpp
h_("h", -6154107.41641135, 2006.46063673904, 0.0, 0.0, 0.0, 0.0),

```

```cpp
Cpg_
(
    "Cpg",
    811.875582789397,
    2099.04089516451,
    1627.3,
    1603.63660583455,
    724.41
),

```

```cpp
B_
(
    "B",
    -0.000383641934194752,
    0.447249234048222,
    -469062.208605302,
    5.5628080458239e+18,
    -2.3040162514986e+21
),

```

```cpp
mu_("mu", -51.964, 3670.6, 5.7331, -5.3495e-29, 10.0),

```

```cpp
mug_("mug", 2.6986e-06, 0.498, 1257.7, -19570.0),

```

```cpp
kappa_("kappa", -0.4267, 0.0056903, -8.0065e-06, 1.815e-09, 0.0, 0.0),

```

```cpp
kappag_("kappag", 6.977e-05, 1.1243, 844.9, -148850.0),

```

```cpp
sigma_("sigma", 705.0, 1.0, 0.0, 0.0, 0.0, 0.0), // note: set to constant

```

```cpp
D_("D", 147.18, 20.1, 60.056, 28.0), // note: Same as nHeptane

```

```cpp
Hf_(h_.value(Tstd))

```

--------------------------------

### Get Patch Starts in C++

Source: https://cpp.openfoam.org/v11/polyMeshAdder_8H_source.html

Retrieves the starting indices for patches within a polyBoundaryMesh. This function is part of mesh utility operations.

```cpp
static labelList getPatchStarts(const polyBoundaryMesh&);
```

--------------------------------

### IOobject Constructors

Source: https://cpp.openfoam.org/v11/classFoam_1_1solvers_1_1solidDisplacement.html

Demonstrates the various ways to construct an IOobject, from basic initialization to copying and cloning.

```APIDOC
## IOobject Constructors

### Description
Constructs an IOobject with specified parameters or from existing objects.

### Methods
- IOobject (const word &name, const fileName &instance, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const word &name, const fileName &instance, const fileName &local, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const fileName &path, const objectRegistry &registry, readOption r=NO_READ, writeOption w=NO_WRITE, bool registerObject=true)
- IOobject (const IOobject &io, const objectRegistry &registry)
- IOobject (const IOobject &io, const word &name)
- IOobject (const IOobject &io)=default

### Request Example
```cpp
// Example of constructing an IOobject
IOobject myObject("myObjectName", "1.0", db(), IOobject::READ_IF_MODIFIED, IOobject::WRITE_IF_CHANGED);
```

### Response
#### Success Response (200)
N/A for constructors.

#### Response Example
N/A for constructors.
```

--------------------------------

### Get Non-Feature Start Index

Source: https://cpp.openfoam.org/v11/extendedFeatureEdgeMeshI_8H_source.html

Returns the label for the start of non-feature edges in the extended feature edge mesh. This is an inline function.

```cpp
inline Foam::label Foam::extendedFeatureEdgeMesh::nonFeatureStart() const
{
 return nonFeatureStart_;
}
```

--------------------------------

### searchableDisk Specification Example

Source: https://cpp.openfoam.org/v11/classFoam_1_1searchableDisk.html

Example of how to specify a searchableDisk in a snappyHexMeshDict.

```C++
        type       searchableDisk;
        origin     (10 10 10);
        normal     (0 1 0);
        radius     5;

```

--------------------------------

### Get Concave Start Index

Source: https://cpp.openfoam.org/v11/extendedFeatureEdgeMeshI_8H_source.html

Returns the label for the start of concave edges in the extended feature edge mesh. This is an inline function.

```cpp
inline Foam::label Foam::extendedFeatureEdgeMesh::concaveStart() const
{
 return concaveStart_;
}
```

--------------------------------

### Example Usage of Variable Heat Transfer Coefficient Model

Source: https://cpp.openfoam.org/v11/classFoam_1_1fv_1_1heatTransferCoefficientModels_1_1variable.html

Demonstrates how to instantiate and configure the variable heat transfer coefficient model in a dictionary. Ensure all required parameters like 'a', 'b', 'c', 'Pr', and 'L' are provided.

```C++
{
    heatTransferCoefficientModel variable;

    a           1;
    b           2;
    c           3;
    Pr          0.7;
    L           1e-3;
}
```

--------------------------------

### Get Convex Start Index

Source: https://cpp.openfoam.org/v11/extendedFeatureEdgeMeshI_8H_source.html

Returns the label for the start of convex edges in the extended feature edge mesh. This is an inline function.

```cpp
inline Foam::label Foam::extendedFeatureEdgeMesh::convexStart() const
{
 return convexStart_;
}
```