v4/mapDistributeBaseTemplates_8C_source.html

 /*---------------------------------------------------------------------------*\
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2015-2016 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 "Pstream.H"
 #include "PstreamBuffers.H"
 #include "PstreamCombineReduceOps.H"
 #include "flipOp.H"

 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //

 template<class T, class CombineOp, class negateOp>
 void Foam::mapDistributeBase::flipAndCombine
 (
     const UList<label>& map,
     const bool hasFlip,
     const UList<T>& rhs,
     const CombineOp& cop,
     const negateOp& negOp,
     List<T>& lhs
 )
 {
     if (hasFlip)
     {
         forAll(map, i)
         {
             if (map[i] > 0)
             {
                 label index = map[i]-1;
                 cop(lhs[index], rhs[i]);
             }
             else if (map[i] < 0)
             {
                 label index = -map[i]-1;
                 cop(lhs[index], negOp(rhs[i]));
             }
             else
             {
                 FatalErrorInFunction
                     << "At index " << i << " out of " << map.size()
                     << " have illegal index " << map[i]
                     << " for field " << rhs.size() << " with flipMap"
                     << exit(FatalError);
             }
         }
     }
     else
     {
         forAll(map, i)
         {
             cop(lhs[map[i]], rhs[i]);
         }
     }
 }


 template<class T, class negateOp>
 T Foam::mapDistributeBase::accessAndFlip
 (
     const UList<T>& fld,
     const label index,
     const bool hasFlip,
     const negateOp& negOp
 )
 {
     T t;
     if (hasFlip)
     {
         if (index > 0)
         {
             t = fld[index-1];
         }
         else if (index < 0)
         {
             t = negOp(fld[-index-1]);
         }
         else
         {
             FatalErrorInFunction
                 << "Illegal index " << index
                 << " into field of size " << fld.size()
                 << " with face-flipping"
                 << exit(FatalError);
             t = fld[index];
         }
     }
     else
     {
         t = fld[index];
     }
     return t;
 }


 // Distribute list.
 template<class T, class negateOp>
 void Foam::mapDistributeBase::distribute
 (
     const Pstream::commsTypes commsType,
     const List<labelPair>& schedule,
     const label constructSize,
     const labelListList& subMap,
     const bool subHasFlip,
     const labelListList& constructMap,
     const bool constructHasFlip,
     List<T>& field,
     const negateOp& negOp,
     const int tag
 )
 {
     if (!Pstream::parRun())
     {
         // Do only me to me.

         const labelList& mySubMap = subMap[Pstream::myProcNo()];

         List<T> subField(mySubMap.size());
         forAll(mySubMap, i)
         {
             subField[i] = accessAndFlip(field, mySubMap[i], subHasFlip, negOp);
         }

         // Receive sub field from myself (subField)
         const labelList& map = constructMap[Pstream::myProcNo()];

         field.setSize(constructSize);

         flipAndCombine
         (
             map,
             constructHasFlip,
             subField,
             eqOp<T>(),
             negOp,
             field
         );

         return;
     }

     if (commsType == Pstream::blocking)
     {
         // Since buffered sending can reuse the field to collect the
         // received data.

         // Send sub field to neighbour
         for (label domain = 0; domain < Pstream::nProcs(); domain++)
         {
             const labelList& map = subMap[domain];

             if (domain != Pstream::myProcNo() && map.size())
             {
                 OPstream toNbr(Pstream::blocking, domain, 0, tag);

                 List<T> subField(map.size());
                 forAll(subField, i)
                 {
                     subField[i] = accessAndFlip
                     (
                         field,
                         map[i],
                         subHasFlip,
                         negOp
                     );
                 }
                 toNbr << subField;
             }
         }

         // Subset myself
         const labelList& mySubMap = subMap[Pstream::myProcNo()];

         List<T> subField(mySubMap.size());
         forAll(mySubMap, i)
         {
             subField[i] = accessAndFlip(field, mySubMap[i], subHasFlip, negOp);
         }

         // Receive sub field from myself (subField)
         const labelList& map = constructMap[Pstream::myProcNo()];

         field.setSize(constructSize);

         flipAndCombine
         (
             map,
             constructHasFlip,
             subField,
             eqOp<T>(),
             negOp,
             field
         );

         // Receive sub field from neighbour
         for (label domain = 0; domain < Pstream::nProcs(); domain++)
         {
             const labelList& map = constructMap[domain];

             if (domain != Pstream::myProcNo() && map.size())
             {
                 IPstream fromNbr(Pstream::blocking, domain, 0, tag);
                 List<T> subField(fromNbr);

                 checkReceivedSize(domain, map.size(), subField.size());

                 flipAndCombine
                 (
                     map,
                     constructHasFlip,
                     subField,
                     eqOp<T>(),
                     negOp,
                     field
                 );
             }
         }
     }
     else if (commsType == Pstream::scheduled)
     {
         // Need to make sure I don't overwrite field with received data
         // since the data might need to be sent to another processor. So
         // allocate a new field for the results.
         List<T> newField(constructSize);

         // Receive sub field from myself
         {
             const labelList& mySubMap = subMap[Pstream::myProcNo()];

             List<T> subField(mySubMap.size());
             forAll(subField, i)
             {
                 subField[i] = accessAndFlip
                 (
                     field,
                     mySubMap[i],
                     subHasFlip,
                     negOp
                 );
             }

             // Receive sub field from myself (subField)
             flipAndCombine
             (
                 constructMap[Pstream::myProcNo()],
                 constructHasFlip,
                 subField,
                 eqOp<T>(),
                 negOp,
                 newField
             );
         }

         // Schedule will already have pruned 0-sized comms
         forAll(schedule, i)
         {
             const labelPair& twoProcs = schedule[i];
             // twoProcs is a swap pair of processors. The first one is the
             // one that needs to send first and then receive.

             label sendProc = twoProcs[0];
             label recvProc = twoProcs[1];

             if (Pstream::myProcNo() == sendProc)
             {
                 // I am send first, receive next
                 {
                     OPstream toNbr(Pstream::scheduled, recvProc, 0, tag);

                     const labelList& map = subMap[recvProc];
                     List<T> subField(map.size());
                     forAll(subField, i)
                     {
                         subField[i] = accessAndFlip
                         (
                             field,
                             map[i],
                             subHasFlip,
                             negOp
                         );
                     }
                     toNbr << subField;
                 }
                 {
                     IPstream fromNbr(Pstream::scheduled, recvProc, 0, tag);
                     List<T> subField(fromNbr);

                     const labelList& map = constructMap[recvProc];

                     checkReceivedSize(recvProc, map.size(), subField.size());

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         subField,
                         eqOp<T>(),
                         negOp,
                         newField
                     );
                 }
             }
             else
             {
                 // I am receive first, send next
                 {
                     IPstream fromNbr(Pstream::scheduled, sendProc, 0, tag);
                     List<T> subField(fromNbr);

                     const labelList& map = constructMap[sendProc];

                     checkReceivedSize(sendProc, map.size(), subField.size());

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         subField,
                         eqOp<T>(),
                         negOp,
                         newField
                     );
                 }
                 {
                     OPstream toNbr(Pstream::scheduled, sendProc, 0, tag);

                     const labelList& map = subMap[sendProc];
                     List<T> subField(map.size());
                     forAll(subField, i)
                     {
                         subField[i] = accessAndFlip
                         (
                             field,
                             map[i],
                             subHasFlip,
                             negOp
                         );
                     }
                     toNbr << subField;
                 }
             }
         }
         field.transfer(newField);
     }
     else if (commsType == Pstream::nonBlocking)
     {
         label nOutstanding = Pstream::nRequests();

         if (!contiguous<T>())
         {
             PstreamBuffers pBufs(Pstream::nonBlocking, tag);

             // Stream data into buffer
             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = subMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     // Put data into send buffer
                     UOPstream toDomain(domain, pBufs);

                     List<T> subField(map.size());
                     forAll(subField, i)
                     {
                         subField[i] = accessAndFlip
                         (
                             field,
                             map[i],
                             subHasFlip,
                             negOp
                         );
                     }
                     toDomain << subField;
                 }
             }

             // Start receiving. Do not block.
             pBufs.finishedSends(false);

             {
                 // Set up 'send' to myself
                 const labelList& mySub = subMap[Pstream::myProcNo()];
                 List<T> mySubField(mySub.size());
                 forAll(mySub, i)
                 {
                     mySubField[i] = accessAndFlip
                     (
                         field,
                         mySub[i],
                         subHasFlip,
                         negOp
                     );
                 }
                 // Combine bits. Note that can reuse field storage
                 field.setSize(constructSize);
                 // Receive sub field from myself
                 {
                     const labelList& map = constructMap[Pstream::myProcNo()];

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         mySubField,
                         eqOp<T>(),
                         negOp,
                         field
                     );
                 }
             }

             // Block ourselves, waiting only for the current comms
             Pstream::waitRequests(nOutstanding);

             // Consume
             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = constructMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     UIPstream str(domain, pBufs);
                     List<T> recvField(str);

                     checkReceivedSize(domain, map.size(), recvField.size());

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         recvField,
                         eqOp<T>(),
                         negOp,
                         field
                     );
                 }
             }
         }
         else
         {
             // Set up sends to neighbours

             List<List<T > > sendFields(Pstream::nProcs());

             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = subMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     List<T>& subField = sendFields[domain];
                     subField.setSize(map.size());
                     forAll(map, i)
                     {
                         subField[i] = accessAndFlip
                         (
                             field,
                             map[i],
                             subHasFlip,
                             negOp
                         );
                     }

                     OPstream::write
                     (
                         Pstream::nonBlocking,
                         domain,
                         reinterpret_cast<const char*>(subField.begin()),
                         subField.byteSize(),
                         tag
                     );
                 }
             }

             // Set up receives from neighbours

             List<List<T > > recvFields(Pstream::nProcs());

             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = constructMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     recvFields[domain].setSize(map.size());
                     IPstream::read
                     (
                         Pstream::nonBlocking,
                         domain,
                         reinterpret_cast<char*>(recvFields[domain].begin()),
                         recvFields[domain].byteSize(),
                         tag
                     );
                 }
             }


             // Set up 'send' to myself

             {
                 const labelList& map = subMap[Pstream::myProcNo()];

                 List<T>& subField = sendFields[Pstream::myProcNo()];
                 subField.setSize(map.size());
                 forAll(map, i)
                 {
                     subField[i] = accessAndFlip
                     (
                         field,
                         map[i],
                         subHasFlip,
                         negOp
                     );
                 }
             }


             // Combine bits. Note that can reuse field storage

             field.setSize(constructSize);


             // Receive sub field from myself (sendFields[Pstream::myProcNo()])
             {
                 const labelList& map = constructMap[Pstream::myProcNo()];
                 const List<T>& subField = sendFields[Pstream::myProcNo()];

                 flipAndCombine
                 (
                     map,
                     constructHasFlip,
                     subField,
                     eqOp<T>(),
                     negOp,
                     field
                 );
             }


             // Wait for all to finish

             Pstream::waitRequests(nOutstanding);


             // Collect neighbour fields

             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = constructMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     const List<T>& subField = recvFields[domain];

                     checkReceivedSize(domain, map.size(), subField.size());

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         subField,
                         eqOp<T>(),
                         negOp,
                         field
                     );
                 }
             }
         }
     }
     else
     {
         FatalErrorInFunction
             << "Unknown communication schedule " << commsType
             << abort(FatalError);
     }
 }


 // Distribute list.
 template<class T, class CombineOp, class negateOp>
 void Foam::mapDistributeBase::distribute
 (
     const Pstream::commsTypes commsType,
     const List<labelPair>& schedule,
     const label constructSize,
     const labelListList& subMap,
     const bool subHasFlip,
     const labelListList& constructMap,
     const bool constructHasFlip,
     List<T>& field,
     const CombineOp& cop,
     const negateOp& negOp,
     const T& nullValue,
     const int tag
 )
 {
     if (!Pstream::parRun())
     {
         // Do only me to me.

         const labelList& mySubMap = subMap[Pstream::myProcNo()];

         List<T> subField(mySubMap.size());
         forAll(mySubMap, i)
         {
             subField[i] = accessAndFlip(field, mySubMap[i], subHasFlip, negOp);
         }

         // Receive sub field from myself (subField)
         const labelList& map = constructMap[Pstream::myProcNo()];

         field.setSize(constructSize);
         field = nullValue;

         flipAndCombine(map, constructHasFlip, subField, cop, negOp, field);

         return;
     }

     if (commsType == Pstream::blocking)
     {
         // Since buffered sending can reuse the field to collect the
         // received data.

         // Send sub field to neighbour
         for (label domain = 0; domain < Pstream::nProcs(); domain++)
         {
             const labelList& map = subMap[domain];

             if (domain != Pstream::myProcNo() && map.size())
             {
                 OPstream toNbr(Pstream::blocking, domain, 0, tag);
                 List<T> subField(map.size());
                 forAll(subField, i)
                 {
                     subField[i] = accessAndFlip
                     (
                         field,
                         map[i],
                         subHasFlip,
                         negOp
                     );
                 }
                 toNbr << subField;
             }
         }

         // Subset myself
         const labelList& mySubMap = subMap[Pstream::myProcNo()];

         List<T> subField(mySubMap.size());
         forAll(mySubMap, i)
         {
             subField[i] = accessAndFlip(field, mySubMap[i], subHasFlip, negOp);
         }

         // Receive sub field from myself (subField)
         const labelList& map = constructMap[Pstream::myProcNo()];

         field.setSize(constructSize);
         field = nullValue;

         flipAndCombine(map, constructHasFlip, subField, cop, negOp, field);

         // Receive sub field from neighbour
         for (label domain = 0; domain < Pstream::nProcs(); domain++)
         {
             const labelList& map = constructMap[domain];

             if (domain != Pstream::myProcNo() && map.size())
             {
                 IPstream fromNbr(Pstream::blocking, domain, 0, tag);
                 List<T> subField(fromNbr);

                 checkReceivedSize(domain, map.size(), subField.size());

                 flipAndCombine
                 (
                     map,
                     constructHasFlip,
                     subField,
                     cop,
                     negOp,
                     field
                 );
             }
         }
     }
     else if (commsType == Pstream::scheduled)
     {
         // Need to make sure I don't overwrite field with received data
         // since the data might need to be sent to another processor. So
         // allocate a new field for the results.
         List<T> newField(constructSize, nullValue);

         {
             const labelList& mySubMap = subMap[Pstream::myProcNo()];

             // Subset myself
             List<T> subField(mySubMap.size());
             forAll(subField, i)
             {
                 subField[i] = accessAndFlip
                 (
                     field,
                     mySubMap[i],
                     subHasFlip,
                     negOp
                 );
             }

             // Receive sub field from myself (subField)
             const labelList& map = constructMap[Pstream::myProcNo()];

             flipAndCombine
             (
                 map,
                 constructHasFlip,
                 subField,
                 cop,
                 negOp,
                 newField
             );
         }


         // Schedule will already have pruned 0-sized comms
         forAll(schedule, i)
         {
             const labelPair& twoProcs = schedule[i];
             // twoProcs is a swap pair of processors. The first one is the
             // one that needs to send first and then receive.

             label sendProc = twoProcs[0];
             label recvProc = twoProcs[1];

             if (Pstream::myProcNo() == sendProc)
             {
                 // I am send first, receive next
                 {
                     OPstream toNbr(Pstream::scheduled, recvProc, 0, tag);

                     const labelList& map = subMap[recvProc];

                     List<T> subField(map.size());
                     forAll(subField, i)
                     {
                         subField[i] = accessAndFlip
                         (
                             field,
                             map[i],
                             subHasFlip,
                             negOp
                         );
                     }
                     toNbr << subField;
                 }
                 {
                     IPstream fromNbr(Pstream::scheduled, recvProc, 0, tag);
                     List<T> subField(fromNbr);
                     const labelList& map = constructMap[recvProc];

                     checkReceivedSize(recvProc, map.size(), subField.size());

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         subField,
                         cop,
                         negOp,
                         newField
                     );
                 }
             }
             else
             {
                 // I am receive first, send next
                 {
                     IPstream fromNbr(Pstream::scheduled, sendProc, 0, tag);
                     List<T> subField(fromNbr);
                     const labelList& map = constructMap[sendProc];

                     checkReceivedSize(sendProc, map.size(), subField.size());

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         subField,
                         cop,
                         negOp,
                         newField
                     );
                 }
                 {
                     OPstream toNbr(Pstream::scheduled, sendProc, 0, tag);

                     const labelList& map = subMap[sendProc];

                     List<T> subField(map.size());
                     forAll(subField, i)
                     {
                         subField[i] = accessAndFlip
                         (
                             field,
                             map[i],
                             subHasFlip,
                             negOp
                         );
                     }
                     toNbr << subField;
                 }
             }
         }
         field.transfer(newField);
     }
     else if (commsType == Pstream::nonBlocking)
     {
         label nOutstanding = Pstream::nRequests();

         if (!contiguous<T>())
         {
             PstreamBuffers pBufs(Pstream::nonBlocking, tag);

             // Stream data into buffer
             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = subMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     // Put data into send buffer
                     UOPstream toDomain(domain, pBufs);

                     List<T> subField(map.size());
                     forAll(subField, i)
                     {
                         subField[i] = accessAndFlip
                         (
                             field,
                             map[i],
                             subHasFlip,
                             negOp
                         );
                     }
                     toDomain << subField;
                 }
             }

             // Start receiving. Do not block.
             pBufs.finishedSends(false);

             {
                 // Set up 'send' to myself
                 const labelList& myMap = subMap[Pstream::myProcNo()];

                 List<T> mySubField(myMap.size());
                 forAll(myMap, i)
                 {
                     mySubField[i] = accessAndFlip
                     (
                         field,
                         myMap[i],
                         subHasFlip,
                         negOp
                     );
                 }

                 // Combine bits. Note that can reuse field storage
                 field.setSize(constructSize);
                 field = nullValue;
                 // Receive sub field from myself
                 {
                     const labelList& map = constructMap[Pstream::myProcNo()];

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         mySubField,
                         cop,
                         negOp,
                         field
                     );
                 }
             }

             // Block ourselves, waiting only for the current comms
             Pstream::waitRequests(nOutstanding);

             // Consume
             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = constructMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     UIPstream str(domain, pBufs);
                     List<T> recvField(str);

                     checkReceivedSize(domain, map.size(), recvField.size());

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         recvField,
                         cop,
                         negOp,
                         field
                     );
                 }
             }
         }
         else
         {
             // Set up sends to neighbours

             List<List<T > > sendFields(Pstream::nProcs());

             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = subMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     List<T>& subField = sendFields[domain];
                     subField.setSize(map.size());
                     forAll(map, i)
                     {
                         subField[i] = accessAndFlip
                         (
                             field,
                             map[i],
                             subHasFlip,
                             negOp
                         );
                     }

                     OPstream::write
                     (
                         Pstream::nonBlocking,
                         domain,
                         reinterpret_cast<const char*>(subField.begin()),
                         subField.size()*sizeof(T),
                         tag
                     );
                 }
             }

             // Set up receives from neighbours

             List<List<T > > recvFields(Pstream::nProcs());

             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = constructMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     recvFields[domain].setSize(map.size());
                     UIPstream::read
                     (
                         Pstream::nonBlocking,
                         domain,
                         reinterpret_cast<char*>(recvFields[domain].begin()),
                         recvFields[domain].size()*sizeof(T),
                         tag
                     );
                 }
             }

             // Set up 'send' to myself

             {
                 const labelList& map = subMap[Pstream::myProcNo()];

                 List<T>& subField = sendFields[Pstream::myProcNo()];
                 subField.setSize(map.size());
                 forAll(map, i)
                 {
                     subField[i] = accessAndFlip
                     (
                         field,
                         map[i],
                         subHasFlip,
                         negOp
                     );
                 }
             }


             // Combine bits. Note that can reuse field storage

             field.setSize(constructSize);
             field = nullValue;

             // Receive sub field from myself (subField)
             {
                 const labelList& map = constructMap[Pstream::myProcNo()];
                 const List<T>& subField = sendFields[Pstream::myProcNo()];

                 flipAndCombine
                 (
                     map,
                     constructHasFlip,
                     subField,
                     cop,
                     negOp,
                     field
                 );
             }


             // Wait for all to finish

             Pstream::waitRequests(nOutstanding);


             // Collect neighbour fields

             for (label domain = 0; domain < Pstream::nProcs(); domain++)
             {
                 const labelList& map = constructMap[domain];

                 if (domain != Pstream::myProcNo() && map.size())
                 {
                     const List<T>& subField = recvFields[domain];

                     checkReceivedSize(domain, map.size(), subField.size());

                     flipAndCombine
                     (
                         map,
                         constructHasFlip,
                         subField,
                         cop,
                         negOp,
                         field
                     );
                 }
             }
         }
     }
     else
     {
         FatalErrorInFunction
             << "Unknown communication schedule " << commsType
             << abort(FatalError);
     }
 }


 template<class T>
 void Foam::mapDistributeBase::send(PstreamBuffers& pBufs, const List<T>& field)
 const
 {
     // Stream data into buffer
     for (label domain = 0; domain < Pstream::nProcs(); domain++)
     {
         const labelList& map = subMap_[domain];

         if (map.size())
         {
             // Put data into send buffer
             UOPstream toDomain(domain, pBufs);

             List<T> subField(map.size());
             forAll(subField, i)
             {
                 subField[i] = accessAndFlip
                 (
                     field,
                     map[i],
                     subHasFlip_,
                     flipOp()
                 );
             }
             toDomain << subField;
         }
     }

     // Start sending and receiving but do not block.
     pBufs.finishedSends(false);
 }


 template<class T>
 void Foam::mapDistributeBase::receive(PstreamBuffers& pBufs, List<T>& field)
 const
 {
     // Consume
     field.setSize(constructSize_);

     for (label domain = 0; domain < Pstream::nProcs(); domain++)
     {
         const labelList& map = constructMap_[domain];

         if (map.size())
         {
             UIPstream str(domain, pBufs);
             List<T> recvField(str);

             if (recvField.size() != map.size())
             {
                 FatalErrorInFunction
                     << "Expected from processor " << domain
                     << " " << map.size() << " but received "
                     << recvField.size() << " elements."
                     << abort(FatalError);
             }

             flipAndCombine
             (
                 map,
                 constructHasFlip_,
                 recvField,
                 eqOp<T>(),
                 flipOp(),
                 field
             );
         }
     }
 }


 //- Distribute data using default commsType.
 template<class T, class negateOp>
 void Foam::mapDistributeBase::distribute
 (
     List<T>& fld,
     const negateOp& negOp,
     const int tag
 ) const
 {
     if (Pstream::defaultCommsType == Pstream::nonBlocking)
     {
         distribute
         (
             Pstream::nonBlocking,
             List<labelPair>(),
             constructSize_,
             subMap_,
             subHasFlip_,
             constructMap_,
             constructHasFlip_,
             fld,
             negOp,
             tag
         );
     }
     else if (Pstream::defaultCommsType == Pstream::scheduled)
     {
         distribute
         (
             Pstream::scheduled,
             schedule(),
             constructSize_,
             subMap_,
             subHasFlip_,
             constructMap_,
             constructHasFlip_,
             fld,
             negOp,
             tag
         );
     }
     else
     {
         distribute
         (
             Pstream::blocking,
             List<labelPair>(),
             constructSize_,
             subMap_,
             subHasFlip_,
             constructMap_,
             constructHasFlip_,
             fld,
             negOp,
             tag
         );
     }
 }


 //- Distribute data using default commsType.
 template<class T>
 void Foam::mapDistributeBase::distribute
 (
     List<T>& fld,
     const int tag
 ) const
 {
     distribute(fld, flipOp(), tag);
 }


 //- Distribute data using default commsType.
 template<class T>
 void Foam::mapDistributeBase::distribute
 (
     DynamicList<T>& fld,
     const int tag
 ) const
 {
     fld.shrink();

     List<T>& fldList = static_cast<List<T>& >(fld);

     distribute(fldList, tag);

     fld.setCapacity(fldList.size());
 }


 //- Reverse distribute data using default commsType.
 template<class T>
 void Foam::mapDistributeBase::reverseDistribute
 (
     const label constructSize,
     List<T>& fld,
     const int tag
 ) const
 {
     if (Pstream::defaultCommsType == Pstream::nonBlocking)
     {
         distribute
         (
             Pstream::nonBlocking,
             List<labelPair>(),
             constructSize,
             constructMap_,
             constructHasFlip_,
             subMap_,
             subHasFlip_,
             fld,
             flipOp(),
             tag
         );
     }
     else if (Pstream::defaultCommsType == Pstream::scheduled)
     {
         distribute
         (
             Pstream::scheduled,
             schedule(),
             constructSize,
             constructMap_,
             constructHasFlip_,
             subMap_,
             subHasFlip_,
             fld,
             flipOp(),
             tag
         );
     }
     else
     {
         distribute
         (
             Pstream::blocking,
             List<labelPair>(),
             constructSize,
             constructMap_,
             constructHasFlip_,
             subMap_,
             subHasFlip_,
             fld,
             flipOp(),
             tag
         );
     }
 }


 //- Reverse distribute data using default commsType.
 //  Since constructSize might be larger than supplied size supply
 //  a nullValue
 template<class T>
 void Foam::mapDistributeBase::reverseDistribute
 (
     const label constructSize,
     const T& nullValue,
     List<T>& fld,
     const int tag
 ) const
 {
     if (Pstream::defaultCommsType == Pstream::nonBlocking)
     {
         distribute
         (
             Pstream::nonBlocking,
             List<labelPair>(),
             constructSize,
             constructMap_,
             constructHasFlip_,
             subMap_,
             subHasFlip_,
             fld,
             eqOp<T>(),
             flipOp(),
             nullValue,
             tag
         );
     }
     else if (Pstream::defaultCommsType == Pstream::scheduled)
     {
         distribute
         (
             Pstream::scheduled,
             schedule(),
             constructSize,
             constructMap_,
             constructHasFlip_,
             subMap_,
             subHasFlip_,
             fld,
             eqOp<T>(),
             flipOp(),
             nullValue,
             tag
         );
     }
     else
     {
         distribute
         (
             Pstream::blocking,
             List<labelPair>(),
             constructSize,
             constructMap_,
             constructHasFlip_,
             subMap_,
             subHasFlip_,
             fld,
             eqOp<T>(),
             flipOp(),
             nullValue,
             tag
         );
     }
 }


 // ************************************************************************* //
Foam::flipOp
Class containing functor to negate primitives. Dummy for all other types.
Definition: flipOp.H:50

forAll
#define forAll(list, i)
Loop across all elements in list.
Definition: UList.H:428

Foam::label
intWM_LABEL_SIZE_t label
A label is an int32_t or int64_t as specified by the pre-processor macro WM_LABEL_SIZE.
Definition: label.H:59

Foam::PstreamBuffers::finishedSends
void finishedSends(const bool block=true)
Mark all sends as having been done. This will start receives.
Definition: PstreamBuffers.C:82

Foam::exit
errorManipArg< error, int > exit(error &err, const int errNo=1)
Definition: errorManip.H:124

Foam::UPstream::nonBlocking
Definition: UPstream.H:68

Foam::FatalError
error FatalError

FatalErrorInFunction
#define FatalErrorInFunction
Report an error message using Foam::FatalError.
Definition: error.H:319

Foam::UPstream::commsTypes
commsTypes
Types of communications.
Definition: UPstream.H:64

Foam::List
A 1D array of objects of type <T>, where the size of the vector is known and used for subscript bound...
Definition: HashTable.H:59

Foam::List::size
void size(const label)
Override size to be inconsistent with allocated storage.
Definition: ListI.H:76

Foam::mapDistributeBase::subMap_
labelListList subMap_
Maps from subsetted data back to original data.
Definition: mapDistributeBase.H:110

flipOp.H

PstreamCombineReduceOps.H
Combination-Reduction operation for a parallel run. The information from all nodes is collected on th...

Foam::mapDistributeBase::constructSize_
label constructSize_
Size of reconstructed data.
Definition: mapDistributeBase.H:107

Foam::IPstream
Input inter-processor communications stream.
Definition: IPstream.H:50

Foam::UIPstream
Input inter-processor communications stream operating on external buffer.
Definition: UIPstream.H:53

Foam::UList::byteSize
std::streamsize byteSize() const
Return the binary size in number of characters of the UList.
Definition: UList.C:100

Foam::UPstream::scheduled
Definition: UPstream.H:67

Foam::read
bool read(const char *, int32_t &)
Definition: int32IO.C:85

Foam::Pair
An ordered pair of two objects of type <T> with first() and second() elements.
Definition: contiguous.H:49

fld
gmvFile<< "tracers "<< particles.size()<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){gmvFile<< iter().position().x()<<  ' ';}gmvFile<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){gmvFile<< iter().position().y()<<  ' ';}gmvFile<< nl;forAllConstIter(Cloud< passiveParticle >, particles, iter){gmvFile<< iter().position().z()<<  ' ';}gmvFile<< nl;forAll(lagrangianScalarNames, i){const word &name=lagrangianScalarNames[i];IOField< scalar > fld(IOobject(name, runTime.timeName(), cloud::prefix, mesh, IOobject::MUST_READ, IOobject::NO_WRITE))

Foam::eqOp
Definition: ops.H:70

Foam::DynamicList
A 1D vector of objects of type <T> that resizes itself as necessary to accept the new objects...
Definition: DynamicList.H:56

Foam::UPstream::blocking
Definition: UPstream.H:66

Pstream.H

Foam::mapDistributeBase::accessAndFlip
static T accessAndFlip(const UList< T > &fld, const label index, const bool hasFlip, const negateOp &negOp)
Definition: mapDistributeBaseTemplates.C:80

Foam::DynamicList::setCapacity
void setCapacity(const label)
Alter the size of the underlying storage.
Definition: DynamicListI.H:118

Foam::UList::begin
iterator begin()
Return an iterator to begin traversing the UList.
Definition: UListI.H:216

Foam::mapDistributeBase::distribute
static void distribute(const Pstream::commsTypes commsType, const List< labelPair > &schedule, const label constructSize, const labelListList &subMap, const bool subHasFlip, const labelListList &constructMap, const bool constructHasFlip, List< T > &, const negateOp &negOp, const int tag=UPstream::msgType())
Distribute data. Note:schedule only used for Pstream::scheduled.
Definition: mapDistributeBaseTemplates.C:119

Foam::abort
errorManip< error > abort(error &err)
Definition: errorManip.H:131

Foam::mapDistributeBase::constructMap_
labelListList constructMap_
Maps from subsetted data to new reconstructed data.
Definition: mapDistributeBase.H:113

Foam::UList
A 1D vector of objects of type <T>, where the size of the vector is known and can be used for subscri...
Definition: HashTable.H:60

Foam::UOPstream
Output inter-processor communications stream operating on external buffer.
Definition: UOPstream.H:54

Foam::DynamicList::shrink
DynamicList< T, SizeInc, SizeMult, SizeDiv > & shrink()
Shrink the allocated space to the number of elements used.
Definition: DynamicListI.H:240

Foam::mapDistributeBase::schedule
const List< labelPair > & schedule() const
Return a schedule. Demand driven. See above.
Definition: mapDistributeBase.C:168

Foam::OPstream
Output inter-processor communications stream.
Definition: OPstream.H:50

Foam::PstreamBuffers
Buffers for inter-processor communications streams (UOPstream, UIPstream).
Definition: PstreamBuffers.H:85

Foam::T
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
Definition: FieldFieldFunctions.C:55

T
const volScalarField & T
Definition: createFieldRefs.H:2

Foam::mapDistributeBase::subHasFlip_
bool subHasFlip_
Whether subMap includes flip or not.
Definition: mapDistributeBase.H:116

PstreamBuffers.H

Foam::UList::size
label size() const
Return the number of elements in the UList.
Definition: UListI.H:299

Foam::UPstream::defaultCommsType
static commsTypes defaultCommsType
Default commsType.
Definition: UPstream.H:268

Foam::List::setSize
void setSize(const label)
Reset size of List.
Definition: List.C:295

Foam::UPstream::nProcs
static label nProcs(const label communicator=0)
Number of processes in parallel run.
Definition: UPstream.H:399

Foam::mapDistributeBase::constructHasFlip_
bool constructHasFlip_
Whether constructMap includes flip or not.
Definition: mapDistributeBase.H:119

Foam::mapDistributeBase::send
void send(PstreamBuffers &, const List< T > &) const
Do all sends using PstreamBuffers.
Definition: mapDistributeBaseTemplates.C:1077

Foam::mapDistributeBase::reverseDistribute
void reverseDistribute(const label constructSize, List< T > &, const int tag=UPstream::msgType()) const
Reverse distribute data using default commsType.
Definition: mapDistributeBaseTemplates.C:1242

Foam::mapDistributeBase::receive
void receive(PstreamBuffers &, List< T > &) const
Do all receives using PstreamBuffers.
Definition: mapDistributeBaseTemplates.C:1111

Foam::List::transfer
void transfer(List< T > &)
Transfer the contents of the argument List into this list.
Definition: List.C:365

write
runTime write()

Foam::mapDistributeBase::flipAndCombine
static void flipAndCombine(const UList< label > &map, const bool hasFlip, const UList< T > &rhs, const CombineOp &cop, const negateOp &negOp, List< T > &lhs)
Definition: mapDistributeBaseTemplates.C:35