Merge in default branch

--HG--
branch : macMerge

src/OSspecific/POSIX/multiThreader/multiThreader.C

@@ -318,7 +318,7 @@ void multiThreader::addToWorkQueue
 (
     void (*tFunction)(void*),
     void *arg
-)
+) const
 {
     if (singleThreaded())
     {
@@ -494,7 +494,7 @@ int multiThreader::getNumThreads() const
 
 
 //- Obtain the thread ID for a given index
-pthread_t multiThreader::getID(int index)
+pthread_t multiThreader::getID(int index) const
 {
     if (multiThreaded())
     {
@@ -536,7 +536,7 @@ int multiThreader::getMaxQueueSize() const
 
 
 //- Set the maxQueueSize
-void multiThreader::setMaxQueueSize(int size)
+void multiThreader::setMaxQueueSize(int size) const
 {
     if (size > 0)
     {

src/OSspecific/POSIX/multiThreader/multiThreader.H

@@ -176,9 +176,9 @@ class multiThreader
 {
     // Private data
 
-        int numThreads_;
+        mutable int numThreads_;
 
-        int maxQueueSize_;
+        mutable int maxQueueSize_;
 
         // Work-queue item: Holds a pointer to the method and its argument
         struct workQueueItem
@@ -189,7 +189,7 @@ class multiThreader
         };
 
         // Common structure for all threads in the pool.
-        struct threadPool
+        mutable struct threadPool
         {
             multiThreader *threader;
             int numThreads;
@@ -246,7 +246,7 @@ public:
         int getNumThreads() const;
 
         //- Obtain the thread ID for a given index
-        pthread_t getID(int index);
+        pthread_t getID(int index) const;
 
         //- Return true if the number of threads is equal to one.
         bool singleThreaded() const;
@@ -258,10 +258,10 @@ public:
         int getMaxQueueSize() const;
 
         //- Set the maxQueueSize
-        void setMaxQueueSize(int size);
+        void setMaxQueueSize(int size) const;
 
         //- Add a function to the work queue
-        void addToWorkQueue(void (*tFunction)(void*), void *arg);
+        void addToWorkQueue(void (*tFunction)(void*), void *arg) const;
 
         //- Conditional handling
         void waitForCondition(Conditional&, Mutex&) const;

src/OSspecific/POSIX/multiThreader/threadHandler.H

@@ -76,21 +76,21 @@ class threadHandler
     pthread_t pthreadID_;
 
     // Is this a master/slave thread
-    bool master_;
+    mutable bool master_;
 
     // Synchronization mutexes
-    Mutex startMutex_;
-    Mutex stopMutex_;
+    mutable Mutex startMutex_;
+    mutable Mutex stopMutex_;
 
     // Conditionals for synchronization
-    Conditional startConditional_;
-    Conditional stopConditional_;
+    mutable Conditional startConditional_;
+    mutable Conditional stopConditional_;
 
     // On some implementations, a conditional wait
     // might return prematurely due to a spurious
     // wake-up signal. Use a predicate to avoid this
     // behaviour.
-    FixedList<bool, 2> predicate_;
+    mutable FixedList<bool, 2> predicate_;
 
 public:
 
@@ -121,43 +121,43 @@ public:
     inline void set(const label index, void* argPtr);
 
     // Return a reference to the multiThreader
-    inline const multiThreader& threader();
+    inline const multiThreader& threader() const;
 
     // Return the number of threads
-    inline label nThreads();
+    inline label nThreads() const;
 
     // Designate as master thread
-    inline void setMaster();
+    inline void setMaster() const;
 
     // Designate as slave thread
-    inline void setSlave();
+    inline void setSlave() const;
 
     // Is this a master thread?
-    inline bool master();
+    inline bool master() const;
 
     // Is this a slave thread?
-    inline bool slave();
+    inline bool slave() const;
 
     // Lock this thread
-    inline void lock(const signalType sType);
+    inline void lock(const signalType sType) const;
 
     // Unlock this thread
-    inline void unlock(const signalType sType);
+    inline void unlock(const signalType sType) const;
 
     // Send signal to a waiting conditional
-    inline void sendSignal(const signalType sType);
+    inline void sendSignal(const signalType sType) const;
 
     // Wait for signal
-    inline void waitForSignal(const signalType sType);
+    inline void waitForSignal(const signalType sType) const;
 
     // Return state of the predicate variable
-    inline bool predicate(const signalType sType);
+    inline bool predicate(const signalType sType) const;
 
     // Set the predicate variable
-    inline void setPredicate(const signalType sType);
+    inline void setPredicate(const signalType sType) const;
 
     // Unset the predicate variable
-    inline void unsetPredicate(const signalType sType);
+    inline void unsetPredicate(const signalType sType) const;
 
     // Set the ID
     inline void setID(const pthread_t& pt);
@@ -165,11 +165,41 @@ public:
     // Return the ID
     inline pthread_t ID() const;
 
+    // Does the calling thread correspond to this handler?
+    inline bool self() const;
+
     // Return an argument pointer at a particular index
     inline void * operator()(const label index);
 };
 
 
+// Lock all threads provided by sequence
+template <class T>
+void lockThreads
+(
+    const List<label>& sequence,
+    const PtrList<threadHandler<T> >& handler
+);
+
+
+// Synchronize all threads provided by sequence
+template <class T>
+void synchronizeThreads
+(
+    const List<label>& sequence,
+    const PtrList<threadHandler<T> >& handler
+);
+
+
+// Execute threads for the submitted static function by sequence
+template <class T>
+void executeThreads
+(
+    const List<label>& sequence,
+    PtrList<threadHandler<T> >& handler,
+    void (*tFunction)(void*)
+);
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/OSspecific/POSIX/multiThreader/threadHandlerI.H

@@ -113,7 +113,7 @@ inline void threadHandler<T>::set
 
 // Return a reference to the multiThreader
 template<class T>
-inline const multiThreader& threadHandler<T>::threader()
+inline const multiThreader& threadHandler<T>::threader() const
 {
     return threader_;
 }
@@ -121,7 +121,7 @@ inline const multiThreader& threadHandler<T>::threader()
 
 // Return the number of threads
 template<class T>
-inline label threadHandler<T>::nThreads()
+inline label threadHandler<T>::nThreads() const
 {
     return nThreads_;
 }
@@ -129,7 +129,7 @@ inline label threadHandler<T>::nThreads()
 
 // Designate as master thread
 template<class T>
-inline void threadHandler<T>::setMaster()
+inline void threadHandler<T>::setMaster() const
 {
     master_ = true;
 }
@@ -137,7 +137,7 @@ inline void threadHandler<T>::setMaster()
 
 // Designate as slave thread
 template<class T>
-inline void threadHandler<T>::setSlave()
+inline void threadHandler<T>::setSlave() const
 {
     master_ = false;
 }
@@ -145,7 +145,7 @@ inline void threadHandler<T>::setSlave()
 
 // Is this a master thread?
 template<class T>
-inline bool threadHandler<T>::master()
+inline bool threadHandler<T>::master() const
 {
     return (master_ == true);
 }
@@ -153,7 +153,7 @@ inline bool threadHandler<T>::master()
 
 // Is this a slave thread?
 template<class T>
-inline bool threadHandler<T>::slave()
+inline bool threadHandler<T>::slave() const
 {
     return !master();
 }
@@ -164,7 +164,7 @@ template<class T>
 inline void threadHandler<T>::lock
 (
     const signalType sType
-)
+) const
 {
     if (sType == START)
     {
@@ -183,7 +183,7 @@ template<class T>
 inline void threadHandler<T>::unlock
 (
     const signalType sType
-)
+) const
 {
     if (sType == START)
     {
@@ -202,7 +202,7 @@ template<class T>
 inline void threadHandler<T>::sendSignal
 (
     const signalType sType
-)
+) const
 {
     lock(sType);
 
@@ -249,7 +249,7 @@ template<class T>
 inline void threadHandler<T>::waitForSignal
 (
     const signalType sType
-)
+) const
 {
     if (sType == START)
     {
@@ -294,7 +294,7 @@ template<class T>
 inline bool threadHandler<T>::predicate
 (
     const signalType sType
-)
+) const
 {
     return predicate_[sType];
 }
@@ -305,7 +305,7 @@ template<class T>
 inline void threadHandler<T>::setPredicate
 (
     const signalType sType
-)
+) const
 {
     predicate_[sType] = true;
 }
@@ -316,7 +316,7 @@ template<class T>
 inline void threadHandler<T>::unsetPredicate
 (
     const signalType sType
-)
+) const
 {
     predicate_[sType] = false;
 }
@@ -338,6 +338,14 @@ inline pthread_t threadHandler<T>::ID() const
 }
 
 
+// Does the calling thread correspond to this handler?
+template<class T>
+inline bool threadHandler<T>::self() const
+{
+    return pthread_equal(ID(), pthread_self());
+}
+
+
 // Return an argument pointer at a particular index
 template<class T>
 inline void * threadHandler<T>::operator()
@@ -371,6 +379,88 @@ inline void * threadHandler<T>::operator()
 }
 
 
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+// Lock all threads provided by sequence
+template <class T>
+void lockThreads
+(
+    const List<label>& sequence,
+    const PtrList<threadHandler<T> >& handler
+)
+{
+    forAll(sequence, i)
+    {
+        handler[sequence[i]].lock(threadHandler<T>::START);
+        handler[sequence[i]].lock(threadHandler<T>::STOP);
+
+        handler[sequence[i]].unsetPredicate(threadHandler<T>::START);
+        handler[sequence[i]].unsetPredicate(threadHandler<T>::STOP);
+    }
+}
+
+
+// Synchronize all threads provided by sequence
+template <class T>
+void synchronizeThreads
+(
+    const List<label>& sequence,
+    const PtrList<threadHandler<T> >& handler
+)
+{
+    forAll(sequence, i)
+    {
+        // Wait for a signal from this thread before moving on.
+        handler[sequence[i]].waitForSignal(threadHandler<T>::STOP);
+    }
+}
+
+
+// Execute threads for the submitted static function by sequence
+template <class T>
+void executeThreads
+(
+    const List<label>& sequence,
+    PtrList<threadHandler<T> >& handler,
+    void (*tFunction)(void*)
+)
+{
+    if (!handler.size())
+    {
+        FatalErrorIn
+        (
+            "\n\n"
+            "template <class T>\n"
+            "void executeThreads\n"
+            "(\n"
+            "    const List<label>& sequence,\n"
+            "    PtrList<threadHandler<T> >& handler,\n"
+            "    void (*tFunction)(void*)\n"
+            ")\n"
+        )
+            << "Empty handler list."
+            << abort(FatalError);
+    }
+
+    // Fetch threader reference
+    const multiThreader& threader = handler[0].threader();
+
+    // Lock slave threads by sequence
+    lockThreads(sequence, handler);
+
+    forAll(sequence, i)
+    {
+        // Submit jobs to the work queue
+        threader.addToWorkQueue(tFunction, &(handler[sequence[i]]));
+
+        // Wait for a signal from this thread before moving on.
+        handler[sequence[i]].waitForSignal(threadHandler<T>::START);
+    }
+
+    // Synchronize threads
+    synchronizeThreads(sequence, handler);
+}
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/decompositionMethods/scotchDecomp/scotchDecomp.C

@@ -23,8 +23,8 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
     From scotch forum:
- 	
-    By: Francois PELLEGRINI RE: Graph mapping 'strategy' string [ reply ]  
+
+    By: Francois PELLEGRINI RE: Graph mapping 'strategy' string [ reply ]
     2008-08-22 10:09 Strategy handling in Scotch is a bit tricky. In order
     not to be confused, you must have a clear view of how they are built.
     Here are some rules:

src/finiteVolume/cfdTools/general/MRF/MRFZones.C

@@ -50,12 +50,42 @@ Foam::MRFZones::MRFZones(const fvMesh& mesh)
             IOobject::NO_WRITE
         ),
         MRFZone::iNew(mesh)
-    )
+    ),
+    mesh_(mesh)
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+Foam::tmp<Foam::surfaceScalarField> Foam::MRFZones::fluxCorrection() const
+{
+    tmp<surfaceScalarField> tMRFZonesPhiCorr
+    (
+        new surfaceScalarField
+        (
+            IOobject
+            (
+                "MRFZonesPhiCorr",
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh_,
+            dimensionedScalar("zero", dimVelocity*dimArea, 0)
+        )
+    );
+    surfaceScalarField& MRFZonesPhiCorr = tMRFZonesPhiCorr();
+
+    forAll(*this, i)
+    {
+        operator[](i).relativeFlux(MRFZonesPhiCorr);
+    }
+
+    return tMRFZonesPhiCorr;
+}
+
+
 void Foam::MRFZones::addCoriolis(fvVectorMatrix& UEqn) const
 {
     forAll(*this, i)

src/finiteVolume/cfdTools/general/MRF/MRFZones.H

@@ -53,6 +53,11 @@ class MRFZones
 :
     public IOPtrList<MRFZone>
 {
+    // Private data
+
+        //- Mesh reference
+        const fvMesh& mesh_;
+
 
     // Private Member Functions