Merge branch 'master' of ssh://dm/home/dm4/OpenFOAM/OpenFOAM-dev

applications/test/extendedStencil/Test-ExtendedStencil2.C

@@ -0,0 +1,206 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Application
+    testExtendedStencil2
+
+Description
+    Test app for determining extended cell-to-cell stencil.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "fvMesh.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "Time.H"
+#include "OFstream.H"
+#include "meshTools.H"
+
+#include "CFCCellToCellStencil.H"
+
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+void writeStencilOBJ
+(
+    const fileName& fName,
+    const point& fc,
+    const List<point>& stencilCc
+)
+{
+    OFstream str(fName);
+    label vertI = 0;
+
+    meshTools::writeOBJ(str, fc);
+    vertI++;
+
+    forAll(stencilCc, i)
+    {
+        meshTools::writeOBJ(str, stencilCc[i]);
+        vertI++;
+        str << "l 1 " << vertI << nl;
+    }
+}
+
+
+// Stats
+void writeStencilStats(const labelListList& stencil)
+{
+    label sumSize = 0;
+    label nSum = 0;
+    label minSize = labelMax;
+    label maxSize = labelMin;
+
+    forAll(stencil, i)
+    {
+        const labelList& sCells = stencil[i];
+
+        if (sCells.size() > 0)
+        {
+            sumSize += sCells.size();
+            nSum++;
+            minSize = min(minSize, sCells.size());
+            maxSize = max(maxSize, sCells.size());
+        }
+    }
+    reduce(sumSize, sumOp<label>());
+    reduce(nSum, sumOp<label>());
+    sumSize /= nSum;
+
+    reduce(minSize, minOp<label>());
+    reduce(maxSize, maxOp<label>());
+
+    Info<< "Stencil size :" << nl
+        << "    average : " << sumSize << nl
+        << "    min     : " << minSize << nl
+        << "    max     : " << maxSize << nl
+        << endl;
+}
+
+
+// Main program:
+
+int main(int argc, char *argv[])
+{
+#   include "addTimeOptions.H"
+#   include "setRootCase.H"
+#   include "createTime.H"
+
+    // Get times list
+    instantList Times = runTime.times();
+#   include "checkTimeOptions.H"
+    runTime.setTime(Times[startTime], startTime);
+#   include "createMesh.H"
+
+
+    //---- CELL CENTRED STENCIL -----
+
+    // Centred, cell stencil
+    // ~~~~~~~~~~~~~~~~~~~~~
+
+    {
+        // Full stencil. This is per local cell a set of global indices, either
+        // into cells or also boundary faces.
+        CFCCellToCellStencil stencil(mesh);
+
+        // Construct exchange map and renumber stencil
+        List<Map<label> > compactMap(Pstream::nProcs());
+        mapDistribute map
+        (
+            stencil.globalNumbering(),
+            stencil,
+            compactMap
+        );
+
+
+        // Print some stats
+        Info<< "cellFaceCell:" << endl;
+        writeStencilStats(stencil);
+
+
+        // Collect the data in stencil form
+        List<List<vector> > stencilPoints;
+        {
+            const volVectorField& fld = mesh.C();
+
+            // 1. Construct cell data in compact addressing
+            List<point> compactFld(map.constructSize(), pTraits<point>::zero);
+
+            // Insert my internal values
+            forAll(fld, cellI)
+            {
+                compactFld[cellI] = fld[cellI];
+            }
+            // Insert my boundary values
+            label nCompact = fld.size();
+            forAll(fld.boundaryField(), patchI)
+            {
+                const fvPatchField<vector>& pfld = fld.boundaryField()[patchI];
+
+                forAll(pfld, i)
+                {
+                    compactFld[nCompact++] = pfld[i];
+                }
+            }
+
+            // Do all swapping
+            map.distribute(compactFld);
+
+            // 2. Pull to stencil
+            stencilPoints.setSize(stencil.size());
+
+            forAll(stencil, cellI)
+            {
+                const labelList& compactCells = stencil[cellI];
+
+                stencilPoints[cellI].setSize(compactCells.size());
+
+                forAll(compactCells, i)
+                {
+                    stencilPoints[cellI][i] = compactFld[compactCells[i]];
+                }
+            }
+        }
+
+
+        forAll(stencilPoints, cellI)
+        {
+            writeStencilOBJ
+            (
+                runTime.path()/"centredCell" + Foam::name(cellI) + ".obj",
+                mesh.cellCentres()[cellI],
+                stencilPoints[cellI]
+            );
+        }
+    }
+
+    Pout<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/postProcessing/miscellaneous/temporalInterpolate/temporalInterpolate.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,6 +37,8 @@ Description
 #include "surfaceFields.H"
 #include "pointFields.H"
 #include "ReadFields.H"
+#include "interpolationWeights.H"
+#include "uniformInterpolate.H"
 
 using namespace Foam;
 
@@ -48,6 +50,8 @@ class fieldInterpolator
     const HashSet<word>& selectedFields_;
     instant ti_;
     instant ti1_;
+    const interpolationWeights& interpolator_;
+    const wordList& timeNames_;
     int divisions_;
 
 public:
@@ -60,6 +64,8 @@ public:
         const HashSet<word>& selectedFields,
         const instant& ti,
         const instant& ti1,
+        const interpolationWeights& interpolator,
+        const wordList& timeNames,
         int divisions
     )
     :
@@ -69,6 +75,8 @@ public:
         selectedFields_(selectedFields),
         ti_(ti),
         ti1_(ti1),
+        interpolator_(interpolator),
+        timeNames_(timeNames),
         divisions_(divisions)
     {}
 
@@ -98,34 +106,6 @@ void fieldInterpolator::interpolate()
             {
                 Info<< " " << fieldIter()->name() << '(';
 
-                GeoFieldType fieldi
-                (
-                    IOobject
-                    (
-                        fieldIter()->name(),
-                        ti_.name(),
-                        fieldIter()->db(),
-                        IOobject::MUST_READ,
-                        IOobject::NO_WRITE,
-                        false
-                    ),
-                    mesh_
-                );
-
-                GeoFieldType fieldi1
-                (
-                    IOobject
-                    (
-                        fieldIter()->name(),
-                        ti1_.name(),
-                        fieldIter()->db(),
-                        IOobject::MUST_READ,
-                        IOobject::NO_WRITE,
-                        false
-                    ),
-                    mesh_
-                );
-
                 scalar deltaT = (ti1_.value() - ti_.value())/(divisions_ + 1);
 
                 for (int j=0; j<divisions_; j++)
@@ -141,20 +121,51 @@ void fieldInterpolator::interpolate()
                         Info<< " ";
                     }
 
-                    scalar lambda = scalar(j + 1)/scalar(divisions_ + 1);
+                    // Calculate times to read and weights
+                    labelList indices;
+                    scalarField weights;
+                    interpolator_.valueWeights
+                    (
+                        runTime_.value(),
+                        indices,
+                        weights
+                    );
+
+                    const wordList selectedTimeNames
+                    (
+                        UIndirectList<word>(timeNames_, indices)()
+                    );
+
+                    //Info<< "For time " << runTime_.value()
+                    //    << " need times " << selectedTimeNames
+                    //    << " need weights " << weights << endl;
+
+
+                    // Read on the objectRegistry all the required fields
+                    ReadFields<GeoFieldType>
+                    (
+                        fieldIter()->name(),
+                        mesh_,
+                        selectedTimeNames
+                    );
 
                     GeoFieldType fieldj
                     (
-                        IOobject
+                        uniformInterpolate<GeoFieldType>
                         (
+                            IOobject
+                            (
+                                fieldIter()->name(),
+                                runTime_.timeName(),
+                                fieldIter()->db(),
+                                IOobject::NO_READ,
+                                IOobject::NO_WRITE,
+                                false
+                            ),
                             fieldIter()->name(),
-                            timej.name(),
+                            selectedTimeNames,
-                            fieldIter()->db(),
+                            weights
-                            IOobject::NO_READ,
+                        )
-                            IOobject::NO_WRITE,
-                            false
-                        ),
-                        (1.0 - lambda)*fieldi + lambda*fieldi1
                     );
 
                     fieldj.write();
@@ -188,6 +199,12 @@ int main(int argc, char *argv[])
         "integer",
         "specify number of temporal sub-divisions to create (default = 1)."
     );
+    argList::addOption
+    (
+        "interpolationType",
+        "word",
+        "specify type of interpolation (linear or spline)"
+    );
 
     #include "setRootCase.H"
     #include "createTime.H"
@@ -198,15 +215,51 @@ int main(int argc, char *argv[])
     {
         args.optionLookup("fields")() >> selectedFields;
     }
+    if (selectedFields.size())
+    {
+        Info<< "Interpolating fields " << selectedFields << nl << endl;
+    }
+    else
+    {
+        Info<< "Interpolating all fields" << nl << endl;
+    }
+
 
     int divisions = 1;
     if (args.optionFound("divisions"))
     {
         args.optionLookup("divisions")() >> divisions;
     }
+    Info<< "Using " << divisions << " per time interval" << nl << endl;
+
+
+    const word interpolationType = args.optionLookupOrDefault<word>
+    (
+        "interpolationType",
+        "linear"
+    );
+    Info<< "Using interpolation " << interpolationType << nl << endl;
+
 
     instantList timeDirs = timeSelector::select0(runTime, args);
 
+    scalarField timeVals(timeDirs.size());
+    wordList timeNames(timeDirs.size());
+    forAll(timeDirs, i)
+    {
+        timeVals[i] = timeDirs[i].value();
+        timeNames[i] = timeDirs[i].name();
+    }
+    autoPtr<interpolationWeights> interpolatorPtr
+    (
+        interpolationWeights::New
+        (
+            interpolationType,
+            timeVals
+        )
+    );
+
+
     #include "createMesh.H"
 
     Info<< "Interpolating fields for times:" << endl;
@@ -226,6 +279,8 @@ int main(int argc, char *argv[])
             selectedFields,
             timeDirs[timei],
             timeDirs[timei+1],
+            interpolatorPtr(),
+            timeNames,
             divisions
         );
 

src/OpenFOAM/Make/files

@@ -576,6 +576,13 @@ $(interpolations)/interpolationTable/tableReaders/tableReaders.C
 $(interpolations)/interpolationTable/tableReaders/openFoam/openFoamTableReaders.C
 $(interpolations)/interpolationTable/tableReaders/csv/csvTableReaders.C
 
+interpolationWeights = $(interpolations)/interpolationWeights
+$(interpolationWeights)/interpolationWeights/interpolationWeights.C
+$(interpolationWeights)/linearInterpolationWeights/linearInterpolationWeights.C
+$(interpolationWeights)/splineInterpolationWeights/splineInterpolationWeights.C
+
+
+
 algorithms/indexedOctree/indexedOctreeName.C
 algorithms/indexedOctree/treeDataCell.C
 

src/OpenFOAM/containers/Lists/UIndirectList/UIndirectList.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -119,6 +119,12 @@ public:
             inline void operator=(const T&);
 
 
+    // STL type definitions
+
+        //- Type of values the UList contains.
+        typedef T value_type;
+
+
     // Ostream operator
 
         //- Write UIndirectList to Ostream

src/OpenFOAM/db/objectRegistry/objectRegistry.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -151,9 +151,25 @@ Foam::wordList Foam::objectRegistry::sortedNames(const word& ClassName) const
 
 const Foam::objectRegistry& Foam::objectRegistry::subRegistry
 (
-    const word& name
+    const word& name,
+    const bool forceCreate
 ) const
 {
+    if (forceCreate && !foundObject<objectRegistry>(name))
+    {
+        objectRegistry* fieldsCachePtr = new objectRegistry
+        (
+            IOobject
+            (
+                name,
+                time().constant(),
+                *this,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            )
+        );
+        fieldsCachePtr->store();
+    }
     return lookupObject<objectRegistry>(name);
 }
 

src/OpenFOAM/db/objectRegistry/objectRegistry.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -147,8 +147,13 @@ public:
             template<class Type>
             wordList names() const;
 
-            //- Lookup and return a const sub-objectRegistry
+            //- Lookup and return a const sub-objectRegistry. Optionally create
-            const objectRegistry& subRegistry(const word& name) const;
+            //  it if it does not exist.
+            const objectRegistry& subRegistry
+            (
+                const word& name,
+                const bool forceCreate = false
+            ) const;
 
             //- Lookup and return all objects of the given Type
             template<class Type>

src/OpenFOAM/fields/GeometricFields/GeometricField/uniformInterpolate.C

@@ -0,0 +1,142 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class GeoField>
+Foam::tmp<GeoField> Foam::uniformInterpolate
+(
+    const HashPtrTable<GeoField, label, Hash<label> >& fields,
+    const labelList& indices,
+    const scalarField& weights
+)
+{
+    const GeoField& field0 = *(*fields.begin());
+
+    // Interpolate
+    tmp<GeoField> tfld
+    (
+        new GeoField
+        (
+            IOobject
+            (
+                "uniformInterpolate(" + field0.name() + ')',
+                field0.time().timeName(),
+                field0.db(),
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            weights[0]*(*fields[indices[0]])
+        )
+    );
+    GeoField& fld = tfld();
+
+    for (label i = 1; i < indices.size(); ++i)
+    {
+        fld += weights[i]*(*fields[indices[i]]);
+    }
+
+    return tfld;
+}
+
+
+template<class GeoField>
+Foam::tmp<GeoField> Foam::uniformInterpolate
+(
+    const IOobject& fieldIO,
+    const word& fieldName,
+    const wordList& times,
+    const scalarField& weights,
+    const objectRegistry& fieldsCache
+)
+{
+    // Look up the first field
+    const objectRegistry& time0Fields = fieldsCache.lookupObject
+    <
+        const objectRegistry
+    >
+    (
+        times[0]
+    );
+    const GeoField& field0 = time0Fields.lookupObject
+    <
+        const GeoField
+    >
+    (
+        fieldName
+    );
+
+
+    // Interpolate
+    tmp<GeoField> tfld(new GeoField(fieldIO, weights[0]*field0));
+    GeoField& fld = tfld();
+
+    for (label i = 1; i < times.size(); ++i)
+    {
+        const objectRegistry& timeIFields = fieldsCache.lookupObject
+        <
+            const objectRegistry
+        >
+        (
+            times[i]
+        );
+        const GeoField& fieldI = timeIFields.lookupObject
+        <
+            const GeoField
+        >
+        (
+            fieldName
+        );
+
+        fld += weights[i]*fieldI;
+    }
+
+    return tfld;
+}
+
+
+template<class GeoField>
+Foam::tmp<GeoField> Foam::uniformInterpolate
+(
+    const IOobject& fieldIO,
+    const word& fieldName,
+    const wordList& times,
+    const scalarField& weights,
+    const word& registryName
+)
+{
+    return uniformInterpolate<GeoField>
+    (
+        fieldIO,
+        fieldName,
+        times,
+        weights,
+        fieldIO.db().subRegistry(registryName, true)
+    );
+}
+
+
+// ************************************************************************* //

src/OpenFOAM/fields/GeometricFields/GeometricField/uniformInterpolate.H

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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 "GeometricField.H"
+#include "HashPtrTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Global functions  * * * * * * * * * * * * * //
+
+//- Interpolate selected fields (given by indices and corresponding weights)
+//  (boundary type becomes calculated). Fields stored per index. Field gets name
+//  "uniformInterpolate(" + fld.name() + ')'.
+template<class GeoField>
+tmp<GeoField> uniformInterpolate
+(
+    const HashPtrTable<GeoField, label, Hash<label> >& fields,
+    const labelList& indices,
+    const scalarField& weights
+);
+
+//- Interpolate fields. fieldsCache contains per timeName all loaded fields.
+//  Resulting field gets properties according to fieldIO
+template<class GeoField>
+tmp<GeoField> uniformInterpolate
+(
+    const IOobject& fieldIO,
+    const word& fieldName,
+    const wordList& times,
+    const scalarField& weights,
+    const objectRegistry& fieldsCache
+);
+
+//- Interpolate fields. fieldsCache contains per timeName all loaded fields.
+//  Resulting field gets properties according to fieldIO
+template<class GeoField>
+tmp<GeoField> uniformInterpolate
+(
+    const IOobject& fieldIO,
+    const word& fieldName,
+    const wordList& times,
+    const scalarField& weights,
+    const word& registryName = "fieldsCache"
+);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "uniformInterpolate.C"
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/fields/ReadFields/ReadFields.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -127,4 +127,134 @@ Foam::wordList Foam::ReadFields
 }
 
 
+template<class GeoField>
+void Foam::ReadFields
+(
+    const word& fieldName,
+    const typename GeoField::Mesh& mesh,
+    const wordList& timeNames,
+    objectRegistry& fieldsCache
+)
+{
+    // Collect all times that are no longer used
+    {
+        HashSet<word> usedTimes(timeNames);
+
+        DynamicList<word> unusedTimes(fieldsCache.size());
+
+        forAllIter(objectRegistry, fieldsCache, timeIter)
+        {
+            const word& tm = timeIter.key();
+            if (!usedTimes.found(tm))
+            {
+                unusedTimes.append(tm);
+            }
+        }
+
+        //Info<< "Unloading times " << unusedTimes << endl;
+
+        forAll(unusedTimes, i)
+        {
+            objectRegistry& timeCache = const_cast<objectRegistry&>
+            (
+                fieldsCache.lookupObject<objectRegistry>(unusedTimes[i])
+            );
+            fieldsCache.checkOut(timeCache);
+        }
+    }
+
+
+    // Load any new fields
+    forAll(timeNames, i)
+    {
+        const word& tm = timeNames[i];
+
+        // Create if not found
+        if (!fieldsCache.found(tm))
+        {
+            //Info<< "Creating registry for time " << tm << endl;
+
+            // Create objectRegistry if not found
+            objectRegistry* timeCachePtr = new objectRegistry
+            (
+                IOobject
+                (
+                    tm,
+                    tm,
+                    fieldsCache,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                )
+            );
+            timeCachePtr->store();
+        }
+
+        // Obtain cache for current time
+        const objectRegistry& timeCache =
+            fieldsCache.lookupObject<objectRegistry>
+            (
+                tm
+            );
+
+        // Store field if not found
+        if (!timeCache.found(fieldName))
+        {
+            //Info<< "Loading field " << fieldName
+            //    << " for time " << tm << endl;
+
+            GeoField loadedFld
+            (
+                IOobject
+                (
+                    fieldName,
+                    tm,
+                    mesh.thisDb(),
+                    IOobject::MUST_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                mesh
+            );
+
+            // Transfer to timeCache (new objectRegistry and store flag)
+            GeoField* fldPtr = new GeoField
+            (
+                IOobject
+                (
+                    fieldName,
+                    tm,
+                    timeCache,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE
+                ),
+                loadedFld
+            );
+            fldPtr->store();
+        }
+    }
+}
+
+
+template<class GeoField>
+void Foam::ReadFields
+(
+    const word& fieldName,
+    const typename GeoField::Mesh& mesh,
+    const wordList& timeNames,
+    const word& registryName
+)
+{
+    ReadFields<GeoField>
+    (
+        fieldName,
+        mesh,
+        timeNames,
+        const_cast<objectRegistry&>
+        (
+            mesh.thisDb().subRegistry(registryName, true)
+        )
+    );
+}
+
+
 // ************************************************************************* //

src/OpenFOAM/fields/ReadFields/ReadFields.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -55,6 +55,28 @@ wordList ReadFields
     const bool syncPar = true
 );
 
+//- Helper routine to read GeometricFields. The fieldsCache is per time
+//  an objectRegistry of all stored fields
+template<class GeoField>
+static void ReadFields
+(
+    const word& fieldName,
+    const typename GeoField::Mesh& mesh,
+    const wordList& timeNames,
+    objectRegistry& fieldsCache
+);
+
+//- Helper routine to read GeometricFields. The fieldsCache is per time
+//  an objectRegistry of all stored fields
+template<class GeoField>
+static void ReadFields
+(
+    const word& fieldName,
+    const typename GeoField::Mesh& mesh,
+    const wordList& timeNames,
+    const word& registryName = "fieldsCache"
+);
+
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/OpenFOAM/interpolations/interpolationWeights/interpolationWeights/interpolationWeights.C

@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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 "interpolationWeights.H"
+#include "addToRunTimeSelectionTable.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(interpolationWeights, 0);
+defineRunTimeSelectionTable(interpolationWeights, word);
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+interpolationWeights::interpolationWeights
+(
+    const scalarField& samples
+)
+:
+    samples_(samples)
+{}
+
+
+// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
+
+autoPtr<interpolationWeights> interpolationWeights::New
+(
+    const word& type,
+    const scalarField& samples
+)
+{
+    Info<< nl << "Selecting interpolationWeights "
+        << type << endl;
+
+    wordConstructorTable::iterator cstrIter =
+        wordConstructorTablePtr_->find(type);
+
+    if (cstrIter == wordConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "interpolationWeights::New(const word&, "
+            "const scalarField&)"
+        )   << "Unknown interpolationWeights type "
+            << type
+            << endl << endl
+            << "Valid interpolationWeights types are :" << endl
+            << wordConstructorTablePtr_->sortedToc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<interpolationWeights>(cstrIter()(samples));
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+interpolationWeights::~interpolationWeights()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//objectRegistry& interpolationWeights::registry
+//(
+//    const objectRegistry& obr,
+//    const word& name
+//)
+//{
+//    if (!obr.foundObject<objectRegistry>(name))
+//    {
+//        objectRegistry* fieldsCachePtr = new objectRegistry
+//        (
+//            IOobject
+//            (
+//                name,
+//                obr.time().constant(),
+//                obr,
+//                IOobject::NO_READ,
+//                IOobject::NO_WRITE
+//            )
+//        );
+//        fieldsCachePtr->store();
+//    }
+//    return const_cast<objectRegistry&>(obr.subRegistry(name));
+//}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/OpenFOAM/interpolations/interpolationWeights/interpolationWeights/interpolationWeights.H

@@ -0,0 +1,159 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Class
+    Foam::interpolationWeights
+
+Description
+    Abstract base class for interpolating in 1D
+
+SourceFiles
+    interpolationWeights.C
+    interpolationWeightsTemplates.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef interpolationWeights_H
+#define interpolationWeights_H
+
+#include "scalarField.H"
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+#include "pointField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class fvMesh;
+class objectRegistry;
+
+/*---------------------------------------------------------------------------*\
+                       Class interpolationWeights Declaration
+\*---------------------------------------------------------------------------*/
+
+class interpolationWeights
+{
+
+private:
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        interpolationWeights(const interpolationWeights&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const interpolationWeights&);
+
+protected:
+
+        const scalarField& samples_;
+
+public:
+
+    //- Runtime type information
+    TypeName("interpolationWeights");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            interpolationWeights,
+            word,
+            (
+                const scalarField& samples
+            ),
+            (samples)
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        interpolationWeights(const scalarField& samples);
+
+
+    // Selectors
+
+        //- Return a reference to the selected interpolationWeights
+        static autoPtr<interpolationWeights> New
+        (
+            const word& type,
+            const scalarField& samples
+        );
+
+
+    //- Destructor
+    virtual ~interpolationWeights();
+
+
+    // Member Functions
+
+        //- Calculate weights and indices to calculate t from samples.
+        //  Returns true if indices changed.
+        virtual bool valueWeights
+        (
+            const scalar t,
+            labelList& indices,
+            scalarField& weights
+        ) const = 0;
+
+        //- Calculate weights and indices to calculate integrand of t1..t2
+        //  from samples. Returns true if indices changed.
+        virtual bool integrationWeights
+        (
+            const scalar t1,
+            const scalar t2,
+            labelList& indices,
+            scalarField& weights
+        ) const = 0;
+
+        //- Helper: weighted sum
+        template<class ListType1, class ListType2>
+        static typename outerProduct
+        <
+            typename ListType1::value_type,
+            typename ListType2::value_type
+        >::type
+        weightedSum(const ListType1& f1, const ListType2& f2);
+
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "interpolationWeightsTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/interpolations/interpolationWeights/interpolationWeights/interpolationWeightsTemplates.C

@@ -0,0 +1,77 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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 "interpolationWeights.H"
+#include "ListOps.H"
+#include "IOobject.H"
+#include "HashSet.H"
+#include "objectRegistry.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class ListType1, class ListType2>
+typename Foam::outerProduct
+<
+    typename ListType1::value_type,
+    typename ListType2::value_type
+>::type
+Foam::interpolationWeights::weightedSum
+(
+    const ListType1& f1,
+    const ListType2& f2
+)
+{
+    typedef typename outerProduct
+    <
+        typename ListType1::value_type,
+        typename ListType2::value_type
+    >::type returnType;
+
+    if (f1.size())
+    {
+        returnType SumProd = f1[0]*f2[0];
+        for (label i = 1; i < f1.size(); ++i)
+        {
+            SumProd += f1[i]*f2[i];
+        }
+        return SumProd;
+    }
+    else
+    {
+        return pTraits<returnType>::zero;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/OpenFOAM/interpolations/interpolationWeights/linearInterpolationWeights/linearInterpolationWeights.C

@@ -0,0 +1,249 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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 "linearInterpolationWeights.H"
+#include "addToRunTimeSelectionTable.H"
+#include "ListOps.H"
+#include "Pair.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(linearInterpolationWeights, 0);
+addToRunTimeSelectionTable
+(
+    interpolationWeights,
+    linearInterpolationWeights,
+    word
+);
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::Pair<Foam::scalar> linearInterpolationWeights::integrationWeights
+(
+    const label i,
+    const scalar t
+) const
+{
+    // t is in range samples_[i] .. samples_[i+1]
+
+    scalar s = (t-samples_[i])/(samples_[i+1]-samples_[i]);
+
+    if (s < -SMALL || s > 1+SMALL)
+    {
+        FatalErrorIn("linearInterpolationWeights::integrationWeights(..)")
+            << "Value " << t << " outside range " << samples_[i]
+            << " .. " << samples_[i+1]
+            << exit(FatalError);
+    }
+
+    scalar d = samples_[i+1]-t;
+
+    return Pair<scalar>(d*0.5*(1-s), d*0.5*(1+s));
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+linearInterpolationWeights::linearInterpolationWeights
+(
+    const scalarField& samples
+)
+:
+    interpolationWeights(samples),
+    index_(-1)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool linearInterpolationWeights::valueWeights
+(
+    const scalar t,
+    labelList& indices,
+    scalarField& weights
+) const
+{
+    bool indexChanged = false;
+
+    // Check if current timeIndex is still valid
+    if
+    (
+        index_ >= 0
+     && index_ < samples_.size()
+     && (
+            samples_[index_] <= t
+         && (index_ == samples_.size()-1 || t <= samples_[index_+1])
+        )
+    )
+    {
+        // index_ still at correct slot
+    }
+    else
+    {
+        // search for correct index
+        index_ = findLower(samples_, t);
+        indexChanged = true;
+    }
+
+
+    if (index_ == -1)
+    {
+        // Use first element only
+        indices.setSize(1);
+        weights.setSize(1);
+        indices[0] = 0;
+        weights[0] = 1.0;
+    }
+    else if (index_ == samples_.size()-1)
+    {
+        // Use last element only
+        indices.setSize(1);
+        weights.setSize(1);
+        indices[0] = samples_.size()-1;
+        weights[0] = 1.0;
+    }
+    else
+    {
+        // Interpolate
+        indices.setSize(2);
+        weights.setSize(2);
+
+        indices[0] = index_;
+        indices[1] = index_+1;
+
+        scalar t0 = samples_[indices[0]];
+        scalar t1 = samples_[indices[1]];
+        scalar deltaT = t1-t0;
+
+        weights[0] = (t1-t)/deltaT;
+        weights[1] = 1.0-weights[0];
+    }
+
+    return indexChanged;
+}
+
+
+bool linearInterpolationWeights::integrationWeights
+(
+    const scalar t1,
+    const scalar t2,
+    labelList& indices,
+    scalarField& weights
+) const
+{
+    if (t2 < t1-VSMALL)
+    {
+        FatalErrorIn("linearInterpolationWeights::integrationWeights(..)")
+            << "Integration should be in positive direction."
+            <<  " t1:" << t1 << " t2:" << t2
+            << exit(FatalError);
+    }
+
+    // Currently no fancy logic on cached index
+    label i1 = findLower(samples_, t1);
+    label i2 = findLower(samples_, t2);
+
+    // For now just fail if any outside table
+    if (i1 == -1 || i2 == samples_.size()-1)
+    {
+        FatalErrorIn("linearInterpolationWeights::integrationWeights(..)")
+            << "Integrating outside table " << samples_[0] << ".."
+            << samples_.last() << " not implemented."
+            << " t1:" << t1 << " t2:" << t2 << exit(FatalError);
+    }
+
+    label nIndices = i2-i1+2;
+
+
+    // Determine if indices already correct
+    bool anyChanged = false;
+
+    if (nIndices != indices.size())
+    {
+        anyChanged = true;
+    }
+    else
+    {
+        // Closer check
+
+        label index = i1;
+        forAll(indices, i)
+        {
+            if (indices[i] != index)
+            {
+                anyChanged = true;
+                break;
+            }
+            index++;
+        }
+    }
+
+    indices.setSize(nIndices);
+    weights.setSize(nIndices);
+    weights = 0.0;
+
+    // Sum from i1+1 to i2+1
+    for (label i = i1+1; i <= i2; i++)
+    {
+        scalar d = samples_[i+1]-samples_[i];
+        indices[i-i1] = i;
+        weights[i-i1] += 0.5*d;
+        indices[i+1-i1] = i+1;
+        weights[i+1-i1] += 0.5*d;
+    }
+
+    // Add from i1 to t1
+    {
+        Pair<scalar> i1Tot1 = integrationWeights(i1, t1);
+        indices[0] = i1;
+        weights[0] += i1Tot1.first();
+        indices[1] = i1+1;
+        weights[1] += i1Tot1.second();
+    }
+
+    // Subtract from t2 to i2+1
+    {
+        Pair<scalar> wghts = integrationWeights(i2, t2);
+        indices[i2-i1] = i2;
+        weights[i2-i1] += -wghts.first();
+        indices[i2-i1+1] = i2+1;
+        weights[i2-i1+1] += -wghts.second();
+    }
+
+    return anyChanged;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/OpenFOAM/interpolations/interpolationWeights/linearInterpolationWeights/linearInterpolationWeights.H

@@ -0,0 +1,120 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Class
+    Foam::linearInterpolationWeights
+
+Description
+
+SourceFiles
+    linearInterpolationWeights.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef linearInterpolationWeights_H
+#define linearInterpolationWeights_H
+
+#include "interpolationWeights.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class linearInterpolationWeights Declaration
+\*---------------------------------------------------------------------------*/
+
+class linearInterpolationWeights
+:
+    public interpolationWeights
+{
+
+private:
+
+    // Private data
+
+        //- Cached index in samples from previous invocation
+        mutable label index_;
+
+    // Private Member Functions
+
+        //- Get weights of i and i+1 to calculate integration from t to
+        //  samples_[i+1]
+        Pair<scalar> integrationWeights
+        (
+            const label i,
+            const scalar t
+        ) const;
+
+public:
+
+    //- Runtime type information
+    TypeName("linear");
+
+    // Constructors
+
+        //- Construct from components
+        linearInterpolationWeights
+        (
+            const scalarField& samples
+        );
+
+
+    //- Destructor
+    virtual ~linearInterpolationWeights()
+    {}
+
+
+    // Member Functions
+
+        //- Calculate weights and indices to calculate t from samples.
+        //  Returns true if indices changed.
+        virtual bool valueWeights
+        (
+            const scalar t,
+            labelList& indices,
+            scalarField& weights
+        ) const;
+
+        //- Calculate weights and indices to calculate integrand of t1..t2
+        //  from samples. Returns true if indices changed.
+        virtual bool integrationWeights
+        (
+            const scalar t1,
+            const scalar t2,
+            labelList& indices,
+            scalarField& weights
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/interpolations/interpolationWeights/splineInterpolationWeights/splineInterpolationWeights.C

@@ -0,0 +1,228 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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 "splineInterpolationWeights.H"
+#include "addToRunTimeSelectionTable.H"
+#include "ListOps.H"
+#include "linearInterpolationWeights.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(splineInterpolationWeights, 0);
+addToRunTimeSelectionTable
+(
+    interpolationWeights,
+    splineInterpolationWeights,
+    word
+);
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+splineInterpolationWeights::splineInterpolationWeights
+(
+    const scalarField& samples,
+    const bool checkEqualDistance
+)
+:
+    interpolationWeights(samples),
+    index_(-1)
+{
+    if (checkEqualDistance && samples_.size() > 2)
+    {
+        const scalar interval = samples_[1]-samples[0];
+        for (label i = 2; i < samples_.size(); i++)
+        {
+            scalar d = samples_[i]-samples[i-1];
+
+            if (mag(d-interval) > SMALL)
+            {
+                WarningIn
+                (
+                    "splineInterpolationWeights::splineInterpolationWeights"
+                    "(const scalarField&)"
+                )   << "Spline interpolation only valid for constant intervals."
+                    << nl
+                    << "Interval 0-1 : " << interval << nl
+                    << "Interval " << i-1 << '-' << i << " : "
+                    << d << endl;
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool splineInterpolationWeights::valueWeights
+(
+    const scalar t,
+    labelList& indices,
+    scalarField& weights
+) const
+{
+    bool indexChanged = false;
+
+    // linear interpolation
+    if (samples_.size() <= 2)
+    {
+        return linearInterpolationWeights(samples_).valueWeights
+        (
+            t,
+            indices,
+            weights
+        );
+    }
+
+    // Check if current timeIndex is still valid
+    if
+    (
+        index_ >= 0
+     && index_ < samples_.size()
+     && (
+            samples_[index_] <= t
+         && (index_ == samples_.size()-1 || t <= samples_[index_+1])
+        )
+    )
+    {
+        // index_ still at correct slot
+    }
+    else
+    {
+        // search for correct index
+        index_ = findLower(samples_, t);
+        indexChanged = true;
+    }
+
+
+    // Clamp if outside table
+    if (index_ == -1)
+    {
+        indices.setSize(1);
+        weights.setSize(1);
+
+        indices[0] = 0;
+        weights[0] = 1;
+        return indexChanged;
+    }
+    else if (index_ == samples_.size()-1)
+    {
+        indices.setSize(1);
+        weights.setSize(1);
+
+        indices[0] = samples_.size()-1;
+        weights[0] = 1;
+        return indexChanged;
+    }
+
+
+
+    label lo = index_;
+    label hi = index_+1;
+
+    // weighting
+    scalar mu = (t - samples_[lo])/(samples_[hi] - samples_[lo]);
+
+    scalar w0 = 0.5*(mu*(-1+mu*(2-mu)));            // coeff of lo-1
+    scalar w1 = 0.5*(2+mu*(mu*(-5 + mu*(3))));      // coeff of lo
+    scalar w2 = 0.5*(mu*(1 + mu*(4 + mu*(-3))));    // coeff of hi
+    scalar w3 = 0.5*(mu*mu*(-1 + mu));              // coeff of hi+1
+
+    if (lo > 0)
+    {
+        if (hi < samples_.size()-1)
+        {
+            // Four points available
+            indices.setSize(4);
+            weights.setSize(4);
+
+            indices[0] = lo-1;
+            indices[1] = lo;
+            indices[2] = hi;
+            indices[3] = hi+1;
+
+            weights[0] = w0;
+            weights[1] = w1;
+            weights[2] = w2;
+            weights[3] = w3;
+        }
+        else
+        {
+            // No y3 available. Extrapolate: y3=3*y2-y1
+            indices.setSize(3);
+            weights.setSize(3);
+
+            indices[0] = lo-1;
+            indices[1] = lo;
+            indices[2] = hi;
+
+            weights[0] = w0;
+            weights[1] = w1 - w3;
+            weights[2] = w2 + 2*w3;
+        }
+    }
+    else
+    {
+        // No y0 available. Extrapolate: y0=2*y1-y2;
+        if (hi < samples_.size()-1)
+        {
+            indices.setSize(3);
+            weights.setSize(3);
+
+            indices[0] = lo;
+            indices[1] = hi;
+            indices[2] = hi+1;
+
+            weights[0] = w1 + 2*w0;
+            weights[1] = w2 - w0;
+            weights[2] = w3;
+        }
+        else
+        {
+            indices.setSize(2);
+            weights.setSize(2);
+
+            indices[0] = lo;
+            indices[1] = hi;
+
+            weights[0] = w1 + 2*w0 - w3;
+            weights[1] = w2 - w0 + 2*w3;
+        }
+    }
+
+    return indexChanged;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/OpenFOAM/interpolations/interpolationWeights/splineInterpolationWeights/splineInterpolationWeights.H

@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Class
+    Foam::splineInterpolationWeights
+
+Description
+    Catmull-Rom spline interpolation.
+
+SourceFiles
+    splineInterpolationWeights.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef splineInterpolationWeights_H
+#define splineInterpolationWeights_H
+
+#include "interpolationWeights.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                  Class splineInterpolationWeights Declaration
+\*---------------------------------------------------------------------------*/
+
+class splineInterpolationWeights
+:
+    public interpolationWeights
+{
+
+private:
+
+    // Private data
+
+        //- Cached index in samples from previous invocation
+        mutable label index_;
+
+public:
+
+    //- Runtime type information
+    TypeName("spline");
+
+    // Constructors
+
+        //- Construct from components. By default make sure samples are
+        //  equidistant.
+        splineInterpolationWeights
+        (
+            const scalarField& samples,
+            const bool checkEqualDistance = true
+        );
+
+
+    //- Destructor
+    virtual ~splineInterpolationWeights()
+    {}
+
+
+    // Member Functions
+
+        //- Calculate weights and indices to calculate t from samples.
+        //  Returns true if indices changed.
+        virtual bool valueWeights
+        (
+            const scalar t,
+            labelList& indices,
+            scalarField& weights
+        ) const;
+
+        //- Calculate weights and indices to calculate integrand of t1..t2
+        //  from samples. Returns true if indices changed.
+        virtual bool integrationWeights
+        (
+            const scalar t1,
+            const scalar t2,
+            labelList& indices,
+            scalarField& weights
+        ) const
+        {
+            notImplemented
+            (
+                "splineInterpolationWeights::integrationWeights(..)"
+            );
+            return false;
+        }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/primitives/functions/DataEntry/Table/TableBase.C

@@ -26,6 +26,29 @@ License
 #include "TableBase.H"
 #include "Time.H"
 
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+const Foam::interpolationWeights& Foam::TableBase<Type>::interpolator() const
+{
+    if (interpolatorPtr_.empty())
+    {
+        // Re-work table into linear list
+        tableSamples_.setSize(table_.size());
+        forAll(table_, i)
+        {
+            tableSamples_[i] = table_[i].first();
+        }
+        interpolatorPtr_ = interpolationWeights::New
+        (
+            interpolationScheme_,
+            tableSamples_
+        );
+    }
+    return interpolatorPtr_();
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
@@ -39,6 +62,10 @@ Foam::TableBase<Type>::TableBase(const word& name, const dictionary& dict)
             dict.lookupOrDefault<word>("outOfBounds", "clamp")
         )
     ),
+    interpolationScheme_
+    (
+        dict.lookupOrDefault<word>("interpolationScheme", "linear")
+    ),
     table_(),
     dimensions_(dimless)
 {}
@@ -49,8 +76,11 @@ Foam::TableBase<Type>::TableBase(const TableBase<Type>& tbl)
 :
     name_(tbl.name_),
     boundsHandling_(tbl.boundsHandling_),
+    interpolationScheme_(tbl.interpolationScheme_),
     table_(tbl.table_),
-    dimensions_(tbl.dimensions_)
+    dimensions_(tbl.dimensions_),
+    tableSamples_(tbl.tableSamples_),
+    interpolatorPtr_(tbl.interpolatorPtr_)
 {}
 
 
@@ -307,6 +337,9 @@ void Foam::TableBase<Type>::convertTimeBase(const Time& t)
         scalar value = table_[i].first();
         table_[i].first() = t.userTimeToTime(value);
     }
+
+    tableSamples_.clear();
+    interpolatorPtr_.clear();
 }
 
 
@@ -325,88 +358,104 @@ Type Foam::TableBase<Type>::value(const scalar x) const
         return table_.last().second();
     }
 
-    // Find i such that x(i) < xDash < x(i+1)
+    // Use interpolator
-    label i = 0;
+    interpolator().valueWeights(x, currentIndices_, currentWeights_);
-    while ((table_[i+1].first() < xDash) && (i+1 < table_.size()))
+
+    Type t = currentWeights_[0]*table_[currentIndices_[0]].second();
+    for (label i = 1; i < currentIndices_.size(); i++)
     {
-        i++;
+        t += currentWeights_[i]*table_[currentIndices_[i]].second();
     }
+    return t;
 
-Info <<
+    //// Find i such that x(i) < xDash < x(i+1)
-     (xDash - table_[i].first())/(table_[i+1].first() - table_[i].first())
+    //label i = 0;
-      * (table_[i+1].second() - table_[i].second())
+    //while ((table_[i+1].first() < xDash) && (i+1 < table_.size()))
-      + table_[i].second() << endl;
+    //{
-
+    //    i++;
-    // Linear interpolation to find value
+    //}
-    return Type
+    //
-    (
+    //// Linear interpolation to find value
-        (xDash - table_[i].first())/(table_[i+1].first() - table_[i].first())
+    //return Type
-      * (table_[i+1].second() - table_[i].second())
+    //(
-      + table_[i].second()
+    //    (xDash - table_[i].first())/(table_[i+1].first() - table_[i].first())
-    );
+    //  * (table_[i+1].second() - table_[i].second())
+    //  + table_[i].second()
+    //);
 }
 
 
 template<class Type>
 Type Foam::TableBase<Type>::integrate(const scalar x1, const scalar x2) const
 {
-    // Initialise return value
+    // Use interpolator
-    Type sum = pTraits<Type>::zero;
+    interpolator().integrationWeights(x1, x2, currentIndices_, currentWeights_);
 
-    // Return zero if out of bounds
+    Type sum = currentWeights_[0]*table_[currentIndices_[0]].second();
-    if ((x1 > table_.last().first()) || (x2 < table_[0].first()))
+    for (label i = 1; i < currentIndices_.size(); i++)
     {
-        return sum;
+       sum += currentWeights_[i]*table_[currentIndices_[i]].second();
     }
-
-    // Find next index greater than x1
-    label id1 = 0;
-    while ((table_[id1].first() < x1) && (id1 < table_.size()))
-    {
-        id1++;
-    }
-
-    // Find next index less than x2
-    label id2 = table_.size() - 1;
-    while ((table_[id2].first() > x2) && (id2 >= 1))
-    {
-        id2--;
-    }
-
-    if ((id1 - id2) == 1)
-    {
-        // x1 and x2 lie within 1 interval
-        sum = 0.5*(value(x1) + value(x2))*(x2 - x1);
-    }
-    else
-    {
-        // x1 and x2 cross multiple intervals
-
-        // Integrate table body
-        for (label i=id1; i<id2; i++)
-        {
-            sum +=
-                (table_[i].second() + table_[i+1].second())
-              * (table_[i+1].first() - table_[i].first());
-        }
-        sum *= 0.5;
-
-        // Add table ends (partial segments)
-        if (id1 > 0)
-        {
-            sum += 0.5
-              * (value(x1) + table_[id1].second())
-              * (table_[id1].first() - x1);
-        }
-        if (id2 < table_.size() - 1)
-        {
-            sum += 0.5
-              * (table_[id2].second() + value(x2))
-              * (x2 - table_[id2].first());
-        }
-    }
-
     return sum;
+
+
+    //// Initialise return value
+    //Type sum = pTraits<Type>::zero;
+    //
+    //// Return zero if out of bounds
+    //if ((x1 > table_.last().first()) || (x2 < table_[0].first()))
+    //{
+    //    return sum;
+    //}
+    //
+    //// Find next index greater than x1
+    //label id1 = 0;
+    //while ((table_[id1].first() < x1) && (id1 < table_.size()))
+    //{
+    //    id1++;
+    //}
+    //
+    //// Find next index less than x2
+    //label id2 = table_.size() - 1;
+    //while ((table_[id2].first() > x2) && (id2 >= 1))
+    //{
+    //    id2--;
+    //}
+    //
+    //if ((id1 - id2) == 1)
+    //{
+    //    // x1 and x2 lie within 1 interval
+    //    sum = 0.5*(value(x1) + value(x2))*(x2 - x1);
+    //}
+    //else
+    //{
+    //    // x1 and x2 cross multiple intervals
+    //
+    //    // Integrate table body
+    //    for (label i=id1; i<id2; i++)
+    //    {
+    //        sum +=
+    //            (table_[i].second() + table_[i+1].second())
+    //          * (table_[i+1].first() - table_[i].first());
+    //    }
+    //    sum *= 0.5;
+    //
+    //    // Add table ends (partial segments)
+    //    if (id1 > 0)
+    //    {
+    //        sum += 0.5
+    //          * (value(x1) + table_[id1].second())
+    //          * (table_[id1].first() - x1);
+    //    }
+    //    if (id2 < table_.size() - 1)
+    //    {
+    //        sum += 0.5
+    //          * (table_[id2].second() + value(x2))
+    //          * (x2 - table_[id2].first());
+    //    }
+    //}
+    //
+    //return sum;
 }
 
 

src/OpenFOAM/primitives/functions/DataEntry/Table/TableBase.H

@@ -38,6 +38,7 @@ SourceFiles
 #include "DataEntry.H"
 #include "Tuple2.H"
 #include "dimensionSet.H"
+#include "interpolationWeights.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -80,10 +81,13 @@ protected:
     // Protected data
 
         //- Table name
-        word name_;
+        const word name_;
 
         //- Enumeration for handling out-of-bound values
-        boundsHandling boundsHandling_;
+        const boundsHandling boundsHandling_;
+
+        //- Interpolation type
+        const word interpolationScheme_;
 
         //- Table data
         List<Tuple2<scalar, Type> > table_;
@@ -91,9 +95,24 @@ protected:
         //- The dimension set
         dimensionSet dimensions_;
 
+        //- Extracted values
+        mutable scalarField tableSamples_;
+
+        //- Interpolator method
+        mutable autoPtr<interpolationWeights> interpolatorPtr_;
+
+        //- Cached indices and weights
+        mutable labelList currentIndices_;
+
+        mutable scalarField currentWeights_;
+
 
     // Protected Member Functions
 
+
+        //- Return (demand driven) interpolator
+        const interpolationWeights& interpolator() const;
+
         //- Disallow default bitwise assignment
         void operator=(const TableBase<Type>&);
 

src/OpenFOAM/primitives/functions/DataEntry/TableFile/TableFile.C

@@ -45,6 +45,15 @@ Foam::TableFile<Type>::TableFile(const word& entryName, const dictionary& dict)
     fileName expandedFile(fName_);
     IFstream is(expandedFile.expand());
 
+    if (!is.good())
+    {
+        FatalIOErrorIn
+        (
+            "TableFile<Type>::TableFile(const word&, const dictionary&)",
+            is
+        )   << "Cannot open file." << exit(FatalIOError);
+    }
+
     is  >> this->table_;
 
     TableBase<Type>::check();

src/OpenFOAM/primitives/functions/DataEntry/TableFile/TableFile.H

@@ -31,9 +31,10 @@ Description
         <entryName>   tableFile;
         tableFileCoeffs
         {
-            dimensions      [0 0 1 0 0]; // optional dimensions
+            dimensions          [0 0 1 0 0]; // optional dimensions
-            fileName        dataFile;    // name of data file
+            fileName            dataFile;    // name of data file
-            outOfBounds     clamp;       // optional out-of-bounds handling
+            outOfBounds         clamp;       // optional out-of-bounds handling
+            interpolationScheme linear;      // optional interpolation method
         }
     \endverbatim
 

src/finiteVolume/fields/fvPatchFields/derived/timeVaryingMappedFixedValue/timeVaryingMappedFixedValueFvPatchField.C

@@ -209,7 +209,7 @@ template<class Type>
 void timeVaryingMappedFixedValueFvPatchField<Type>::checkTable()
 {
     // Initialise
-    if (startSampleTime_ == -1 && endSampleTime_ == -1)
+    if (mapperPtr_.empty())
     {
         pointIOField samplePoints
         (

src/fvMotionSolver/Make/files

@@ -38,6 +38,7 @@ $(derivedPoint)/surfaceDisplacement/surfaceDisplacementPointPatchVectorField.C
 $(derivedPoint)/waveDisplacement/waveDisplacementPointPatchVectorField.C
 
 $(derivedPoint)/timeVaryingMappedFixedValue/timeVaryingMappedFixedValuePointPatchFields.C
+$(derivedPoint)/uniformInterpolatedDisplacement/uniformInterpolatedDisplacementPointPatchVectorField.C
 
 
 

src/fvMotionSolver/pointPatchFields/derived/uniformInterpolatedDisplacement/uniformInterpolatedDisplacementPointPatchVectorField.C

@@ -0,0 +1,291 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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 "uniformInterpolatedDisplacementPointPatchVectorField.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "Time.H"
+#include "polyMesh.H"
+#include "interpolationWeights.H"
+#include "uniformInterpolate.H"
+#include "ReadFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+uniformInterpolatedDisplacementPointPatchVectorField::
+uniformInterpolatedDisplacementPointPatchVectorField
+(
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF
+)
+:
+    fixedValuePointPatchField<vector>(p, iF)
+{}
+
+
+uniformInterpolatedDisplacementPointPatchVectorField::
+uniformInterpolatedDisplacementPointPatchVectorField
+(
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    fixedValuePointPatchField<vector>(p, iF, dict),
+    fieldName_(dict.lookup("fieldName")),
+    interpolationScheme_(dict.lookup("interpolationScheme"))
+{
+    const pointMesh& pMesh = this->dimensionedInternalField().mesh();
+
+    // Read time values
+    instantList allTimes = Time::findTimes(pMesh().time().path());
+
+    // Only keep those that contain the field
+    DynamicList<word> names(allTimes.size());
+    DynamicList<scalar> values(allTimes.size());
+
+    forAll(allTimes, i)
+    {
+        IOobject io
+        (
+            fieldName_,
+            allTimes[i].name(),
+            pMesh(),
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        );
+        if (io.headerOk())
+        {
+            names.append(allTimes[i].name());
+            values.append(allTimes[i].value());
+        }
+    }
+    timeNames_.transfer(names);
+    timeVals_.transfer(values);
+
+    Info<< type() << " : found " << fieldName_ << " for times "
+        << timeNames_ << endl;
+
+    if (timeNames_.size() < 1)
+    {
+        FatalErrorIn
+        (
+            "uniformInterpolatedDisplacementPointPatchVectorField::\n"
+            "uniformInterpolatedDisplacementPointPatchVectorField\n"
+            "(\n"
+            "    const pointPatch&,\n"
+            "    const DimensionedField<vector, pointMesh>&,\n"
+            "    const dictionary&\n"
+            ")\n"
+        )   << "Did not find any times with " << fieldName_
+            << exit(FatalError);
+    }
+
+
+    if (!dict.found("value"))
+    {
+        updateCoeffs();
+    }
+}
+
+
+uniformInterpolatedDisplacementPointPatchVectorField::
+uniformInterpolatedDisplacementPointPatchVectorField
+(
+    const uniformInterpolatedDisplacementPointPatchVectorField& ptf,
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    fixedValuePointPatchField<vector>(ptf, p, iF, mapper),
+    fieldName_(ptf.fieldName_),
+    interpolationScheme_(ptf.interpolationScheme_),
+    timeNames_(ptf.timeNames_),
+    timeVals_(ptf.timeVals_),
+    interpolatorPtr_(ptf.interpolatorPtr_)
+{}
+
+
+uniformInterpolatedDisplacementPointPatchVectorField::
+uniformInterpolatedDisplacementPointPatchVectorField
+(
+    const uniformInterpolatedDisplacementPointPatchVectorField& ptf,
+    const DimensionedField<vector, pointMesh>& iF
+)
+:
+    fixedValuePointPatchField<vector>(ptf, iF),
+    fieldName_(ptf.fieldName_),
+    interpolationScheme_(ptf.interpolationScheme_),
+    timeNames_(ptf.timeNames_),
+    timeVals_(ptf.timeVals_),
+    interpolatorPtr_(ptf.interpolatorPtr_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void uniformInterpolatedDisplacementPointPatchVectorField::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    if (!interpolatorPtr_.valid())
+    {
+        interpolatorPtr_ = interpolationWeights::New
+        (
+            interpolationScheme_,
+            timeVals_
+        );
+    }
+
+    const pointMesh& pMesh = this->dimensionedInternalField().mesh();
+    const Time& t = pMesh().time();
+
+    // Update indices of times and weights
+    bool timesChanged = interpolatorPtr_->valueWeights
+    (
+        t.timeOutputValue(),
+        currentIndices_,
+        currentWeights_
+    );
+
+    const wordList currentTimeNames
+    (
+        UIndirectList<word>(timeNames_, currentIndices_)
+    );
+
+
+    // Load if necessary fields for this interpolation
+    if (timesChanged)
+    {
+        objectRegistry& fieldsCache = const_cast<objectRegistry&>
+        (
+            pMesh.thisDb().subRegistry("fieldsCache", true)
+        );
+        // Save old times so we now which ones have been loaded and need
+        // 'correctBoundaryConditions'. Bit messy.
+        HashSet<word> oldTimes(fieldsCache.toc());
+
+        ReadFields<pointVectorField>
+        (
+            fieldName_,
+            pMesh,
+            currentTimeNames
+        );
+
+        forAllConstIter(objectRegistry, fieldsCache, fieldsCacheIter)
+        {
+            if (!oldTimes.found(fieldsCacheIter.key()))
+            {
+                // Newly loaded fields. Make sure the internal
+                // values are consistent with the boundary conditions.
+                // This is quite often not the case since these
+                // fields typically are constructed 'by hand'
+
+                const objectRegistry& timeCache = dynamic_cast
+                <
+                    const objectRegistry&
+                >(*fieldsCacheIter());
+
+
+                pointVectorField& d = const_cast<pointVectorField&>
+                (
+                    timeCache.lookupObject<pointVectorField>
+                    (
+                        fieldName_
+                    )
+                );
+                d.correctBoundaryConditions();
+            }
+        }
+    }
+
+
+    // Interpolate the whole field
+    pointVectorField result
+    (
+        uniformInterpolate<pointVectorField>
+        (
+            IOobject
+            (
+                word("uniformInterpolate(")
+              + this->dimensionedInternalField().name()
+              + ')',
+                pMesh.time().timeName(),
+                pMesh.thisDb(),
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            fieldName_,
+            currentTimeNames,
+            currentWeights_
+        )
+    );
+
+
+    // Extract back from the internal field
+    this->operator==
+    (
+        this->patchInternalField(result.dimensionedInternalField())
+    );
+
+    fixedValuePointPatchField<vector>::updateCoeffs();
+}
+
+
+void uniformInterpolatedDisplacementPointPatchVectorField::write(Ostream& os)
+const
+{
+    pointPatchField<vector>::write(os);
+    os.writeKeyword("fieldName")
+        << fieldName_ << token::END_STATEMENT << nl;
+    os.writeKeyword("interpolationScheme")
+        << interpolationScheme_ << token::END_STATEMENT << nl;
+    writeEntry("value", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchTypeField
+(
+    pointPatchVectorField,
+    uniformInterpolatedDisplacementPointPatchVectorField
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/fvMotionSolver/pointPatchFields/derived/uniformInterpolatedDisplacement/uniformInterpolatedDisplacementPointPatchVectorField.H

@@ -0,0 +1,183 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Class
+    Foam::uniformInterpolatedDisplacementPointPatchVectorField
+
+Description
+    Interpolates pre-specified motion.
+
+    Motion specified as pointVectorFields. E.g.
+
+    walls
+    {
+        type                uniformInterpolatedDisplacement;
+        value               uniform (0 0 0);
+        fieldName           wantedDisplacement;
+        interpolationScheme linear;
+    }
+
+    This will scan the case for 'wantedDisplacement' pointVectorFields
+    and interpolate those in time (using 'linear' interpolation) to
+    obtain the current displacement.
+    The advantage of specifying displacement in this way is that it
+    automatically works through decomposePar.
+
+SourceFiles
+    uniformInterpolatedDisplacementPointPatchVectorField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uniformInterpolatedDisplacementPointPatchVectorField_H
+#define uniformInterpolatedDisplacementPointPatchVectorField_H
+
+#include "fixedValuePointPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class interpolationWeights;
+
+/*---------------------------------------------------------------------------*\
+    Class uniformInterpolatedDisplacementPointPatchVectorField Declaration
+\*---------------------------------------------------------------------------*/
+
+class uniformInterpolatedDisplacementPointPatchVectorField
+:
+    public fixedValuePointPatchField<vector>
+{
+    // Private data
+
+        //- Name of displacement field
+        const word fieldName_;
+
+        const word interpolationScheme_;
+
+        //- Times with pre-specified displacement
+        wordList timeNames_;
+
+        //- Times with pre-specified displacement
+        scalarField timeVals_;
+
+        //- User-specified interpolator
+        autoPtr<interpolationWeights> interpolatorPtr_;
+
+
+        //- Cached interpolation times
+        labelList currentIndices_;
+
+        //- Cached interpolation weights
+        scalarField currentWeights_;
+
+public:
+
+    //- Runtime type information
+    TypeName("uniformInterpolatedDisplacement");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        uniformInterpolatedDisplacementPointPatchVectorField
+        (
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        uniformInterpolatedDisplacementPointPatchVectorField
+        (
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<vector> onto a new patch
+        uniformInterpolatedDisplacementPointPatchVectorField
+        (
+            const uniformInterpolatedDisplacementPointPatchVectorField&,
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct and return a clone
+        virtual autoPtr<pointPatchField<vector> > clone() const
+        {
+            return autoPtr<pointPatchField<vector> >
+            (
+                new uniformInterpolatedDisplacementPointPatchVectorField
+                (
+                    *this
+                )
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        uniformInterpolatedDisplacementPointPatchVectorField
+        (
+            const uniformInterpolatedDisplacementPointPatchVectorField&,
+            const DimensionedField<vector, pointMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual autoPtr<pointPatchField<vector> > clone
+        (
+            const DimensionedField<vector, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<vector> >
+            (
+                new uniformInterpolatedDisplacementPointPatchVectorField
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/surfMesh/MeshedSurface/MeshedSurface.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -656,6 +656,7 @@ bool Foam::MeshedSurface<Face>::stitchFaces
                 << " faces" << endl;
         }
         faceLst.setSize(newFaceI);
+        faceMap.setSize(newFaceI);
         remapFaces(faceMap);
     }
     faceMap.clear();