src/dynamicMesh/dynamicFvMesh/dynamicTopoFvMesh/meshOpsTemplates.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright held by original author
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     meshOps
  27
  28 Description
  29     Various utility functions that perform mesh-related operations.
  30
  31 Author
  32     Sandeep Menon
  33     University of Massachusetts Amherst
  34     All rights reserved
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #include "Pair.H"
  39 #include "meshOps.H"
  40 #include "ListOps.H"
  41
  42 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  43
  44 namespace Foam
  45 {
  46
  47 namespace meshOps
  48 {
  49 // Parallel non-blocking send for fixed lists
  50 template <class Type, unsigned Size>
  51 inline void pWrite
  52 (
  53     const label toID,
  54     const FixedList<Type, Size>& data
  55 )
  56 {
  57     OPstream::write
  58     (
  59         Pstream::blocking,
  60         toID,
  61         reinterpret_cast<const char*>(&data[0]),
  62         Size*sizeof(Type)
  63     );
  64 }
  65
  66
  67 // Parallel non-blocking receive for fixed lists
  68 template <class Type, unsigned Size>
  69 inline void pRead
  70 (
  71     const label fromID,
  72     FixedList<Type, Size>& data
  73 )
  74 {
  75     IPstream::read
  76     (
  77         Pstream::blocking,
  78         fromID,
  79         reinterpret_cast<char*>(data.begin()),
  80         Size*sizeof(Type)
  81     );
  82 }
  83
  84
  85 // Parallel non-blocking send for lists
  86 template <class Type>
  87 inline void pWrite
  88 (
  89     const label toID,
  90     const UList<Type>& data
  91 )
  92 {
  93     OPstream::write
  94     (
  95         Pstream::nonBlocking,
  96         toID,
  97         reinterpret_cast<const char*>(&data[0]),
  98         data.size()*sizeof(Type)
  99     );
 100 }
 101
 102
 103 // Parallel non-blocking receive for lists
 104 template <class Type>
 105 inline void pRead
 106 (
 107     const label fromID,
 108     UList<Type>& data
 109 )
 110 {
 111     IPstream::read
 112     (
 113         Pstream::nonBlocking,
 114         fromID,
 115         reinterpret_cast<char*>(&data[0]),
 116         data.size()*sizeof(Type)
 117     );
 118 }
 119
 120
 121 // Utility method to size-up the list to include an item
 122 template <class Type>
 123 inline void sizeUpList
 124 (
 125     const Type& item,
 126     List<Type>& list
 127 )
 128 {
 129     list.setSize(list.size() + 1, item);
 130 }
 131
 132
 133 // Utility method to size-down the list to remove an item
 134 template <class Type>
 135 inline void sizeDownList
 136 (
 137     const Type& item,
 138     List<Type>& list
 139 )
 140 {
 141     label index = -1;
 142
 143     if ((index = findIndex(list, item)) > -1)
 144     {
 145         meshOps::removeIndex(index, list);
 146     }
 147     else
 148     {
 149         FatalErrorIn
 150         (
 151             "inline void meshOps::sizeDownList"
 152             "(const Type& item, List<Type>& list)"
 153         )
 154             << nl << "Item: " << item
 155             << " was not found in list. " << nl
 156             << " List: " << nl << list
 157             << abort(FatalError);
 158     }
 159 }
 160
 161
 162 // Remove an item at a particular index in the list
 163 template <class Type>
 164 inline void removeIndex
 165 (
 166     const label index,
 167     List<Type>& list
 168 )
 169 {
 170     // Create a new list
 171     List<Type> newList(list.size() - 1);
 172
 173     // Copy individual items
 174     label n = 0;
 175
 176     forAll(list, itemI)
 177     {
 178         if (itemI == index)
 179         {
 180             continue;
 181         }
 182
 183         newList[n++] = list[itemI];
 184     }
 185
 186     // Overwrite
 187     list.transfer(newList);
 188 }
 189
 190
 191 } // End namespace meshOps
 192
 193
 194 } // End namespace Foam
 195
 196 // ************************************************************************* //