Difference between revisions of "Snip calculating mass flow"

From OpenFOAMWiki
m (Reverted edit of Pvaqbj, changed back to last version by Bgschaid)
 
(9 intermediate revisions by 7 users not shown)
Line 1: Line 1:
 
 
== Description ==
 
== Description ==
  
Line 24: Line 23:
 
#include "SortableList.H"
 
#include "SortableList.H"
  
wordList buildGlobalBoundaryList(polyMesh &mesh)
+
wordList buildGlobalBoundaryList(polyMesh &mesh)
 
{
 
{
 
     int i;
 
     int i;
Line 37: Line 36:
 
     forAll (mesh.boundaryMesh(), patchIndex)
 
     forAll (mesh.boundaryMesh(), patchIndex)
 
     {
 
     {
         const polyPatch& patch = mesh.boundaryMesh()[patchIndex];
+
         const polyPatch& patch = mesh.boundaryMesh()[patchIndex];
 
         if (typeid(patch) != typeid(processorPolyPatch))
 
         if (typeid(patch) != typeid(processorPolyPatch))
 
         {
 
         {
Line 135: Line 134:
 
}
 
}
 
</cpp>
 
</cpp>
<div id="ghsfg5dfhsdfhd" style="overflow:auto;height:4px;">[http://www.zorpia.com/replicawatch2 replica watch] </div>
 

Latest revision as of 08:20, 21 August 2006

1 Description

This describes how to set up the solver in order to calculate the mass fluxes on the boundary. It works in serial and parallel.

It was taken from the thread Calculation of integral boundary values.

2 Preparing the solver

Firstly, you need to #include "SortableList.H" as one of the top level includes in a solver application.

Then #include "buildGlobalBoundaryList.H" once "createMesh.H" and other initialisations have been run in the main function. (This only needs to be run once.)

The result of this is a wordList variable called "globalPatchNames" that is available on each processor, and contains a sorted list of all real patches in the model.

To compute mass fluxes after each timestep, #include "computeMassFlux.H"

3 The files

3.1 buildGlobalBoundaryList.H

 
#include "SortableList.H"
 
wordList buildGlobalBoundaryList(polyMesh &mesh)
{
    int i;
    label numPatches;
    SortableList<word> sortablePatchNames(0);
    List<wordList> gatheredPatchNames(Pstream::nProcs());
 
    Info<< "Building global boundary list" << endl;
 
    // collect all real patches into a wordList
    wordList realPatches(0);
    forAll (mesh.boundaryMesh(), patchIndex)
    {
        const polyPatch& patch = mesh.boundaryMesh()[patchIndex];
        if (typeid(patch) != typeid(processorPolyPatch))
        {
            realPatches.setSize(realPatches.size()+1);
            realPatches[realPatches.size()-1] = patch.name();
        }
    }
 
    // gather real patches from each processor
    gatheredPatchNames[Pstream::myProcNo()] = realPatches;
    Pstream::gatherList(gatheredPatchNames);
 
    if (Pstream::master())
    {
        // store unique patches (using a HashSet)
        HashSet<word> hashSetPatchNames(0);
        forAll (gatheredPatchNames, patchListProc)
        {
            forAll (gatheredPatchNames[patchListProc], patchNameItr)
            {
                hashSetPatchNames.insert(
                    gatheredPatchNames[patchListProc][patchNameItr]
                    );
            }
        }
 
        // store patch names into a SortableList
        sortablePatchNames.setSize(hashSetPatchNames.size());
        i=0;
        for
        (
            HashSet<word>::const_iterator iter = hashSetPatchNames.begin();
            iter != hashSetPatchNames.end();
            ++iter
        )
        {
            sortablePatchNames[i++] = iter.key();
        }
 
        // *** SORT CAUSES SEG-FAULT **********
	// sortablePatchNames.sort();
        // ************************************
 
        // save the number of patches
        numPatches = sortablePatchNames.size();
    }
 
    // scatter the number of patches to each processor
    Pstream::scatter(numPatches);
 
    // reset the list size on all other processors
    if (!Pstream::master())
    {
        sortablePatchNames.setSize(numPatches);
    }
 
    // scatter individual patch names to each processor
    // and rebuild the patch list
    word tmpPatchName;
    for (i=0; i<numPatches; i++)
    {
        if(Pstream::master())
        {
            tmpPatchName = sortablePatchNames[i];
        }
        Pstream::scatter(tmpPatchName);
        if(!Pstream::master())
        {
            sortablePatchNames[i] = tmpPatchName;
        }
    }
 
    // return the global patch names
    return sortablePatchNames;
}

3.2 calculateMassFlux.H

 
{
    scalar netFlux = 0;
    forAll (globalBoundaryList, patchI)
    {
        scalar flux = 0;
        label patchIndex = mesh.boundaryMesh().findPatchID(globalBoundaryList[patchI]);
        if (patchIndex >= 0)
        {
            flux = sum(phi.boundaryField()[patchIndex]);
        }
        reduce(flux, sumOp<scalar>());
        Info<< "Mass flux at " << globalBoundaryList[patchI]
            << " = " << flux << endl;
        netFlux += flux;
    }
    Info<< "Net mass flux = " << netFlux << endl << endl;
}