noiseModel.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) 2015-2023 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::noiseModel

Description
    Base class for noise models.

    Data is read from a dictionary, e.g.

    \verbatim
    rhoRef          1;
    N               4096;
    minFreq         25;
    maxFreq         10000;
    startTime       0;

    outputPrefix    "test1";

    SPLweighting    dBA;

    // Optional write options dictionary
    writeOptions
    {
        writePrmsf  no;
        writeSPL    yes;
        writePSD    yes;
        writePSDf   no;
        writeOctaves yes;
    }
    \endverbatim

    where
    \table
        Property     | Description                   | Required  | Default value
        rhoRef       | Reference density             | no        | 1
        N            | Number of samples in sampling window | no | 65536 (2^16)
        minFreq      | Lower frequency bounds (fl)   | no        | 25
        maxFreq      | Upper frequency bounds (fu)   | no        | 10000
        sampleFreq   | Sample frequency              | no        | 0
        startTime    | Start time                    | no        | 0
        outputPrefix | Prefix applied to output files| no        | ''
        SPLweighting | Weighting: dBA, dBB, dBC, DBD | no        | none
        dBRef        | Reference for dB calculation  | no        | 2e-5
        writePrmsf   | Write Prmsf data              | no        | yes
        writeSPL     | Write SPL data                | no        | yes
        writePSD     | Write PSD data                | no        | yes
        writePSDf    | Write PSDf data               | no        | yes
        writeOctaves | Write octaves data            | no        | yes
    \endtable

    If provided, the sampleFreq is used to define the deltaT between samples.
    Otherwise the deltaT is determined from the time samples themselves.

SourceFiles
    noiseModel.C

\*---------------------------------------------------------------------------*/

#ifndef Foam_noiseModel_H
#define Foam_noiseModel_H

#include "writeFile.H"
#include "dictionary.H"
#include "scalarList.H"
#include "instantList.H"
#include "windowModel.H"
#include "Enum.H"
#include "Tuple2.H"
#include "runTimeSelectionTables.H"
#include <fftw3.h>

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

namespace Foam
{

/*---------------------------------------------------------------------------*\
                         Class noiseModel Declaration
\*---------------------------------------------------------------------------*/

class noiseModel
:
    public functionObjects::writeFile
{
public:

    enum class weightingType
    {
        none,
        dBA,
        dBB,
        dBC,
        dBD
    };

    static const Enum<weightingType> weightingTypeNames_;

    //- FFTW planner information
    //  Note: storage uses double for use directly with FFTW
    struct planInfo
    {
        bool active;
        label windowSize;
        List<double> in;
        List<double> out;
        fftw_plan plan;
    };

    //- Octave band information
    struct octaveBandInfo
    {
        label octave;

        // IDs of bin boundaries in pressure data
        labelList binIDs;

        // Centre frequencies for each bin
        scalarField centreFreq;
    };


protected:

    // Protected Data

        //- Copy of dictionary used for construction
        const dictionary dict_;

        //- Reference density (to convert from kinematic to static pressure)
        scalar rhoRef_;

        //- Number of samples in sampling window, default = 2^16
        label nSamples_;

        //- Lower frequency limit, default = 25Hz
        scalar fLower_;

        //- Upper frequency limit, default = 10kHz
        scalar fUpper_;

        //- Prescribed sample frequency
        scalar sampleFreq_;

        //- Start time, default = 0s
        scalar startTime_;

        //- Window model
        autoPtr<windowModel> windowModelPtr_;

        //- Weighting
        weightingType SPLweighting_;

        //- Reference for dB calculation, default = 2e-5
        scalar dBRef_;


        // Data validation

            //- Min pressure value
            scalar minPressure_;

            //- Min pressure value
            scalar maxPressure_;


        // Write options

            //- Output  file prefix, default = ''
            fileName outputPrefix_;

            //- Write Prmsf; default = yes
            bool writePrmsf_;

            //- Write SPL; default = yes
            bool writeSPL_;

            //- Write PSD; default = yes
            bool writePSD_;

            //- Write PSDf; default = yes
            bool writePSDf_;

            //- Write writeOctaves; default = yes
            bool writeOctaves_;


        // FFT

            //- Plan information for FFTW
            mutable planInfo planInfo_;


    // Protected Member Functions

        //- Check and return uniform time step
        scalar checkUniformTimeStep
        (
            const scalarList& times
        ) const;

        //- Return true if all pressure data is within min/max bounds
        bool validateBounds(const scalarList& p) const;

        //- Find and return start time index
        FOAM_DEPRECATED_FOR(2022-07, "instant::findStart() static method")
        static label findStartTimeIndex
        (
            const instantList& allTimes,
            const scalar startTime
        )
        {
            return instant::findStart(allTimes, startTime);
        }

        //- Return the base output directory
        fileName baseFileDir(const label dataseti) const;

        //- Write output file header
        void writeFileHeader
        (
            Ostream& os,
            const string& x,
            const string& y,
            const UList<Tuple2<string, token>>& headerValues
                = UList<Tuple2<string, token>>::null()
        ) const;

        // Write frequency-based data to file
        void writeFreqDataToFile
        (
            Ostream& os,
            const scalarField& f,
            const scalarField& fx
        ) const;

        //- Create a field of equally spaced frequencies for the current set of
        //- data - assumes a constant time step
        tmp<scalarField> uniformFrequencies
        (
            const scalar deltaT,
            const bool check
        ) const;

        //- Return a list of the frequency indices wrt f field that correspond
        //- to the bands limits for a given octave
        static void setOctaveBands
        (
            const scalarField& f,
            const scalar fLower,
            const scalar fUpper,
            const scalar octave,
            labelList& fBandIDs,
            scalarField& fCentre
        );

        //- Generate octave data
        tmp<scalarField> octaves
        (
            const scalarField& data,
            const scalarField& f,
            const labelUList& freqBandIDs
        ) const;

        //- Return the fft of the given pressure data
        tmp<scalarField> Pf(const scalarField& p) const;

        //- Return the multi-window mean fft of the complete pressure data [Pa]
        tmp<scalarField> meanPf(const scalarField& p) const;

        //- Return the multi-window RMS mean fft of the complete pressure
        //- data [Pa]
        tmp<scalarField> RMSmeanPf(const scalarField& p) const;

        //- Return the multi-window Power Spectral Density (PSD) of the complete
        //- pressure data [Pa^2/Hz]
        tmp<scalarField> PSDf(const scalarField& p, const scalar deltaT) const;


        // Weightings

            //- A weighting function
            scalar RAf(const scalar f) const;

            //- A weighting as gain in dB
            scalar gainA(const scalar f) const;

            //- B weighting function
            scalar RBf(const scalar f) const;

            //- B weighting as gain in dB
            scalar gainB(const scalar f) const;

            //- C weighting function
            scalar RCf(const scalar f) const;

            //- C weighting as gain in dB
            scalar gainC(const scalar f) const;

            //- D weighting function
            scalar RDf(const scalar f) const;

            //- D weighting as gain in dB
            scalar gainD(const scalar f) const;


public:

    //- Runtime type information
    TypeName("noiseModel");

    //- Run time selection table
    declareRunTimeSelectionTable
    (
        autoPtr,
        noiseModel,
        dictionary,
        (
            const dictionary& dict,
            const objectRegistry& obr
        ),
        (dict, obr)
    );


    // Generated Methods

        //- No copy construct
        noiseModel(const noiseModel&) = delete;

        //- No copy assignment
        void operator=(const noiseModel&) = delete;


    // Constructors

        //- Constructor
        noiseModel
        (
            const dictionary& dict,
            const objectRegistry& obr,
            const word& name,
            const bool readFields = true
        );

        //- Selector
        static autoPtr<noiseModel> New
        (
            const dictionary& dict,
            const objectRegistry& obr
        );


    //- Destructor
    virtual ~noiseModel() = default;


    // Public Member Functions

        //- Read from dictionary
        virtual bool read(const dictionary& dict);

        //- Abstract call to calculate
        virtual void calculate() = 0;

        //- PSD [dB/Hz]
        tmp<Foam::scalarField> PSD(const scalarField& PSDf) const;

        //- SPL [dB]
        tmp<scalarField> SPL
        (
            const scalarField& Prms2,
            const scalar f
        ) const;

        //- SPL [dB]
        tmp<scalarField> SPL
        (
            const scalarField& Prms2,
            const scalarField& f
        ) const;

        //- Clean up the FFTW
        void cleanFFTW();

        //- Helper function to check weightings
        void writeWeightings() const;
};


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

} // End namespace Foam

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

#endif

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