Datasets:

introvoyz042
/

OpenFOAM-dev

License:

Dataset card Files Files and versions

xet

Community

OpenFOAM-dev / data /src /Lagrangian /cloud /LagrangianModels /pointInjection /pointInjection.C

introvoyz042

Migrated from GitHub

5a600cf verified 25 days ago

Raw History Blame Contribute Delete

8.68 kB

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2025-2026 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/>.
\*---------------------------------------------------------------------------*/

#include "pointInjection.H"
#include "addToRunTimeSelectionTable.H"
#include "LagrangianFields.H"

// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

namespace Foam
{
namespace Lagrangian
{
    defineTypeNameAndDebug(pointInjection, 0);
    addToRunTimeSelectionTable(LagrangianModel, pointInjection, dictionary);
}
}


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

void Foam::Lagrangian::pointInjection::readCoeffs(const dictionary& modelDict)
{
    point_.reset
    (
        Function1<vector>::New
        (
            "point",
            mesh().time().userUnits(),
            dimensions::length,
            modelDict
        ).ptr()
    );

    numberRate_.reset
    (
        Function1<scalar>::New
        (
            "numberRate",
            mesh().time().userUnits(),
            dimensions::rate,
            modelDict
        ).ptr()
    );

    numberDeferred_ = 0;

    injectionLocation_ = injectionLocation::unset;
}


// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

Foam::Lagrangian::pointInjection::pointInjection
(
    const word& name,
    const LagrangianMesh& mesh,
    const dictionary& modelDict,
    const dictionary& stateDict
)
:
    LagrangianInjection(name, mesh),
    point_(nullptr),
    numberRate_(nullptr),
    numberDeferred_(stateDict.lookupOrDefault<scalar>("numberDeferred", 0)),
    rndGen_("rndGen", stateDict, name, true),
    timeIndex_(-1),
    injectionLocation_(injectionLocation::unset),
    coordinates_(barycentric::uniform(NaN)),
    celli_(-1),
    facei_(-1),
    faceTrii_(-1)
{
    readCoeffs(modelDict);
}


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

void Foam::Lagrangian::pointInjection::correct()
{
    // If anything is moving then all coordinates have to be constructed on the
    // fly, so don't store anything
    if (mesh().poly().moving() || !point_->constant())
    {
        injectionLocation_ =
            injectionLocation::multiplePoints;
    }

    // If nothing is moving, and coordinates are not already stored, then
    // construct and store the coordinates for repeated usage
    if
    (
        injectionLocation_ == injectionLocation::unset
     || injectionLocation_ == injectionLocation::multiplePoints
    )
    {
        const scalar t1 = mesh().time().value();
        const scalar t0 = t1 - mesh().time().deltaT().value();

        // Evaluate the position
        const point p = point_->value(t0);

        // Locate within the mesh
        const LagrangianMesh::location l =
            mesh().locate(p, coordinates_, celli_, facei_, faceTrii_, 0);

        // Check for failure
        checkLocation(l, p);

        // Set the location flag
        injectionLocation_ =
            celli_ >= 0
          ? injectionLocation::fixedPointOnThisProcessor
          : injectionLocation::fixedPointOnAnotherProcessor;
    }
}


Foam::LagrangianSubMesh Foam::Lagrangian::pointInjection::modify
(
    LagrangianMesh& mesh,
    const LagrangianSubMesh&
) const
{
    const scalar t1 = mesh.time().value();
    const scalar t0 = t1 - mesh.time().deltaT().value();

    // Restart the generator if necessary and set the time index up to date
    rndGen_.start(timeIndex_ == time().timeIndex());
    timeIndex_ = time().timeIndex();

    // Calculate the number of particles to inject. Round down to get an
    // integer number. Store the excess to apply at a later time.
    const scalar number = numberRate_->integral(t0, t1) + numberDeferred_;
    const label numberInt = floor(number);
    numberDeferred_ = number - numberInt;

    // Inject at random times throughout the time-step
    scalarField fraction(rndGen_.scalar01(numberInt));

    // Create particles in the Lagrangian mesh
    switch (injectionLocation_)
    {
        case injectionLocation::unset:
            FatalErrorInFunction
                << "Injection location has not been set"
                << exit(FatalError);
            return LagrangianSubMesh(mesh, LagrangianGroup::none, -1, -1);

        case injectionLocation::fixedPointOnThisProcessor:
        {
            // Use stored coordinates to inject the particles
            return
                mesh.inject
                (
                    *this,
                    barycentricField(numberInt, coordinates_),
                    labelField(numberInt, celli_),
                    labelField(numberInt, facei_),
                    labelField(numberInt, faceTrii_),
                    LagrangianMesh::fractionName,
                    fraction
                );
        }

        case injectionLocation::fixedPointOnAnotherProcessor:
        {
            // Inject nothing. We need this because source conditions evaluated
            // on the process containing the point may communicate; e.g., to
            // sum the flow rate across the processes.
            return
                mesh.inject
                (
                    *this,
                    barycentricField(),
                    labelField(),
                    labelField(),
                    labelField(),
                    LagrangianMesh::fractionName,
                    scalarField()
                );
        }

        case injectionLocation::multiplePoints:
        {
            // Evaluate the variable positions
            const pointField positions(point_->value(t0 + fraction*(t1 - t0)));

            // Locate within the moving mesh
            barycentricField coordinates(numberInt);
            labelField celli(numberInt), facei(numberInt), faceTrii(numberInt);
            const List<LagrangianMesh::location> locations =
                mesh.locate
                (
                    positions,
                    coordinates,
                    celli,
                    facei,
                    faceTrii,
                    fraction
                );

            // Check for any failures
            checkLocation(locations, positions);

            // Remove particles not on this process
            filter(coordinates, celli, facei, faceTrii, fraction);

            // Inject particles
            return
                mesh.inject
                (
                    *this,
                    coordinates,
                    celli,
                    facei,
                    faceTrii,
                    LagrangianMesh::fractionName,
                    fraction
                );
        }
    }

    return LagrangianSubMesh(mesh, LagrangianGroup::none, -1, -1);
}


void Foam::Lagrangian::pointInjection::topoChange(const polyTopoChangeMap&)
{
    injectionLocation_ = injectionLocation::unset;
}


void Foam::Lagrangian::pointInjection::mapMesh(const polyMeshMap&)
{
    injectionLocation_ = injectionLocation::unset;
}


void Foam::Lagrangian::pointInjection::distribute(const polyDistributionMap&)
{
    injectionLocation_ = injectionLocation::unset;
}


bool Foam::Lagrangian::pointInjection::read(const dictionary& modelDict)
{
    if (LagrangianInjection::read(modelDict))
    {
        readCoeffs(modelDict);
        return true;
    }
    else
    {
        return false;
    }
}


void Foam::Lagrangian::pointInjection::writeState(Ostream& os) const
{
    LagrangianInjection::writeState(os);

    writeEntry(os, "numberDeferred", numberDeferred_);
    writeEntry(os, "rndGen", rndGen_);
}


// ************************************************************************* //

	/---------------------------------------------------------------------------\
	========= \|
	\\ / F ield \| OpenFOAM: The Open Source CFD Toolbox
	\\ / O peration \| Website: https://openfoam.org
	\\ / A nd \| Copyright (C) 2025-2026 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/>.

	\---------------------------------------------------------------------------/

	#include "pointInjection.H"
	#include "addToRunTimeSelectionTable.H"
	#include "LagrangianFields.H"

	// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

	namespace Foam
	{
	namespace Lagrangian
	{
	defineTypeNameAndDebug(pointInjection, 0);
	addToRunTimeSelectionTable(LagrangianModel, pointInjection, dictionary);
	}
	}


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

	void Foam::Lagrangian::pointInjection::readCoeffs(const dictionary& modelDict)
	{
	point_.reset
	(
	Function1<vector>::New
	(
	"point",
	mesh().time().userUnits(),
	dimensions::length,
	modelDict
	).ptr()
	);

	numberRate_.reset
	(
	Function1<scalar>::New
	(
	"numberRate",
	mesh().time().userUnits(),
	dimensions::rate,
	modelDict
	).ptr()
	);

	numberDeferred_ = 0;

	injectionLocation_ = injectionLocation::unset;
	}


	// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //

	Foam::Lagrangian::pointInjection::pointInjection
	(
	const word& name,
	const LagrangianMesh& mesh,
	const dictionary& modelDict,
	const dictionary& stateDict
	)
	:
	LagrangianInjection(name, mesh),
	point_(nullptr),
	numberRate_(nullptr),
	numberDeferred_(stateDict.lookupOrDefault<scalar>("numberDeferred", 0)),
	rndGen_("rndGen", stateDict, name, true),
	timeIndex_(-1),
	injectionLocation_(injectionLocation::unset),
	coordinates_(barycentric::uniform(NaN)),
	celli_(-1),
	facei_(-1),
	faceTrii_(-1)
	{
	readCoeffs(modelDict);
	}


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

	void Foam::Lagrangian::pointInjection::correct()
	{
	// If anything is moving then all coordinates have to be constructed on the
	// fly, so don't store anything
	if (mesh().poly().moving() \|\| !point_->constant())
	{
	injectionLocation_ =
	injectionLocation::multiplePoints;
	}

	// If nothing is moving, and coordinates are not already stored, then
	// construct and store the coordinates for repeated usage
	if
	(
	injectionLocation_ == injectionLocation::unset
	\|\| injectionLocation_ == injectionLocation::multiplePoints
	)
	{
	const scalar t1 = mesh().time().value();
	const scalar t0 = t1 - mesh().time().deltaT().value();

	// Evaluate the position
	const point p = point_->value(t0);

	// Locate within the mesh
	const LagrangianMesh::location l =
	mesh().locate(p, coordinates_, celli_, facei_, faceTrii_, 0);

	// Check for failure
	checkLocation(l, p);

	// Set the location flag
	injectionLocation_ =
	celli_ >= 0
	? injectionLocation::fixedPointOnThisProcessor
	: injectionLocation::fixedPointOnAnotherProcessor;
	}
	}


	Foam::LagrangianSubMesh Foam::Lagrangian::pointInjection::modify
	(
	LagrangianMesh& mesh,
	const LagrangianSubMesh&
	) const
	{
	const scalar t1 = mesh.time().value();
	const scalar t0 = t1 - mesh.time().deltaT().value();

	// Restart the generator if necessary and set the time index up to date
	rndGen_.start(timeIndex_ == time().timeIndex());
	timeIndex_ = time().timeIndex();

	// Calculate the number of particles to inject. Round down to get an
	// integer number. Store the excess to apply at a later time.
	const scalar number = numberRate_->integral(t0, t1) + numberDeferred_;
	const label numberInt = floor(number);
	numberDeferred_ = number - numberInt;

	// Inject at random times throughout the time-step
	scalarField fraction(rndGen_.scalar01(numberInt));

	// Create particles in the Lagrangian mesh
	switch (injectionLocation_)
	{
	case injectionLocation::unset:
	FatalErrorInFunction
	<< "Injection location has not been set"
	<< exit(FatalError);
	return LagrangianSubMesh(mesh, LagrangianGroup::none, -1, -1);

	case injectionLocation::fixedPointOnThisProcessor:
	{
	// Use stored coordinates to inject the particles
	return
	mesh.inject
	(
	*this,
	barycentricField(numberInt, coordinates_),
	labelField(numberInt, celli_),
	labelField(numberInt, facei_),
	labelField(numberInt, faceTrii_),
	LagrangianMesh::fractionName,
	fraction
	);
	}

	case injectionLocation::fixedPointOnAnotherProcessor:
	{
	// Inject nothing. We need this because source conditions evaluated
	// on the process containing the point may communicate; e.g., to
	// sum the flow rate across the processes.
	return
	mesh.inject
	(
	*this,
	barycentricField(),
	labelField(),
	labelField(),
	labelField(),
	LagrangianMesh::fractionName,
	scalarField()
	);
	}

	case injectionLocation::multiplePoints:
	{
	// Evaluate the variable positions
	const pointField positions(point_->value(t0 + fraction*(t1 - t0)));

	// Locate within the moving mesh
	barycentricField coordinates(numberInt);
	labelField celli(numberInt), facei(numberInt), faceTrii(numberInt);
	const List<LagrangianMesh::location> locations =
	mesh.locate
	(
	positions,
	coordinates,
	celli,
	facei,
	faceTrii,
	fraction
	);

	// Check for any failures
	checkLocation(locations, positions);

	// Remove particles not on this process
	filter(coordinates, celli, facei, faceTrii, fraction);

	// Inject particles
	return
	mesh.inject
	(
	*this,
	coordinates,
	celli,
	facei,
	faceTrii,
	LagrangianMesh::fractionName,
	fraction
	);
	}
	}

	return LagrangianSubMesh(mesh, LagrangianGroup::none, -1, -1);
	}


	void Foam::Lagrangian::pointInjection::topoChange(const polyTopoChangeMap&)
	{
	injectionLocation_ = injectionLocation::unset;
	}


	void Foam::Lagrangian::pointInjection::mapMesh(const polyMeshMap&)
	{
	injectionLocation_ = injectionLocation::unset;
	}


	void Foam::Lagrangian::pointInjection::distribute(const polyDistributionMap&)
	{
	injectionLocation_ = injectionLocation::unset;
	}


	bool Foam::Lagrangian::pointInjection::read(const dictionary& modelDict)
	{
	if (LagrangianInjection::read(modelDict))
	{
	readCoeffs(modelDict);
	return true;
	}
	else
	{
	return false;
	}
	}


	void Foam::Lagrangian::pointInjection::writeState(Ostream& os) const
	{
	LagrangianInjection::writeState(os);

	writeEntry(os, "numberDeferred", numberDeferred_);
	writeEntry(os, "rndGen", rndGen_);
	}


	// ************************************************************************* //