mapDistribute.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
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
13  the Free Software Foundation, either version 3 of the License, or
14  (at your 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, see <http://www.gnu.org/licenses/>.
23 
24 Class
25  Foam::mapDistribute
26 
27 Description
28  Class containing processor-to-processor mapping information.
29 
30  We store mapping from the bits-to-send to the complete starting list
31  (subXXXMap) and from the received bits to their location in the new
32  list (constructXXXMap).
33 
34 Note:
35  Schedule is a list of processor pairs (one send, one receive. One of
36  them will be myself) which forms a scheduled (i.e. non-buffered) exchange.
37  See distribute on how to use it.
38  Note2: number of items sent on one processor have to equal the number
39  of items received on the other processor.
40 
41  To aid constructing these maps there are the constructors from global
42  numbering, either with or without transforms.
43 
44  - without transforms:
45  Constructors using compact numbering: layout is
46  - all my own elements first (whether used or not)
47  - followed by used-only remote elements sorted by remote processor.
48  So e.g 4 procs and on proc 1 the compact
49  table will first have all globalIndex.localSize() elements from proc1
50  followed by used-only elements of proc0, proc2, proc3.
51  The constructed mapDistribute sends the local elements from and
52  receives the remote elements into their compact position.
53  compactMap[procI] is the position of elements from procI in the compact
54  map. compactMap[myProcNo()] is empty since trivial addressing.
55 
56  It rewrites the input global indices into indices into the constructed
57  data.
58 
59 
60  - with transforms:
61  This requires the precalculated set of possible transforms
62  (globalIndexAndTransform). These are given as permutations (+, -, or none)
63  of up to 3 independent transforms.
64  The layout of the data is
65  - all my own elements first (whether used or not)
66  - followed by used-only remote elements sorted by remote processor.
67  - followed by - for each transformation index - the set of local or
68  remote elements with that transformation.
69  The inputs for the constructor are
70  - the set of untransformed local or remote indices in globalIndex
71  numbering. These get rewritten to be indices into the layout of the data.
72  - the set of transformed local or remote indices in globalIndexAndTransform
73  encoding. These are labelPairs.
74 
75  Any distribute with transforms is now done as:
76  1. exchange data with other processors and receive these into the
77  slots for that processor
78  2. for all transformations transform a subset of the data according
79  to transformElements_[transformI] and store this starting from
80  transformStart_[transformI]
81 
82  In the same way a reverse distribute will
83  1. apply the inverse transform to the data starting at
84  transformStart_[transformI] and copy the result back into the
85  transformElements_[transformI]. These might be local or remote slots.
86  2. the data in the remote slots will now be sent back to the correct
87  location in the originating processor.
88 
89  E.g. a map to handle
90  - mesh points on a mesh with
91  - 1 cyclic so 3 permutations (+,-,none) will have layout
92  - on e.g. processor 1 out of 2:
93 
94  +------+ <- transformStart[2]
95  | |
96  | | <- transform2 applied to data in local or remote slots
97  | |
98  +------+ <- transformStart[1]
99  | |
100  | | <- transform1 applied to data in local or remote slots
101  | |
102  +------+ <- transformStart[1]
103  | |
104  | | <- transform0 applied to data in local or remote slots
105  | |
106  +------+ <- transformStart[0]
107  | |
108  | | <- data from proc2
109  | |
110  +------+
111  | |
112  | | <- data from proc0
113  | |
114  +------+ <- mesh.nPoints()
115  | |
116  | |
117  | |
118  +------+ 0
119 
120 
121 SourceFiles
122  mapDistribute.C
123  mapDistributeTemplates.C
124 
125 \*---------------------------------------------------------------------------*/
126 
127 #ifndef mapDistribute_H
128 #define mapDistribute_H
129 
130 #include "transformList.H"
131 #include "labelList.H"
132 #include "labelPair.H"
133 #include "Pstream.H"
134 #include "boolList.H"
135 #include "Map.H"
136 #include "vectorTensorTransform.H"
137 #include "coupledPolyPatch.H"
138 
139 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
140 
141 namespace Foam
142 {
143 
144 class mapPolyMesh;
145 class globalIndex;
146 class PstreamBuffers;
147 class globalIndexAndTransform;
148 
149 /*---------------------------------------------------------------------------*\
150  Class mapDistribute Declaration
151 \*---------------------------------------------------------------------------*/
153 class mapDistribute
154 {
155  // Private data
156 
157  //- Size of reconstructed data
158  label constructSize_;
159 
160  //- Maps from subsetted data back to original data
161  labelListList subMap_;
162 
163  //- Maps from subsetted data to new reconstructed data
164  labelListList constructMap_;
165 
166  // Optional transformation
167 
168  //- For every globalIndexAndTransform::transformPermutations
169  // gives the elements that need to be transformed
170  labelListList transformElements_;
171 
172  //- Destination in constructMap for transformed elements
173  labelList transformStart_;
174 
175 
176  //- Schedule
177  mutable autoPtr<List<labelPair> > schedulePtr_;
178 
179 
180  // Private Member Functions
181 
182  static void checkReceivedSize
183  (
184  const label procI,
185  const label expectedSize,
186  const label receivedSize
187  );
188 
189  void calcCompactAddressing
190  (
191  const globalIndex& globalNumbering,
192  const labelList& elements,
193  List<Map<label> >& compactMap
194  ) const;
195  void calcCompactAddressing
196  (
197  const globalIndex& globalNumbering,
198  const labelListList& elements,
199  List<Map<label> >& compactMap
200  ) const;
201 
202  void exchangeAddressing
203  (
204  const int tag,
205  const globalIndex& globalNumbering,
206  labelList& elements,
207  List<Map<label> >& compactMap,
208  labelList& compactStart
209  );
210  void exchangeAddressing
211  (
212  const int tag,
213  const globalIndex& globalNumbering,
214  labelListList& elements,
215  List<Map<label> >& compactMap,
216  labelList& compactStart
217  );
218 
219 
220  //- Helper function: copy transformElements without transformation
221  template<class T>
222  void applyDummyTransforms(List<T>& field) const;
223 
224  template<class T, class TransformOp>
225  void applyTransforms
226  (
227  const globalIndexAndTransform& globalTransforms,
228  List<T>& field,
229  const TransformOp& top
230  ) const;
231 
232  //- Helper function: copy transformElements without transformation
233  template<class T>
234  void applyDummyInverseTransforms(List<T>& field) const;
235 
236  template<class T, class TransformOp>
237  void applyInverseTransforms
238  (
239  const globalIndexAndTransform& globalTransforms,
240  List<T>& field,
241  const TransformOp& top
242  ) const;
243 
244 
245 public:
246 
247  // Public classes
248 
249  //- Default transformation behaviour
250  class transform
251  {
252  public:
253 
254  template<class Type>
255  void operator()
256  (
257  const vectorTensorTransform& vt,
258  const bool forward,
259  List<Type>& fld
260  ) const
261  {
262  const tensor T(forward ? vt.R() : vt.R().T());
263  transformList(T, fld);
264  }
265 
266  template<class Type>
267  void operator()
268  (
269  const vectorTensorTransform& vt,
270  const bool forward,
271  List<List<Type> >& flds
272  ) const
273  {
274  forAll(flds, i)
275  {
276  operator()(vt, forward, flds[i]);
277  }
278  }
279 
280  //- Transform patch-based field
281  template<class Type>
282  void operator()(const coupledPolyPatch& cpp, UList<Type>& fld) const
283  {
284  if (!cpp.parallel())
285  {
286  transformList(cpp.forwardT(), fld);
287  }
288  }
289 
290  //- Transform sparse field
291  template<class Type, template<class> class Container>
292  void operator()(const coupledPolyPatch& cpp, Container<Type>& map)
293  const
294  {
295  if (!cpp.parallel())
296  {
297  transformList(cpp.forwardT(), map);
298  }
299  }
300  };
301 
302  //- Default transformation behaviour for position
303  class transformPosition
304  {
305  public:
306 
307  void operator()
308  (
309  const vectorTensorTransform& vt,
310  const bool forward,
312  ) const
313  {
314  pointField pfld(fld.xfer());
315  if (forward)
316  {
317  fld = vt.transformPosition(pfld);
318  }
319  else
320  {
321  fld = vt.invTransformPosition(pfld);
322  }
323  }
324  void operator()
325  (
326  const vectorTensorTransform& vt,
327  const bool forward,
328  List<List<point> >& flds
329  ) const
330  {
331  forAll(flds, i)
332  {
333  operator()(vt, forward, flds[i]);
334  }
335  }
336  //- Transform patch-based field
337  void operator()(const coupledPolyPatch& cpp, pointField& fld) const
338  {
339  cpp.transformPosition(fld);
340  }
341  template<template<class> class Container>
342  void operator()(const coupledPolyPatch& cpp, Container<point>& map)
343  const
344  {
345  Field<point> fld(map.size());
346  label i = 0;
347  forAllConstIter(typename Container<point>, map, iter)
348  {
349  fld[i++] = iter();
350  }
351  cpp.transformPosition(fld);
352  i = 0;
353  forAllIter(typename Container<point>, map, iter)
354  {
355  iter() = fld[i++];
356  }
357  }
358  };
359 
360 
361 
362  // Declare name of the class and its debug switch
363  ClassName("mapDistribute");
364 
365 
366  // Constructors
367 
368  //- Construct null
369  mapDistribute();
370 
371  //- Construct from components
373  (
374  const label constructSize,
375  const Xfer<labelListList>& subMap,
376  const Xfer<labelListList>& constructMap
377  );
378 
379  //- Construct from components
381  (
382  const label constructSize,
383  const Xfer<labelListList>& subMap,
384  const Xfer<labelListList>& constructMap,
385  const Xfer<labelListList>& transformElements,
386  const Xfer<labelList>& transformStart
387  );
388 
389  //- Construct from reverse addressing: per data item the send
390  // processor and the receive processor. (note: data is not stored
391  // sorted per processor so cannot use printLayout).
393  (
394  const labelList& sendProcs,
395  const labelList& recvProcs
396  );
397 
398  //- Construct from list of (possibly) remote elements in globalIndex
399  // numbering (or -1). Determines compact numbering (see above) and
400  // distribute map to get data into this ordering and renumbers the
401  // elements to be in compact numbering.
403  (
404  const globalIndex&,
405  labelList& elements,
406  List<Map<label> >& compactMap,
407  const int tag = Pstream::msgType()
408  );
409 
410  //- Special variant that works with the info sorted into bins
411  // according to local indices. E.g. think cellCells where
412  // cellCells[localCellI] is a list of global cells
414  (
415  const globalIndex&,
416  labelListList& cellCells,
417  List<Map<label> >& compactMap,
418  const int tag = Pstream::msgType()
419  );
420 
421  //- Construct from list of (possibly remote) untransformed elements
422  // in globalIndex numbering (or -1) and (possibly remote)
423  // transformded elements in globalIndexAndTransform numbering.
424  // Determines compact numbering (see above) and
425  // distribute map to get data into this ordering and renumbers the
426  // elements to be in compact numbering.
428  (
429  const globalIndex&,
430  labelList& untransformedElements,
432  const labelPairList& transformedElements,
433  labelList& transformedIndices,
434  List<Map<label> >& compactMap,
435  const int tag = Pstream::msgType()
436  );
437 
438  //- As above but with ListLists.
440  (
441  const globalIndex&,
442  labelListList& cellCells,
444  const List<labelPairList>& transformedElements,
445  labelListList& transformedIndices,
446  List<Map<label> >& compactMap,
447  const int tag = Pstream::msgType()
448  );
449 
450  //- Construct by transferring parameter content
452 
453  //- Construct copy
455 
456 
457  // Member Functions
458 
459  // Access
460 
461  //- Constructed data size
462  label constructSize() const
463  {
464  return constructSize_;
465  }
466 
467  //- Constructed data size
469  {
470  return constructSize_;
471  }
472 
473  //- From subsetted data back to original data
474  const labelListList& subMap() const
475  {
476  return subMap_;
477  }
478 
479  //- From subsetted data back to original data
481  {
482  return subMap_;
483  }
484 
485  //- From subsetted data to new reconstructed data
486  const labelListList& constructMap() const
487  {
488  return constructMap_;
489  }
490 
491  //- From subsetted data to new reconstructed data
493  {
494  return constructMap_;
495  }
496 
497  //- For every globalIndexAndTransform::transformPermutations
498  // gives the elements that need to be transformed
499  const labelListList& transformElements() const
500  {
501  return transformElements_;
502  }
503 
504  //- Destination in constructMap for transformed elements
505  const labelList& transformStart() const
506  {
507  return transformStart_;
508  }
509 
510  //- Find transform from transformElements
511  label whichTransform(const label index) const;
512 
513  //- Calculate a schedule. See above.
515  (
516  const labelListList& subMap,
517  const labelListList& constructMap,
518  const int tag
519  );
520 
521  //- Return a schedule. Demand driven. See above.
522  const List<labelPair>& schedule() const;
523 
524 
525  // Other
526 
527  //- Transfer the contents of the argument and annul the argument.
528  void transfer(mapDistribute&);
529 
530  //- Transfer contents to the Xfer container
532 
533  //- Helper for construct from globalIndex. Renumbers element
534  // (in globalIndex numbering) into compact indices.
535  static label renumber
536  (
537  const globalIndex&,
538  const List<Map<label> >& compactMap,
539  const label globalElement
540  );
541 
542  //- Compact maps. Gets per field a bool whether it is used (locally)
543  // and works out itself what this side and sender side can remove
544  // from maps.
545  void compact
546  (
547  const boolList& elemIsUsed,
548  const int tag = UPstream::msgType()
549  );
550 
551  //- Distribute data. Note:schedule only used for Pstream::scheduled
552  // for now, all others just use send-to-all, receive-from-all.
553  template<class T>
554  static void distribute
555  (
556  const Pstream::commsTypes commsType,
557  const List<labelPair>& schedule,
558  const label constructSize,
559  const labelListList& subMap,
560  const labelListList& constructMap,
561  List<T>&,
562  const int tag = UPstream::msgType()
563  );
564 
565  //- Distribute data. If multiple processors writing to same
566  // position adds contributions using cop.
567  template<class T, class CombineOp>
568  static void distribute
569  (
570  const Pstream::commsTypes commsType,
571  const List<labelPair>& schedule,
572  const label constructSize,
573  const labelListList& subMap,
574  const labelListList& constructMap,
575  List<T>&,
576  const CombineOp& cop,
577  const T& nullValue,
578  const int tag = UPstream::msgType()
579  );
580 
581  //- Distribute data using default commsType.
582  template<class T>
583  void distribute
584  (
585  DynamicList<T>& fld,
586  const bool dummyTransform = true,
587  const int tag = UPstream::msgType()
588  ) const;
589 
590  //- Distribute data using default commsType.
591  template<class T>
592  void distribute
593  (
594  List<T>& fld,
595  const bool dummyTransform = true,
596  const int tag = UPstream::msgType()
597  ) const;
598 
599  //- Same but with transforms
600  template<class T, class TransformOp>
601  void distribute
602  (
604  List<T>& fld,
605  const TransformOp& top,
606  const int tag = UPstream::msgType()
607  ) const;
608 
609  //- Reverse distribute data using default commsType.
610  template<class T>
611  void reverseDistribute
612  (
613  const label constructSize,
614  List<T>&,
615  const bool dummyTransform = true,
616  const int tag = UPstream::msgType()
617  ) const;
618 
619  //- Same but with transforms
620  template<class T, class TransformOp>
621  void reverseDistribute
622  (
624  const label constructSize,
625  List<T>& fld,
626  const TransformOp& top,
627  const int tag = UPstream::msgType()
628  ) const;
629 
630  //- Reverse distribute data using default commsType.
631  // Since constructSize might be larger than supplied size supply
632  // a nullValue
633  template<class T>
634  void reverseDistribute
635  (
636  const label constructSize,
637  const T& nullValue,
638  List<T>& fld,
639  const bool dummyTransform = true,
640  const int tag = UPstream::msgType()
641  ) const;
642 
643  //- Same but with transforms
644  template<class T, class TransformOp>
645  void reverseDistribute
646  (
648  const label constructSize,
649  const T& nullValue,
650  List<T>& fld,
651  const TransformOp& top,
652  const int tag = UPstream::msgType()
653  ) const;
654 
655  //- Do all sends using PstreamBuffers
656  template<class T>
657  void send(PstreamBuffers&, const List<T>&) const;
658  //- Do all receives using PstreamBuffers
659  template<class T>
660  void receive(PstreamBuffers&, List<T>&) const;
661 
662  //- Debug: print layout. Can only be used on maps with sorted
663  // storage (local data first, then non-local data)
664  void printLayout(Ostream& os) const;
665 
666  //- Correct for topo change.
667  void updateMesh(const mapPolyMesh&)
668  {
670  (
671  "mapDistribute::updateMesh(const mapPolyMesh&)"
672  );
673  }
674 
675  // Member Operators
676 
677  void operator=(const mapDistribute&);
678 
679 
680  // IOstream operators
681 
682  //- Read dictionary from Istream
684 
685  //- Write dictionary to Ostream
686  friend Ostream& operator<<(Ostream&, const mapDistribute&);
687 
688 };
689 
690 
691 template<>
692 void mapDistribute::transform::operator()
693 (
694  const vectorTensorTransform&,
695  const bool,
696  List<label>&
697 ) const;
698 template<>
699 void mapDistribute::transform::operator()
700 (
701  const coupledPolyPatch&,
702  UList<label>&
703 ) const;
704 template<>
705 void mapDistribute::transform::operator()
706 (
707  const coupledPolyPatch&,
708  Map<label>&
709 ) const;
710 template<>
711 void mapDistribute::transform::operator()
712 (
713  const coupledPolyPatch&,
715 ) const;
716 
717 template<>
718 void mapDistribute::transform::operator()
719 (
720  const coupledPolyPatch&,
722 ) const;
723 template<>
724 void mapDistribute::transform::operator()
725 (
726  const vectorTensorTransform&,
727  const bool,
728  List<scalar>&
729 ) const;
730 template<>
731 void mapDistribute::transform::operator()
732 (
733  const coupledPolyPatch&,
734  Map<scalar>&
735 ) const;
736 template<>
737 void mapDistribute::transform::operator()
738 (
739  const coupledPolyPatch&,
741 ) const;
742 
743 template<>
744 void mapDistribute::transform::operator()
745 (
746  const coupledPolyPatch& cpp,
748 ) const;
749 template<>
750 void mapDistribute::transform::operator()
751 (
752  const vectorTensorTransform&,
753  const bool,
754  List<bool>&
755 ) const;
756 template<>
757 void mapDistribute::transform::operator()
758 (
759  const coupledPolyPatch&,
760  Map<bool>&
761 ) const;
762 template<>
763 void mapDistribute::transform::operator()
764 (
765  const coupledPolyPatch&,
767 ) const;
768 
769 
770 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
771 
772 } // End namespace Foam
773 
774 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
775 
776 #ifdef NoRepository
777 # include "mapDistributeTemplates.C"
778 #endif
779 
780 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
781 
782 #endif
783 
784 // ************************************************************************* //
void receive(PstreamBuffers &, List< T > &) const
Do all receives using PstreamBuffers.
virtual const tensorField & forwardT() const
Return face transformation tensor.
void send(PstreamBuffers &, const List< T > &) const
Do all sends using PstreamBuffers.
const labelListList & subMap() const
From subsetted data back to original data.
Determination and storage of the possible independent transforms introduced by coupledPolyPatches, as well as all of the possible permutations of these transforms generated by the presence of multiple coupledPolyPatches, i.e. more than one cyclic boundary.
Default transformation behaviour for position.
Buffers for inter-processor communications streams (UOPstream, UIPstream).
label whichTransform(const label index) const
Find transform from transformElements.
static void distribute(const Pstream::commsTypes commsType, const List< labelPair > &schedule, const label constructSize, const labelListList &subMap, const labelListList &constructMap, List< T > &, const int tag=UPstream::msgType())
Distribute data. Note:schedule only used for Pstream::scheduled.
Default transformation behaviour.
void T(FieldField< Field, Type > &f1, const FieldField< Field, Type > &f2)
Class containing mesh-to-mesh mapping information after a change in polyMesh topology.
Definition: mapPolyMesh.H:158
const labelListList & transformElements() const
For every globalIndexAndTransform::transformPermutations.
static label renumber(const globalIndex &, const List< Map< label > > &compactMap, const label globalElement)
Helper for construct from globalIndex. Renumbers element.
const labelListList & constructMap() const
From subsetted data to new reconstructed data.
Xfer< List< T > > xfer()
Transfer contents to the Xfer container.
Definition: ListI.H:90
Class containing processor-to-processor mapping information.
An Istream is an abstract base class for all input systems (streams, files, token lists etc)...
Definition: Istream.H:57
A simple container for copying or transferring objects of type <T>.
Definition: Xfer.H:85
#define forAllIter(Container, container, iter)
Definition: UList.H:440
Calculates a unique integer (label so might not have enough room - 2G max) for processor + local inde...
Definition: globalIndex.H:63
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
void operator=(const mapDistribute &)
virtual void transformPosition(pointField &) const =0
Transform a patch-based position from other side to this side.
void compact(const boolList &elemIsUsed, const int tag=UPstream::msgType())
Compact maps. Gets per field a bool whether it is used (locally)
Namespace for OpenFOAM.
friend Istream & operator>>(Istream &, mapDistribute &)
Read dictionary from Istream.
mapDistribute()
Construct null.
forAllConstIter(PtrDictionary< phaseModel >, mixture.phases(), phase)
Definition: pEqn.H:39
void reverseDistribute(const label constructSize, List< T > &, const bool dummyTransform=true, const int tag=UPstream::msgType()) const
Reverse distribute data using default commsType.
virtual bool parallel() const
Are the cyclic planes parallel.
commsTypes
Types of communications.
Definition: UPstream.H:64
#define forAll(list, i)
Definition: UList.H:421
void operator()(const vectorTensorTransform &vt, const bool forward, List< Type > &fld) const
static int & msgType()
Message tag of standard messages.
Definition: UPstream.H:451
Xfer< mapDistribute > xfer()
Transfer contents to the Xfer container.
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 ))
Vector-tensor class used to perform translations and rotations in 3D space.
const List< labelPair > & schedule() const
Return a schedule. Demand driven. See above.
void transformList(const tensor &, UList< T > &)
Apply transformation to list. Either single transformation tensor.
Definition: transformList.C:49
A 1D vector of objects of type <T> that resizes itself as necessary to accept the new objects...
Definition: DynamicList.H:56
const labelList & transformStart() const
Destination in constructMap for transformed elements.
Spatial transformation functions for primitive fields.
void updateMesh(const mapPolyMesh &)
Correct for topo change.
void transfer(mapDistribute &)
Transfer the contents of the argument and annul the argument.
An Ostream is an abstract base class for all output systems (streams, files, token lists...
Definition: Ostream.H:53
ClassName("mapDistribute")
#define notImplemented(functionName)
Issue a FatalErrorIn for a function not currently implemented.
Definition: error.H:356
The coupledPolyPatch is an abstract base class for patches that couple regions of the computational d...
An auto-pointer similar to the STL auto_ptr but with automatic casting to a reference to the type and...
Definition: PtrList.H:117
void printLayout(Ostream &os) const
Debug: print layout. Can only be used on maps with sorted.
friend Ostream & operator<<(Ostream &, const mapDistribute &)
Write dictionary to Ostream.
label constructSize() const
Constructed data size.