ENH: functionObjects improvements.

- readFields works seamlessly on-the-fly and as postprocessor
- new surfaceInterpolateFields to create interpolated field
- writeRegisteredObject only check upon writing, not upon startup
- add min,max to faceSource

src/postProcessing/functionObjects/field/readFields/readFields.C

@@ -89,14 +89,29 @@ void Foam::readFields::read(const dictionary& dict)
 
 void Foam::readFields::execute()
 {
-    Info<< type() << " " << name_ << ":" << nl;
+    //Info<< type() << " " << name_ << ":" << nl;
+
+    // Clear out any previously loaded fields 
+    vsf_.clear();
+    vvf_.clear();
+    vSpheretf_.clear();
+    vSymmtf_.clear();
+    vtf_.clear();
+
+    ssf_.clear();
+    svf_.clear();
+    sSpheretf_.clear();
+    sSymmtf_.clear();
+    stf_.clear();
+
     forAll(fieldSet_, fieldI)
     {
-        setField<scalar>(fieldSet_[fieldI]);
-        setField<vector>(fieldSet_[fieldI]);
-        setField<sphericalTensor>(fieldSet_[fieldI]);
-        setField<symmTensor>(fieldSet_[fieldI]);
-        setField<tensor>(fieldSet_[fieldI]);
+        // If necessary load field
+        loadField<scalar>(fieldSet_[fieldI], vsf_, ssf_);
+        loadField<vector>(fieldSet_[fieldI], vvf_, svf_);
+        loadField<sphericalTensor>(fieldSet_[fieldI], vSpheretf_, sSpheretf_);
+        loadField<symmTensor>(fieldSet_[fieldI], vSymmtf_, sSymmtf_);
+        loadField<tensor>(fieldSet_[fieldI], vtf_, stf_);
     }
 }
 

src/postProcessing/functionObjects/field/readFields/readFields.H

@@ -39,6 +39,8 @@ SourceFiles
 
 #include "OFstream.H"
 #include "pointFieldFwd.H"
+#include "volFields.H"
+#include "surfaceFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -68,9 +70,22 @@ protected:
         //- on/off switch
         bool active_;
 
-        //- Fields to assess min/max
+        //- Fields to load
         wordList fieldSet_;
 
+        //- Loaded fields
+        PtrList<volScalarField> vsf_;
+        PtrList<volVectorField> vvf_;
+        PtrList<volSphericalTensorField> vSpheretf_;
+        PtrList<volSymmTensorField> vSymmtf_;
+        PtrList<volTensorField> vtf_;
+
+        PtrList<surfaceScalarField> ssf_;
+        PtrList<surfaceVectorField> svf_;
+        PtrList<surfaceSphericalTensorField> sSpheretf_;
+        PtrList<surfaceSymmTensorField> sSymmtf_;
+        PtrList<surfaceTensorField> stf_;
+
 
     // Protected Member Functions
 
@@ -81,7 +96,12 @@ protected:
         void operator=(const readFields&);
 
         template<class Type>
-        void setField(const word& fieldName);
+        void loadField
+        (
+            const word&,
+            PtrList<GeometricField<Type, fvPatchField, volMesh> >&,
+            PtrList<GeometricField<Type, fvsPatchField, surfaceMesh> >&
+        ) const;
 
 
 public:

src/postProcessing/functionObjects/field/readFields/readFieldsTemplates.C

@@ -31,7 +31,12 @@ License
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 template<class Type>
-void Foam::readFields::setField(const word& fieldName)
+void Foam::readFields::loadField
+(
+    const word& fieldName,
+    PtrList<GeometricField<Type, fvPatchField, volMesh> >& vflds,
+    PtrList<GeometricField<Type, fvsPatchField, surfaceMesh> >& sflds
+) const
 {
     typedef GeometricField<Type, fvPatchField, volMesh> vfType;
     typedef GeometricField<Type, fvsPatchField, surfaceMesh> sfType;
@@ -40,53 +45,55 @@ void Foam::readFields::setField(const word& fieldName)
     {
         if (debug)
         {
-            Info<< "Field " << fieldName << " already in database" << endl;
+            Info<< "readFields : Field " << fieldName << " already in database"
+                << endl;
         }
-
-        vfType& vf =  const_cast<vfType&>(obr_.lookupObject<vfType>(fieldName));
-        vf.checkOut();
     }
-    if (obr_.foundObject<sfType>(fieldName))
+    else if (obr_.foundObject<sfType>(fieldName))
     {
         if (debug)
         {
-            Info<< "Field " << fieldName << " already in database" << endl;
+            Info<< "readFields : Field " << fieldName << " already in database"
+                << endl;
         }
-
-        sfType& sf =  const_cast<sfType&>(obr_.lookupObject<sfType>(fieldName));
-        sf.checkOut();
     }
-
-    const fvMesh& mesh = refCast<const fvMesh>(obr_);
-
-    IOobject fieldHeader
-    (
-        fieldName,
-        mesh.time().timeName(),
-        mesh,
-        IOobject::MUST_READ,
-        IOobject::NO_WRITE
-    );
-
-    if
-    (
-        fieldHeader.headerOk()
-     && fieldHeader.headerClassName() == vfType::typeName
-    )
+    else
     {
-        // store field on the mesh database
-        Info<< "    Reading " << fieldName << endl;
-        obr_.store(new vfType(fieldHeader, mesh));
-    }
-    else if
-    (
-        fieldHeader.headerOk()
-     && fieldHeader.headerClassName() == sfType::typeName
-    )
-    {
-        // store field on the mesh database
-        Info<< "    Reading " << fieldName << endl;
-        obr_.store(new sfType(fieldHeader, mesh));
+        const fvMesh& mesh = refCast<const fvMesh>(obr_);
+
+        IOobject fieldHeader
+        (
+            fieldName,
+            mesh.time().timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        );
+
+        if
+        (
+            fieldHeader.headerOk()
+         && fieldHeader.headerClassName() == vfType::typeName
+        )
+        {
+            // store field locally
+            Info<< "    Reading " << fieldName << endl;
+            label sz = vflds.size();
+            vflds.setSize(sz+1);
+            vflds.set(sz, new vfType(fieldHeader, mesh));
+        }
+        else if
+        (
+            fieldHeader.headerOk()
+         && fieldHeader.headerClassName() == sfType::typeName
+        )
+        {
+            // store field locally
+            Info<< "    Reading " << fieldName << endl;
+            label sz = sflds.size();
+            sflds.setSize(sz+1);
+            sflds.set(sz, new sfType(fieldHeader, mesh));
+        }
     }
 }