Steps to Fix Distribution of DimensionedFields

===============================================================================
Step 1 - Add a constructor for DimensionedField which is consistent with the one
         used in fvMeshSubset for geometric fields, with inputs of
         IOobject, mesh, and dictionary
         
         It's a good idea to re-compile src after this step.
===============================================================================

*******************************************************************************
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.H

line 151ish, add:

    //- Construct from dictionary
    DimensionedField
    (
        const IOobject&,
        const Mesh& mesh,
        const dictionary& fieldDict,
        const word& fieldDictEntry="value"
    );
    
*******************************************************************************
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldIO.C

line 82ish, add:

    template<class Type, class GeoMesh>
    Foam::DimensionedField<Type, GeoMesh>::DimensionedField
    (
        const IOobject& io,
        const Mesh& mesh,
        const dictionary& fieldDict,
        const word& fieldDictEntry
    )
    :
        regIOobject(io),
        Field<Type>(0),
        mesh_(mesh),
        dimensions_(dimless)
    {
        readField(fieldDict, fieldDictEntry);
    }

===============================================================================
Step 2 - Add an interpolate template to fvMeshSubset that can handle
         a DimensionedField<type,volMesh> input
===============================================================================

*******************************************************************************
src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.H

line 345ish, add:

    //- Map dimensioned fields
    template<class Type>
    static tmp<DimensionedField<Type, volMesh> >
    interpolate
    (
        const DimensionedField<Type, volMesh>&,
        const fvMesh& sMesh,
        const labelList& cellMap
    );
    
    template<class Type>
    tmp<DimensionedField<Type, volMesh> >
    interpolate
    (
        const DimensionedField<Type, volMesh>&
    ) const;
    
*******************************************************************************
src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubsetInterpolate.C

line 38ish, add:

    template<class Type>
    tmp<DimensionedField<Type, volMesh> > fvMeshSubset::interpolate
    (
        const DimensionedField<Type, volMesh>& df,
        const fvMesh& sMesh,
        const labelList& cellMap
    )
    {
        // Create and map the internal-field values
        Field<Type> internalField(df, cellMap);

        // Create the complete field from the pieces
        tmp<DimensionedField<Type, volMesh> > tresF
        (
            new DimensionedField<Type, volMesh>
            (
                IOobject
                (
                    "subset"+df.name(),
                    sMesh.time().timeName(),
                    sMesh,
                    IOobject::NO_READ,
                    IOobject::NO_WRITE
                ),
                sMesh,
                df.dimensions(),
                internalField
            )
        );

        return tresF;
    }


    template<class Type>
    tmp<DimensionedField<Type, volMesh> > fvMeshSubset::interpolate
    (
        const DimensionedField<Type, volMesh>& df
    ) const
    {
        return interpolate
        (
            df,
            subMesh(),
            cellMap()
        );
    }
    
===============================================================================
Step 3 - Update the field mapping in fvMeshAdder to include the templates for
         DimensionedFields and add the calls to map those fields to the "add"
         function
===============================================================================

*******************************************************************************
src/dynamicMesh/fvMeshAdder/fvMeshAdder.H

line 148ish, add:

    //- Update single dimensioned Field.
    template<class Type>
    static void MapDimField
    (
        const mapAddedPolyMesh& meshMap,

        DimensionedField<Type, volMesh>& fld,
        const DimensionedField<Type, volMesh>& fldToAdd
    );

line 190ish, add:

    //- Map all dimensionedFields of Type
    template<class Type>
    static void MapDimFields
    (
        const mapAddedPolyMesh&,
        const fvMesh& mesh,
        const fvMesh& meshToAdd
    );

*******************************************************************************
src/dynamicMesh/fvMeshAdder/fvMeshAdderTemplates.C

line 353ish, add:

    template<class Type>
    void Foam::fvMeshAdder::MapDimField
    (
        const mapAddedPolyMesh& meshMap,

        DimensionedField<Type, volMesh>& fld,
        const DimensionedField<Type, volMesh>& fldToAdd
    )
    {
        const fvMesh& mesh = fld.mesh();

        // Internal field
        // ~~~~~~~~~~~~~~

        {
            // Store old internal field
            Field<Type> oldInternalField(fld);

            // Modify internal field
            Field<Type>& intFld = fld;

            intFld.setSize(mesh.nCells());

            map(oldInternalField, meshMap.oldCellMap(), intFld);
            map(fldToAdd, meshMap.addedCellMap(), intFld);
        }
    }


    template<class Type>
    void Foam::fvMeshAdder::MapDimFields
    (
        const mapAddedPolyMesh& meshMap,
        const fvMesh& mesh,
        const fvMesh& meshToAdd
    )
    {
        HashTable<const DimensionedField<Type, volMesh>*> fields
        (
            mesh.objectRegistry::lookupClass
            <DimensionedField<Type, volMesh> >
            ()
        );

        HashTable<const DimensionedField<Type, volMesh>*> fieldsToAdd
        (
            meshToAdd.objectRegistry::lookupClass
            <DimensionedField<Type, volMesh> >
            ()
        );


        for
        (
            typename HashTable<const DimensionedField<Type, volMesh>*>::
                iterator fieldIter = fields.begin();
            fieldIter != fields.end();
            ++fieldIter
        )
        {
            DimensionedField<Type, volMesh>& fld =
                const_cast<DimensionedField<Type, volMesh>&>
                (
                    *fieldIter()
                );

            if (fieldsToAdd.found(fld.name()))
            {
                const DimensionedField<Type, volMesh>& fldToAdd =
                    *fieldsToAdd[fld.name()];

                MapDimField<Type>(meshMap, fld, fldToAdd);
            }
            else
            {
                WarningIn("fvMeshAdder::MapDimFields(..)")
                    << "Not mapping field " << fld.name()
                    << " since not present on mesh to add"
                    << endl;
            }
        }
    }

*******************************************************************************
src/dynamicMesh/fvMeshAdder/fvMeshAdder.C

line 104ish, add:

    fvMeshAdder::MapDimFields<scalar>(mapPtr, mesh0, mesh1);
    fvMeshAdder::MapDimFields<vector>(mapPtr, mesh0, mesh1);
    fvMeshAdder::MapDimFields<sphericalTensor>(mapPtr, mesh0, mesh1);
    fvMeshAdder::MapDimFields<symmTensor>(mapPtr, mesh0, mesh1);
    fvMeshAdder::MapDimFields<tensor>(mapPtr, mesh0, mesh1);
    


===============================================================================
Step 4 - Add in the actual distribution if the different types of
         DimensionedFields in fvMeshDistribute.
         
         Some typedefs of DimensionedFields like there are of geometric fields
         would be nice. Something like:
         
           typedef DimensionedField<scalar,volmesh> dimensionedScalarField;
           typedef DimensionedField<vector,volmesh> dimensionedVectorField;
           
           and soforth
           
===============================================================================

*******************************************************************************
src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
        
line 1735ish, add:
    
    const wordList dimScalarFields
    (
        mesh_.names(DimensionedField<scalar, volMesh>::typeName)
    );
    checkEqualWordList("dimScalarFields", dimScalarFields);
    
    const wordList dimVectorFields
    (
        mesh_.names(DimensionedField<vector, volMesh>::typeName)
    );
    checkEqualWordList("dimVectorFields", dimVectorFields);
    
    const wordList dimSphericalTensorFields
    (
        mesh_.names(DimensionedField<sphericalTensor, volMesh>::typeName)
    );
    checkEqualWordList("dimSphericalTensorFields", dimSphericalTensorFields);
    
    const wordList dimSymmTensorFields
    (
        mesh_.names(DimensionedField<symmTensor, volMesh>::typeName)
    );
    checkEqualWordList("dimSymmTensorFields", dimSymmTensorFields);
    
    const wordList dimTensorFields
    (
        mesh_.names(DimensionedField<tensor, volMesh>::typeName)
    );
    checkEqualWordList("dimTensorFields", dimTensorFields);
    
    
    
line 1997ish (immediately after the sendFields<surfaceTensorField>, add:
    
    sendFields<DimensionedField<scalar,volMesh> >
    (
        recvProc,
        dimScalarFields,
        subsetter,
        str
    );
    sendFields<DimensionedField<vector,volMesh> >
    (
        recvProc,
        dimVectorFields,
        subsetter,
        str
    );
    sendFields<DimensionedField<sphericalTensor,volMesh> >
    (
        recvProc,
        dimSphericalTensorFields,
        subsetter,
        str
    );
    sendFields<DimensionedField<symmTensor,volMesh> >
    (
        recvProc,
        dimSymmTensorFields,
        subsetter,
        str
    );
    sendFields<DimensionedField<tensor,volMesh> >
    (
        recvProc,
        dimTensorFields,
        subsetter,
        str
    );
    
line 2180ish (after the PtrList<surfaceTensorField> line), add:

    PtrList<DimensionedField<scalar,volMesh> > isf;
    PtrList<DimensionedField<vector,volMesh> > ivf;
    PtrList<DimensionedField<sphericalTensor,volMesh> > istf;
    PtrList<DimensionedField<symmTensor,volMesh> > isytf;
    PtrList<DimensionedField<tensor,volMesh> > itf;
    
line 2290ish (after the receiveFields<surfaceTensorField> call), add:

    receiveFields<DimensionedField<scalar,volMesh> >
    (
        sendProc,
        dimScalarFields,
        domainMesh,
        isf,
        fieldDicts.subDict(DimensionedField<scalar,volMesh>::typeName)
    );
    receiveFields<DimensionedField<vector,volMesh> >
    (
        sendProc,
        dimVectorFields,
        domainMesh,
        ivf,
        fieldDicts.subDict(DimensionedField<vector,volMesh>::typeName)
    );
    receiveFields<DimensionedField<sphericalTensor,volMesh> >
    (
        sendProc,
        dimSphericalTensorFields,
        domainMesh,
        istf,
        fieldDicts.subDict(DimensionedField<sphericalTensor,volMesh>::typeName)
    );
    receiveFields<DimensionedField<symmTensor,volMesh> >
    (
        sendProc,
        dimSymmTensorFields,
        domainMesh,
        isytf,
        fieldDicts.subDict(DimensionedField<symmTensor,volMesh>::typeName)
    );
    receiveFields<DimensionedField<tensor,volMesh> >
    (
        sendProc,
        dimTensorFields,
        domainMesh,
        itf,
        fieldDicts.subDict(DimensionedField<tensor,volMesh>::typeName)
    );