diff --git a/src/OpenFOAM/primitives/functions/Function1/CSV/CSV.C b/src/OpenFOAM/primitives/functions/Function1/CSV/CSV.C
index 9d2d858174..b82b4d3010 100644
--- a/src/OpenFOAM/primitives/functions/Function1/CSV/CSV.C
+++ b/src/OpenFOAM/primitives/functions/Function1/CSV/CSV.C
@@ -204,7 +204,8 @@ Foam::Function1Types::CSV<Type>::CSV
 (
     const word& entryName,
     const dictionary& dict,
-    const word& ext
+    const word& ext,
+    const fileName& fName
 )
 :
     TableBase<Type>(entryName, dict.subDict(entryName + ext)),
@@ -214,7 +215,7 @@ Foam::Function1Types::CSV<Type>::CSV
     componentColumns_(coeffs_.lookup("componentColumns")),
     separator_(coeffs_.lookupOrDefault<string>("separator", string(","))[0]),
     mergeSeparators_(readBool(coeffs_.lookup("mergeSeparators"))),
-    fName_(coeffs_.lookup("fileName"))
+    fName_(fName != fileName::null ? fName : coeffs_.lookup("fileName"))
 {
     if (componentColumns_.size() != pTraits<Type>::nComponents)
     {
diff --git a/src/OpenFOAM/primitives/functions/Function1/CSV/CSV.H b/src/OpenFOAM/primitives/functions/Function1/CSV/CSV.H
index 97e0047a2b..ddba48afa5 100644
--- a/src/OpenFOAM/primitives/functions/Function1/CSV/CSV.H
+++ b/src/OpenFOAM/primitives/functions/Function1/CSV/CSV.H
@@ -122,7 +122,8 @@ public:
         (
             const word& entryName,
             const dictionary& dict,
-            const word& ext = "Coeffs"
+            const word& ext = "Coeffs",
+            const fileName& fName = fileName::null
         );
 
         //- Copy constructor
diff --git a/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.C b/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.C
index 21d52bb3dd..ae80887fe8 100644
--- a/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.C
+++ b/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.C
@@ -94,17 +94,41 @@ Foam::label Foam::noiseModel::findStartTimeIndex
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::noiseModel::noiseModel(const dictionary& dict)
+Foam::noiseModel::noiseModel(const dictionary& dict, const bool readFields)
 :
     dict_(dict),
-    rhoRef_(dict.lookupOrDefault<scalar>("rhoRef", 1)),
-    nSamples_(dict.lookupOrDefault<label>("N", 65536)),
-    fLower_(dict.lookupOrDefault<scalar>("fl", 25)),
-    fUpper_(dict.lookupOrDefault<scalar>("fu", 10000)),
-    startTime_(dict.lookupOrDefault<scalar>("startTime", 0)),
-    windowModelPtr_(windowModel::New(dict, nSamples_)),
-    graphFormat_(dict.lookupOrDefault<word>("graphFormat", "raw"))
+    rhoRef_(1),
+    nSamples_(65536),
+    fLower_(25),
+    fUpper_(10000),
+    startTime_(0),
+    windowModelPtr_(),
+    graphFormat_("raw")
 {
+    if (readFields)
+    {
+        read(dict);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::noiseModel::~noiseModel()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::noiseModel::read(const dictionary& dict)
+{
+    dict.readIfPresent("rhoRef", rhoRef_);
+    dict.readIfPresent("N", nSamples_);
+    dict.readIfPresent("fl", fLower_);
+    dict.readIfPresent("fu", fUpper_);
+    dict.readIfPresent("startTime", startTime_);
+    dict.readIfPresent("graphFormat", graphFormat_);
+
     // Check number of samples  - must be a power of 2 for our FFT
     bool powerOf2 = ((nSamples_ != 0) && !(nSamples_ & (nSamples_ - 1)));
     if (!powerOf2)
@@ -139,13 +163,11 @@ Foam::noiseModel::noiseModel(const dictionary& dict)
             << exit(FatalIOError);
 
     }
+
+    windowModelPtr_ = windowModel::New(dict, nSamples_);
+
+    return true;
 }
 
 
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::noiseModel::~noiseModel()
-{}
-
-
 // ************************************************************************* //
diff --git a/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.H b/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.H
index 28643cbf56..89c41edb84 100644
--- a/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.H
+++ b/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.H
@@ -124,7 +124,7 @@ protected:
         scalar checkUniformTimeStep
         (
             const scalarList& times
-        ) const; 
+        ) const;
 
         //- Find and return start time index
         label findStartTimeIndex
@@ -139,7 +139,7 @@ public:
     //- Runtime type information
     TypeName("noiseModel");
 
-    //- Run time selection table  
+    //- Run time selection table
     declareRunTimeSelectionTable
     (
         autoPtr,
@@ -155,7 +155,7 @@ public:
     static autoPtr<noiseModel> New(const dictionary& dict);
 
     //- Constructor
-    noiseModel(const dictionary& dict);
+    noiseModel(const dictionary& dict, const bool readFields = true);
 
     //- Destructor
     virtual ~noiseModel();
@@ -163,6 +163,9 @@ public:
 
     // Public Member Functions
 
+        //- Read from dictionary
+        virtual bool read(const dictionary& dict);
+
         //- Abstract call to calculate
         virtual void calculate() = 0;
 };
diff --git a/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.C b/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.C
index fc03d03003..36e5032e7e 100644
--- a/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.C
+++ b/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.C
@@ -43,14 +43,12 @@ addToRunTimeSelectionTable(noiseModel, pointNoise, dictionary);
 
 void pointNoise::filterTimeData
 (
-    const Function1Types::CSV<scalar>& pData,
+    const scalarField& t0,
+    const scalarField& p0,
     scalarField& t,
     scalarField& p
-)
+) const
 {
-    const scalarField t0(pData.x());
-    const scalarField p0(pData.y());
-
     DynamicList<scalar> tf(t0.size());
     DynamicList<scalar> pf(t0.size());
 
@@ -68,23 +66,15 @@ void pointNoise::filterTimeData
 }
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void pointNoise::calculate()
+void pointNoise::processData(const Function1Types::CSV<scalar>& data)
 {
-    // Point data only handled by master
-    if (!Pstream::master())
-    {
-        return;
-    }
+    Info<< "Reading data file " << data.fName() << endl;
 
-    Info<< "Reading data file" << endl;
-
-    Function1Types::CSV<scalar> pData("pressure", dict_, "Data");
+    const fileName& fNameBase = data.fName()(true);
 
     // Time and pressure history data
     scalarField t, p;
-    filterTimeData(pData, t, p);
+    filterTimeData(data.x(), data.y(), t, p);
     p *= rhoRef_;
 
     Info<< "    read " << t.size() << " values" << nl << endl;
@@ -96,7 +86,7 @@ void pointNoise::calculate()
     windowModelPtr_->validate(t.size());
     const windowModel& win = windowModelPtr_();
     const scalar deltaf = 1.0/(deltaT*win.nSamples());
-    fileName outDir(fileName("postProcessing")/"noise"/typeName);
+    fileName outDir(fileName("postProcessing")/"noise"/typeName/fNameBase);
 
     // Create the fft
     noiseFFT nfft(deltaT, p);
@@ -185,12 +175,45 @@ void pointNoise::calculate()
 }
 
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void pointNoise::calculate()
+{
+    // Point data only handled by master
+    if (!Pstream::master())
+    {
+        return;
+    }
+
+
+    if (inputFileNames_.size())
+    {
+        forAll(inputFileNames_, i)
+        {
+            const fileName fName = inputFileNames_[i].expand();
+            Function1Types::CSV<scalar> data("pressure", dict_, "Data", fName);
+            processData(data);
+        }
+    }
+    else
+    {
+        Function1Types::CSV<scalar> data("pressure", dict_, "Data");
+        processData(data);
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-pointNoise::pointNoise(const dictionary& dict)
+pointNoise::pointNoise(const dictionary& dict, const bool readFields)
 :
     noiseModel(dict)
-{}
+{
+    if (readFields)
+    {
+        read(dict);
+    }
+}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
@@ -199,6 +222,18 @@ pointNoise::~pointNoise()
 {}
 
 
+bool pointNoise::read(const dictionary& dict)
+{
+    if (noiseModel::read(dict))
+    {
+        dict.readIfPresent("inputFiles", inputFileNames_);
+        return true;
+    }
+
+    return false;
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace noiseModels
diff --git a/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.H b/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.H
index 30bc669ae9..374678487f 100644
--- a/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.H
+++ b/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.H
@@ -76,8 +76,8 @@ SeeAlso
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef pointNoise_H
-#define pointNoise_H
+#ifndef noiseModels_pointNoise_H
+#define noiseModels_pointNoise_H
 
 #include "noiseModel.H"
 #include "CSV.H"
@@ -100,14 +100,24 @@ class pointNoise
 
 protected:
 
+    // Protected data
+
+        //- Input file names - optional
+        List<fileName> inputFileNames_;
+
+
     // Protected Member Functions
 
         void filterTimeData
         (
-            const Function1Types::CSV<scalar>& pData,
+            const scalarField& t0,
+            const scalarField& p0,
             scalarField& t,
             scalarField& p
-        );
+        ) const;
+
+        //- Process the CSV data
+        void processData(const Function1Types::CSV<scalar>& data);
 
 
 public:
@@ -116,7 +126,7 @@ public:
     TypeName("pointNoise");
 
     //- Constructor
-    pointNoise(const dictionary& dict);
+    pointNoise(const dictionary& dict, const bool readFields = true);
 
     //- Destructor
     virtual ~pointNoise();
@@ -124,6 +134,9 @@ public:
 
     // Public Member Functions
 
+        //- Read from dictionary
+        virtual bool read(const dictionary& dict);
+
         //- Calculate
         virtual void calculate();
 
diff --git a/src/randomProcesses/noise/noiseModels/surfaceNoise/surfaceNoise.C b/src/randomProcesses/noise/noiseModels/surfaceNoise/surfaceNoise.C
index 69cb1713c1..00b4386b00 100644
--- a/src/randomProcesses/noise/noiseModels/surfaceNoise/surfaceNoise.C
+++ b/src/randomProcesses/noise/noiseModels/surfaceNoise/surfaceNoise.C
@@ -44,12 +44,9 @@ addToRunTimeSelectionTable(noiseModel, surfaceNoise, dictionary);
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
-void surfaceNoise::initialise(const dictionary& dict)
+void surfaceNoise::initialise(const fileName& fName)
 {
-    dict.lookup("inputFile") >> inputFileName_;
-    inputFileName_.expand();
-
-    dict.readIfPresent("fftWriteInterval", fftWriteInterval_);
+    Info<< "Reading data file " << fName << endl;
 
     label nAvailableTimes = 0;
 
@@ -57,17 +54,15 @@ void surfaceNoise::initialise(const dictionary& dict)
     if (Pstream::master())
     {
         // Create the surface reader
-        const word readerType(dict.lookup("reader"));
-        readerPtr_.reset(surfaceReader::New(readerType, inputFileName_).ptr());
+        readerPtr_ = surfaceReader::New(readerType_, fName);
 
         // Find the index of the pressure data
-        const word pName(dict.lookupOrDefault<word>("p", "p"));
         const List<word> fieldNames(readerPtr_->fieldNames(0));
-        pIndex_ = findIndex(fieldNames, pName);
+        pIndex_ = findIndex(fieldNames, pName_);
         if (pIndex_ == -1)
         {
             FatalErrorInFunction
-                << "Unable to find pressure field name " << pName
+                << "Unable to find pressure field name " << pName_
                 << " in list of available fields: " << fieldNames
                 << exit(FatalError);
         }
@@ -76,12 +71,6 @@ void surfaceNoise::initialise(const dictionary& dict)
         // - Could be done later, but since this utility can process a lot of
         //   data we can ensure that the user-input is correct prior to doing
         //   the heavy lifting
-        const word writerType(dict.lookup("writer"));
-        dictionary optDict
-        (
-            dict.subOrEmptyDict("writeOptions").subOrEmptyDict(writerType)
-        );
-        writerPtr_.reset(surfaceWriter::New(writerType, optDict).ptr());
 
         // Set the time range
         const instantList allTimes = readerPtr_->times();
@@ -404,18 +393,25 @@ Foam::scalar surfaceNoise::surfaceAverage
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-surfaceNoise::surfaceNoise(const dictionary& dict)
+surfaceNoise::surfaceNoise(const dictionary& dict, const bool readFields)
 :
-    noiseModel(dict),
-    inputFileName_("unknown-inputFile"),
+    noiseModel(dict, false),
+    inputFileNames_(),
+    pName_("p"),
     pIndex_(0),
     times_(),
     deltaT_(0),
     startTimeIndex_(0),
     nFace_(0),
-    fftWriteInterval_(1)
+    fftWriteInterval_(1),
+    readerType_(word::null),
+    readerPtr_(nullptr),
+    writerPtr_(nullptr)
 {
-    initialise(dict);
+    if (readFields)
+    {
+        read(dict);
+    }
 }
 
 
@@ -427,271 +423,307 @@ surfaceNoise::~surfaceNoise()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+bool surfaceNoise::read(const dictionary& dict)
+{
+    if (noiseModel::read(dict))
+    {
+        dict.lookup("inputFiles") >> inputFileNames_;
+        dict.readIfPresent("fftWriteInterval", fftWriteInterval_);
+        dict.readIfPresent("p", pName_);
+
+        dict.lookup("reader") >> readerType_;
+
+        word writerType(dict.lookup("writer"));
+        dictionary optDict
+        (
+            dict.subOrEmptyDict("writeOptions").subOrEmptyDict(writerType)
+        );
+
+        writerPtr_ = surfaceWriter::New(writerType, optDict);
+
+        return true;
+    }
+
+    return false;
+}
+
+
 void surfaceNoise::calculate()
 {
-    // Container for pressure time history data per face
-    List<scalarField> pData;
-
-    // Processor procFaceOffsets
-    labelList procFaceOffset;
-    if (Pstream::parRun())
+    forAll(inputFileNames_, i)
     {
-        const label nProcs = Pstream::nProcs();
-        const label nFacePerProc = floor(nFace_/nProcs) + 1;
+        fileName fName = inputFileNames_[i];
 
-        procFaceOffset.setSize(nProcs + 1, 0);
-        for (label i = 1; i < procFaceOffset.size(); i++)
+        initialise(fName.expand());
+
+        // Container for pressure time history data per face
+        List<scalarField> pData;
+
+        // Processor procFaceOffsets
+        labelList procFaceOffset;
+        if (Pstream::parRun())
         {
-            procFaceOffset[i] = min(i*nFacePerProc, nFace_);
+            const label nProcs = Pstream::nProcs();
+            const label nFacePerProc = floor(nFace_/nProcs) + 1;
+
+            procFaceOffset.setSize(nProcs + 1, 0);
+            for (label i = 1; i < procFaceOffset.size(); i++)
+            {
+                procFaceOffset[i] = min(i*nFacePerProc, nFace_);
+            }
         }
-    }
-    else
-    {
-        procFaceOffset.setSize(1, nFace_);
-    }
-
-    // Read pressure data from file
-    readSurfaceData(procFaceOffset, pData);
-
-    // Process the pressure data, and store results as surface values per
-    // frequency so that it can be output using the surface writer
-
-    Info<< "Creating noise FFTs" << endl;
-
-    // Storage for FFT data
-    const label nLocalFace = pData.size();
-    const scalarField freq1(noiseFFT::frequencies(nSamples_, deltaT_));
-    const label nFFT = freq1.size()/fftWriteInterval_;
-    List<scalarField> surfPrmsf(nFFT);
-    List<scalarField> surfPSDf(nFFT);
-    forAll(surfPrmsf, freqI)
-    {
-        surfPrmsf[freqI].setSize(nLocalFace);
-        surfPSDf[freqI].setSize(nLocalFace);
-    }
-
-    // Storage for 1/3 octave data
-    labelList octave13BandIDs;
-    scalarField octave13FreqCentre;
-    noiseFFT::octaveBandInfo
-    (
-        freq1,
-        fLower_,
-        fUpper_,
-        3,
-        octave13BandIDs,
-        octave13FreqCentre
-    );
-
-    label bandSize = 0;
-    if (octave13BandIDs.empty())
-    {
-        WarningInFunction
-            << "Ocatve band calculation failed (zero sized). "
-            << "please check your input data"
-            << endl;
-    }
-    else
-    {
-        bandSize = octave13BandIDs.size() - 1;
-    }
-
-    List<scalarField> surfPSD13f(bandSize);
-    List<scalarField> surfPrms13f2(bandSize);
-    forAll(surfPSD13f, freqI)
-    {
-        surfPSD13f[freqI].setSize(nLocalFace);
-        surfPrms13f2[freqI].setSize(nLocalFace);
-    }
-
-    const windowModel& win = windowModelPtr_();
-
-    forAll(pData, faceI)
-    {
-        const scalarField& p = pData[faceI];
-
-        noiseFFT nfft(deltaT_, p);
-        graph Prmsf(nfft.RMSmeanPf(win));
-        graph PSDf(nfft.PSDf(win));
-
-        // Store the frequency results in slot for face of surface
-        forAll(surfPrmsf, i)
+        else
         {
-            label freqI = (i + 1)*fftWriteInterval_ - 1;
-            surfPrmsf[i][faceI] = Prmsf.y()[freqI];
-            surfPSDf[i][faceI] = PSDf.y()[freqI];
+            procFaceOffset.setSize(1, nFace_);
         }
 
-        // PSD [Pa^2/Hz]
-        graph PSD13f(nfft.octaves(PSDf, octave13BandIDs, false));
+        // Read pressure data from file
+        readSurfaceData(procFaceOffset, pData);
 
-        // Integrated PSD = P(rms)^2 [Pa^2]
-        graph Prms13f2(nfft.octaves(PSDf, octave13BandIDs, true));
+        // Process the pressure data, and store results as surface values per
+        // frequency so that it can be output using the surface writer
 
-        // Store the 1/3 octave results in slot for face of surface
+        Info<< "Creating noise FFTs" << endl;
+
+        // Storage for FFT data
+        const label nLocalFace = pData.size();
+        const scalarField freq1(noiseFFT::frequencies(nSamples_, deltaT_));
+        const label nFFT = freq1.size()/fftWriteInterval_;
+        List<scalarField> surfPrmsf(nFFT);
+        List<scalarField> surfPSDf(nFFT);
+        forAll(surfPrmsf, freqI)
+        {
+            surfPrmsf[freqI].setSize(nLocalFace);
+            surfPSDf[freqI].setSize(nLocalFace);
+        }
+
+        // Storage for 1/3 octave data
+        labelList octave13BandIDs;
+        scalarField octave13FreqCentre;
+        noiseFFT::octaveBandInfo
+        (
+            freq1,
+            fLower_,
+            fUpper_,
+            3,
+            octave13BandIDs,
+            octave13FreqCentre
+        );
+
+        label bandSize = 0;
+        if (octave13BandIDs.empty())
+        {
+            WarningInFunction
+                << "Ocatve band calculation failed (zero sized). "
+                << "please check your input data"
+                << endl;
+        }
+        else
+        {
+            bandSize = octave13BandIDs.size() - 1;
+        }
+
+        List<scalarField> surfPSD13f(bandSize);
+        List<scalarField> surfPrms13f2(bandSize);
         forAll(surfPSD13f, freqI)
         {
-            surfPSD13f[freqI][faceI] = PSD13f.y()[freqI];
-            surfPrms13f2[freqI][faceI] = Prms13f2.y()[freqI];
+            surfPSD13f[freqI].setSize(nLocalFace);
+            surfPrms13f2[freqI].setSize(nLocalFace);
         }
-    }
 
-    // Output directory for graphs
-    fileName outDir(fileName("postProcessing")/"noise"/typeName);
+        const windowModel& win = windowModelPtr_();
 
-    const scalar deltaf = 1.0/(deltaT_*win.nSamples());
-    Info<< "Writing fft surface data" << endl;
-    {
-        scalarField PrmsfAve(surfPrmsf.size(), 0);
-        scalarField PSDfAve(surfPrmsf.size(), 0);
-        scalarField fOut(surfPrmsf.size(), 0);
-
-        forAll(surfPrmsf, i)
+        forAll(pData, faceI)
         {
-            label freqI = i*fftWriteInterval_;
-            fOut[i] = freq1[freqI];
-            const word& fName = inputFileName_.name(true);
-            const word gName = "fft";
-            PrmsfAve[i] = writeSurfaceData
-            (
-                fName,
-                gName,
-                "Prmsf",
-                freq1[freqI],
-                surfPrmsf[i],
-                procFaceOffset
-            );
+            const scalarField& p = pData[faceI];
 
-            PSDfAve[i] = writeSurfaceData
-            (
-                fName,
-                gName,
-                "PSDf",
-                freq1[freqI],
-                surfPSDf[i],
-                procFaceOffset
-            );
-            writeSurfaceData
-            (
-                fName,
-                gName,
-                "PSD",
-                freq1[freqI],
-                noiseFFT::PSD(surfPSDf[i]),
-                procFaceOffset
-            );
-            writeSurfaceData
-            (
-                fName,
-                gName,
-                "SPL",
-                freq1[freqI],
-                noiseFFT::SPL(surfPSDf[i]*deltaf),
-                procFaceOffset
-            );
+            noiseFFT nfft(deltaT_, p);
+            graph Prmsf(nfft.RMSmeanPf(win));
+            graph PSDf(nfft.PSDf(win));
+
+            // Store the frequency results in slot for face of surface
+            forAll(surfPrmsf, i)
+            {
+                label freqI = (i + 1)*fftWriteInterval_ - 1;
+                surfPrmsf[i][faceI] = Prmsf.y()[freqI];
+                surfPSDf[i][faceI] = PSDf.y()[freqI];
+            }
+
+            // PSD [Pa^2/Hz]
+            graph PSD13f(nfft.octaves(PSDf, octave13BandIDs, false));
+
+            // Integrated PSD = P(rms)^2 [Pa^2]
+            graph Prms13f2(nfft.octaves(PSDf, octave13BandIDs, true));
+
+            // Store the 1/3 octave results in slot for face of surface
+            forAll(surfPSD13f, freqI)
+            {
+                surfPSD13f[freqI][faceI] = PSD13f.y()[freqI];
+                surfPrms13f2[freqI][faceI] = Prms13f2.y()[freqI];
+            }
         }
 
-        graph Prmsfg
+        const word& fNameBase = fName.name(true);
+
+        // Output directory for graphs
+        fileName outDir
         (
-            "Average Prms(f)",
-            "f [Hz]",
-            "P(f) [Pa]",
-            fOut,
-            PrmsfAve
+            fileName("postProcessing")/"noise"/typeName/fNameBase
         );
-        Prmsfg.write(outDir, graph::wordify(Prmsfg.title()), graphFormat_);
 
-        graph PSDfg
-        (
-            "Average PSD_f(f)",
-            "f [Hz]",
-            "PSD(f) [PaPa_Hz]",
-            fOut,
-            PSDfAve
-        );
-        PSDfg.write(outDir, graph::wordify(PSDfg.title()), graphFormat_);
-
-        graph PSDg
-        (
-            "Average PSD_dB_Hz(f)",
-            "f [Hz]",
-            "PSD(f) [dB_Hz]",
-            fOut,
-            noiseFFT::PSD(PSDfAve)
-        );
-        PSDg.write(outDir, graph::wordify(PSDg.title()), graphFormat_);
-
-        graph SPLg
-        (
-            "Average SPL_dB(f)",
-            "f [Hz]",
-            "SPL(f) [dB]",
-            fOut,
-            noiseFFT::SPL(PSDfAve*deltaf)
-        );
-        SPLg.write(outDir, graph::wordify(SPLg.title()), graphFormat_);
-    }
-
-
-    Info<< "Writing one-third octave surface data" << endl;
-    {
-        scalarField PSDfAve(surfPSD13f.size(), 0);
-        scalarField Prms13f2Ave(surfPSD13f.size(), 0);
-
-        forAll(surfPSD13f, i)
+        const scalar deltaf = 1.0/(deltaT_*win.nSamples());
+        Info<< "Writing fft surface data" << endl;
         {
-            const word& fName = inputFileName_.name(true);
-            const word gName = "oneThirdOctave";
-            PSDfAve[i] = writeSurfaceData
-            (
-                fName,
-                gName,
-                "PSD13f",
-                octave13FreqCentre[i],
-                surfPSD13f[i],
-                procFaceOffset
-            );
-            writeSurfaceData
-            (
-                fName,
-                gName,
-                "PSD13",
-                octave13FreqCentre[i],
-                noiseFFT::PSD(surfPSD13f[i]),
-                procFaceOffset
-            );
-            writeSurfaceData
-            (
-                fName,
-                gName,
-                "SPL13",
-                octave13FreqCentre[i],
-                noiseFFT::SPL(surfPrms13f2[i]),
-                procFaceOffset
-            );
+            scalarField PrmsfAve(surfPrmsf.size(), 0);
+            scalarField PSDfAve(surfPrmsf.size(), 0);
+            scalarField fOut(surfPrmsf.size(), 0);
 
-            Prms13f2Ave[i] = surfaceAverage(surfPrms13f2[i], procFaceOffset);
+            forAll(surfPrmsf, i)
+            {
+                label freqI = i*fftWriteInterval_;
+                fOut[i] = freq1[freqI];
+                const word gName = "fft";
+                PrmsfAve[i] = writeSurfaceData
+                (
+                    fNameBase,
+                    gName,
+                    "Prmsf",
+                    freq1[freqI],
+                    surfPrmsf[i],
+                    procFaceOffset
+                );
+
+                PSDfAve[i] = writeSurfaceData
+                (
+                    fNameBase,
+                    gName,
+                    "PSDf",
+                    freq1[freqI],
+                    surfPSDf[i],
+                    procFaceOffset
+                );
+                writeSurfaceData
+                (
+                    fNameBase,
+                    gName,
+                    "PSD",
+                    freq1[freqI],
+                    noiseFFT::PSD(surfPSDf[i]),
+                    procFaceOffset
+                );
+                writeSurfaceData
+                (
+                    fNameBase,
+                    gName,
+                    "SPL",
+                    freq1[freqI],
+                    noiseFFT::SPL(surfPSDf[i]*deltaf),
+                    procFaceOffset
+                );
+            }
+
+            graph Prmsfg
+            (
+                "Average Prms(f)",
+                "f [Hz]",
+                "P(f) [Pa]",
+                fOut,
+                PrmsfAve
+            );
+            Prmsfg.write(outDir, graph::wordify(Prmsfg.title()), graphFormat_);
+
+            graph PSDfg
+            (
+                "Average PSD_f(f)",
+                "f [Hz]",
+                "PSD(f) [PaPa_Hz]",
+                fOut,
+                PSDfAve
+            );
+            PSDfg.write(outDir, graph::wordify(PSDfg.title()), graphFormat_);
+
+            graph PSDg
+            (
+                "Average PSD_dB_Hz(f)",
+                "f [Hz]",
+                "PSD(f) [dB_Hz]",
+                fOut,
+                noiseFFT::PSD(PSDfAve)
+            );
+            PSDg.write(outDir, graph::wordify(PSDg.title()), graphFormat_);
+
+            graph SPLg
+            (
+                "Average SPL_dB(f)",
+                "f [Hz]",
+                "SPL(f) [dB]",
+                fOut,
+                noiseFFT::SPL(PSDfAve*deltaf)
+            );
+            SPLg.write(outDir, graph::wordify(SPLg.title()), graphFormat_);
         }
 
-        graph PSD13g
-        (
-            "Average PSD13_dB_Hz(fm)",
-            "fm [Hz]",
-            "PSD(fm) [dB_Hz]",
-            octave13FreqCentre,
-            noiseFFT::PSD(PSDfAve)
-        );
-        PSD13g.write(outDir, graph::wordify(PSD13g.title()), graphFormat_);
 
-        graph SPL13g
-        (
-            "Average SPL13_dB(fm)",
-            "fm [Hz]",
-            "SPL(fm) [dB]",
-            octave13FreqCentre,
-            noiseFFT::SPL(Prms13f2Ave)
-        );
-        SPL13g.write(outDir, graph::wordify(SPL13g.title()), graphFormat_);
+        Info<< "Writing one-third octave surface data" << endl;
+        {
+            scalarField PSDfAve(surfPSD13f.size(), 0);
+            scalarField Prms13f2Ave(surfPSD13f.size(), 0);
+
+            forAll(surfPSD13f, i)
+            {
+                const word gName = "oneThirdOctave";
+                PSDfAve[i] = writeSurfaceData
+                (
+                    fNameBase,
+                    gName,
+                    "PSD13f",
+                    octave13FreqCentre[i],
+                    surfPSD13f[i],
+                    procFaceOffset
+                );
+                writeSurfaceData
+                (
+                    fNameBase,
+                    gName,
+                    "PSD13",
+                    octave13FreqCentre[i],
+                    noiseFFT::PSD(surfPSD13f[i]),
+                    procFaceOffset
+                );
+                writeSurfaceData
+                (
+                    fNameBase,
+                    gName,
+                    "SPL13",
+                    octave13FreqCentre[i],
+                    noiseFFT::SPL(surfPrms13f2[i]),
+                    procFaceOffset
+                );
+
+                Prms13f2Ave[i] =
+                    surfaceAverage(surfPrms13f2[i], procFaceOffset);
+            }
+
+            graph PSD13g
+            (
+                "Average PSD13_dB_Hz(fm)",
+                "fm [Hz]",
+                "PSD(fm) [dB_Hz]",
+                octave13FreqCentre,
+                noiseFFT::PSD(PSDfAve)
+            );
+            PSD13g.write(outDir, graph::wordify(PSD13g.title()), graphFormat_);
+
+            graph SPL13g
+            (
+                "Average SPL13_dB(fm)",
+                "fm [Hz]",
+                "SPL(fm) [dB]",
+                octave13FreqCentre,
+                noiseFFT::SPL(Prms13f2Ave)
+            );
+            SPL13g.write(outDir, graph::wordify(SPL13g.title()), graphFormat_);
+        }
     }
 }
 
diff --git a/src/randomProcesses/noise/noiseModels/surfaceNoise/surfaceNoise.H b/src/randomProcesses/noise/noiseModels/surfaceNoise/surfaceNoise.H
index 054944a158..165a1cefd7 100644
--- a/src/randomProcesses/noise/noiseModels/surfaceNoise/surfaceNoise.H
+++ b/src/randomProcesses/noise/noiseModels/surfaceNoise/surfaceNoise.H
@@ -53,7 +53,7 @@ Description
     }
 
     // Input file
-    inputFile   "postProcessing/faceSource1/surface/patch/patch.case";
+    inputFiles  ("postProcessing/faceSource1/surface/patch/patch.case");
 
     // Write interval for FFT data, default = 1
     fftWriteInterval 100;
@@ -83,8 +83,8 @@ SeeAlso
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef surfaceNoise_H
-#define surfaceNoise_H
+#ifndef noiseModels_surfaceNoise_H
+#define noiseModels_surfaceNoise_H
 
 #include "noiseModel.H"
 #include "labelList.H"
@@ -115,8 +115,11 @@ protected:
 
     // Protected Data
 
-        //- Input file name
-        fileName inputFileName_;
+        //- Input file names
+        List<fileName> inputFileNames_;
+
+        //- Name of pressure field
+        word pName_;
 
         //- Index of pressure field in reader field list
         label pIndex_;
@@ -138,17 +141,20 @@ protected:
         //  result in a very large number of output files (1 per frequency)
         label fftWriteInterval_;
 
+        //- Reader type
+        word readerType_;
+
         //- Pointer to the surface reader
         mutable autoPtr<surfaceReader> readerPtr_;
 
         //- Pointer to the surface writer
-        autoPtr<surfaceWriter> writerPtr_;
+        mutable autoPtr<surfaceWriter> writerPtr_;
 
 
     // Protected Member Functions
 
         //- Initialise
-        void initialise(const dictionary& dict);
+        void initialise(const fileName& fName);
 
         //- Read surface data
         void readSurfaceData
@@ -183,7 +189,7 @@ public:
     TypeName("surfaceNoise");
 
     //- Constructor
-    surfaceNoise(const dictionary& dict);
+    surfaceNoise(const dictionary& dict, const bool readFields = true);
 
     //- Destructor
     virtual ~surfaceNoise();
@@ -191,6 +197,9 @@ public:
 
     // Public Member Functions
 
+        //- Read from dictionary
+        virtual bool read(const dictionary& dict);
+
         //- Calculate
         virtual void calculate();
 };